One of the key features of EF Core is its extensibility through the EF Core pipeline. The pipeline represents the sequence of operations that occur when EF Core interacts with the database. Developers can tap into this pipeline to customize or extend the behavior of EF Core to suit their application's specific requirements.

Tapping into the EF Core pipeline allows developers to:

• Intercept database operations: By intercepting operations such as query execution, saving changes, or database schema creation, developers can add custom logic, logging, or validation.

• Customize query generation: EF Core generates SQL queries based on LINQ expressions or raw SQL statements. Developers can customize this process to optimize queries or handle specific database features.

• Implement change tracking: EF Core tracks changes made to entities and detects when to insert, update, or delete records in the database. Developers can customize change tracking behavior for performance or business logic reasons.

There are 3 most common ways to deal with EF Core pipeline:

• Override the SaveChanges method.

• Using the saving and tracking event handlers

• Interceptors

In the next sections of this article, we will delve into code examples and techniques for tapping into the EF Core pipeline, showcasing the flexibility and power it provides to developers working with database interactions in their .NET applications.

Override the SaveChanges method

SaveChanges method saves the changes made to entities to the database. It prepares the SQL queries to insert, update or delete the records. EF Core allows to override this method in DBContext class.

public override int SaveChanges() {
    var result = base.SaveChanges();
    return result;
}

Developer could perform various operations in this overridden method. Some examples of such operations are:

• adding additional logging before or after saving the changes.

• Modifying the entities in change tracker before saving the data. (updating the shadow properties)

Saving and tracking event handlers

EF Core provides below events which could be used to perform operations before, after or during EF Core operations:

Using Interceptor to work with EF Core pipeline

Interceptors allows to intercept the EF Core operations; developer could modify or suppress the intercepted operation.

Interceptors are different from logging and diagnostic as they allow modification or suppression of operation.

There are three types of interceptors provided by EF Core:

Table source: Interceptors - EF Core | Microsoft Learn

That's it for now, in this article we have learnt about tapping into EF Core pipeline where developer could perform additional operations before or after execution of operation. Let me know your feedback in comments.

We have covered the basic understanding of Options pattern into Options pattern in ASP.NET Core: Introduction article. Please go through it if not familiar with it.

We will cover below scenarios which are handled using Options pattern:

• Validation of configuration settings using data annotation.

• Validation of configuration settings using custom validation logic.

• Validation of configuration settings during application startup.

• Handling command line arguments or environment variables using options pattern.

• Monitoring the changes of configuration settings.

Let's dive directly into code to understand all how Options pattern is used to handle all these scenarios.

GitHub repo link for the code sample https://github.com/dkj468/OptionsPatternDemo

Validation of configuration settings using data annotation

Options pattern allows to bind the DataAnnotations rules to class which represents the section of application settings. This is powerful mechanism to validate for non empty, range and many more things.

consider the FileOptions class from our first article :

    public class FileOptions {
        public const string Key = "file";

        [Required(AllowEmptyStrings =false)]
        public string MaxSize { get; set; }
        public string FileType { get; set; }
        public bool CanModify { get; set; }
        [Range(minimum:2, maximum:6)]
        public int MaxFileCount { get; set; }
    }

We have applied some validation rules to class properties which represents the configuration setting.

Now we need to modify Program.cs file to validate these data annotations.

builder.Services
       .AddOptions<FileOptions>().Bind(builder.Configuration.GetSection("file"))
       .ValidateDataAnnotations();  // validate the annotations

With above code changes, application is ready to validate annotation rule when user tries to access the configuration settings via Options pattern.

if you just remove the MaxSize property from appsettings.json file and try to access this inside controller then Microsoft.Extensions.Options.OptionsValidationException exception will be thrown with proper message.

Microsoft.Extensions.Options.OptionsValidationException: DataAnnotation validation failed for 'FileOptions' members: 'MaxSize' with the error: 'The MaxSize field is required.'.

 [Required(AllowEmptyStrings =false, ErrorMessage ="MaxSize cannot be empty")]
 public string MaxSize { get; set; }

Custom validation

You could write custom validation logic to validate configuration settings value.

builder.Services
       .AddOptions<FileOptions>().Bind(builder.Configuration.GetSection("file"))
       .Validate(fileOptions => {
           if (string.IsNullOrEmpty(fileOptions.FileType) {
               return false;
           }
           return true;
       });

Validate on application startup

builder.Services
       .AddOptions<FileOptions>().Bind(builder.Configuration.GetSection("file"))
       .ValidateDataAnnotations()
       .ValidateOnStart();

With .NET 8 , you could combine this with AddOptions method.

builder.Services
    .AddOptionsWithValidateOnStart<FileOptions>()
    .Bind(builder.Configuration.GetSection("file"));

Handling command line arguments or environment variables

To manage command line arguments or environment variables using options pattern, we somehow need a way to use ASP.NET Core dependency injection mechanism to access the required data.

So far we have used AddOptions method to tell ASP.NET Core to bind the C# class with a specific section of the appsettings.json file. So this method only allows us to bind the configurations which are part of appsettings.json file. We need a way to bind the configuration from other sources like command line, environment variables, database, xml or ini files etc.

To achieve this, we will set options pattern using IConfigurationOptions . This is two step process:

• Create a class which implements IConfigureOptions interface, this class will allow us to access the other configuration sources via dependency injection.

• Modify Program.cs to use the class created in above step.

let's see this with code:

First, we will modify the FileOptions class to include two new properties: FileMode and Version.

let's create class with implementation of IConfigureOptions

    public class FileOptionsSetup : IConfigureOptions<FileOptions> {
        private readonly IConfiguration _config;
        public FileOptionsSetup(IConfiguration config) {
            _config = config;
        }
        public void Configure(FileOptions options) {
            _config.GetSection("file").Bind(options);
            // bind the environment variable
            options.filemode = Environment.GetEnvironmentVariable("filemode");
            // bind the command line argument
            options.version = _config.GetValue<string>("version"); 
        }
    }

In above code, we first bind the appsettings.json section to FileOptions object and then read the configuration from environment variable and command line respectively.

We could extend above code to include configurations from almost any source

Now let's tell our program.cs to use above class for configurations.

builder.Services.ConfigureOptions<FileOptionsSetup>();

With all above code, our code is now powered to handle configuration from sources other than appsettings.json

Monitoring the changes in configuration settings

Let's recall how our code uses the IOptions interface for injecting the FileOptions class into controller constructor. There are two more interfaces which could be used to inject the options classes vai dependency injection into ASP.NET Core application.

Let's understand more about these in details :

IOptions

• After running the program, IOptions doesn't monitor for changes into application configurations. It always gives the same value.

• This works as singleton and can be injected in any service lifetime.

IOptionsSnapshot

• This is useful in scenario where configuration needs to be read for each request - It works as a scoped service.

• This can be injected into a scoped or transient service but not in singleton service.

• appsettings.json is read for each request.

IOptionsMonitor

• This works as singleton and can be injected in any service lifetime.

• this interface has an OnChnage method which is triggered if there are changes in appsettings.json

            public FileController(IConfiguration config, 
                                IOptionsMonitor<FileOptions> optionsMonitor) {
                _config = config;
                _optionsMonitor = optionsMonitor;
                _fileOptions = _optionsMonitor.CurrentValue; // notice here
                _optionsMonitor.OnChange(options => { // onchange method
                    _fileOptions = options;
                });
            }
  

🚀 Use IOptions<T> when you are not expecting changes in appsettings content.

🚀 Use IOptionsSnapshot<T> when values are expected to change but want it to be consistent during a request.

🚀 Use IOptionsMonitor<T> when real time value is expected.

Conclusion

In this article we have learned about some advance use cases where options pattern is quite useful. All such scenarios are difficult to manage using IConfiguration method.

Thanks for reading.

if you are already familiar with Options pattern and want to understand about some advance scenario handled by this pattern then please refer another article : Options pattern in ASP.NET Core: Advance scenario

Application's setting or configuration could come from multiple sources:

• JSON files - appsettings.json or any other JSON file.

• Environment variables

• Command lines arguments.

• Other sources like from DB, from xml file, from INI files etc.

Let's dive into code to solidify the understanding.

GitHub repo link for the code sample: dkj468/OptionsPatternDemo (github.com)

Let's assume we have some application configurations defined in appsettings.json file:

  "file": {
    "maxSize": "2Mib",
    "fileType": "pdf;jpeg;",
    "canModify": false,
    "maxFileCount":  5
  }

Our aim is to read this configuration data and use it throughout the application. There are multiple ways to read this data from appsettings.json in ASP.NET Core applications. Here, we will start with basic way which is to use IConfiguration interface and then will explore the Options pattern to achieve the same thing.

Reading configuration data using IConfiguration

appsettings.json content can be read easily using IConfiguration interface. We simply need to inject an instance of IConfiguration into controller constructor and all the config values are accessible to use.

    public class FileController : ControllerBase {
        private readonly IConfiguration _config;
        public FileController (IConfiguration config) {
            _config = config;
        }
        [HttpGet("config/iconfiguration")]
        public IActionResult GetFileConfig_IConfiguration() {
            var fileSize = _config.GetValue<string>("file:maxSize");
            var fileType = _config.GetValue<string>("file:fileType");
            var canModify = _config.GetValue<bool>("file:canModify"); 
            var maxFileCount = _config.GetValue<int>("file:maxFileCount");
            return Ok(new { fileSize = fileSize, fileType = fileType, canModify = canModify, maxFileCount = maxFileCount });
        } 
    }

Reading config data using IConfiguration is straightforward and doesn't require any rocket science in ASP.NET Core code. However, this approach has some problems such as:

• Security: IConfiguration has access to whole appsettings.json contents thus exposing the other settings as well.

• Code maintainability: configuration key must be named and used properly to avoid mistakes.

• No validation: There is no mechanism to validate configurations with IConfiguration

• No type safety: IConfiguration reads configuration values as string and those strings must be parsed manually to appropriate type.

• No default value: There is no mechanism to have a default value for a configuration.

• No reload on change: sometimes there are requirements to reload the changed configurations. with IConfiguration this can't be achieved.

As explained above, managing configurations using IConfiguration is straightforward but comes with some limitations. Now let's explore Options pattern to overcome all above shortcomings.

Reading Configuration data using Options pattern

There are 3 steps involved in using Options pattern:

• Defining a C# class which represents a mapping of configuration data.

• Binding the C# class with intended section of configuration file and registering it with services container

• Injecting the IOptions interface via constructor injection to use it.

Let's see this in action using code.

First, we will create a C# class representing the configuration data.

    public class FileOptions {
        public const string Key = "file";
        public string MaxSize { get; set; }
        public string FileType { get; set; }
        public bool CanModify { get; set; }
        public int MaxFileCount { get; set; }
    }

Second, we will bind the FileOptions class with file section of the configuration file and will register it with IServiceCollection inside Program.cs file.

builder.Services
    .Configure<FileOptions>(builder.Configuration.GetSection("file"));

There is another way to bind the configuration with Options class which is to use AddOptions extension method.

builder.Services
       .AddOptions<FileOptions>().Bind(builder.Configuration.GetSection("file"));

The later returns a OptionsBuilder<T> which allows to chain the configuration for advance scenario like handling custom validations, validations during startup of the application etc. We will discuss it further in upcoming article.

Third and final step, we will use this FileOptions options inside a controller to fetch the configuration data.

    public class FileController : ControllerBase {
        private readonly IConfiguration _config;
        private readonly FileOptions _fileOptions;

        public FileController(IConfiguration config, IOptions<FileOptions> fileOptions) {
            _config = config;
            _fileOptions = fileOptions.Value;
        }
        [HttpGet("config/iconfiguration")]
        public IActionResult GetFileConfig_IConfiguration() {
            var fileSize = _config.GetValue<string>("file:maxSize");
            var fileType = _config.GetValue<string>("file:fileType");
            var canModify = _config.GetValue<bool>("file:canModify");
            var maxFileCount = _config.GetValue<int>("file:maxFileCount");             
            return Ok(new { fileSize = fileSize, fileType = fileType, canModify = canModify, maxFileCount = maxFileCount });
        }

        // get config data using Options Pattern
        [HttpGet("config/option")]
        public IActionResult GetFileConfig_IOptions() {
            var fileSize = _fileOptions.MaxSize;
            var fileType = _fileOptions.FileType;
            var canModify = _fileOptions.CanModify;
            var maxFileCount = _fileOptions.MaxFileCount;
            return Ok(new { fileSize = fileSize, fileType = fileType, canModify = canModify, maxFileCount = maxFileCount });
        }
    }

In above code, we have injected IOptions with type FileOptions . Notice that Value property of IOptions interface returns an instance of FileOptions

There are some advance scenarios which could be handled easily with Options pattern for example:

• validation of configuration.

• validating the configuration values during application start-up.

• handling command line arguments or environment variables using Options pattern.

• monitoring for changes into configuration data etc.

This article aimed to explore the fundamental of Options pattern. In upcoming articles, we will explore how to handle above mentioned scenarios using this pattern.

Conclusion

In this article we have explored how to read application configuration using basic way i.e. using IConfiguration and later learned about Options pattern to achieve the same thing. On the surface, it seems an overkilling to use this pattern for the simple use case, but Options pattern has helped us achieving below things:

💥 type safety and manageable code: no more hard coded strings into code. Easy to change the configuration key names.

💥 Separation of concerns: Bind only related config and hide other details of configuration settings.

That's it for this article, In next article we will explore some advance use cases solved using Options pattern.

References and motivation

👉 Options pattern - .NET | Microsoft Learn

👉 Options Pattern inASP.NETCore – Bind & Validate Configurations from appsettings.json - codewithmukesh

👉 The Options Pattern Simplified. Easily use your configuration in your… | by Andre Lopes | Checkout.com-techblog | Medium

👉 How To Use The Options Pattern In ASP.NET Core 7 (milanjovanovic.tech)

Value Types

• Most of the c# built-in types such as numeric types, char types and boolean types are value types.

• custom structs and enum types are also value types.

• content of a value-type variable or constant is simply a value.

• The assignment operator always copies the value.

    int a = 10;
    int b = 7;
    b = a;   // copies the value of a into b
    Console.WriteLine(" a = {0}, b = {1}", a, b);  //  a = 10, b = 10
    a = 15;  // b won't change
    Console.WriteLine(" a = {0}, b = {1}", a, b);  //  a = 15, b = 10
  

custom value types

custom value types can be created using struct or enum .

 public struct Point { public int X; public int Y; }
 Point p1 = new Point();
 p1.X = 7;
 Point p2 = p1; // Assignment causes copy
 Console.WriteLine (p1.X); // 7
 Console.WriteLine (p2.X); // 7

 p1.X = 9; // Change p1.X
 Console.WriteLine (p1.X); // 9
 Console.WriteLine (p2.X); // 7

Reference Types

• A reference type has two parts: an object and the reference to that object.

• content of a reference-type variable or constant is a reference to an object that contains the value.

• a class type, an interface type, an array type, a delegate type, or the dynamic type are all reference types.

public class Point { public int X, Y; }
Point p1 = new Point();
p1.X = 7;
Point p2 = p1; // Copies p1 reference
Console.WriteLine (p1.X); // 7
Console.WriteLine (p2.X); // 7
p1.X = 9; // Change p1.X
Console.WriteLine (p1.X); // 9
Console.WriteLine (p2.X); // 9

value types and reference types and null

• null can be assigned to reference types without any issue. assigning null to a reference type indicates that the reference points at nothing.

• a value type cannot have null [Except Nullable Value types ]

  int x = null // compile time error

That's it for this article. Thanks for reading it. Please share your thoughts into comment section.

Below is the list of all the access modifiers used in the C# language

Public

• type or members with private access modifiers could be accessed by any code in the same assembly or another assembly referencing it.

• public is the default access modifier for members of an enum or interface.

• accessibility of public members is controlled by the access modifier of the type itself.

  Code example

  
    using System;
    namespace AccessModifierCode {
    class Employee {
        public int EmpId;
        public string Name;
        public Employee(int empid, string name) {
            EmpId = empid;
            Name = name;
        }
    }
    class Program {
        static void Main(string[] args) {
            // Creating object of the class Employee
            Employee E = new Employee(1, "Deepak");
            Console.WriteLine("Emp Id: {0}", E.EmpId);
            Console.WriteLine("Name: {0}", E.Name);
            Console.WriteLine();
        }
     }
    }
  

Private

• members declared with private access modifier are accessible only within the containing type.

• private access modifier is the most restrictive one.

• one can not declare a private class or struct directly inside a namespace.

  

• private is the default accessibility for members of a class or struct.

    public class Demo {
       string Name; //  private
    }
  

    using System;
    namespace AccessModifierCode {
    class Employee {
        public int EmpId;
        public string Name;
        private decimal Salary
        public Employee(int empid, string name, decimal salary) {
            EmpId = empid;
            Name = name;
            Salary = salary;
        }
    }
    class Program {
        static void Main(string[] args) {
            // Creating object of the class Employee
            Employee E = new Employee(1, "Deepak", 0);
            Console.WriteLine("Emp Id: {0}", E.EmpId);
            Console.WriteLine("Name: {0}", E.Name);
            Console.WriteLine("Salary: {0}", E.Salary); 
            // Error : 'Employee.Salary is inaccessible due to its protection level'
            Console.WriteLine();
        }
     }
    }
  

Internal

• types or members declared with internal modifiers are accessible within the same assembly or friend assembly. Learn more about Friend assembly

• internal is the default access modifier for class and struct types.

Protected

protected type or members are accessible within the same class or derived class.

public class Shape {
    protected int Width { get; set; }
    protected int Height { get; set; }
}
public class Rectangle : Shape {
    public Rectangle(int width, int height) {
        Width = width;
        Height = height;
    }
}

protected internal

• Types or members declared with the protected internal modifier can be accessed only within the same assembly or in a derived class from another assembly.

private protected

• A member that is private protected is accessible only within the containing type, or subclasses that reside in the same assembly (making it less accessible than protected or internal alone).

Restrictions on Access Modifiers

• Interfaces declared directly within a namespace can be public or internal and, just like classes and structs, interfaces default to internal access.

• Interface members are public by default.

• Enumeration members are always public, and no access modifiers can be applied.

• Delegates function similarly to classes and structs. When declared directly within a namespace, they have internal access by default, and when nested, they have private access.

• Derived classes and derived records can't have greater accessibility than their base types. You can't declare a public class B that derives from an internal class A. If allowed, it would have the effect of making A public, because all protected or internal members of A are accessible from the derived class.

When overriding a base class function, accessibility must be identical to the over‐ ridden function.

class BaseClass { 
    protected virtual void Foo() {} 
}
class Subclass1 : BaseClass { 
    protected override void Foo() {} // OK
} 
class Subclass2 : BaseClass { 
    public override void Foo() {} // Error
}

Summary table

(note: copied from MS learn)

So, that concludes our discussion on access modifiers. In this article, we covered the six access modifiers in C#: public, private, protected, internal, protected internal, and private protected. We learned about the purpose of each access modifier and their applications.

By employing the appropriate access modifier, we can ensure that our code is secure, user-friendly, and easy to maintain. Ultimately, this allows us to establish a clear and consistent structure for our code.

References and further reading

• https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers

• C# 10 in a Nutshell: The Definitive Reference

• https://stackoverflow.com/questions/614818/in-c-what-is-the-difference-between-public-private-protected-and-having-no

a delegate is a reference type variable that holds the reference of a method. C# delegates are similar to the C / C++ equivalent of pointers to the method - a delegate holds the address of a method that can be called using the delegate.

A delegate is an object that knows how to call a method.

Defining the delegate

A delegate type defines the kind of method that delegate instances can call. Specifically, it defines the method’s return type and its parameter types. The following defines a delegate type called Transformer:

delegate int Transformer (int x);

above delegate Transformer is compatible with any method with an int return type and a single int parameter. for example

    int Square (int x) { return x * x; }
    // OR
    int Square (int x) => x * x;

assigning a method to a delegate variable creates a delegate instance. a delegate instance can be invoked in the same way as a method.

Transformer t = Square;
int answer = t(3);  // 9
//OR 
int answer = t.Invoke(3); // 9

// t(3) is shorthand for t.Invoke(3)

• Delegates are used to define callback methods and implement event handling.

• Delegates allow methods to be passed as parameters.

• Delegates can be chained together; for example, multiple methods can be called on a single event (multicast delegates).

Multicast delegates

all delegates have multicast ability which means a delegate instance can reference more than one method.

SomeDelegate d = SomeMethod1;
d += SomeMethod2;

• multicast delegates are invoked in the order in which they are added.

• a method could be removed at runtime from the multicast delegate.

  d -= SomeMethod1;

• If a multicast delegate has a nonvoid return type, the caller receives the return value from the last method to be invoked. for most of the scenarios where multicast delegates are used, methods have a void return type.

Generic delegate types

A delegate type can have generic type parameters and return type :

public delegate T Transformer<T> (T arg);
int[] values = { 1, 2, 3 };
Util.Transform (values, Square); // Hook in Square
foreach (int i in values)
  Console.Write (i + " "); // 1 4 9
int Square (int x) => x * x;
public class Util {
 public static void Transform<T> (T[] values, Transformer<T> t) {
   for (int i = 0; i < values.Length; i++)
     values[i] = t (values[i]);
 }
}

The Func and Action Delegates

both Func and Action delegates are reference types that encapsulate a method.

The Func delegate refers to a method that accepts some parameters and returns a value.

The Action delegate refers to a method that accepts parameters but do not return any value.

below is the declaration syntax of a Func delegate :

Func<in_param 1, in_param 2, out_Param > name ;

      static void Main(string[] args) {
         Func<string, string, string> func = Concat;
         string fullName = func("Deepak", "Jain");
         Console.WriteLine(fullName);
         Console.ReadLine();
      }
      static string Concat (string firstName, string lastName) {
         return firstName + lastName;
      }

Below is an example of Action delegate :

Action<in_param> name

static void Main(string[] args) {
         Action<string> act = Display;
         act("Hello World"); // Hello World
         Console.ReadLine();
      }
      static Display (string content) {
         console.log(content);
      }

That's it for this article, please share your feedback in comment section.

references and further reading

• C# 10 in a Nutshell: The Definitive Reference

Boxing

Boxing is the process of converting value type (int, char etc) to reference type (object). Boxing is an implicit conversion where a value type being allocated on the heap rather than the stack.

int i = 10;
object o = i; //performs boxing - implicit boxing
object o = (object)i;  // explicit boxing
object o = (object)i;  // explicit boxing but never required

//more practical example
List<object> mixedList = new List<object>();

mixedList.Add("First Group:");  // boxing - string to object
mixedList.Add(10);              // boxing - int to object

Unboxing

Unboxing is explicit conversion from Object / reference type to value type. In the unboxing process, the boxed value type is unboxed from the heap and assigned to a value type that is stored on the stack. This process involves below steps

• Checking that object instance being 'unboxed' is a 'boxed' value of given value type.

• copying the value from object instance to value-type variable.

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;   // unboxing

//more practical example
List<object> mixedList = new List<object>();

mixedList.Add("First Group:");  // boxing - string to object
mixedList.Add(10); 
foreach (var item in mixedList) {
    // mixedList items are of object type,
    // while priting, object type will be 'unboxed' to 
    // corresponding value-type.
    Console.WriteLine(item); 
}

For the unboxing of value types to succeed at run time, the item being unboxed must be a reference to an object that was previously created by boxing an instance of that value type. Attempting to unbox null causes a NullReferenceException. Attempting to unbox a reference to an incompatible value type causes an InvalidCastException.

That's it for this article. Thanks for reading it and share your thoughts in comment section.

References and further reading

• https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/boxing-and-unboxing

• https://www.pluralsight.com/guides/csharp-passing-reference-vs-value-objective

As mentioned above, exceptions disrupt the flow of the program and terminate the program abnormally. It's the developer's responsibility to handle exceptions gracefully. If these errors are not handled properly, the program might crash and you may never know the root cause of failure.

Handling or responding to exceptions is called Exception Handling.

In C#, exception handling is achieved using 4 keywords :

• try: code that might generate exceptions is put inside the try block.

• catch: This block 'catches' the exception generated inside try block. The developer could decide what's need done once an exception is generated i.e. logging the stack trace, logging error messages, showing error prompts to the user etc.

• finally: This code block when written will always execute no matter whether an exception is raised or not. This is useful in scenarios where some clean-up code is required for example closing a file.

• throw: throw keyword is used to generate new exceptions in code.

In C#, exceptions are a type represented by classes derived from class Exception.

Exception classes

C# .NET includes built-in exception classes for every possible error. The Exception class is the base class of all the exception classes.

below is a list of common C# exception classes :

• System.NullReferenceException – Very common exception related to calling a method on a null object reference.

• System.IndexOutOfRangeException – Occurs attempting to access an array element that does not exist.

• System.IO.IOException – Used around many file I/O type operations.

• System.NET.WebException – Commonly thrown around any errors performing HTTP calls.

• System.Data.SqlClient.SqlException – Various types of SQL Server exceptions.

• System.StackOverflowException – If a method calls itself recursively, you may get this exception.

• System.OutOfMemoryException – If your app runs out of memory.

• System.InvalidCastException – If you try to cast an object to a type that it can’t be cast to.

• System.InvalidOperationException – Common generic exception in a lot of libraries.

• System.ObjectDisposedException – Trying to use an object that has already been disposed of.

Handling exception

try {
    int num = 0;
    // code that may raise an exception 
    int divideByZero = 7 / num;
}
catch (Exception e){
    // 'catching' and 'handling' the exception
    Console.WriteLine("Exception has occurred :" + e.Message);
}

running the above program shows the below output

if finally block is also available then it also gets executed

try {
    int num = 0;
    // code that may raise an exception 
    int divideByZero = 7 / num;
}
catch (Exception e){
    // 'catching' and 'handling' the exception
    Console.WriteLine("Exception has occurred :" + e.Message);
}
finally {
    Console.WriteLine("Inside finally");
}

How exception handling workflow works

When an exception is thrown within a try statement, the CLR performs a test:

Does the try statement have any compatible catch blocks?

• If so, execution jumps to the compatible catch block, followed by the finally block (if present), and then execution continues normally.

• If not, execution jumps directly to the finally block (if present), then the CLR looks up the call stack for other try blocks; if found, it repeats the test.

If no function in the call stack takes responsibility for the exception, the program terminates.

Multiple Catch Blocks

A program code that is written inside a try block might raise multiple types of exceptions. These multiple types of exceptions could be handled using multiple catch blocks. Remember that a more specialized catch block should come before a generalized one. Otherwise, the compiler will show a compilation error.

    class Test {
        static void Main(string[] args) {
            try {
                byte b = byte.Parse(args[0]);
                Console.WriteLine(b);
            }
            catch (IndexOutOfRangeException) {
                Console.WriteLine("Please provide at least one argument");
            }
            catch (FormatException) {
                Console.WriteLine("That's not a number!");
            }
            catch (OverflowException) {
                Console.WriteLine("You've given me more than a byte!");
            }
        }
    }

Catching all exception types

a catch block without bracket or having type as Exception can handle all exception types.

        try{
            div = 100 / x;
            Console.WriteLine("Not executed line");
        }
        catch {
            Console.WriteLine("oException");
        }

Throwing an Exception

using throw keyword, an exception could be thrown programmatically.

public class ProgramLog {
    FileStream logFile = null!;
    public void OpenLog(FileInfo fileName, FileMode mode) { }
    public void WriteLog() {
        if (!logFile.CanWrite) {
            throw new InvalidOperationException("Logfile cannot be read-only");
        }
        // Else write data to the log and return.
    }
}

User-defined exceptions

a user-defined exception class can be created by deriving from the Exception class.

When creating your own exceptions, end the class name of the user-defined exception with the word "Exception", and implement the three common constructors, shown below code :

using System;
public class EmployeeListNotFoundException : Exception {
    public EmployeeListNotFoundException() {
    }
    public EmployeeListNotFoundException(string message)
        : base(message) {
    }
    public EmployeeListNotFoundException(string message, Exception inner)
        : base(message, inner) {
    }
}

That's it for this article, please share your feedback in the comments.

References and further reading

• Handling and throwing exceptions in .NET | Microsoft Learn

• C# 10 in a Nutshell: The Definitive Reference

abstract: This modifier indicates that thing being modified has a missing or incomplete implementation.

This modifier in C# language applies to the following :

1. Class

2. Method

3. Properties

4. Indexers

5. Events

Abstract class

A class declared with abstract modifier is an abstract class.

• abstract classes are intended to be a base class of other classes - the developer can not create an Object of an abstract class.

• an abstract class can have both abstract methods ( methods with definition) and non-abstract methods (methods without definition).

• As an object can not be created for an abstract class, a derived class must be created for an abstract class.

    public abstract class Asset {
        public abstract decimal BuyPrice { get; }
        public abstract decimal SellPrice { get; }
        public abstract decimal CalculateProfit();
    }
    public class Stock : Asset {
        public override decimal BuyPrice => 100;
        public override decimal SellPrice => 150;
        public override decimal CalculateProfit() {
            return (SellPrice - BuyPrice);
        }
    }

• An abstract class must provide implementation for all interface members

• An abstract class that implements an interface might map the interface methods onto abstract methods.

    interface I {
        void M();
    }
    abstract class C : I {
        public abstract void M();
    }
  

Abstract methods / Properties

• abstract method declaration doesn't provide any implementation.

    public abstract class Asset {
            public abstract decimal CalculateProfit();
        }
  

• An abstract method is implicitly a virtual method - base class must provide its implementation.

• It is an error to use static or virtual modifiers in an abstract method declaration.

• Abstract method declarations are only permitted in abstract classes.

  

• Abstract properties behave like abstract methods, except for the differences in declaration and invocation syntax..

That's it for this article. Thanks for reading this, please share your feedback in the comments section below.

Before moving further to understand about virtual, override and new , it's important to understand how polymorphism is achieved in c#.

What is polymorphism?

The word polymorphism means having "many forms". In OOPs terminology, it has two aspects :

1. objects of the derived class may be treated as objects of the base class at run time i.e. derived class behavior could be accessed using the base class object.

2. the base class may define a method that could be overridden by child classes.

in C#, polymorphism is achieved in 3 ways: method overloading, method overriding and method hiding

Now let's discuss how virtual , override and new keyword comes into play to implement polymorphism.

• The base class declares a member as virtual. The member could be a method, property or event.

• Derived class may override the base class method to provide a new implementation of the base class method into the derived class.

• A derived class may hide the base class method using a new keyword.

Enough theory, now we would dive into code to understand these concepts.

Method overriding example

    public class Animal {
        public string Name;
        public virtual string AnimalType { get => "base"; }
        public virtual string Speak() {
            return "Speaks";
        }
    }
    public class Horse : Animal {
        public override string AnimalType { get => "Pet";  }
        public override string Speak() {
            return "Neighs";
        }
    }
    public class Lion: Animal {
        public override string AnimalType { get => "Wild"; }
        public override string Speak() {
            return "Roars";
        }
    }
    public static void Main(string[] args) {        
        Console.WriteLine("Start Of the Program");
        Lion l1 = new Lion();
        Animal a = l1;
        Console.WriteLine($"This animal is a {a.AnimalType} animal and it {a.Speak()}");

        Horse h1 = new Horse();
        Animal b = h1;
        Console.WriteLine($"This animal is a {b.AnimalType} animal and it {b.Speak()}");
        Console.ReadKey();
    }

In the above code block, Animal is base class that has few virtual members. These virtual members are being overridden by derived classes Lion and Horse differently

Method hiding example

derived classes may hide the base class method i.e. derived class could have a method same ( same method name, return type and parameters) as a base class. new keyword is used to hide the base class method

    public class BaseClass {
        public virtual void Display() {
            Console.WriteLine("BaseClass.Display");
        }
    }
    public class Overrider : BaseClass {
        public override void Display() { 
            Console.WriteLine("Overrider.Display"); 
        }
    }
    public class Hider : BaseClass {
        public new void Display() { 
            Console.WriteLine("Hider.Foo"); 
        }
    }

The difference in the output of the above two classes would be as :

  public static void Main(string[] args) {
        Console.WriteLine("Start Of the Program");
        Overrider over = new Overrider();
        BaseClass b1 = over;
        over.Display(); // Overrider.Foo
        b1.Display(); // Overrider.Foo
        Hider h = new Hider();
        BaseClass b2 = h;
        h.Display(); // Hider.Foo
        b2.Display(); // BaseClass.Foo

        Console.ReadKey();
 }

NOTE: base class method could be hidden even without using the new keyword. new keyword just suppresses the compiler warning which generates without using new.

Prevent derived class from overriding virtual method

A method declared as virtual in the base class will be available for an override at each level of the inheritance chain.

    public class A
    {
        public virtual void DoSomething() { }
    }
    public class B : A
    {
        public void DoSomethingElse() {}
    }
    public class C : B
    {
        public override void DoSomething() { }
    }

// class B decides not to override base class method still this method is available in class C to override.

Now if this user wants no further availability of DoSomething method in classes inherited by class C then it could be acheived using sealed keyword.

That's it for this article. Thanks for reading this, please share your feedback in the comments section below.

static : something which belongs to the type itself, not with an instance of the type.

The modifier in C# language applies to the following :

1. Variable

2. Methods

3. Class

4. Constructor

Now we would look at examples of each

static variable

• static variables are accessed with the name of the class.

• Only a single copy of the variable is created and shared among all the instances of the class.

• static variable can't be accessed with the instance.

• var can not be used to declare a static variable, one must specify the type of variable after the static keyword.

   public class Employee{
        public static int EmpCount = 0;
        public void AddEmployee(){
            EmpCount++;
        }
    }
    public static void Main(string[] args){
        Console.WriteLine("Start Of the Program");
        Employee emp1 = new Employee();
        emp1.AddEmployee();
        Console.WriteLine(Employee.EmpCount); // output 1

        Employee emp2 = new Employee();
        emp2.AddEmployee();
        Console.WriteLine(Employee.EmpCount); // output 2
        Console.WriteLine(emp2.EmpCount); // compilation error
        Console.ReadKey();
    }

static method

• Similar to static variables, static methods are also accessed with the name of the class.

• static methods could use both static and non-static class members.

• static members are directly accessed inside the static method without a class name, and non-static members are accessed using instances.

        public class Employee {
        private string FirstName;
        private string LastName;
        public Employee(string firstName, string lastName) {
            FirstName = firstName;
            LastName = lastName;
        }
        public string FullName { 
                get{
                    return ($"{this.FirstName} {this.LastName}");
                } 
        }
        public static int EmpCount = 0;
        public static void AddEmployee(Employee emp) {
            EmpCount++;
            Console.WriteLine(emp.FullName);
        }
    }
    public static void Main(string[] args) {
        Console.WriteLine("Start Of the Program");
        Employee emp1 = new Employee("John", "Smith");
        Employee.AddEmployee(emp1); // "John Smith" : instance specific data
        Console.WriteLine(Employee.EmpCount); // 1: static data
        Employee emp2 = new Employee("John", "Bold"); // "John Bold" : instance specific data
        Employee.AddEmployee(emp2);
        Console.WriteLine(Employee.EmpCount); // 2: static data
        Console.ReadKey();
    }

static constructor

• a static constructor is used to initialize static data or to perform an action that needs to be performed only once.

• A class can have only one static constructor.

• No parameter, No access modifier, No inheritance or overloading

• static methods could use both static and non-static class members.

• a static constructor is called automatically by the CLR. The user has no control over when a static constructor is executed in the program. static constructor runs before the instance constructor.

• a static constructor is called only for a single time during program execution.

    public class Organization {        
        static Organization() {
            Console.WriteLine("Static constrctor called");
        } 
        public Organization() {
            Console.WriteLine("Instance constructor called");
        }
    }
    public static void Main(string[] args) {
        Console.WriteLine("Start Of the Program");        
        Organization org1 = new Organization();
        Console.ReadKey();
    }
** Output **
Start Of the Program
Static constrctor called
Instance constructor called

static class

• static class can only contain static data members, static methods and static constructor. [Error if there are non-static fields, the non-static method in static class]

• Instances can not be created for a static class. [Error if user tries to create an instance of static class]

• static classes are sealed, they can't be inherited.

• static members can be accessed directly without using the class name inside the static class.

    public static class Organization {
        private static string FounderName = "James Clark";
        private static DateTime StartDate = new DateTime(1990, 01, 01);

        public static string Introduction;
        static Organization() {
            Introduction = $"This organization was founded by {FounderName} in {StartDate.Year}";
        }
    }
    public static void Main(string[] args) {
        Console.WriteLine("Start Of the Program");
        Console.WriteLine(Organization.Introduction);
    }
** Output **
Start Of the Program
This organization was founded by James Clark in 1990.

In this post, we have learned about static keyword in c#. Please share your feedback and suggestios to improve this.

Filters allows some code to run before and after specific stage in request processing pipeline. ASP.NET core has provided some built in filters , user could also create custom filters as well. Filters can also avoid duplicate code, for example exception filter can consolidate the error handling.

Built in filters are used for authorization, response caching, short circuiting the request processing pipeline.

Custom filters can be used for error handling, caching, configurations and logging purposes.

Filter pipeline runs after ASP.NET Core selects the action to be executed.

Filter types

Authorization Filter

Authorization filter is executed at the beginning of the request processing pipeline. This filter is used to determine whether user is authorized for request, and if not request pipeline can be short circuited.

    public class AuthorizationFilter : Attribute, IAuthorizationFilter {
        public void OnAuthorization(AuthorizationFilterContext context) {
            context.HttpContext.Response.WriteAsync("  OnAuthorization  ==> ");
        }
    }

Resource Filter

Resource filter is executed just after Authorization filter. This filter can be used to implement response caching, short circuiting the pipeline.

OnResourceExecuting runs code before the model binding. OnResourceExecuted runs after rest of the pipeline is executed.

    public class ResourceFilter : Attribute, IResourceFilter  {
        public void OnResourceExecuted(ResourceExecutedContext context)  {
            context.HttpContext.Response.WriteAsync("  OnResourceExecuted  ==>  ");
        }
        public void OnResourceExecuting(ResourceExecutingContext context) {
            context.HttpContext.Response.WriteAsync("  OnResourceExecuting  ==>  ");
        }
    }

Action Filter

Action filter is executed before and after the execution of action method inside controller. A custom action filter can be used to execute some reusable code block before or after execution of controller action. Action filter can modify the arguments passed into action method or can modify the result returned from action method.

    public class ActionFilter : Attribute, IActionFilter {
        public void OnActionExecuted(ActionExecutedContext context) {
            context.HttpContext.Response.WriteAsync("  OnActionExecuted  ==>  ");
        }
        public void OnActionExecuting(ActionExecutingContext context) {
            context.HttpContext.Response.WriteAsync("  OnActionExecuting  ==>  ");
        }
    }

Exception Filter

Exception filter can be used to handle exception during request processing pipeline. Using this filter, exceptions can be handled globally.

    public class ExceptionFilter : Attribute, IExceptionFilter  {
        public void OnException(ExceptionContext context)  {
            throw new NotImplementedException();
        }
    }

Result Filter

This filter runs immediately before and after the execution of action result. This runs after completion of the action method.

   public class ResultFilter : Attribute, IResultFilter {
        public void OnResultExecuted(ResultExecutedContext context) {
            context.HttpContext.Response.WriteAsync("  OnResultExecuted  ==>  ");
        }
        public void OnResultExecuting(ResultExecutingContext context) {
            context.HttpContext.Response.WriteAsync("  OnResultExecuting  ==>  "); 
        }
    }

Filter Scope

A filter can be added to the pipeline at three levels

• Controller level

using an attribute, Filter can be added to pipeline

    [AuthorizationFilter]
    [ResourceFilter]
    [ActionFilter]
    [ResultFilter]
    public class HomeController : Controller {
        private readonly ILogger<HomeController> _logger;
        public HomeController(ILogger<HomeController> logger) {
            _logger = logger;
        }
        public IActionResult Index() {
            HttpContext.Response.WriteAsync("  Inside Action ==>");
            return View();
        }
   }

• Action Level Using an Attribute at action level

        [ActionFilter]
        public IActionResult Index()  {
            HttpContext.Response.WriteAsync("  Inside Action ==>");
            return View();
        }

• Globally - For all controllers, Actions

        public void ConfigureServices(IServiceCollection services) {
            services.AddControllersWithViews(option => {
                option.Filters.Add<ResourceFilter>();
            });
        }

A middleware can perform below tasks :

• Decide whether to pass the HTTP request to the next middleware in request processing pipeline.
• Can modify the request / response before / after passing it to next middleware in pipeline.

Configuring the middleware

Middleware components are configured in Configure method of Startup.cs file. ASP.NET Core has provided some built-in middleware. Middleware can also be added via Nuget package manager or custom middleware can be added.

Below is the Startup.cs file's Configure method. All the middleware shown in this file are built-in middleware

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

Middleware ordering

Middleware components are executed in the order they are added to the pipeline and care should be taken to add the middleware in the right order otherwise the application may not function as expected. This ordering is critical for security, performance, and functionality.

Adding inline middleware using app.Use and app.Run method

Inline middleware can be added using app.use or app.Run method.

Middleware defined using app.Use may call next middleware component in the pipeline. Middlware defined using app.Run will never call subsequent middleware.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.Use(async (context, next) =>
    {
        await context.Response.WriteAsync("Middleware 1 using app.Use()");
        await next();
    });

    app.Use(async (context, next) =>
    {
        await context.Response.WriteAsync("Middleware 2 using app.Use()");
        await next();
    });

    app.Run(async context =>
    {
        await context.Response.WriteAsync("Middleware 3 using app.Run()");
        // Short circuiting the pipeline
    });

    // This will never be called
    app.Use(async (context, next) =>
    {
        await context.Response.WriteAsync("Middleware 4 using app.Use()");
        await next();
    });
}

Adding custom middleware

below is an example where a middleware is created to log the incoming request's http method

public class LogRequestMethodMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LogRequestMethodMiddleware> _logger;
    public LogRequestMethodMiddleware(RequestDelegate next, 
            ILogger<LogRequestMethodMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync (HttpContext context)
    {
        _logger.LogInformation(context.Request.Method);
        await _next(context);
    }
}

Inside Startup.cs file

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<LogRequestMethodMiddleware>();
    app.Run(async context =>
    {
        await context.Response.WriteAsync("\n Adding custom middleware");
    });
}

Built-in Middleware

ASP.NET Core has some built-in middleware for common application scenario :

• Exception/error handling
• HTTPS Redirection Middleware (UseHttpsRedirection) redirects HTTP requests to HTTPS.
• Static File Middleware (UseStaticFiles) returns static files and short-circuits further request processing.
• Cookie Policy Middleware (UseCookiePolicy) conforms the app to the EU General Data Protection Regulation (GDPR) regulations.
• Routing Middleware (UseRouting) to route requests.
• Authentication Middleware (UseAuthentication) attempts to authenticate the user before they're allowed access to secure resources.
• Authorization Middleware (UseAuthorization) authorizes a user to access secure resources.
• Session Middleware (UseSession) establishes and maintains session state. If the app uses session state, call Session Middleware after Cookie Policy Middleware and before MVC Middleware.
• Endpoint Routing Middleware (UseEndpoints with MapRazorPages) to add Razor Pages endpoints to the request pipeline.