Today in this article, we will understand the role of hostfxr.dll in application lifecycle and learn few Guidelines and Best Practices around its usage.

New .NET ecosystem is already a lightweight abstraction layer around all complex components of .NET legacy. This lets you use only components which are needed for your application in declarative manner.

The hostfxr.dll file is core component in .NET Applicaiton (specifically .NET Core 3.1, or.NET6 onwards).

It’s responsible for creating .NET runtime within an application.

This component is responsible for initializing required libraries Example- CoreCLR etc. , hosting application and managing the lifecycle, and managing the execution of .NET applications by interfacing with the operating system.

Role of hostfxr.dll Components

When you build a .NET application, the hostfxr.dll plays a crucial role in bootstrapping the application’s runtime environment.

Bootstrapping the Applicaiton Runtime

• Hostfxr.dll serves as the entry point for .NET Core applications.

• It performs the initial setup, loading the necessary runtime components and preparing the environment for executing managed code.

• hostfxr.dll loads necessary system libraries and core components, including CoreCLR, i.e coreclr.dll and other required runtime libraries.

Runtime Components Configuration and Initialization

Being an entry point, it reads the application’s runtime configuration.

• Load framework version

• Read Runtime configurations

• Identify paths to runtime components

• Loads core libraries example coreclr.dll (the CoreCLR runtime) and other essential runtime components.

• Initializes the runtime, which provides added
  • Just-In-Time (JIT) compilation,
  • garbage collection(GC)
  • other runtime functionalities.

Application Hosting Lifecycle Management

• hostfxr.dll activates the .NET application by creating an application domain and providing the necessary execution context for the application to start executing managed code.

• hostfxr manages the application’s lifecycle, handling loading, unloading, and execution of managed code within the designated runtime environment.

• hostfxr.dll manages error messages, diagnostics, and logging and also provides mechanisms for reporting errors or failures while application execution.

• hostfxr.dll manages version compatibility and allows to management of multiple versions of the .NET Core runtime.

• hostfxr.dll interacts with the operating system (Cloud, Non-Cloud system) to manage resources, memory, and process execution. It enables portability supporting multiple operating systems.

How to install and use hostfxr.dll

hostfxr.dll is actually a part of the .NET Core runtime installation and hence simply will be available on target machine based on the .NET Core runtime requirements on the machine.

Configuration on Physical server

Please follow below steps to ensure right .NET core version and all its dependencies are deployed.

• On Windows:
  • Download the .NET Core runtime installer or SDK from the official .NET website.

• On Linux:
  • use apt-get (Ubuntu), yum (CentOS), or others to install the .NET Core runtime.
  • Ensure to install the runtime packages that include hostfxr.dll.

Self-Contained Vs Framework Dependent Deployment

As we discussed above, If the target machine has the required .NET version already installed then the application built using .NET should work without any issue. This approach called as Framework Dependent Deployment.

If the required .NET core SDK/runtime is not installed then one can follow any of the below approaches discussed. An approach using Self-content deployment doesn’t require a .NET Core SDK/Runtime to be installed on the target machines.

For more details, please visit below article,

Self Contained Vs Framework Dependent Deployment -Guidelines

Once .NET core is installed successfully, please cross verify the version using below commands,

Configuration on Cloud server

In the context of cloud generally, you will specify the container image.

For application with container images, especially when creating Docker images for .NET applications, hostfxr.dll is not necessary.

The Docker images for .NET applications will include the necessary runtime files and dependencies provided by Microsoft in their official images.

• Docker image for a .NET applicatio, if using an official .NET image.
• These base images already contain the required hostfxr.dll and other runtime components, allowing your application to run within the container without explicitly including this file.

Sample Docker file

For example, using a Dockerfile for a .NET Core application might look like this:

# Use the official .NET SDK image
FROM mcr.microsoft.com/dotnet/sdk:6.0

# Copy the application files to the container and build the application
WORKDIR /app
COPY . ./
RUN dotnet publish -c Release -o out



# Run the application
ENTRYPOINT ["dotnet", "TheCodeBuzz.dll"]

In above example, the base image mcr.microsoft.com/dotnet/aspnet:6.0 already contains hostfxr.dll and other required runtime files.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Role of hostfxr.dll In Application Lifecycle -Guidelines and Best Practices first appeared on TheCodeBuzz.

SqlBulkCopy is a very useful component in the .NET framework used mainly for efficient bulk-inserting large amounts of data into SQL Server databases.

Compared to traditional row-by-row insert operations SqlBulkCopy allows high-performance bulk insert insert by minimizing the network round trips and database interaction.

SqlBulkCopy is very adaptable and works with DataReader, DataTable, and other custom data structures for different scenarios.

Synchronous SqlBulkCopy C# for Bulk insert

Let’s see the below example to demonstrate the SqlBulkCopy usage.

In the below code, we have two source tables i. Source Table and Destination Table placeholder which need to be inserted into SQL.

We are establishing a SqlConnection to SQL Server,

 using SqlConnection connection = new SqlConnection(conString);
 connection.Open();

Using SQL transactions for each DataTable, you create parameterized SQL queries and use SqlBulkCopy to insert the data.

using SqlTransaction transaction = connection.BeginTransaction();
///your logic
transaction.Commit();

For each DataTable, you create parameterized SQL queries and use SqlBulkCopy to insert the data.

         using SqlBulkCopy bulkCopy = 
         new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, transaction);

 
         bulkCopy.DestinationTableName = destTableName;
         await bulkCopy.WriteToServerAsync(sourceTable);

Since we are using transactions, please commit the changes to make the update final.

Please Close the SqlConnection post all processing.

Ex.

         using SqlConnection connection = new SqlConnection(conString);
         connection.Open();

          /// your logicc here 

         connection.Close();

Here is the complete code,

Asynchronous c# SqlBulkCopy for Bulk insert

Let’s see the below example to demonstrate the SqlBulkCopy usage,

The below reusable method can be called asynchronously from the Calle side and can take advantage of multithreading.

Please note that there are no major differences between synchronous and asynchronous calls except use of the await keyword and method return type as Task.

Best Practices of Using to Use SqlBulkCopy

Below are a few best practices for using SqlBulkCopy,

• Ensure Proper Data Validation:
  • Validate data integrity before performing bulk inserts to avoid errors.
  • This includes data type compatibility and constraints.

• Use Appropriate Column Mapping:
  • Ensure that the source data columns are correctly mapped to the destination table
  • Mismatched columns can lead to data corruption.

• Consider Using Transactions:
  • Wrap your bulk copy operation in a transaction (SqlTransaction).
  • This allows you to commit or roll back the entire operation as a single transaction, ensuring data consistency.

• Handle Exceptions Gracefully:
  • Implement exception handling to capture any errors that occur during the bulk copy operation. This will help you identify and address issues promptly.

• Optimize Destination Table:
  • Disable non-clustered indexes, triggers, and constraints on the destination table before performing the bulk copy operation.
  • Rebuild or re-enable them after the operation to improve performance.

• Consider Using Temporary Tables:
  • In some cases, using temporary tables for bulk inserts and then transferring the data to the final table can improve performance.
  • This is especially useful when dealing with large datasets in a production environment.

• Asynchronous and Parallelism:
  • Depending on the hardware and the nature of your data, consider asynchronous and parallelizing your bulk copy operations to take full advantage of multi-core processors.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post SqlBulkCopy – Quick and Efficient Bulk Data Insert first appeared on TheCodeBuzz.

Today in this article, we shall see how to check which version of C# your Application is using.

We will see various easy-to-use techniques to verify the version. The below techniques can be used to verify the version on your developer machines or build a machine or cloud server.

You may find the need to check the C# version on the hosted application or server or in a cloud container etc.

We will cover the below aspects in the article,

Please note that as per recent guidelines from Microsoft default version of C# used by the application will be driven by the underlying .NET framework used (This is true for .NET or .NET Core framework used).

Get C# Version using Command line (Windows/Linux/MacOS)

Using any Shell or CLI ex. Visual Studio Command prompt:

Command

csc /langversion:?

C# compiler determines a default language version based on your project’s target framework. The target project when built gets the highest compatible language version by default as per this versioning semantics.

Get C# Version using #Error Directive

One can use the below directive to verify the c# language version.

Just type the below command anywhere in .cs file and mouse hover on it

Command

#error version

Check .NET Core version- SDK and Runtime version Programmatically

Additionally, if you are interested in knowing what version of .NET Core or framework is installed please follow the techniques discussed below,

Command

dotnet --list-sdks

For more details on the commands, please visit the below article,

• How to Check .NET Core version installed SDK and Runtime

C# Version using Visual Studio – Option is disabled now

Previously it used to be easy to find C# vesion by navigating the Project- Properties-> Build tab.

However as per new guidelines (explained below).. The visual studio above option is disabled.

As per Microsoft guidelines

Moving forward, however, each version of each framework will have a single supported and default version, and we won’t support arbitrary versions. To reflect this change in support, this commit permanently disables the language version combo box and adds a link to a document explaining the change.

So if using .NET or .NET Core then the framework will always target only a single language version and which will also be a default version.

The default version will be a major version of C#.

So with the above guidelines Visual Studio option to check or update the C# language version is disabled.

Project > Properties > Build > Advanced option is disabled.

Check all supported C# versions to date

Please visit the below Microsoft list,

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/configure-language-version#c-language-version-reference

How to Target specific version

If you need to change or target your application to use a particular C# language version, then there are various approaches to achieve this. Please refer to the below article,

• How to Enable C# Language Versioning – Guidelines

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post How to Check Which Version of C# App is using first appeared on TheCodeBuzz.

Today in this article we will see a simple approach to Insert Data Table into SQL Server databases Efficiently and Faster way.

You may want to insert single or multiple data tables efficiently into an SQL Database.

Inserting data from the Datatable can be optimized using SQL Server’s Table-Valued Parameters (TVPs) combined with a custom user-defined table type for each DataTable.

However, if you are interested in inserting the Datatable records without using Table-Valued Parameters (TVPs) or stored procedures(SP) then it can be achieved using parameterized SQL queries which are explained below in detail.

Please install System.Data.SqlClient Nuget package as explained in this article to use ADO.NET features in your application where class SqlClient is defined.

• Connect SQL Server Database C# Example

Insert DataTable into SQL – Using Table Valued Parameters (TVPs)

For each of your DataTables, create a user-defined table type in SQL. Please make sure the table type matches the structure of the source DataTables.

This is the most efficient way of inserting the Table into the SQL server Database.

Please use SQL Server Management Studio or SQL scripts to achieve the same. (Ensure to have process edit access to your DB).

Example

CREATE TYPE EmployeeTypeA AS TABLE
(
        ID INT,
        NAME VARCHAR(25),
        CITY VARCHAR(50),
	COUNTRY VARCHAR(50)
);



CREATE TYPE EmployeeTypeB AS TABLE
(
        ID INT,
        NAME VARCHAR(25),
	CITY VARCHAR(50),
	COUNTRY VARCHAR(50)

);

Sample code to execute ADO.NET core for two or multiple tables using the TVP approach.

In the above code, we performed the steps in the below order.

1. We have two table employeeTableA and employeeTableB, that match the structures of EmployeeTypeA and EmployeeTypeB.
2. We establish a SqlConnection to your SQL Server.
3. We create two SqlCommands that call stored procedures, one for each table type, which use TVPs for insertion. These stored procedures should insert data from the TVPs into the respective target tables.
4. For each SqlCommand, we create a SqlParameter for the TVP, specifying the parameter name, SqlDbType (SqlDbType.Structured), and the TVP’s type name.
5. We execute the stored procedures for both EmployeeTypeA and EmployeeTypeB, which will insert the data from the DataTables into the respective tables.

Insert DataTable into SQL – Without TVP or Store Procedure (SqlBulkCopy)

If you are looking for other options like Inserting DataTable into SQL – Without TVP or Store Procedure then there is a simple approach of using SqlBulkCopy.

Synchronous SqlBulkCopy for Bulk insert

Here is a complete sample code for the same schema discussed above,

In the above code, we performed the steps in the below order.

1. We have two source tables employeeTableA and employeeTableB which needs to be inserted into SQL
2. We establish a SqlConnection to your SQL Server.
3. We consider using SQL transactions to ensure that either all or none of the data from the DataTables is inserted. If everything goes well, then only you commit the transaction.
4. For each DataTable, you create parameterized SQL queries and use SqlBulkCopy to insert the data.
5. Since using transaction, commit it to make the changes as final commit.
6. Close the SqlConnection when you’re done.

Additionally, to handle any exception please make sure to use try-and-catch blocks,

                    try
                    {
                      
                        bulkCopy.WriteToServer(employeeTableA );
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                    finally
                    {
                       
                        connection.Close();
                    }

While using SqlBulkCopy it’s recommended to use SQL transactions to ensure that either all or none of the data from the DataTables is inserted.

This approach is reasonably efficient and one of other best option along with TRV.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Insert Data Table into SQL Server database – Best Practices first appeared on TheCodeBuzz.

Today in this article, we will see how to Read files as Key value Dictionary pairs using a simple and effective approach.

Using this approach you can generate a Dictionary list of possible values.

To keep it simple we will use the below file where we have content separated by pipe delimiter.

However, the below-discussed approach can be used for other separator like comma-separated values(,) or space( ) or any other separator, etc.

Sample file

Below is a sample code of how we can read the content and create a dictionary of key values pair using Employee ID as Key and Employee Name as Value.

Below fileLineReader is each line from the target file. It read the content and split the data using the “I” pipe delimiter.

File with Pipe Delimiter

                   string[] keyvalue = fileLineReader.Current.Split('|');
                    if (keyvalue.Length == 3)
                    {
                        employeeDict.Add(keyvalue[1], keyvalue[0]);
                    }

Below sample code using File Emuerator

Parse File line with Space

string[] keyvalue = fileLineReader.Current.Split(' ');
                    if (keyvalue.Length == 3)
                    {
                        employeeDict.Add(keyvalue[1], keyvalue[0]);
                    }

Parse File line with comma-separated values

string[] keyvalue = fileLineReader.Current.Split(' ');
                    if (keyvalue.Length == 3)
                    {
                        employeeDict.Add(keyvalue[1], keyvalue[0]);
                    }

Are you dealing with a huge file that needs chunking logic to be used due to its size?

If you have a huge file size to deal with then it’s important to check the performance of the filter or query.

Kindly check below 2-3 approaches discussed below for effective chunking and converting the file into a dictionary.

Kindly visit below a few useful articles on dealing with file size,

• Read a Large File in Chunks in C# Guidelines?

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post C# Read file as Key value Dictionary pair first appeared on TheCodeBuzz.