While developing a real-time project, we should offer different authorizations to different users. This means, for example,  users who are "Admin" ,can access a timesheet, but users who are "HR" can rollout pay changes. Here we are trying to define different roles. A group of users belonging to a role will have same access or authorization. But users from different roles, will have different authorizations.

 
So, before hosting our application, we should define the basic roles in place. We don't expect consumers/end-users to define roles in general. We can achieve that using .Net core identity and entity framework.
 
Prerequisite
A .Net core project with Identity, Entity framework and language as C#.
 
In Entity framework , we can define default database table values before creating database model. This concept is called seeding. We are going to use seeding in order to define default users and roles here.
 
I have a class AppDbContext which inherits from IdentityDbContext. We will need to override OnModelCreating() method to meet seeding. Here is the sample code.
 
Startup.cs
    public void ConfigureServices(IServiceCollection services)  
           {  
               #region database configuration              
               string connectionString = config.GetConnectionString("AppDb");  
      
               services.AddDbContextPool<AppDbContext>(options => options.UseSqlServer(connectionString));  
      
               services.AddIdentity<User, IdentityRole>()  
                   .AddEntityFrameworkStores<AppDbContext>();  
               #endregion                         
           }  

AppDbContext.cs
    public class AppDbContext : IdentityDbContext<User>  
        {  
            public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)  
            {  
      
            }  
      
            protected override void OnModelCreating(ModelBuilder builder)  
            {  
                base.OnModelCreating(builder);  
                this.SeedUsers(builder);  
                this.SeedUserRoles(builder);  
            }  
      
            private void SeedUsers(ModelBuilder builder)  
            {  
                User user = new User()  
                {  
                    Id = "b74ddd14-6340-4840-95c2-db12554843e5",  
                    UserName = "Admin",  
                    Email = "[email protected]",  
                    LockoutEnabled = false,  
                    PhoneNumber = "1234567890"  
                };  
      
                PasswordHasher<User> passwordHasher = new PasswordHasher<User>();  
                passwordHasher.HashPassword(user, "Admin*123");  
      
                builder.Entity<User>().HasData(user);  
            }  
      
            private void SeedRoles(ModelBuilder builder)  
            {  
                builder.Entity<IdentityRole>().HasData(  
                    new IdentityRole() { Id = "fab4fac1-c546-41de-aebc-a14da6895711", Name = "Admin", ConcurrencyStamp = "1", NormalizedName = "Admin" },  
                    new IdentityRole() { Id = "c7b013f0-5201-4317-abd8-c211f91b7330", Name = "HR", ConcurrencyStamp = "2", NormalizedName = "Human Resource" }  
                    );  
            }  
      
            private void SeedUserRoles(ModelBuilder builder)  
            {  
                builder.Entity<IdentityUserRole<string>>().HasData(  
                    new IdentityUserRole<string>() { RoleId = "fab4fac1-c546-41de-aebc-a14da6895711", UserId = "b74ddd14-6340-4840-95c2-db12554843e5" }  
                    );  
            }  
        }  

After adding this piece of code, we need to build the application. Now, let's open Package Manager Console . We need to run "add-migration user_role" and "update-database" commands in order to reflect seeding changes in database.

Now lets open SQL query window just to make sure EF has updated User, Role and UserRole table. Here you go.

As you can see, we have default users and roles before we deploy our application.
 
Note

You can see few GUIDs that I have used as ID, you can customize it based on your project design. 

 
We have succeeded in seeding user and role data. Thanks for coming this far in the article. Please feel free to give your valuable comments/suggestions/feedback.

A special method of the class that is automatically invoked when an instance of the class is created is called a constructor. A constructor is a special method that is used to initialize objects. The advantage of a constructor, is that it is called when an object of a class is created.
 

When we create instance of a class a default constructor  is invoked automatically having the same name as Class . Some key points,
    Constructor is used to initialize an object (instance) of a class.
    Constructor is a like a method without any return type.
    Constructor has the same name as class name.
    Constructor follows the access scope (Can be private, protected, public, Internal and external).
    Constructor can be overloaded.

Following is the list of constructors in C#.
    Default constructor
    Parameterized constructor
    Private Constructor
    Static Constructor
    Copy Constructor

Default Constructor
A constructor without any parameters is called a default constructor. If we do not create constructor the class will automatically call default constructor when an object is created.
 
Example of Default Constructor,
    using System;  
    namespace DefaultConstractor {  
        class addition {  
            int a, b;  
            public addition() //default contructor  
            {  
                a = 100;  
                b = 175;  
            }  
            public static void Main() {  
                addition obj = new addition(); //an object is created , constructor is called  
                Console.WriteLine(obj.a);  
                Console.WriteLine(obj.b);  
                Console.Read();  
            }  
        }  
    }  

Parameter Constructor
A constructor with at least one parameter is called a parameterized constructor.
 
Private Constructor
Private constructors are used to restrict the instantiation of object using 'new' operator. A private constructor is a special instance constructor. It is commonly used in classes that contain static members only.
 
Static Constructor
A static constructor is used to initialize any static data, or to perform a particular action that needs to be performed once only. It is called automatically before the first instance is created or any static members are referenced
 
Copy Constructor
The constructor which creates an object by copying variables from another object is called a copy constructor.
 
Is it possible to have a class without Constructor?
If a class contains no instance constructor declarations, a default instance constructor is automatically provided. The only classes in C# which don't have any instance constructors are static classes, and they can't have constructors.
 
Example
    class Person {  
        //This class has no constructor  
        public void getPersonProfile() {  
            Console.WriteLine("Base class:getPersonProfile() have no constructor");  
        }  
    }  
    class Program {  
        static void Main(string[] args) {  
            //Create object of person  
            Person p = new Person();  
            p.getPersonProfile();  
        }  
    }  

HostForLIFE ASP.NET 3.1.9 Hosting
HostForLIFE is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

Program.cs is where the application starts. Program.cs file will work the same as Program.cs file in traditional console application of .NET Framework. Program.cs fille is the entry point of application and will be responsible to register Startup.cs fill, IISIntegration and Create a host using an instance of IWebHostBuilder, the Main method.

Global.asax is no longer  in ASP.NET Core application. Startup.cs file is a replacement of Global.asax file in ASP.NET Core.

Startup.cs file is entry point, and it will be called after Program.cs file is executed at application level.  It handles the request pipeline. Startup class triggers the second the application launches.

Description
 
What is Program.cs ?

Program.cs is where the application starts. Program.cs class file is entry point of our application and creates an instance of IWebHost which hosts a web application.
    public class Program {  
        public static void Main(string[] args) {  
            BuildWebHost(args).Run();  
        }  
        public static IWebHost BuildWebHost(string[] args) => WebHost.CreateDefaultBuilder(args).UseStartup < startup > ().Build();  
    }   

WebHost is used to create instance of IWebHost and IWebHostBuilder and IWebHostBuilder which are pre-configured defaults. The CreateDefaultBuilder() method creates a new instance of WebHostBuilder. UseStartup<startup>() method specifies the Startup class to be used by the web host. We can also specify our custom class in place of startup.

Build() method returns an instance of IWebHost and Run() starts web application until it stops.

Program.cs in ASP.NET Core makes it easy for us to setup a web host.
    public static IWebHostBuilder CreateDefaultBuilder(string[] args) {  
        var builder = new WebHostBuilder().UseKestrel().UseContentRoot(Directory.GetCurrentDirectory()).ConfigureAppConfiguration((hostingContext, config) => {  
            /* setup config */ }).ConfigureLogging((hostingContext, logging) => {  
            /* setup logging */ }).UseIISIntegration()  
        return builder;  
    }   

the UseKestrel() specify method is an extension, which specifies Kestrel as an internal web server. The Kestrel is an open-source, cross-platform web server for ASP.NET Core. Application is running with Asp.Net Core Module and it is necessary to enable IIS Integration (UseIISIntegration()), which configures the application base address and port.
 
It also configures UseIISIntegration(), UseContentRoot(), UseEnvironment("Development"), UseStartup<startup>() and other configurations are also available, like Appsetting.json and Environment Variable. UseContentRoot is used to denote current directory path.
 
We can also register logging and set minimium loglevel as shown below. It also overrides loglevel configured in appsetting.json file.
    .ConfigureLogging(logging => { logging.SetMinimumLevel(LogLevel.Warning); })   

In the same way we can also control body size of our request and response by enabling in program.cs file as below.
    .ConfigureKestrel((context, options) => { options.Limits.MaxRequestBodySize = 20000000; });   

ASP.net Core is cross-platform and open-source and also it is compatible to host into any server rather than IIS, external web server such as IIS, Apache, Nginx etc.
 
What is Startup file?
Now the question is, is startup.cs file is mandatory or not? Yes, startup.cs is mandatory, it can be decorated with any access modifier like public, private, internal. Multiple Startup classes are allowed in a single application. ASP.NET Core will select the appropriate class based on its enviroment.

If a class Startup{EnvironmentName} exists, that class will be called for that EnvironmentName or Environment Specific startup file will be executed to avoid frequent changes of code/setting/configuration based on environment.
 
ASP.NET Core supports multiple environment variables like Development, Production and Staging. It reads the environment variable ASPNETCORE_ENVIRONMENT at application startup and store value into Hosting Environment interface.

Should we need to define class name with startup.cs? No, it is not necessary, that class name should be Startup.

We can define two methods in startup file like ConfigureServices and Configure along with constructor.

Startup file example
    public class Startup {  
        // Use this method to add services to the container.  
        public void ConfigureServices(IServiceCollection services) {  
            ...  
        }  
        // Use this method to configure the HTTP request pipeline.  
        public void Configure(IApplicationBuilder app) {  
            ...  
        }  
    }   

ConfigureServices Method
This is an optional method in Startup class which is used to configure services for application. When any request comes to the application, he ConfigureService method will be called first.

ConfigureServices method includes IServiceCollection parameter to register services. This method must be declared with a public access modifier, so that environment will be able to read the content from metadata.
    public void ConfigureServices(IServiceCollection services)  
    {  
       services.AddMvc();  
    }  

Configure Method
The Configure method is used to specify how the application will respond in each HTTP request. This method is mostly used for registering middleware in HTTP pipeline. This method method accept IApplicationBuilder parameter along with some other services like IHostingEnvironment and ILoggerFactory. Once we add some service in ConfigureService method, it will be available to Configure method to be used.
    public void Configure(IApplicationBuilder app)  
    {  
       app.UseMvc();  
    }   

Above example shows how to enable MVC feature in our framework. We need to register UseMvc() into Configure and also need to register service AddMvc() into ConfigureServices. UseMvc is know as middlware. Middleware is new concept introduce with Asp.net Core, thereaew  many inbuilt middleware available, and some are as below.
    app.UseHttpsRedirection();  
    app.UseStaticFiles();  
    app.UseRouting();  
    app.UseAuthorization();  
    UseCookiePolicy();  
    UseSession();   

Middleware can be configure in http pipeline using Use, Run, and Map.
 
Run Extension
The nature of Run extension is to short circuit the HTTP pipeline immediately. It is a shorthand way of adding middleware to the pipeline that does not call any other middleware which is next to it and immediately returns HTTP response.
 
Use Extension
It will transfer next invoker, so that HTTP request will be transferred to the next middleware after execution of current use if the next invoker is present.
 
Map Extension
Map simply accepts a path and a function that configures a separate middleware pipeline.
 
app.Map("/MyDelegate", MyDelegate);
 
To get more detailed information about middleware Click here
 
ASP.net core has built-in support for Dependency Injection. We can configure services to DI container using this method. Following ways are to configure method in startup class.
 
AddTransient
Transient objects are always different; a new instance is provided to every controller and every service.
 
Scoped
Scoped objects are the same within a request, but different across different requests.
 
Singleton
Singleton objects are the same for every object and every request.
 
Can we remove startup.cs and merge entire class with Program.cs ?
 
Answer is : Yes we can merge entire class  in to single file.

Here we have gone through basic understanding of how program.cs and startup.cs file is important for our Asp.net Core application and how both can be configured, we have also had a  little walk though  Environment Variable and middleware and how to configure middleware and dependency injection. Additionally we have seen how UseIIsintegration() and UseKestrel() can be configured.

HostForLIFE ASP.NET 3.1.9 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

In this article, we will create an empty ASP.NET Core project that doesn’t include default features, i.e., an empty shell.

Step to be followed

First, create a new empty project using Visual Studio 2017.
    File > New > Project
    Under “.NET Core”, select “ASP.NET Core Web Application”. Enter Name and Location. Click OK.
    Select “Empty”. Click OK.

Next, remove the code from Program.cs and Startup.cs so that they look like below (keeping the necessary "using" statements).
    public class Program {  
        public static void Main(string[] args) {  
            BuildWebHost(args).Run();  
        }  
        public static IWebHost BuildWebHost(string[] args) => WebHost.CreateDefaultBuilder(args).UseStartup().Build();  
    }  
    public class Startup {  
        public Startup(IHostingEnvironment env, ILoggerFactory loggerFactory, IConfiguration config) {}  
        public void ConfigureServices(IServiceCollection services) {  
            // setup dependency injection in service container  
        }  
        public void Configure(IApplicationBuilder app, IHostingEnvironment env) {  
            // setup request pipeline using middleware  
        }  
    }  

Empty project template in Visual Studio 2017 creates a project with Program.cs and Startup.cs classes.

Program.cs
Just like a Console application, "public static void Main()" is the starting point of ASP.NET Core applications. We’re setting up a host (WebHost) that references the server handling requests (Kestrel). This is achieved using CreateDefaultBuilder() method that configures -
    Kestrel- cross-platform web server
    Root- content root will use the web project’s root folder
    IIS- as the reverse proxy server
    Startup- points to a class that sets up configuration, services, and pipeline (see next section).
    Configuration- adds JSON and environment variables to IConfiguration available via Dependency Injection (see the next section).
    Logging- adds a Console and Debugs the logging providers.

Once configured, we Build() and Run() the host, at which point, the main thread is blocked and the host starts listening to the request from the Server.

When setting up WebHostBuilder, you could set values for various settings via UseSetting()method, which takes in a key/value pair for a property. These properties include applicationName (string), contentRoot (string), detailedErrors (bool), environment (string), URLs (semicolon separated list) and Webroot (string). Some of these properties can also be set via extension methods on WebHostBuilder.

Startup.cs
This class sets up the application dependency injection services and requests pipeline for our application, using the following methods.
    ConfigureServices(): add services to the service container
    Configure(): setup request pipeline using Middleware.

The parameters for these methods can be seen in the code attachment above.

These methods are called in the same sequence as listed above. The important point to remember about the sequence in which they run is that the service container is available after ConfigureServices, i.e., in Configure() method, and not before that.

This article provides some guidelines on how to use AutoMapper in C#.
We have come across a lot of situations when we need to copy data from one object to another. Normally, we follow the below mentioned approach to achieve this. Let’s say we have two classes declared as below,

First Class:
    public class UserObject  
       {  
           public int Id;  
           public string Name;  
           public string Address;  
       }  

Second Class:
    public class UserAnotherObject  
    {  
        public int Id;  
        public string Name;  
        public string Address;  
    }  

Now, if an object of the first class have some data in it and we want to copy that data to an object of the second class, we would be using the following approach for this:
    UserObject uObj = new UserObject();                         //an object of First Class  
               UserAnotherObject uAnotherObj = new UserAnotherObject();    //an object of Second   
      
               uAnotherObj.Id = uObj.Id;  
               uAnotherObj.Name = uObj.Name;  
               uAnotherObj.Address = uObj.Address;   

This is undoubtedly a tedious and repetitive task in case the object has a lot of properties.

Now, to overcome this task we can use a Nuget Package called the Auto-Mapper. Its working is quite simple to explain, in that it creates copy of one object into another but a bit automatically on the basis of Datatypes and names of the properties.

In order to use AutoMapper we would have to install it first from the Nuget Package Manager as pictorially explained below:

Step 1: Go to Manage NuGet Packages.. option in the project.
 

Step 2: Search and install AutoMapper to your project.

Step 3: Include the required Library on the page.
    using AutoMapper.Mappers;   

Now that this been done, we create a Mapper between the UserObject class and UserAnotherObject class. This will be done using the following line.

    AutoMapper.Mapper.CreateMap<UserObject, UserAnotherObject>();   

After creating this Mapper, let’s put some data into the object of the class UserObject that we made above,
    uObj.Id = 123;  
    uObj.Name = "Peter";  
    uObj.Address = "London";  

Now that we have the data, let’s copy the data from the object of UserObject class into the object of class UserAnotherObject using the AutoMapper that we just created above.
    uAnotherObj = AutoMapper.Mapper.Map<UserAnotherObject>(uObj);   

This copies the complete data from the uObj object to uAnotherObj object.

Note:
We need to keep it in mind that Auto Mapper copies data to properties in the target object with the same name as the properties name in the source object. The name should be the same but NOT CASE-SENSITIVE i.e. the name in source object can be “id” and that in the target object can be “ID”.

In this tutorial, I will show you how to work with structured logging in ASP.NET Core and Serilog. Let's start with logging, add NuGet packages:
    Serilog.AspNetCore
    Serilog.Sinks.Literate
    Serilog.Sinks.Seq

In Program.cs, configure Serilog using its LoggerConfiguration class and storing an instance of ILogger (returned by CreateLogger) in Serilog’s static Log class.
    public static void Main(string[] args)  
          {  
              Log.Logger = new LoggerConfiguration()  
                          .WriteTo.LiterateConsole()  
                          .CreateLogger();  
      
             BuildWebHost(args).Run();  
          }  
      
          public static IWebHost BuildWebHost(string[] args) =>  
              WebHost.CreateDefaultBuilder(args)  
                  .UseStartup<Startup>()  
                  .UseSerilog()  
                  .Build();  

Using the ILogger is the same process as described in our previous post, however, with Serilog we can do structured logging.
    public async Task Invoke(HttpContext context)  
        {  
            var message = new  
            {  
                GreetingTo = "James Bond",  
                GreetingTime = "Morning",  
                GreetingType = "Good"  
            };  
            this.logger.LogInformation("Inoke executing {@message}", message);  
      
            await context.Response.WriteAsync("Hello Logging!");  
      
            this.logger.LogInformation(  
                "Inoke executed by {developer} at {time}", "Tahir", DateTime.Now);  
        }

Running the application will show messages in Console window.

Structured logging is a technique to include semantic information as part of the messages being logged. This helps ‘machine readability’ of these messages and tools can be written to analyze raw log messages and produce interesting information.

Serilog uses message template, similar to string.Format() in .NET. Few interesting aspects of template syntax are,
    Use {} to enclose property names e.g. {developer} in above solution. These will be stored as metadata and can be queried using structured data storage (e.g. Seq, Azure).
    Use @ to preserve object structure e.g. in solution above the anonymous object is serialized into JSON representation.

Enrichers
In Serilog, enrichers are used to attach information to every log event that can then be used by structured data storage (e.g. Seq, Azure) for viewing and filtering. A simple way to do this is by using .Enrich.WithProperty() when configuring Serilog,
    Log.Logger = new LoggerConfiguration()  
                               .Enrich.WithProperty("ApiVersion", "1.2.5000")  
                               .WriteTo.LiterateConsole()  
                               .CreateLogger();  
As we saw in the previous post, a category can be attached to the logged messages, which normally is the fully qualified name of the class. This information could be used by structured data storage (e.g. Seq, Azure). Serilog provides this mechanism by attaching Context via ForContext() method,
    Log.Logger = new LoggerConfiguration()  
                        .Enrich.WithProperty("ApiVersion", "1.2.5000")  
                        .WriteTo.LiterateConsole()  
                        .CreateLogger()  
                        .ForContext<HelloLoggingMiddleware>();  

Sinks
Sinks in Serilog refer to destination of log messages e.g. file, database or console (in our example). There are several sinks available (refer to link below). I’ll use Seq as an example sink to show how all the metadata we’ve added is available in a structured storage,
    Log.Logger = new LoggerConfiguration()  
                              .Enrich.WithProperty("ApiVersion", "1.2.5000")  
                              .WriteTo.LiterateConsole()  
                              .WriteTo.Seq("http://localhost:5341")  
                              .CreateLogger()  
                              .ForContext<HelloLoggingMiddleware>(); 

Notice how data we added via enricher, context and custom object appears as key/value pairs. This can now be used for filtering data and creating dashboards within Seq.

In this article, I give a brief introduction to writing testable code. Although I have described and used samples in the context of .NET, the high-level principles of writing testable code applies to most of the programming language.  
 
What is Testable Code?
Testable code refers to the loosely coupled code where code does not directly depend on internal/external dependencies, so we can easily replace the real dependencies (sometimes referred to as real service) with mock services in test cases. For example, if my code calls a method GetProductInfo() which is connecting to a real database, fetching the product information, and returning to the main method. To test my main method functionality without actually connecting to the real database, I can write a test that uses a mock service to get product data.
 
While it might seem a little confusing at this point, it is actually very simple when you see a working example of it.
 
Why is it important to write testable code?
Writing testable code is crucial, as it helps you to identify and resolve the potential problems/ bugs in the early development stage instead of getting issues in UAT or production when working with real services. Also, testing the fake services is fast compared to testing real services. For example, connecting to a real database is more time consuming than testing with fake data in mock service.
 
How to write testable code
Writing testable code is all about dependency management. If we are writing code using the SOLID principles, then our code will already be loosely coupled and in compliance with testing standards. While writing testable code, our main objective is to identify the dependencies and moving the instantiation of those dependencies outside of our code. When we create an object of the class using a new keyword inside the current class, then this class directly depends on the class whose object we are creating. For example, in the below code ProcessProduct class creating the object of DBService class. Hence DBService class is the dependency and ProcessProduct class depends directly on DBService.
    class Product  
        {  
            public int Id { get; set; }  
            public string Name { get; set; }  
            public string Category { get; set; }  
            public float Price { get; set; }  
      
        }  
        class ProcessProduct  
        {  
            public void DisplayProduct()  
            {  
                DBService dbService = new DBService();  
                var product = dBService.getProduct();  
                Console.WriteLine($" Product Name: { product.Name } Category: { product.Category } Price: { product.Price }");  
            }  
              
        }  
      
        class DBService  
        {  
            public Product getProduct() {  
                throw new NotImplementedException("Get product from database");  
            }  
        }  

To make this code loosely coupled, we will use a very popular design pattern called dependency injection. There are several ways to implement dependency injection which is itself a very wide topic. So to keep this article simple, I will use one of the ways to implement dependency injection-  Dependency injection using Constructor.
 
In this method, instead of creating the object of DBService inside ProcessProduct, we will inject the object through the constructor of the dependent class and save it in a private variable as shown in the below code:
    class Product  
    {  
        public int Id { get; set; }  
        public string Name { get; set; }  
        public string Category { get; set; }  
        public float Price { get; set; }  
      
    }  
    class ProcessProduct  
    {  
        private IDBservice _dbService;  
      
        public ProcessProduct(IDBservice dbService)  
        {  
            _dbService = dbService;  
        }  
        public void DisplayProduct()  
        {  
            var product = _dbService.getProduct();  
            Console.WriteLine($" Product Name: { product.Name } Category: { product.Category } Price: { product.Price }");  
        }  
          
    }  
      
    interface IDBservice {  
         Product getProduct();  
    }  
      
    class DBService : IDBservice  
    {  
        public Product getProduct() {  
            throw new NotImplementedException("Get product from database");  
        }  
    }  

We have also created an interface IDBService in the above example and declared the object of DBService using this interface. By using this interface, we allow any class’object that implements the IDBService interface to inject through the constructor.
 
Below is an example of passing a mock class object for testing.
    class ProcessProduct  
        {  
            private IDBservice _dbService;  
      
            public ProcessProduct(IDBservice dbService)  
            {  
                _dbService = dbService;  
            }  
            public void DisplayProduct()  
            {  
                var product = _dbService.getProduct();  
                Console.WriteLine($" Product Name: { product.Name } Category: { product.Category } Price:  { product.Price }");  
            }  
      
        }  
      
        interface IDBservice {  
            Product getProduct();  
        }  
      
        class MockDBService : IDBservice  
        {  
            public Product getProduct()  
            {  
                return new Product()  
                {  
                    Id = 2124,  
                    Name = "Eggs",  
                    Category = "Food",  
                    Price = 2.23m  
                };  
      
            }  
      
        }  
      
        class TestProcessProduct  
        {  
            void Test()  
            {  
                ProcessProduct processProduct = new ProcessProduct(new MockDBService());  
                processProduct.DisplayProduct();  
            }  
        }  

In this example, we want to test the ProcessProduct class to display product information without actually connecting to the real database. To achieve this, instead of injecting the DBService class object we are injecting the MockDBService class object. And because of dependency injection, we do not need to do any changes in the ProcessProduct class. Hence, this code is loosely coupled and testable.

Sometimes you want to remove tags from HTML and get only plain text. In general, this is simple task but there are few drawbacks in some scenarios. The simplest solution is to just remove all tags from given HTML without any formatting.

You can do it with code like this:

[ C# ]

public string RemoveHTMLTags(string HTMLCode)
{
 return System.Text.RegularExpressions.Regex.Replace(
   HTMLCode, "<[^>]*>", "");
}

[ VB.NET ]

Public Function RemoveHTMLTags(ByVal HTMLCode As String) As String
 Return System.Text.RegularExpressions.Regex.Replace( _
   HTMLCode, "<[^>]*>", "")
End Function

Better HTML to plain text conversion\

Example above removes any tag from HTML. This is good enough in some scenarios, but there are some issues too:

- Text inside HEAD tag will be visible too
- Empty spaces &nbsp; and new lines <br /> or paragraph <p> will be lost
- Unwanted empty spaces that are invisible in HTML will show in plain text, and that will distract text even more
- Special characters like &amp; or &copy etc. will not be translated etc

To solve all these problems, you need a little more processing of input HTML. Next function will provide better HTML to text conversion:

[ C# ]

// This function converts HTML code to plain text
// Any step is commented to explain it better
// You can change or remove unnecessary parts to suite your needs

public string HTMLToText(string HTMLCode)
{
 // Remove new lines since they are not visible in HTML
 HTMLCode = HTMLCode.Replace("\n", " ");
 
 // Remove tab spaces
 HTMLCode = HTMLCode.Replace("\t", " ");
 
 // Remove multiple white spaces from HTML
 HTMLCode = Regex.Replace(HTMLCode, "\\s+", " ");
 
 // Remove HEAD tag
 HTMLCode = Regex.Replace(HTMLCode, "<head.*?</head>", ""
                     , RegexOptions.IgnoreCase | RegexOptions.Singleline);
 
 // Remove any JavaScript
 HTMLCode = Regex.Replace(HTMLCode, "<script.*?</script>", ""
   , RegexOptions.IgnoreCase | RegexOptions.Singleline);
 
 // Replace special characters like &, <, >, " etc.
 StringBuilder sbHTML = new StringBuilder(HTMLCode);

// Note: There are many more special characters, these are just
// most common. You can add new characters in this arrays if needed
 string[] OldWords = {"&nbsp;", "&amp;", "&quot;", "&lt;",
   "&gt;", "&reg;", "&copy;", "&bull;", "&trade;"};
 string[] NewWords = {" ", "&", "\"", "<", ">", "®", "©", "•", "â„¢"};
 for(int i = 0; i < OldWords.Length; i++)
 {
   sbHTML.Replace(OldWords[i], NewWords[i]);
 }
 
 // Check if there are line breaks (<br>) or paragraph (<p>)
 sbHTML.Replace("<br>", "\n<br>");
 sbHTML.Replace("<br ", "\n<br ");
 sbHTML.Replace("<p ", "\n<p ");
 
 // Finally, remove all HTML tags and return plain text
 return System.Text.RegularExpressions.Regex.Replace(
   sbHTML.ToString(), "<[^>]*>", "");
}

[ VB.NET ]

' This function converts HTML code to plain text
' Any step is commented to explain it better
' You can change or remove unnecessary parts to suite your needs

Public Function HTMLToText(ByVal HTMLCode As String) As String
 ' Remove new lines since they are not visible in HTML
 HTMLCode = HTMLCode.Replace("\n", " ")
 
 ' Remove tab spaces
 HTMLCode = HTMLCode.Replace("\t", " ")
 
 ' Remove multiple white spaces from HTML
 HTMLCode = Regex.Replace(HTMLCode, "\\s+", "  ")
 
 ' Remove HEAD tag
 HTMLCode = Regex.Replace(HTMLCode, "<head.*?</head>", "" _
   , RegexOptions.IgnoreCase Or RegexOptions.Singleline)
 
 ' Remove any JavaScript
 HTMLCode = Regex.Replace(HTMLCode, "<script.*?</script>", "" _
   , RegexOptions.IgnoreCase Or RegexOptions.Singleline)
 
 ' Replace special characters like &, <, >, " etc.
 Dim sbHTML As StringBuilder = New StringBuilder(HTMLCode)

 ' Note: There are many more special characters, these are just
 ' most common. You can add new characters in this arrays if needed

 Dim OldWords() As String = {"&nbsp;", "&amp;", "&quot;", "&lt;", _
    "&gt;", "&reg;", "&copy;", "&bull;", "&trade;"}
 Dim NewWords() As String = {" ", "&", """", "<", ">", "®", "©", "•", "â„¢"}
 For i As Integer = 0 To i < OldWords.Length
   sbHTML.Replace(OldWords(i), NewWords(i))
 Next i
 
 ' Check if there are line breaks (<br>) or paragraph (<p>)
 sbHTML.Replace("<br>", "\n<br>")
 sbHTML.Replace("<br ", "\n<br ")
 sbHTML.Replace("<p ", "\n<p ")
 
 ' Finally, remove all HTML tags and return plain text
 Return System.Text.RegularExpressions.Regex.Replace( _
    sbHTML.ToString(), "<[^>]*>", "")
End Function

HTML to plain text ASP.NET example

Now, you can build an example that convert HTML to plain text. Create new web page with one Button control and two TextBox controls, like on image bellow:

First TextBox control ID will be tbHTML and second TextBox control ID set to tbPlainText. On button's click write this code:

[ C# ]

protected void btnTextToHTML_Click(object sender, EventArgs e)
{
 tbPlainText.Text = HTMLToText(tbHTML.Text);
}

[ VB.NET ]

Protected Sub btnTextToHTML_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnTextToHTML.Click
 tbPlainText.Text = HTMLToText(tbHTML.Text)
End Sub

Please note that HTML is considered as dangerous input. To make this example works you need to add ValidateRequest="false" part to @Page directive. Otherwise, you'll get an error "A potentially dangerous Request.Form value was detected from the client...)" like on next image.

When you set ValidateRequest parameter to false, you can run an example. Place some HTML code to tbHTML TextBox control and click on Button. Plain text will be extracted from given HTML and shown in tbPlainText.

As you see, there are few different options when converting HTML to plain text. Depending of your needs you can only remove tags or provide additional formatting. Suggested HTMLToText function is not perfect. You can make it better if you add all symbols or add line breaks for new table rows, or add tab spaces for evey new table cell etc. Be aware that with every new option included this function becomes slower. If you overdo the conversion could be unsatisfactory, especially if you have large HTML files. Happy coding!

HostForLIFE.eu ASP.NET 5 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

Distributed computing is an integral part of almost every software development. Before .Net Remoting, DCOM was the most used method of developing distributed application on Microsoft platform. Because of object oriented architecture, .NET Remoting replaces DCOM as .Net framework replaces COM.
 
Benefits of Distributed Application Development
 
Fault Tolerance: Fault tolerance means that a system should be resilient when failures within the system occur.
 
Scalability: Scalability is the ability of a system to handle increased load with only an incremental change in performance.
 
Administration: Managing the system from one place.
 
In brief, .NET remoting is an architecture which enables communication between different application domains or processes using different transportation protocols, serialization formats, object lifetime schemes, and modes of object creation. Remote means any object which executes outside the application domain. The two processes can exist on the same computer or on two computers connected by a LAN or the Internet. This is called marshalling (This is the process of passing parameters from one context to another.), and there are two basic ways to marshal an object:
 
Marshal by value: the server creates a copy of the object passes the copy to the client.
 
Marshal by reference: the client creates a proxy for the object and then uses the proxy to access the object.
 
Comparison between .NET Remoting and Web services

Architecture
Remote objects are accessed thro channels. Channels are Transport protocols for passing the messages between Remote objects. A channel is an object that makes communication between a client and a remote object, across app domain boundaries. The .NET Framework implements two default channel classes, as follows:
 
HttpChannel: Implements a channel that uses the HTTP protocol. TcpChannel: Implements a channel that uses the TCP protocol (Transmission Control Protocol). Channel take stream of data and creates package for a transport protocol and sends to other machine. A simple architecture of .NET remoting is as in Fig 1.

As Fig.1 shows, Remoting system creates a proxy for the server object and a reference to the proxy will be returned to the client. When client calls a method, Remoting system sends request thro the channel to the server. Then client receives the response sent by the server process thro the proxy.
 
Example
Let us see a simple example which demonstrates .Net Remoting. In This example the Remoting object will send us the maximum of the two integer numbers sent.
Creating Remote Server and the Service classes on Machine 1: Please note for Remoting support your service (Remote object) should be derived from MarshalByRefObject.
    using System;  
    using System.Runtime.Remoting.Channels; //To support and handle Channel and channel sinks  
    using System.Runtime.Remoting;  
    using System.Runtime.Remoting.Channels.Http; //For HTTP channel  
    using System.IO;  
    namespace ServerApp {  
      public class RemotingServer {  
        public RemotingServer() {  
          //  
          // TODO: Add constructor logic here  
          //  
        }  
      }  
      //Service class  
      public class Service: MarshalByRefObject {  
        public void WriteMessage(int num1, int num2) {  
          Console.WriteLine(Math.Max(num1, num2));  
        }  
      }  
      //Server Class  
      public class Server {  
        public static void Main() {  
          HttpChannel channel = new HttpChannel(8001); //Create a new channel  
          ChannelServices.RegisterChannel(channel); //Register channel  
          RemotingConfiguration.RegisterWellKnownServiceType(typeof Service), "Service", WellKnownObjectMode.Singleton);  
        Console.WriteLine("Server ON at port number:8001");  
        Console.WriteLine("Please press enter to stop the server.");  
        Console.ReadLine();  
      }  
    }  
    }

Save the above file as ServerApp.cs. Create an executable by using Visual Studio.Net command prompt by, csc /r:system.runtime.remoting.dll /r:system.dll ServerApp.cs
 
A ServerApp.Exe will be generated in the Class folder.
 
Run the ServerApp.Exe will give below message on the console
 
Server ON at port number:8001
 
Please press enter to stop the server.
 
In order to check whether the HTTP channel is binded to the port, type http://localhost:8001/Service?WSDL in the browser. You should see a XML file describing the Service class.
 
Please note before running above URL on the browser your server (ServerApp.Exe should be running) should be ON.
 
Creating Proxy and the Client application on Machine 2
 
SoapSuds.exe is a utility which can be used for creating a proxy dll.
 
Type below command on Visual studio.Net command prompt.
 
soapsuds -url:http://< Machine Name where service is running>:8001/Service?WSDL -oa:Server.dll
 
This will generates a proxy dll by name Server.dll. This will be used to access remote object.
 
Client Code
    using System;  
    using System.Runtime.Remoting.Channels; //To support and handle Channel and channel sinks  
    using System.Runtime.Remoting;  
    using System.Runtime.Remoting.Channels.Http; //For HTTP channel  
    using System.IO;  
    using ServerApp;  
    namespace RemotingApp {  
      public class ClientApp {  
        public ClientApp() {}  
        public static void Main(string[] args) {  
          HttpChannel channel = new HttpChannel(8002); //Create a new channel  
          ChannelServices.RegisterChannel(channel); //Register the channel  
          //Create Service class object  
          Service svc = (Service) Activator.GetObject(typeof(Service), "http://<Machine name where Service running>:8001/Service"); //Localhost can be replaced by  
          //Pass Message  
          svc.WriteMessage(10, 20);  
        }  
      }  
    }

Save the above file as ClientApp.cs. Create an executable by using Visual Studio.Net command prompt by, csc /r:system.runtime.remoting.dll /r:system.dll ClientrApp.cs
 
A ClientApp.Exe will be generated in the Class folder. Run ClientApp.Exe , we can see the result on Running ServerApp.EXE command prompt.
 
In the same way we can implement it for TCP channel also.

Today, in this article we will discuss the exception handling concept in any ASP.NET Core application. Exception handling is one of the most import functionality or part for any type of application which always need to be taken care and implement properly. Exceptions are mainly means for the run time errors which occur during the execution time of the application. So, if this type of error is not properly handled, then the application will be terminated.

In ASP.NET Core, the concept of exception handling has been changed, and rather to say, now it is in very much in better shape to implement exception handling. For any API projects implementing exception handling against every action, the method is quite time-consuming and it also requires extra efforts. So, for this purpose, we can implement the Global Exception handler so that all types of unhandled exceptions can be caught in this handler. The benefit of implementing a global exception handler is that we need to define this in one place. Through this handler, any exception that occurs in our application will be handled, even we ann new methods or controllers. So, in this article, we will discuss how to implement global exception handling in the ASP.NET Core Web API.

Create ASP.NET Core Web API Projects in Visual Studio 2019
So, before going to discuss the global exception handler, first, we need to create an ASP.NET Web API project. For this purpose, follow the steps mentioned below,

Now open the Microsoft Visual Studio and Click on Create a New Project
In the Create New Project dialog box, select ASP.NET Core Web Application for C# and then click on the Next Button.

In the Configure your new project window, provide the project name and then click on the Create button.
In the Create a New ASP.NET Core Web Application dialog, select API, and then click on Create Button.
Ensure that the checkboxes “Enable Docker Support” and “Configure for HTTPS” are unchecked. We won’t be using these features.
Ensure that “No Authentication” is selected as we won’t be using authentication either.
Click OK

Use the UseExceptionHandler middleware in ASP.NET Core
So, to implement the global exception handler, we can use the benefits of the ASP.NET Core build-in Middleware. A middleware is indicated as a software component inserted into the request processing pipeline which handles the requests and responses. We can use the ASP.NET Core in-build middleware UseExceptionHandler to use as a global exception handler. The ASP.NET Core request processing pipeline includes a chain of middleware components. This pipeline in turn contains a series of request delegates that are invoked one after another. While the incoming requests flow through each of the middleware components in the pipeline, each of these components can either process the request or pass the request to the next component in the pipeline.

Through this middleware, we can get all the detailed information of the exception object like the Stack trace, inner exception, message, etc., and also return that information through the API to return as an output. We need to put the exception handler middleware inside the configure() of a startup.cs file. If we use any MVC based application, then we can use the exception handler middleware just as below. This code snippet demonstrates how we can configure the UseExceptionHandler middleware to redirect the user to an error page when any type of exception has occurred.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)  
{  
app.UseExceptionHandler("/Home/Error");  
app.UseMvc();  
}  

Now, we need to check this exception message. For that purpose, open the WeatherForecastController.cs file and add the below action method to throw an exception –
[Route("GetExceptionInfo")]  
[HttpGet]  
public IEnumerable<string> GetExceptionInfo()  
{  
string[] arrRetValues = null;  
if (arrRetValues.Length > 0)  
{ }  
return arrRetValues;  
}  

If we want to capture the details of the exception objects – i.e. like the stack trace, message, etc then we use the below code as the exception middleware –
app.UseExceptionHandler(  
    options =>  
    {  
        options.Run(  
            async context =>  
            {  
                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;  
                context.Response.ContentType = "text/html";  
                var exceptionObject = context.Features.Get<IExceptionHandlerFeature>();  
                if (null != exceptionObject)  
                {  
                    var errorMessage = $"<b>Exception Error: {exceptionObject.Error.Message} </b> {exceptionObject.Error.StackTrace}";  
                    await context.Response.WriteAsync(errorMessage).ConfigureAwait(false);  
                }  
            });  
    }  
);  

For checking the output, just execute the API endpoint in any browser:

Define a Custom Exception Middleware to handle Exceptions in ASP.NET Core API
Also, we can write our custom middleware to handle any type of exceptions. In this section, we demonstrate how to create a typical custom middleware class. Custom middleware also provides much more flexibility to handle exceptions. We can add a stack trace, an exception type name, error code, or anything else which we want to include as a part of the error message. The below code snippet shows the typical custom middleware class:
    using Microsoft.AspNetCore.Http;    
    using Newtonsoft.Json;    
    using System;    
    using System.Collections.Generic;    
    using System.Linq;    
    using System.Net;    
    using System.Threading.Tasks;    
        
    namespace API.DemoSample.Exceptions    
    {    
        public class ExceptionHandlerMiddleware    
        {    
            private readonly RequestDelegate _next;    
        
            public ExceptionHandlerMiddleware(RequestDelegate next)    
            {    
                _next = next;    
            }    
        
            public async Task Invoke(HttpContext context)    
            {    
                try    
                {    
                    await _next.Invoke(context);    
                }    
                catch (Exception ex)    
                {    
                        
                }    
            }    
        }    
    }    

In the above class, a request delegate is passed to any middleware. The middleware either processes this or passes it to the next middleware in the chain. If the request is unsuccessful, then an exception will be thrown, and then the HandleExceptionMessageAsync method will be executed within the catch block. So, let's update the Invoke method code as shown below:
    public async Task Invoke(HttpContext context)  
            {  
                try  
                {  
                    await _next.Invoke(context);  
                }  
                catch (Exception ex)  
                {  
                    await HandleExceptionMessageAsync(context, ex).ConfigureAwait(false);  
                }  
            }  

Now, we need to implement the HandleExceptionMessageAsync method, as shown below:
    private static Task HandleExceptionMessageAsync(HttpContext context, Exception exception)  
            {  
                context.Response.ContentType = "application/json";  
                int statusCode = (int)HttpStatusCode.InternalServerError;  
                var result = JsonConvert.SerializeObject(new  
                {  
                    StatusCode = statusCode,  
                    ErrorMessage = exception.Message  
                });  
                context.Response.ContentType = "application/json";  
                context.Response.StatusCode = statusCode;  
                return context.Response.WriteAsync(result);  
            }  

Now, in the next step, we need to create a static class named ExceptionHandlerMiddlewareExtensions and add the below code within that class,
    using Microsoft.AspNetCore.Builder;  
    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Threading.Tasks;  
      
    namespace API.DemoSample.Exceptions  
    {  
        public static class ExceptionHandlerMiddlewareExtensions  
        {  
            public static void UseExceptionHandlerMiddleware(this IApplicationBuilder app)  
            {  
                app.UseMiddleware<ExceptionHandlerMiddleware>();  
            }  
        }  
    }  

Now, in the last step, we need to turn on our custom middleware within the Configure method of the startup class, as shown below:
    app.UseExceptionHandlerMiddleware();  

Conclusion
Exception handling is a mainly cross-cutting concept for any type of application. In this article, we discuss the implementation process of the global exception handling concept. We can take the benefits of global exception handling in any ASP.NET Core application to ensure that every exception will be caught and return the proper details related to that exception. With the global exception handling, we just need to write the exception handling related code for our entire application just in one place. Any suggestions or feedback or query related to this article are most welcome.