DEV Community: shariaretanvir

Custom Middleware in .Net core

shariaretanvir — Mon, 27 Sep 2021 19:11:13 +0000

There are basically two ways to implement custom middleware outside of startup class. In real world it’s not recommended to write middleware inside startup class. In this article I will show those two ways to implement custom middleware.

Custom middleware in a separate class

So create a new class named MyCustomMiddleware and in the constructor initialize the RequestDelegate. Inside the class create a method named InvokeAsync which will call the next middleware and do some changes in the application. Here is the code.

    public class MyCustomMiddleware
    {
        private readonly RequestDelegate next;

        public MyCustomMiddleware(RequestDelegate next)
        {
            this.next = next;
        }

        public async Task InvokeAsync(HttpContext context) {
            await context.Response.WriteAsync("In custom middleware\n");
            await next.Invoke(context);
        }
    }

Now we need to register this class as a custom middleware. For that we need to extend the implementation of IApplicationBuilder interface. In the method body we have to register our middleware into the application pipeline by using UseMiddleware method.

    public static class MiddlwareExtensions
    {
        public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder app)
            => app.UseMiddleware<MyCustomMiddleware>();
    }

At the end we have to modify our Configure method in the startup class by this.

app.Use(async (contect, next) =>
            {
                await contect.Response.WriteAsync("Use middleware 1 start\n");
                await next.Invoke();
                await contect.Response.WriteAsync("Use middleware 1 end\n");
            });
            app.UseCustomMiddleware();

app.Run(async context =>
            {
                await context.Response.WriteAsync("Run middleware\n");
            });

When we run the application we can see our middleware get executed. And the results looks like this.

Using IMiddleware interface

Imiddleware interface have the invoke method by which we can get access both HttpContext and RequestDelegate. So we don’t need to create constructor for initializing delegates.
There are some benefits using this approach like

Application activates our custom middleware as per request as we register our middleware in the service as Transient.
We can use strongly type with our middleware

public class FactoryBasedCustomMiddleware : IMiddleware
    {
        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
        {
            await context.Response.WriteAsync("Factory based custom middleware.\n");
            await next.Invoke(context);
        }
    }

Now as before we have to register our custom middleware class to the IApplicationBuilder.

public static class MiddlwareExtensions
    {
        public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder app)
            => app.UseMiddleware<MyCustomMiddleware>();

        public static IApplicationBuilder UseFactoryBasedCustomMiddleware(this IApplicationBuilder app)
            => app.UseMiddleware<FactoryBasedCustomMiddleware>();
    }

Also change the Configure method like before.

app.Use(async (contect, next) =>
            {
                await contect.Response.WriteAsync("Use middleware 1 start\n");
                await next.Invoke();
                await contect.Response.WriteAsync("Use middleware 1 end\n");
            });
            app.UseCustomMiddleware();
            app.UseFactoryBasedCustomMiddleware();
app.Run(async context =>
            {
                await context.Response.WriteAsync("Run middleware\n");
            });

But in this approach we need to register our middleware class as a service in the ConfigureServices method.

services.AddTransient<FactoryBasedCustomMiddleware>();

Now the output will looks like this and we can see that both our custom middleware will execute.

Both of this approach is easy to implement.

Feel free to comment and let me know your opinion about those approach.

Middleware in .Net core

shariaretanvir — Mon, 27 Sep 2021 19:03:18 +0000

Asp.net core middleware is a software component integrated with application pipeline that we can use to handle http requests and responses. It’s a very important concepts in .net core environment. In .net core middleware are used in the configure method on startup class. We can also use custom middleware in that section. There are couple of ways to implement custom middleware which I will cover in another article.

There are mainly 3 methods by which we can manage middleware in our application.

Run()

This middleware is basically used at the end of the pipeline. It adds a terminal component in the pipeline. It has a single parameter which takes request delegates. It doesn’t has any next delegate as it terminates the pipeline.

Example

 app.Run(async context =>
   {
      await context.Response.WriteAsync("Started");
   });

Here we use run method and in the output we will see Started. After executing run method no other middleware will be executed as it return back to the pipeline process.

Use()

To use multiple middleware we can use this method. It takes 2 parameters, one is request delegate another one is next delegates. Next is used to call the next middleware in the pipeline.

Example

app.Use(async (contect, next) => {
                await contect.Response.WriteAsync("Use middleware 1 start\n");
                await next.Invoke();
                await contect.Response.WriteAsync("Use middleware 1 end\n");
            });

            app.Use(async (context, next) => {
                await context.Response.WriteAsync("Use middleware 2 start\n");
                await next.Invoke();
                await context.Response.WriteAsync("Use middleware 2 end\n");
            });

            app.Run(async context =>
            {
                await context.Response.WriteAsync("Run middleware\n");
            });

            app.Use(async (context, next) => {
                await context.Response.WriteAsync("Use middleware 3 start\n");
                await next.Invoke();
                await context.Response.WriteAsync("Use middleware 3 end\n");
            });

Here we can see multiple use middleware and those are communicating to each other. So in the postman output will be like this.

Use middleware 1 start
Use middleware 2 start
Run middleware
Use middleware 2 end
Use middleware 1 end

One major thing to notice is that middleware 3 is not executing after run middleware. That’s because run doesn’t call next middleware and it terminates the cycle and return back to the upper middleware.

Map()

Map function is used to branch the middleware. When a request comes with a specific path then map function is execute. When the path get matched the in the map function we can use use and run method to execute the middleware.

app.Use(async (contect, next) => {
                await contect.Response.WriteAsync("Use middleware 1 start\n");
                await next.Invoke();
                await contect.Response.WriteAsync("Use middleware 1 end\n");
            });
            app.Map("/getdata", builder =>
            {
                builder.Use(async (context, next) =>
                {
                    await context.Response.WriteAsync("Map middleware start\n");
                    await next.Invoke();
                    await context.Response.WriteAsync("Map middleware end\n");
                });
                builder.Run(async (context) =>
                {
                    await context.Response.WriteAsync("Map Run middleware\n");
                });
            });

So when we call /getdata we can see the following output.

Use middleware 1 start
Map middleware start
Map Run middleware
Map middleware end
Use middleware 1 end

That’s because after the use function get called map middleware will get executed and in the map function there are two function. When run method get executed middleware get terminated and no other middleware will execute.

MapWhen()

Mapwhen function is used to branch the pipeline depending of the given predicate. When the condition returns true then this function executes.

app.Use(async (contect, next) => {
                await contect.Response.WriteAsync("Use middleware 1 start\n");
                await next.Invoke();
                await contect.Response.WriteAsync("Use middleware 1 end\n");
            });

app.MapWhen(context => context.Request.Query.ContainsKey("token"), builder =>
            {
                builder.Use(async (context, next) =>
                {
                    await context.Response.WriteAsync("Use map start\n");
                    await next.Invoke();
                    await context.Response.WriteAsync("use map end\n");
                });
                builder.Run(async context =>
                {
                    await context.Response.WriteAsync("use map run executes");
                });
            });

If we request with the query string contains token then web can see the output given below.

You can see the request link as it contains key name token.

If we have several middleware but not having token query string then those middleware will not execute.

So those are the core concepts of .net core middleware. We can use those concepts to build our custom middleware and use it to our application.

Summery

Middleware is a component which has the ability to access incoming request and responses.
It can communicate to another middleware.
It has an order in which it executes.
We can terminates middleware whenever we want to.
Common functionality like log, exception handling, authentication, and authorization based components can be a proper example for using middleware. In the next article I will be covering how to create custom middleware and incorporate with the application.

IDisposable pattern in .Net Core

shariaretanvir — Sat, 11 Sep 2021 12:48:24 +0000

In .Net we have two kind of resources.

Managed resource
Unmanaged resource

To understand IDisposable pattern we need to understand those concepts.

Managed resource

Managed resource are those which are created and handled by CLR (common language runtime). Garbage collector do a very pretty job to clean up the managed resources. We don’t need to manually clean those resources.

Unmanaged resource

Unmanaged resource are those which are outside of the scope of CLR (common language runtime). Garbage collector most of the time cannot clean up those resources. We developer need to manually clean those resources as soon as they are done.

To handle unmanaged resources .Net give us IDisposable interface. We have to use that pattern to clean
Unmanaged resources.

So to implement IDisposable pattern we have to inherit that interface and implement the pattern. Basic code looks like this. I will explain each line step by step.

public class Excel : IDisposable
    {
        public string FileObject { get; set; }
        public string ConnectionObject { get; set; }

public void OpenExcelFile()
        {
            FileObject = "demo";
            //open excel from specific file path.
            //creating unmanaged resources
        }

        public void OpenManageonnection()
        {
            ConnectionObject = "Managed Connection opened";
        }

}

This is my class which implement IDisposable interface. Here I created demo managed and unmanaged class just to show the purpose of this tutorial. As you can see I have created both resources, now it’s the time to implement pattern. After implementing the pattern we can see the two methods.

Dispose

public void Dispose()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

Dispose is the main method which gets called when someone implement dispose method by finally scope or using statements. What dispose does is to call dispose method which is virtual and it can be inherited by child classes. This is the dispose virtual method.

protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: dispose managed state (managed objects)
                    Console.WriteLine("managed object clean");
                    ConnectionObject = "";
                }

                // TODO: free unmanaged resources (unmanaged objects) and override finalizer
                // TODO: set large fields to null
                if (FileObject != "")
                {
                    Console.WriteLine("unmanaged object clean");
                    FileObject = "";
                }


                disposedValue = true;
            }
        }

This method gets called by Dispose with true value and also get called by Finalizer with false value. disposedValue is a local flag value which get track that this method can only execute once. So if the disposing is true then both managed and unmanaged objects will cleaned up. disposedValue then set to true so that it won’t execute again.

After disposing we have to set that object as it won’t get into the finalizing queue and doesn’t get cleaned again. So we need to call GC for that.

GC.SuppressFinalize(this);

This will do the job for us.

Initialization of Dispose pattern

In the calling method we can simply call this class like this

static void Main(string[] args)
 {
using (Excel excel = new Excel())
            {
                excel.OpenExcelFile();
                excel.OpenManageonnection();
            }
}

Using statement will automatically call the dispose method of Excel class and thus cleaned up the memory of this class.

Finalizer

Finalizer in C# get called by Garbage collector to remove unmanaged resources. But we already clean our resource. But what will happen when developer forget to using the using statement? Then those resources won’t get cleaned. This is what finalizer is useful.

GC automatically call finalizer to clean unmanaged resources. So even if we forgot to clean the unmanaged resources GC will take care if we use finalizer.


        ~Excel()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Console.WriteLine("Finilizing");
            Dispose(disposing: false);
        }

As we can see in finalizer method we call dispose method with false value, which will only clean the unmanaged resources. We don’t need to worry about managed resources, GC will simply take care of that.

So now the IDisposable pattern is complete. We can put some custom code in dispose method if we wish.

The full implementation is looks like that.

public class Excel : IDisposable
    {
        private bool disposedValue;
        public string FileObject { get; set; }
        public string ConnectionObject { get; set; }
        public void OpenExcelFile()
        {
            FileObject = "demo";
            //open excel from specific file path.
            //creating unmanaged resources
        }

        public void OpenManageonnection()
        {
            ConnectionObject = "Managed Connection opened";
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: dispose managed state (managed objects)
                    Console.WriteLine("managed object clean");
                    ConnectionObject = "";
                }

                // TODO: free unmanaged resources (unmanaged objects) and override finalizer
                // TODO: set large fields to null
                if (FileObject != "")
                {
                    Console.WriteLine("unmanaged object clean");
                    FileObject = "";
                }


                disposedValue = true;
            }
        }

        // // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
        ~Excel()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Console.WriteLine("Finilizing");
            Dispose(disposing: false);
        }

        public void Dispose()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: true);
            Console.WriteLine("disposing start");
            GC.SuppressFinalize(this);
        }
    }

It is recommended if you don’t have any unmanaged resource then don’t use Finalizer as it is a costly process which may hamper performance.

If you have any feedback about this topic feel free to comment.

Use of Static class in .Net core

shariaretanvir — Sat, 11 Sep 2021 07:41:13 +0000

We all know about static class. When we use data which will not change according to caller then we can mark that as static.

Today I will show an example to use static class in .Net core. We can use static class for retrieving common information like appsettings or database connection information.

So we need to create a class named DBConnection.cs. We all know for accessing appsettings.json in .Net core we need to implement IConfiguration interface. IConfiguration can be accessed in controller using construction which is done by Dependency injection. Here is the example of this:

public class MyController : ControllerBase
    {
        public IConfiguration Configuration { get; }
        public IWebHostEnvironment Environment { get; }

        public MyController(IConfiguration configuration, IWebHostEnvironment environment, IUnitOfWork unitOfWork)
        {
            Configuration = configuration;
            Environment = environment;            
        }
}

But IConfiguration is not automatically accessed in any custom class other than controller, but we have to need that object to getting data from appsettings.json.

So our static class will do that for us. Why we use static class for this? Because this data will not be changed or need to modified by caller methods. If you still get confused read my article about static keyword where I briefly describe about static and when to use static and when not to.

So here is my code for accessing IConfiguration.

public static class DBConnection
    {
        private static IConfiguration config;
        public static IConfiguration Configuration {
            get {
                var builder = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile("appsettings.json");
                config = builder.Build();
                return config;
            }
         }
}

So now any class can access IConfiguration object by calling our DBConnection class like this

string connectionString =  DBConnection.Configuration.GetSection("LiveConnectionStrings:CapitalMarketDB").Value;

Now we can also get the common information like DBPath, Connection string from our DBConnection static class.

public static string DBPath {
            get {
                return Configuration.GetSection("DBPath:Environment").Value;
            }            
        }

        public static string GetCapitalMarketConnectionString()
        {            
            return DBPath == "UAT" ? Configuration.GetSection("UATConnectionStrings:CapitalMarketDB").Value
                : Configuration.GetSection("LiveConnectionStrings:CapitalMarketDB").Value;
        }
        public static string GetCommonDBConnectionString()
        {
            return DBPath == "UAT" ? Configuration.GetSection("UATConnectionStrings:CommonDB").Value
                : Configuration.GetSection("LiveConnectionStrings:CommonDB").Value;
        }

SO this is a real life example of static class which is implemented on .Net perspective.

Feel free to comment and share your views about this article.

When to use static and when not to in C#

shariaretanvir — Sat, 11 Sep 2021 07:36:42 +0000

In the last post I talked about static keyword. Today I will write about the usage of static. I recommend first read that article where you can get a brief idea about static before read this article.

When to use static in C#

Static provide an easy way to call methods and fields.
Method which doesn’t work differently for different objects can be used as static.
App configuration class can be a good example for static class/methods. Because it stays same throughout the application.
Database Connection string is another good use case of static method.
Static members make code cleaner.
Mainly utility kind operations should be mark as static.

When not to use static in C#

Static hinders unit testing.
Static missing OOP concepts including abstractions.
Do not use static when the class or field is going to change according to caller class.
Async or multithreading sometimes conflicts with static, mostly if someone mark data access layer as static(which is not recommended)

All about Static in C#

shariaretanvir — Sat, 11 Sep 2021 07:28:41 +0000

What is static means?
In real world static means something which is stable or sort of fixed. Something which will act similarly in all aspects.

In C# static is a keyword which makes a member, property, method, constructor or class as a static which we will understand one by one.

Static class
When we put static keyword on a class it becomes static class. And we cannot instantiate a static class. As a result a static class cannot be inherited by another class.

Example:

public static class Calculator
    {
        public static double Result { get; set; }
        public static string Mode { get; set; } = "Normal";
        public static double Add(double num1 , double num2)
        {
            return num1+num2;
        }

        public static void SaveResult(double result)
        {
            Result = result;
        }
    }

In calling function

double result = Calculator.Add(10,20);
            Calculator.SaveResult(result);
            Console.WriteLine("Latest Result {0} ",Calculator.Mode);

As we can see to call a static class we do not need to instantiate an instance.
Important things to note

Static classes cannot be instantiated.
All the members of a static class must be static; otherwise the compiler will give an error.
A static class cannot contain instance members and constructors.
Static classes are sealed class and therefore, cannot be inherited.
Static class members can be accessed using ClassName.MemberName.
A static class remains in memory for the lifetime of the application domain in which your program resides.

Static members:
Properties and field having static keyword called static members. Static members can be use inside non static class also. Usually we can use static members when there is like constant or fixed value.
Example :

public class Employee
    {
        public int EmployeeID { get; set; }
        public string Name { get; set; }
        public string CompanyName { get; set; }
        public static string Nationality { get; set; } = "Bangladeshi";

        public void SaveEmployee(Employee employee)
        {
            string a = Employee.Nationality;
        }
    }

In the calling function

Employee employee = new Employee
            {
                EmployeeID = 0,
                Name = "Akash",
                CompanyName = "abc"
            };
            employee.SaveEmployee(employee);

In this example we define Nationality as static because this is common for all objects. So we don’t need to define it for all objects.

Static constructor:
Constructor having static identifier called static constructor. It will execute only for once. It execute when static method is executes or creating an instance of that object for the first time. After that it will not being called. We call use this feature to initiate some static value for the first time. A non-static class can contain one parameter less static constructor. Parameterized static constructors are not allowed.

Example :

public class Employee
    {
        public int EmployeeID { get; set; }
        public string Name { get; set; }
        public string CompanyName { get; set; }
        public static string Nationality { get; set; }

        static Employee()
        {
            Nationality = "Bangladeshi";
        }
        public void SaveEmployee(Employee employee)
        {
            string a = Employee.Nationality;
        }
    }

static void Main(string[] args)
        {
            //double result = Calculator.Add(10,20);
            //Calculator.SaveResult(result);
            //Console.WriteLine("Latest Result {0} ", Calculator.Mode);
            Employee employee = new Employee
            {
                EmployeeID = 0,
                Name = "Akash",
                CompanyName = "abc"
            };
            employee.SaveEmployee(employee);
            Console.WriteLine("Saved ");
        }

Here Nationality is set in static constructor as it is common for all objects. A non-static class can contain one parameter less static constructor. Parameterized static constructors are not allowed.

Static method:
Method using static keyword is called static method. Concept of static method is easy. Basically the purpose of using static method is to use this method without creating instance.

Example:

public class Employee
    {
        public int EmployeeID { get; set; }
        public string Name { get; set; }
        public string CompanyName { get; set; }
        public static string Nationality { get; set; }

        static Employee()
        {
            Nationality = "Bangladeshi";
        }
        public static void SaveEmployee(Employee employee)
        {
            string a = Employee.Nationality;
        }
    }

static void Main(string[] args)
        {
            //double result = Calculator.Add(10,20);
            //Calculator.SaveResult(result);
            //Console.WriteLine("Latest Result {0} ", Calculator.Mode);
            Employee employee = new Employee
            {
                EmployeeID = 0,
                Name = "Akash",
                CompanyName = "abc"
            };
            Employee.SaveEmployee(employee);
            Console.WriteLine("Saved ");
        }

Static methods cannot access or call non-static variables unless they are explicitly passed as parameters. Static methods can contain local static variables.

Enable SQL Server Authentication in SQL-server

shariaretanvir — Fri, 03 Sep 2021 16:53:01 +0000

Step by step process for enable SQL server authentication.

SQL-server is a very popular RDBMS. After installation the authentication mode is by default set to Windows Authentication. But in real scenario its not recommended for security purpose. SQL-server also give us the option for SQL-authentication. So today I will show how to configure SQL- authentication in SQL-Server.

Step by step process

step 1. First login to sql server using windows authentication.

step 2. Now we need to go to the properties of sql server instance.

step 3. After that go to security tab and check SQL server and windows authentication mode and click OK.

step 4.Now we need to create a user who will access our database as a SQL authentication. For that go to security -> login -> new login options.

step 5. Now give a user name and set up the password for that user.

step 6. Now give the user role as per requirements. For example I give all the permission for this testuser.

step 7. Also set up the status tab just like this. Permission will be grant and login will be Enabled.

So all the necessary setting is done for our new user. Click on the OK button.

Now restart the SQL server and try to login using SQL server authentication mode. Give the user login and password. You will login this time.

#Points of Interest

Sometimes SQL-server can not login and shows some error like this user can not login. For this case you can restart the sqlexpress from the services. After that try to login again. This will solve the error.

So after login you will see that the new SQL user is logged in.

That's it. Now you can login in to SQL server using SQL authentication as well as windows authentication .