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 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.

Today in this article, we will see how to use MailKit a C# .NET library.

We will send emails in ASP.NET Core using MailKit. We will use ASP.NET .NET 6 application examples.

We shall also see how to send an email using attachments i.e. we will attach files like PDF or HTML or Images or Word doc files etc as attachments to emails we are sending to our users.

We will cover the below aspects in today’s article,

I was looking to build send email functionality as a Service using C# .NET Core 3.1 recently using MailKit.

The service’s core functionality was to send emails using the registered SMTP server.

As per Microsoft Send emails using SmtpClient is good for one-off emails from tools but doesn’t scale to modern requirements of the protocol.

It’s recommended to use MailKit or MimeKit or other libraries for any scaled and additional protocol requirements.

So if the requirement is simple enough to send an email SmtpClient approach will still work for you.

I found that .NET Core has full support for email functionality using MailKit.

Let’s send an email from the Gmail mail server (smtp.gmail.com) to another domain (infoATthecodebuzz.com) for this article.

I have used my own Gmail for sending an email and testing purposes which worked very well after some initial travail.

MailkIt gives RFC-compliant SMTP, POP3, and IMAP client implementations.

Getting Started

Create ASP.NET Core 3.1 or .NET 6.0 API

Please add below Nuget packages to the project,

PM> Install-Package MailKit -Version <version>

Note– Please use the latest available version.

We shall be using the POST method for sending out an email.

Please add the below namespace to your file,

using MailKit.Net.Smtp;


using MimeKit;

Let’s write the below code for the POST method.

Send Email in ASP.NET Core using MailKit – Define MimeMessage structure

As a first step please define the MimeMessage structure.

A message structure consists of header fields and a body. The body of the message can be plain text or a tree of MIME entities.

var message = new MimeMessage();
                message.From.Add(new MailboxAddress("TheCodeBuzz", "xxxx@gmail.com"));
                message.To.Add(new MailboxAddress("TheCodeBuzz", "infoATthecodebuzz.com"));
                message.Subject = "My First Email";
                message.Body = new TextPart("plain")
                {
                    Text = emailData
                };

Define SMTP C# MailKit Client

Let’s now define the SMTP MailKit client.

We shall pass the MimeMessage object to the Send() API as below,

using (var client = new MailKit.Net.Smtp.SmtpClient())
          {
                       client.Connect("smtp.gmail.com", 587, false);
                        //SMTP server authentication if needed
                        client.Authenticate("xxxx@gmail.com", "xxxxx");
                        client.Send(message);
                        client.Disconnect(true);
                       
          }

Above GMAIL SMTP using 587 as a standards port for the communication.

Complete the POC example demonstrating the usage as below.

You can very much use the below code in any module as suitable to your layered code structure.

Example

        [HttpPost]
        public ActionResult<IEnumerable<bool>> 
        SendEmail([FromBody] string emailData)
        {
            try
            {
                var message = new MimeMessage();
                message.From.Add(new MailboxAddress("TheCodeBuzz", "xxxx@gmail.com"));
                message.To.Add(new MailboxAddress("TheCodeBuzz", "infoATthecodebuzz.com"));
                message.Subject = "My First Email";
                message.Body = new TextPart("plain")
                {
                    Text = emailData
                };
                
                    using (var client = new MailKit.Net.Smtp.SmtpClient())
                    {
                        client.Connect("smtp.gmail.com", 587, false);
                        //SMTP server authentication if needed
                        client.Authenticate("xxxx@gmail.com", "xxxxx");
                        client.Send(message);
                        client.Disconnect(true);
                    }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return StatusCode(500, "Error occured");
            }
            return Ok(true);
        }

Send Email with Attachment (HTML or . JPEG or . PDF files)

We often need to send an email with custom attachments like PDF, HTML, Images, or Excel files along with custom text bodies.

Using MimeKit.BodyBuilder

BodyBuilder from MimeKit is a helper class for building common MIME body structures and provides you the flexibility to build message structures…

Please see below how to use the BodyBuilder class.

Sending multiple Attachments using MailKit

MimeKit.BodyBuilder lets you send multiple attachments in email. Please update the above message.

The body which is defined for text only as below for both text and attachments like pdf and jpeg as shown below,

Using Gmail SMTP server with MailKit

For the Gmail SMTP server, the above code worked perfectly for me except I had to update a few security settings as mentioned below.

Initially, you might get the below error,

” The SMTP server requires a secure connection or the client was not authenticated. The server response was: 5.5.1 Authentication Required. “

Gmail by default prevents you from accessing your e-mail account from external applications.

But you can update your security settings to accept the login from the application.

I got an email from Gmail saying “Critical security alert for your linked Google Account”.

• I had to enable “Allow less secure apps: ON” to make the send email API work properly.

Such errors are more due to the policy configured on the SMTP email server.

Make sure you are following the proper settings and policies required for a secure connection to connect to the SMTP server.

Finally, an email popped up successfully in my other domain mail Inbox from my Gmail ID.

Retrieving Messages (via Pop3)

Apart from sending emails MaiKit library also provides support for retrieving messages from pop3 servers.

Retrieving Messages (via IMAP )

MailKit library also provides full support for retrieving messages from IMAP servers.

Other Advantages of MailKit

Wide Email Protocol Support:

MailKit provides support for multiple email protocols, including SMTP (for sending emails), POP3 (for receiving emails), and IMAP (for more advanced email operations like folder management and searching).

Open-Source and Cross-Platform:

MailKit is an open-source library, available under the MIT License, making it freely accessible to developers.

High Performance and Efficient:

MailKit is designed to be high-performance and efficient, optimized for handling large volumes of email messages. It utilizes asynchronous programming patterns (async/await) to avoid blocking threads and ensure responsiveness in applications.

Extensive MIME Support:

MailKit provides extensive support for MIME (Multipurpose Internet Mail Extensions) and allows developers to work with multipart emails, attachments, inline images, and other MIME-related functionalities.

Secured Email Communication:

MailKit supports secure communication using SSL/TLS protocols, enabling secure connections to email servers and protecting email communication from eavesdropping or interception.

MailKit is designed to be high-performance and efficient, optimized for handling large volumes of email messages.

It utilizes asynchronous programming patterns (async/await) to avoid blocking threads and ensure responsiveness in applications.

Differences between SMTP Vs MailKit

Please here to understand the high-level differences between SMTP Vs MailKit

Other references :

• Send Email using SMTP .NET client

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

Please sound off your comments below.

Happy Coding !!

Summary

Today in this article we learned how to send an email message using MailKit a .NET open-source library. We understand traditional SMTPClient is now obsolete and it’s recommended to use MailKit or MimeKit for scaled and additional protocol requirements.

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 Send Email in ASP.NET Core using MailKit with Attachments first appeared on TheCodeBuzz.

IndexOutOfRangeException is specific to arrays and collections, indicating attempts to access elements using invalid indices.

ArgumentOutOfRangeException is a more general-purpose exception used for parameter validation in method calls, signifying that provided arguments do not meet expected criteria.

Understanding when and how to use these exceptions is essential for writing robust and error-tolerant C# code, whether you’re working with collections or method parameters.

In this comprehensive comparison, we’ll explore their differences in depth.

IndexOutOfRangeException

IndexOutOfRangeException is an exception that is specifically associated with operations involving arrays or collections.

This exception is thrown when you attempt to access an element in an array or collection using an index that is outside the valid range of indices for that particular array or collection.

Key Characteristics of IndexOutOfRangeException

Array or Collection Indexing

This exception is primarily related to the indexing of arrays, lists, and other collection types in C#. It deals with scenarios where you’re trying to access elements using an index.

Zero-Based Indexing

Most arrays and collections in C# use zero-based indexing. In zero-based indexing, the first element has an index of 0, the second element has an index of 1, and so on. The last element’s index is equal to the length of the array minus one (Length - 1).

Common Causes of Exception

The most common cause of IndexOutOfRangeException is attempting to access an element using an index that is either less than 0 or greater than or equal to the length of the array or collection. This means you’re trying to access an element that doesn’t exist within the valid range of indices.

Example of IndexOutOfRangeException

int[] numberList= { 1, 2, 3 };


int value = numberList[4]; // Throws IndexOutOfRangeException

In this example, we have an array numbers with three elements.

However, when we try to access numbers[4], we’re attempting to access an element at index 3, which is outside the valid range of indices (valid indices for this array are 0, 1, and 2).

This results in an IndexOutOfRangeException.

ArgumentOutOfRangeException

ArgumentOutOfRangeException, on the other hand, is a more general-purpose exception that can be used in various contexts beyond just arrays and collections.

It is thrown when a method or constructor is invoked with an argument (parameter) that falls outside the valid range of acceptable values as defined by the method’s documentation or expectations.

Key Characteristics of ArgumentOutOfRangeException :

Method Parameters

This exception typically arises when validating method parameters. It is thrown to indicate that an argument passed to a method is not within the expected range of valid values.

Custom Validation

Developers often use ArgumentOutOfRangeException to perform custom parameter validation, ensuring that inputs meet certain criteria or constraints defined by the method or constructor.

Common Causes

The most common causes of ArgumentOutOfRangeException include passing an out-of-range value to a method parameter that expects a specific range of values or violating any other parameter-related validation rules defined by the method.

Example of ArgumentOutOfRangeException:

void SetAngle(int angle )
{
    if (angle  < 0 || angle > 360)
    {
        throw new ArgumentOutOfRangeException(nameof(angle ), "Angle is out of range.");
    }
    // other logic
}

In this example, we have a method SetAngle that expects an integer parameter angle.

The method intends to set the angle, but it has a validation check that ensures the angle is within a valid range (0 to 360 degrees).

If the provided anglevalue falls outside this range, an ArgumentOutOfRangeException is thrown with a custom error message.

Characteristic – Context and Use Cases

Now that we’ve looked at the individual characteristics of IndexOutOfRangeException and ArgumentOutOfRangeException, let’s compare them more comprehensively:

Context and Use Cases

• IndexOutOfRangeException: It is specific to array and collection indexing operations. It is used when you attempt to access elements in an array or collection using indices.

• ArgumentOutOfRangeException: It is a more general-purpose exception used for parameter validation in method calls. It is thrown when method parameters fall outside the expected range of valid values.

Source of Exception

• IndexOutOfRangeException: Typically originates from indexing operations (e.g., array[index], list[index]) where the index provided is invalid.

• ArgumentOutOfRangeException: Originates from the method or constructor invocations when an argument provided as a parameter does not meet the expected criteria.

Typical Causes of Exception

• IndexOutOfRangeException:
  • Accessing an array or collection with an index less than 0.
  • Accessing an array or collection with an index greater than or equal to its length or count.
  • Attempting to access an element in an empty collection.

• ArgumentOutOfRangeException:
  • Passing arguments to a method or constructor that fall outside the acceptable range of values defined by the method’s contract.
  • Violating parameter-related validation rules defined by the method or constructor.

Use in Parameter Validation

• IndexOutOfRangeException: Not typically used for parameter validation. It’s more focused on array and collection indexing scenarios.

• ArgumentOutOfRangeException: Commonly used for parameter validation to ensure that arguments provided to methods or constructors adhere to predefined constraints.

Custom Error Messages

• IndexOutOfRangeException: While you can catch and handle this exception, it is not typically used to provide custom error messages, as it is more concerned with the invalid index itself.

• ArgumentOutOfRangeException: It is often used to provide detailed custom error messages that explain why the provided argument is out of range or violates other validation rules.

Handling and Prevention

• IndexOutOfRangeException: To prevent this exception, ensure that you use valid indices when accessing array or collection elements. You can handle it by checking array or collection lengths before indexing or using methods like Enumerable.ElementAtOrDefault().

• ArgumentOutOfRangeException: To prevent this exception, perform thorough parameter validation and document the expected valid ranges for method parameters. Handle it by including validation checks within the method or constructor.

Conclusion

IndexOutOfRangeException and ArgumentOutOfRangeException are exceptions in C# with distinct purposes and use cases. IndexOutOfRangeException is specific to arrays and collections, indicating attempts to access elements using invalid indices. ArgumentOutOfRangeException is a more general-purpose exception used for parameter validation in method calls, signifying that provided arguments do not meet expected criteria.

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 Differences IndexOutOfRangeException and ArgumentOutOfRangeException first appeared on TheCodeBuzz.

Today in this article, we will understand ServiceFilter and TypeFilter differences in .NET.

In .NET Core, both ServiceFilter and TypeFilter are used for implementing filters, which are an easy way to address any cross-cutting concerns to the execution pipeline of an application.

There are many benefits of Filters as explained below,

Benefits of Filters

• Abstract your repetitive and important cross-cutting concern to commonplace.
• Make your business logic free of addressing those concerns implicitly
• As we know “Code is more often read than write”. The code becomes easy to read and understand.
• Developers can better focus on implementing business functionality.

While they serve a similar purpose, there are some differences between ServiceFilter and TypeFilter

When to Use Scenarios

• ServiceFilter: This Filter can be applied to a service or middleware during dependency injection. It allows applying the same filter to multiple services or middleware components.

• TypeFilter: This Filter directly to a controller or action method i.r classes and methods, providing more fine-grained control over which specific components the filter is applied to.

Reusability of Filter

ServiceFilter – Better Reusability

ServiceFilter provides flexibility and reusability because it can be applied to multiple services or interfaces.

You can register a filter as a service and then apply it to multiple services during dependency injection configuration.

This allows you to define a filter once and reuse it in multiple places.

TypeFilter – Normal Reusability

TypeFilter is more specific to individual classes or methods.

It is typically used when you need to apply a filter to a specific class or method and do not require its reuse in other parts of the application.

Filter Configuration

ServiceFilter

Since the ServiceFilter uses the ServiceProvider to resolve the instance of the filter. Instance lifetime can be controlled by registering the filter in the startup class.

ServiceFilter can be registered as a service in the dependency injection container using the AddScoped, AddTransient, or AddSingleton methods.

 public void ConfigureServices(IServiceCollection services)
        {
            // Add service filters.
            services.AddScoped<AddHeaderResultServiceFilter>();
            services.AddScoped<SampleActionFilterAttribute>();
         .
         .
         }

The registered filter can then be applied to services or middleware components by specifying the filter using the [ServiceFilter] attribute or the .AddServiceFilter() method.

Example :

        [ServiceFilter(typeof(SampleActionFilterAttribute))]
        public IActionResult ServiceFilterTest()
        {
            return Content($"From ServiceFilterTest");
        }

Dependency Injection of additional parameters

ServiceFilter allows you to inject additional parameters into the filter constructor when applying it at the service registration level.

These additional parameters can be resolved from the dependency injection container and provided to the filter constructor.

TypeFilter supports the constructor injection of additional parameters through attributes.

You can pass parameters to the filter by providing them as arguments in the attribute declaration.

Example

 [TypeFilter(typeof(CustomFilter), Arguments = new object[] { "id", 123 })]. 

These parameters are then passed to the filter’s constructor.

Summary

ServiceFilter is used to apply filters at the service registration level in the startup class and while TypeFilter is used to apply filters directly to specific classes or methods.

The choice between ServiceFilter and TypeFilter depends on whether you need to apply a filter globally to services/interfaces or selectively to individual classes/methods.

Service filter allows greater reusability and flexibility comapre to TypeFilter.

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 ServiceFilter and TypeFilter differences in .NET first appeared on TheCodeBuzz.