DEV Community: Aman Singh Parihar

Garbage Collection C#

Aman Singh Parihar — Tue, 10 Jan 2023 11:24:42 +0000

Garbage Collector

Glossary

Heap

Portion of memory where dynamically allocated objects resides.

Managed Heap

Whenever we start any process or run our .NET code, it 
reserves some space in the memory which is contiguous and 
it's called managed heap.

There were the days when the developers would be required to release the memory which they have allocated for the objects.

It's the developers responsibility to manage the memory, and this brings some issues during development.

If we create a new object but forget to delete it, it will persist in the memory for a long time even if we didn't want to use it.
If our variable is referencing an object in the memory, and later that variable started referencing another object in the memory, then the previous object will persist in memory even if no variable in referencing this object. It's called memory leak. Object is not referenced by any variable and also not required but still in memory.

To overcome these scenarios, .NET came up with the garbage collector, which will take care of deleting the objects from the memory.

But, the garbage collector is limited to allocate or release the memory of managed code only, it does not allocate or release the unmanaged memory.

Managed Code is the code which runs under the .NET environment. .NET takes care of its memory management.
But the code which is outside of the .NET environment called the unmanaged code. .NET garbage collector doesn't know how to release the memory of unmanaged code.

Managed code written in the .NET might access unmanaged code.

for ex:- Connecting with database using SQL, Oracle classes, Network calls made from managed code, accessing files.

Even though we are writing the managed code, but this code is using the unmanaged code. So as a developer it's our responsibility to release the memory once the work of these objects are completed.

How do we release the memory then?

.NET provides the IDisposable interface for the types (example:- class) which are using the unmanaged code, for ex, network calls, database connection etc.

Those types needs to implement IDisposable interface and provides the implementation of the Dispose() method and write their own logic to release the memory.

And our task as a developer is that once we are done with these objects, we should call the dispose method on these objects.

.NET also provides a Finalize method, in case developer forgets to call the dispose method on this object.

GC releases the memory even if we forget to call the dispose method, if that class also implements the finalize, but the crux here is that finalize in indeterministic and dispose is deterministic.

It means we have control over the dispose method, when to call. But that finalize will be in hand of GC, when it calls.

Authentication and Authorization in dotnet core

Aman Singh Parihar — Tue, 11 May 2021 16:20:24 +0000

I have created a asp.net core empty web application using asp.net core 5.0 version.

Here we will learn very simple way of authentication and authorization.

Authentication means "who are you?" and authorization means "are you allowed?"

So before we ask anyone "are you allowed?", we have to ask "who are you?".

For ex:- If 10 persons standing outside of the main gate of college, and 8 of them showed their college id card (authentication) and entered the college as the college is configured in such a way that it will allow anyone who has the college id card, i.e 8 persons are authorized to enter the college.

2 of them showed their driving license, but since the college is not configured in such a way that it will allow a person with driving license, they will not be authorized to enter the college.

Similarly we have to configure our system to allow or deny the user on the basis of some identity.

if you run your application now it will display "Hello World!" on the web page, as it empty web application.

Lets create a folder "Controller" and add a controller inside this folder named "HomeController.cs"

Add three methods Index(), Restricted() and Authenticate() in the controller and add their respective views and ddd [Authorize] attribute on the Restricted() method.

Currently the code in "HomeController.cs" will be like this.

HomeController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Simple.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }

        [Authorize]
        public IActionResult Restricted() 
        {
            return View();
        }
        public IActionResult Authenticate() 
        {
            return View();
        }
    }
}

Lets modify the code of the startup.cs class, modified code in the startup.cs will be.

Startup.cs

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace Simple
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute();
            });
        }
    }
}

We can clearly see that we have removed "Hello World" code and added code required to show view with controller.

Now if we run the code and try to access Home/Restricted it will give an error.

Its simple right, we haven't configured our pipeline for checking authorization so need to add this method app.UseAuthorization() in configure method.

Lets add this code and run the application again.

But again we get an error.

Lets understand this error, we haven't defined any policy to check, i.e system is asking "Are you allowed?" but it doesn't know "Who are you?"

so we need to configure our system for validating the user first.

Lets add authentication scheme in "ConfigureServices" method of "Startup" class.

Startup.cs

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
            services.AddAuthentication("College-Id")
                .AddCookie("College-Id", configureOptions =>
                {
                    configureOptions.Cookie.Name = "College-Id.Cookie";
                });
        }

Now we have configured our system to look for the college-Id.Cookie, if it found then the user is authenticated.

Lets run the code now.

This time we did not get any error, but check the url now. We are trying to access the Restricted() method of the HomeController and system throws us default page Account/Login to first authenticate our self then we will be able to access the Restricted() method of the HomeController.

Lets write some code in the Authenticate Method of the HomeController.

public IActionResult Authenticate() 
        {
            var claims = new List<Claim>
            {
                new Claim(ClaimTypes.Name,"authenticatedUser"),
                new Claim("College-Id","YES")
            };

            var identity = new ClaimsIdentity(claims,"College Identity");

            var userPrincipal = new ClaimsPrincipal(new [] { identity });

            HttpContext.SignInAsync(userPrincipal);

            return View();
        }

Here we will define claims, identity and user principal.

Claims are basically, what the user is claiming, for instance the college id card.

Identity means, college authority is trusting the person having the college id card.

On the basis of the identity we have created user principal and signed in the user.

Now run this code you will see index page,but try to access "Home/Restricted" you will not be able to access this, as you are not authenticated.

Now lets go to route Home/Authenticate in the url, cookie will be generated.

Now try to access Home/Restricted in the url, you will be able to access the page, as you are not authenticated and authorized to access this page.

Sequence of object creation in .NET

Aman Singh Parihar — Sat, 01 May 2021 12:26:56 +0000

We are going to learn some basics of how the object is created in c# .net, most importantly the sequence of how they are created when the classes are following inheritance.

This is very simple topic but confuses many developers, even I was confused when I first learnt this.

Lets try to understand this.

In this example we will take two classes "Parent" and "Child" to make things simple.

Below is the code for "Parent" class.

Here we can see that we have two constructor, default and parameterized.

Now lets see the code of child class. We will discuss two cases here.

Lets see 1st case:

Here is the code of "Child" class.

Now when we create the object of Child class, like this.

Child c = new Child();

Default constructor of the parent class will be called first, and then the child class constructor will be called.

Output of the above execution will be something like this.

Now lets see 2nd case:

Here we want to explicitly call the "Parent" class parameterized constructor.

For this we have to make some tweak in the "Child" class.

Here is the code of the Child class.

We can see that we have used a "base" keyword here, this will execute the parameterized constructor of the "Parent" class.

Now when we create the object of Child class, like this, by passing any number as a parameter.

Child c = new Child(1);

Parameterized constructor of "Parent" class will be executed first, then the constructor of the "Child" class.

Output of the code will be something like this.

Envrionment in .NET Core

Aman Singh Parihar — Mon, 26 Apr 2021 16:20:08 +0000

We can setup different environments while developing an application in .net core.

When we first create an application in .net core using the web api template, we have two different profiles available in the launchSettings.json.

IIS Express
{Name of the project}

Note: launchSettings.json file is only available at the time of development.

Lets try to understand this file.

In the profile section we have two profiles available.

IIS Express
As we can see commandName is set to IISExpress, and in the environment varialble section we have ASPNETCORE_ENVIRONMENT variable set to Development.
{Name of the Project}
Here we can see commandName is set to Project, and in the environment varialble section we have ASPNETCORE_ENVIRONMENT variable set to Development.

We can select any of these profile to run our application.

If commandName is set to IISExpress, then the application will be launched using IISExpress and if the commandName will be set to Project, then the application will be launched using kestrel server along with a reverse proxy server.

And as in both the cases ASPNETCORE_ENVIRONMENT set to development, so the environment will be development. We can check for different environment in the startup.cs file using various extension methods.

And if no value is set for ASPNETCORE_ENVIRONMENT variable in launchSettings.json, then it will look in the System Environment Variable and if it is also not set there, then the value will be production by default.

Automapper in .NET Core

Aman Singh Parihar — Sat, 24 Apr 2021 06:51:11 +0000

GitHub link for the project:

aman-singh-parihar / Automapper

Automapper in .NET Core

We will create a project in .NET Core using dotnet cli and will use visual studio code as the IDE.

Go to any directory where you want to create this project.

We are using powershell to setup this project.

PS E:/VSCODE/NETProjects>mkdir Automapper
PS E:/VSCODE/NETProjects>cd Automapper

Lets create a solution in Automapper folder.

PS E:/VSCODE/NETProjects>Automapper>dotnet new sln

Lets create a project in the Automapper folder.

PS E:/VSCODE/NETProjects>Automapper>dotnet new webapi -o Automapper.API

Lets add the project in the solution file because as of now they are disconnected to each other.

dotnet sln add Automapper.API/Automapper.API.csproj

Now lets open Automapper folder in vscode.

PS E:/VSCODE/NETProjects>Automapper>code .

Switch to project folder and install automapper.

PS E:/VSCODE/NETProjects>Automapper>cd Automapper.API

PS E:/VSCODE/NETProjects>Automapper>Automapper.API>dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection

We setup our project, now lets write some code. First of all delete the weather api controller and weather api class as we don't need this.

Lets create two folders Models and DTO.
Models will have classes that will exactly match with the database tables and DTO will have classes which need to pass to the client.

In our case we are using Employee class in Models folder and EmployeeDTO in DTO folders.

Employee.cs

EmployeeDTO.cs

You can see that we are not passing employee salary to the client.

Now we will create profile which will map from Employee to EmployeeDTO.

Lets create a folder AutoMapperProfile in the project and add a class AutomapperProfile.cs.

AutomapperProfile.cs

Lets setup the ConfigureServices method of startup class for automapper.

Startup.cs

Now lets create a EmployeeController in Controllers folder.

EmployeeController.cs

We are almost done with this, lets run this project and see the output.

PS E:/VSCODE/NETProjects>Automapper>Automapper.API>dotnet run

Type this url in the browser to view the output: https://localhost:5001/api/Employee