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.

Today in this article we shall see how to use NPOI to perform Read and Write Excel files in C#.NET Core.

In our last post, we saw the usage of OpenXML SDK (open-source SDK from Microsoft) to work with Office Word, Excel, and PowerPoint.

We also looked at another easy-to-use library called EPPlus too.

Today, in this article we shall cover below using NPOI,

Please see the below references if interested to know more about them.

• Read/Write Excel file .NET Core using OpemXML SDK

• Read/Write Excel file in .NET Core using EPPlus

We shall be looking into one more simple approach to dealing with Office Excel using the NPOI .NET Core Library.

You don’t need Microsoft Office

Please note that reading and Creating Excel in C# is possible without installing Microsoft Office. Today we will see a possible and easy-to-implement approach.

Utilizing NPOI, you can efficiently manipulate data, add formatting, read existing Excel files, and add formulas.

It offers a dependable solution for Excel integration in C# applications and is actively maintained and free to use, saving time and resources for developers.

It supports several Excel file types, including.xls and.xlsx, providing versatility and compatibility with multiple Excel versions.

Getting Started

Let’s create a .NET Core project, you can choose any project template. Here we shall use the .NET Core 3.1 or .NET 6 Console project.

NuGet’s package name is NPOI.

Let’s install this package.

PM> Install-Package NPOI -Version <version>

OR

Please install from Nuget Package Manager,

Note: Please use the latest available version

Let’s look at a simple Excel file with the below column and row details. Let’s try to read the file using our NPOI API,

Read the content of the Excel file using C# NPOI

POC example as below. This ready to use API can be used in .NET Core console, or Test project or ASP.NET Core application or logic can be modified or improved as per your requirements.

static string ReadExcel()
        {
            DataTable dtTable = new DataTable();
            List<string> rowList = new List<string>();
            ISheet sheet;
            using (var stream = new FileStream("TestData.xlsx", FileMode.Open))
            {
                stream.Position = 0;
                XSSFWorkbook xssWorkbook = new XSSFWorkbook(stream);
                sheet = xssWorkbook.GetSheetAt(0);
                IRow headerRow = sheet.GetRow(0);
                int cellCount = headerRow.LastCellNum;
                for (int j = 0; j < cellCount; j++)
                {
                    ICell cell = headerRow.GetCell(j);
                    if (cell == null || string.IsNullOrWhiteSpace(cell.ToString())) continue;
                    {
                        dtTable.Columns.Add(cell.ToString());
                    } 
                }
                for (int i = (sheet.FirstRowNum + 1); i <= sheet.LastRowNum; i++)
                {
                    IRow row = sheet.GetRow(i);
                    if (row == null) continue;
                    if (row.Cells.All(d => d.CellType == CellType.Blank)) continue;
                    for (int j = row.FirstCellNum; j < cellCount; j++)
                    {
                        if (row.GetCell(j) != null)
                        {
                            if (!string.IsNullOrEmpty(row.GetCell(j).ToString()) && !string.IsNullOrWhiteSpace(row.GetCell(j).ToString()))
                            {
                                rowList.Add(row.GetCell(j).ToString());
                            }
                        }
                    }
                    if(rowList.Count>0)
                    dtTable.Rows.Add(rowList.ToArray());
                    rowList.Clear(); 
                }
            }
            return JsonConvert.SerializeObject(dtTable);
        }

After executing the above API, one can easily read all the Excel details.

• In the above example, I have used the file “testdata.xlsx” as input. I have kept this file in the output directory bin\Debug\netcoreapp3.1.

• Also if needed you can keep the file locally like ex. 
  string strDoc = @”C:\Users\Public\Documents\testdata .xlsx” .

I am showing the results as JSON out as shown below,

One can map the above output details to respective class objects using the mapping logic of their choice.

Export/Write the data to an Excel file using NPOI

We shall now look at creating or writing the data into an Excel file.

Here is the sample data/object which we want to save as an Excel file.

I am creating a new Excel file in the same project folder to keep everything simple. (Excel file will get created in the ‘bin’ folder of the project). The complete sample API is as below.

static void WriteExcel()
        {
            List<UserDetails> persons = new List<UserDetails>()
            {
                new UserDetails() {ID="1001", Name="ABCD", City ="City1", Country="USA"},
                new UserDetails() {ID="1002", Name="PQRS", City ="City2", Country="INDIA"},
                new UserDetails() {ID="1003", Name="XYZZ", City ="City3", Country="CHINA"},
                new UserDetails() {ID="1004", Name="LMNO", City ="City4", Country="UK"},
           };

            // Lets converts our object data to Datatable for a simplified logic.
            // Datatable is most easy way to deal with complex datatypes for easy reading and formatting.

            DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
            var memoryStream = new MemoryStream();
             
            using (var fs = new FileStream("Result.xlsx", FileMode.Create, FileAccess.Write))
            {
                IWorkbook workbook = new XSSFWorkbook();
                ISheet excelSheet = workbook.CreateSheet("Sheet1");

                List<String> columns = new List<string>();
                IRow row = excelSheet.CreateRow(0);
                int columnIndex = 0;
               
                foreach (System.Data.DataColumn column in table.Columns)
                {
                    columns.Add(column.ColumnName);
                    row.CreateCell(columnIndex).SetCellValue(column.ColumnName);
                    columnIndex++;
                }

                int rowIndex = 1;
                foreach (DataRow dsrow in table.Rows)
                {
                    row = excelSheet.CreateRow(rowIndex);
                    int cellIndex = 0;
                    foreach (String col in columns)
                    {
                        row.CreateCell(cellIndex).SetCellValue(dsrow[col].ToString());
                        cellIndex++;
                    }

                    rowIndex++;
                }
                workbook.Write(fs);
            }

        }

Once you execute ‘workbook.Write(fs)‘ will save the file to the ‘bin’ folder location. You can modify the location of the generated file as needed.

After executing the above API, a new Excel file will be created with the above custom objects transformed into respective Excel Columns and row details as below,

That’s all, we just learned how to import and export data to/from Excel in a simple way in a .NET Core framework-based application using the NPOI library.

Please visit the GitHub link for the complete code.

Other References :

• Read/Write Excel file .NET Core using OpemXML SDK

• Read/Write Excel file in .NET Core using EPPlus

Are you dealing with any complex scenarios? Please let me know and sound off your comments below!

Summary

The NPOI library provides us with easy control while dealing with the Office Excel file. Today we learned, how to import and export data to/from Excel in the .NET Core framework using the NPOI library.

The legacy so-called applications like Excel or Word are no more legacy and can be used on any platform using simple libraries like NPOI etc.

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# NPOI – How to Read and Write Excel files in .NET first appeared on TheCodeBuzz.

Today I am going to talk about a few simple approaches to Read CSV files in C# .NET Core framework.

We will cover multiple approaches to dealing with CSV files in C# .NET project using libraries like TinyCSVParser, CsvHelper, or TextFieldParser

We will see how to use an easy-to-use parser and convert CSV into JSON or other formats as required.

Today in this article we will cover the following aspects,

It is possible that while dealing with modern frameworks and technologies you will still need to use traditional file systems like CSV(.csv), Excel(.xlsx), Doc(.doc) or Text files(.txt).

These file systems are popular and useful means of persisting the application data.

Getting Started

Let’s create a .NET Core application.

To keep simple I have used the .NET Core console application.

I have used the .NET Core 3.1 version but the below example works in any .NET Core frameworks.

Using CSV Parser?

Today in this article, we will cover below simple to use the parser,

• TinyCSVParser

• CsvHelper

• TextFieldParser

Read CSV Using TinyCSVParser

TinyCSVParser is one of the simple and lightweight parsers for CSV Reading and parsing.

This package is available through Nuget Manager,

PM> Install-Package TinyCsvParser

It lets you parse CSV and helps you deserialize the data into proper objects too.

Here is a CSV file with data. Let’s use this file as an example,

 static void Main(string[] args)
        {
            CsvParserOptions csvParserOptions = new CsvParserOptions(true, ',');
            CsvUserDetailsMapping csvMapper = new CsvUserDetailsMapping();
            CsvParser<userdetails> csvParser = new CsvParser<userdetails>(csvParserOptions, csvMapper);
            var result = csvParser
                         .ReadFromFile(@"TestData.csv", Encoding.ASCII)
                         .ToList();
            Console.WriteLine("Name " + "ID   " + "City  " + "Country");
            foreach (var details in result)
            {
                Console.WriteLine(details.Result.Name + " " + details.Result.ID + " " + details.Result.City + " " + details.Result.Country);
            }
      }

In the above example below the line does all tricks,

var result = csvParser.ReadFromFile(@"TestData.csv", Encoding.ASCII).ToList();

The mapping class that needs to be created based on the CSV file’s Column and Row details is as below,

private class CsvUserDetailsMapping : CsvMapping<Userdetails>
        {
            public CsvUserDetailsMapping()
                : base()
            {
                MapProperty(0, x => x.ID);
                MapProperty(1, x => x.Name);
                MapProperty(2, x => x.City);
                MapProperty(3, x => x.Country);
            }
        }

A supporting model entity class UserDetails is as below,

 
public class UserDetails
    {
        public string ID { get; set; }
        public string Name { get; set; }
        public string City { get; set; }
        public string Country { get; set; }
    }

Here is the output on the console,

TinyCSVParser is a very easy-use and efficient way of handling CSV files in C#.

Using CsvHelper Parser to Read CSV files – Approach 2

Csvhelper is one of the simple and lightweight most preferred parsers for CSV Reading and writing purposes.

Please see more details here,

• CsvHelper – Read CSV files in C# .NET Core

Using TextFieldParser for CSV – Approach 3

TextFieldParser is also an easy and simple parser for reading CSV files.

You don’t really need to use any third-party software etc. as it comes with .NET Core 3.0 + above by default.

Please see more details here,

• Read CSV file in .NET Core using TextFieldParser

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 post we learned a few techniques for dealing with CSV files including reading or writing in .NET Core framework-based application.

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 Read CSV files in C# .NET Core with examples first appeared on TheCodeBuzz.

Today in this article, we will learn RESTful API Unit Testing – Best Practices.

The recent popularity of frameworks like RESTful services (WebAPI) is getting huge traction.

We must develop robust microservices with a clear focus on TDD ( Test-driven Development) by following basic Unit Testing, Integration Testing, and Functional testing as a whole.

Today in this article, we will cover below aspects,

While performing Unit testing there is always confusion in developers on what is scoped under the Unit Testing.

Today we shall see basic guidelines for WebAPI Controller Unit testing.

These guidelines revolve more around RESTFul services built using ASP.NET Core WebAPI project templates.

We shall discuss below things that are important from Controller level Unit Testing.

• Verify Inputs
• Verify Controller method Response
• Verify HTTP Status Code(static check only, don’t get confused by the Integration test)
• Verify Mocked method invocation if any
• Verify Extension method invocation if any
• Verify Annotation/Attribute if any

Here I am using the XUnit test framework but you can use a test framework of your choice.

A Controller is a Class!

Before we begin writing unit test cases for the controller, the first thing you should understand is that “Controller” is not special when it comes to Unit testing.

The controller is a class like any other class which has members like methods and properties etc.

In Unit Testing, we create an instance of the target class call its method for various inputs, and assert the result as per expectation.

//Arrange
           BooksController service = new BooksController(mockBookClient.Object);

//Act
            var result = await service.GetAsync(document.Id) as ObjectResult;
            var actualtResult = result.Value;

The only thing we do a bit differently in Controller unit testing is that of the REST response assertion additionally.

All you need to do is create an instance of the Controller class and invoke all its methods and verify I/O

Verify HTTP Status Code

Controller methods always return HTTP responses along with resource details by following the REST principles which should include Model state verification and HTTP Status Code.

Controller methods should be unit tested using assert for REST HTTP Status code.

Use the HttpStatusCode enum type to Assert the responses.

Example 1

Assert.Equal(HttpStatusCode.OK, (HttpStatusCode)result.StatusCode);

Example 2

 Assert.IsType<OkObjectResult>(result);

Above, either way, the Unit test makes our API robust and validates the implementation of the REST principle following HTTP verbs correctly.

Each Controller method should be asserted for all possible types of HTTP Status codes like,

Commonly assertions should include

• Status Code – 200 (OK)
• Status Code – 401(Unauthorized)
• Status Code -201 – Created
• Status Code – 400 (Bad Request)
• Status Code – 500 (InternalServerError )
• + Others

These assertions will ensure that the Controller method produces proper results.

Reference: Asynchronous Method Unit Testing in .NET Core

Verify API Response – Static Checking

If the controller method is returning resources, such resources should be validated for their structure.

The below example has the response cast to the actual type i.e. Book to very the schema of returned responses.

//Act
           var result = await service.GetAsync(document.Id) as ObjectResult;
           var actualtResult = result.Value;
//Assert
            Assert.Equal(document.Author, ((Book)actualtResult).Author);
            Assert.Equal(document.BookName, ((Book)actualtResult).BookName);
            Assert.Equal(document.Id, ((Book)actualtResult).Id);

• This will ensure that the code follows a contract properly when the consumer consumes your API.

• This schema assertion will red flag the code while development if there are any breaking changes.

Reference: Asynchronous Method Unit Testing in .NET Core

Verify Mocked/Extension invocation

Always assert if mocked methods are invoked at least once. The mocked method is the dependency that is avoided intentionally to concentrate only on the unit of work in isolation.

Example:

Verifying for the above code if the GetBooksAsync method which is a dependency (mocked) is called once.

mockBookClient.Verify(c => c.GetBookAsync(It.IsAny<string>()), Times.Once);

Reference: Unit Testing Extension Method in ASP.NET Core

Verify Business exception

API responses are critical as there will be consumers using the same as criteria. One can cross-check if business exception messages are raised appropriately.

Most business exceptions will be based on the HTTP status code giving an indication of the resource state. This static check on the return type will make your code robust.

Reference: Asynchronous Method Unit Testing in .NET Core

Verify Attributes for the Controller method

There is absolutely no problem in adding more test cases including Custom attribute validation or [Authorize] attribute validation within the Unit Test cases.

References: Unit Testing Authorize Attribute ASP.NET Core

Mark your Test method as Async

As good practice mark your Unit test method as async if Controller methods are Asynchronous in nature.

Your test cases are a state machine. Your test suite in any form will protect your code from anomalies and breaking changes apart from making new code robust and compatible with existing code.

-TheCodebuzz

On the good side of unit test cases, you need not have wait for the integration of different modules ( require in Integration test and real API Test) helping in real-time identifying the breaking changes.

Most Unit test cases run as you type your code, hence it is easy to be tested or identify breaking changes.

We are in the world of XP practices and Continuous Development, Continuous review, and Continuous deployment is the way to go.

Do you have any better suggestions to test the Controller method? Please sound off in your comments below.

That’s all, Happy Coding!

Summary

Today in this article, we learned helpful guidelines on Controller or RESTFul API Unit testing. It’s important to unit-test all possible scenarios for a Controller to make our API robust.

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 RESTFul API Unit Testing – Best Practices first appeared on TheCodeBuzz.

This article explains an easy approach on how to get the Current User in ASP.NET Core.

You may find a need to get a logged-in username using your application in the IIS or Cloud-hosted app.

One can easily get the current user name from HttpContext in ASP.NET Core provided user details are transferred for the given session using cookies or other means. etc.

Today in this article, we will cover below aspects,

Below are the basic steps that need to be followed.

Using HTTPContext metadata

HTTPContext lets you access its metadata configured when the request reaches ASP.NET Core API.

This HttpContext sets the various headers including Username and password etc.

This context however also depends on the type of Authentication and Authorization schemes being used to validate the Users.

Getting Current UserName in Controller

Getting UserName in Controller is easy as you can directly access the HttpContext object within Controller.

You need to access HttpContext.User.Identity.Name the property to access the username.

Update Get method for the below code,

        [HttpGet]
        public ActionResult<IEnumerable<string>> Get()
        {
            UserName = HttpContext.User.Identity.Name;
            return Ok(UserName);
        }

Access current UserName in Repository or other Custom Components

Access the current Username in the Repository or other Custom modules using HttpContextAccessor.

HttpContextAccessor lets you access HTTPContext and its metadata in any other module.

Update ConfigureServices() in Startup.cs as below,

.NET Core 3.1 and Above( .NET 5 or .NET6 )

For the .NET Core version 3.1 and above and lower, please register the service for IHttpContextAccessor as below.

 public virtual void ConfigureServices(IServiceCollection services)
        {

            services.AddControllers();
            services.AddHttpContextAccessor();

        }

.NET Core 3.0 and lower version

For the lower version of .NET Core like .NET Core 2.2 and lower, please register the service for IHttpContextAccessor as below.

  public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
            
        }

Dependency Inject (DI) interface IHttpContextAccessor in the Constructor as below,

     

class EmployeeRepository : IEmployeeRepository
      {
        private readonly IHttpContextAccessor _httpContextAccessor;

        public EmployeeRepository( IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor;
        }
...
      }

Getting UserName in Method

  

class EmployeeRepository : IEmployeeRepository
    {
        private readonly IHttpContextAccessor _httpContextAccessor;

        public EmployeeRepository( IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor;
        }

Or Access HttpContext.User.Identity.Name in a method,

Getting UserName in API Middleware

Similarly if needed you can read UserName in the middleware component by accessing HttpContext.

Note:

If you are trying to get a user name using the user identity then please follow the below configuration and the set authentication mode as Windows.

Below configuration let HttpContext.Current.User.Identity.Name set using the usernames logged in.

If Hosting in IIS Server – Set Authentication mode as Windows

This is the preferred setting for IIS-hosted services also where anonymousAuthentication needs to be set as false.

And Set the WindowsAuthentication as true.

"windowsAuthentication": true,
"anonymousAuthentication": false

If Debugging locally

If debugging locally to verify, Please update the launchSettings.json file for the Windows authentication setting as true in the ‘iisSettings’ section as below.

windowsAuthentication”: true,

“anonymousAuthentication”: false

HttpContext.User.Identity.Name is empty

If the above-discussed setting is not followed then you will get HttpContext.User.Identity.Name as empty or null.

Cloud-hosted app Windows authentication will also work if enabled with Windows Authentication using the Active Directory (AD group) or by following other security policy with in the enterprise infrastructure which let you sync up your User IDs with Server/Cloud.

Most enterprise Application uses secured cookies and session token details (with the help of redirection from their intranet sites to the cloud hosted web applicaiton) to send the actual user name logged in to an application.

HttpContext is not threadsafe so please follow the below additional guidelines for its proper usage,

References:

• HttpContext Threadsafety and Usage 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 How to Get the Current User in ASP.NET Core first appeared on TheCodeBuzz.