JavaScript, How Response is processed

Predict output:
Example1.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await context.Response.WriteAsync("First Use Middleware\n"); // first execute
await next();
});

app.Use(async (context, next) =>
{
await context.Response.WriteAsync("Second Use Middleware\n"); // second execute
await next();
});

app.Run();

Output:
First Use Middleware
Second Use Middleware

Example2.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await next();
await context.Response.WriteAsync("First Use Middleware\n"); // #2
});

app.Use(async (context, next) =>
{
await context.Response.WriteAsync("Second Use Middleware\n"); // #1
await next();
});

app.Run();
Output:
Second Use Middleware
First Use Middleware

Example3.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await next();
await context.Response.WriteAsync("First Use Middleware\n"); // #2
});

app.Use(async (context, next) =>
{
await next();
await context.Response.WriteAsync("Second Use Middleware\n"); // #1
});

app.Run();
Output:
Second Use Middleware
First Use Middleware

Example4.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
context.Response.Headers["cutsom-response-header"] = "This is a response header";
await next();
await context.Response.WriteAsync("First Use Middleware\n"); // #2
});

app.Use(async (context, next) =>
{
await next();
await context.Response.WriteAsync("Second Use Middleware\n"); // #1
});

app.Run();
Output:
Second Use Middleware
First Use Middleware

Example5.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
context.Response.Headers["cutsom-response-header"] = "This is a response header"; //#1
await next();
await context.Response.WriteAsync("First Use Middleware\n"); //#4
});

app.Use(async (context, next) =>
{
context.Response.Headers["custom-response-header"] = "This is second response header"; //#2
await next();
await context.Response.WriteAsync("Second Use Middleware\n"); //#3
});

app.Run();
Output:
Second Use Middleware
First Use Middleware

Example6.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await next();
await context.Response.WriteAsync("First Use Middleware\n"); //#4 NEVER executed
context.Response.Headers["response-header-first"] = "This is a response header"; //#3 ERROR Cannot modify after Response has started
});

app.Use(async (context, next) =>
{
context.Response.Headers["response-header-second"] = "This is second response header"; //#1
await next();
await context.Response.WriteAsync("Second Use Middleware\n"); //#2
});

app.Run();
Output:
This localhost page can’t be foundNo webpage was found for the web address: https://localhost:7205/
HTTP ERROR 404

Example7.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await next(); //#1
await context.Response.WriteAsync("First Use Middleware\n"); //#2
context.Response.Headers["response-header-first"] = "This is a response header"; //#3 ERROR
});

app.Run();

Example8.
var builder = WebApplication.CreateBuilder(args);

var env = builder.Environment;
var logging = builder.Logging;
var services = builder.Services;

services.AddControllers();

var app = builder.Build();

app.Use(async (context, next) =>
{
await next(); //#1
context.Response.Headers["response-header-first"] = "This is a response header"; //#2
await context.Response.WriteAsync("First Use Middleware\n"); //#3
});

app.Run();

Output:
First Use Middleware

C# Delegate Revisited

In C#, delegate is a reference type used to encapsulate method with a specific signature and return type. You can encapsulate any matching method in an object of the delegate. A delegate is instanciated similar to class using new operator. We pass a method reference in its constructor. Delegate object can be used to run the method at runtime.

Look at the following example: int x; x=20;

We declare a int type variable and initialize with integer type value.

Same analogy can be drawn w.r.t. delegate.We define a delegate and then declare a variable of delegate type. The variable can be initialized later with relevant value(i.e. the value matching the data type). 

We define a delegate using delegate keyword, (similar to class) which is followed by a return type of method and then method signature (Instead of {}which is followed by class name).

public delegate DelegateName ReturnType Method-Signature

Then delegate reference variable can be declared as follows:

DelegateName refVariableForDelegate;

The delegate reference variable can be initialized with a method reference. A method reference is just the name of a defined method.

Now, We understand the above points by an example.

Suppose, we have the following Operations class with Math related methods in it.

internal class Operations
{
    public static double Sum(double number1, double number2)
    {
        return number1 + number2;
    }
    public static double Product(double number1, double number2)
    {
        return number1 * number2;
    }
}

We observe that Sum and Product have same method signatures. Also, their return type is same i.e. double.

We can define a delegate for these methods which can be as follows:

public delegate double MathFunction(double number1, double number2);

In above delegate definition, note the following points:

• MathFunction is the name of delegate.
• The delegate is public in scope.
• The double is the return type of the delegate.
• The (double number1, double number2) implies that the delegate can refer to any method of two parameters which are of double type and return type is double.
• At this moment, when MathFunction delegate is declared, we cannot say what responsibility will be dispatched to MathFunction delegate; actual behavior will be decided when it will be initialized.

Delegate vs Interface: Note that in a sense, abstract method is given when delegate is defined. It is similar to interface but there are differences between interface and delegate. 

• A class cannot have multiple implementation of interface method but a class can have multiple implementation of delegate method. 
• A class cannot implement method of interface dynamically but delegate methods can be dynamically implemented.

Delegate Reference Variable & its Initialization: We have just defined delegate as reference type. Now we can declare a reference variable of this delegate type. For example, MathFunction action; This statement will be declaration of delegate reference variable, action. (Look at the analogy of int x;). The delegate reference variable is still not initialized. We need a method to initialize this delegate reference variable. We will see it ahead. This will be encapsulation of method of class inside delegate. So, you can say that method encapsulation takes place when a delegate is initialized or you can say that method encapsulation is core objective of delegate. We will see it in forthcoming paragraphs.

Looking the previous example, MathFunction delegate can be delegated the task to execute the Sum and Product methods because both methods signatures and return type matches with the defined delegate. Note that a delegate can be passed the reference of static or not static method. To pass the reference of non-static method, we must first instantiate the class of the method. To pass the reference of static method, we directly use the class name of the method. 

The delegate type should not be static. Using static keyword with a delegate during its defintion is illegal. So, you cannot define the delegate as follows:

public static delegate double MathFunction(double number1, double number2);

Note that delegate is a type and can be defined independently, not necessarily inside Operations class. The Operations class or any other class can consume the defined delegate.

Different ways to initialize Delegates

Now, we see different ways to initialize a delegate (more appropriately, delegate reference variable).

1. By using new operator
2. Without using new operator, just by using method name
3. Anonymous method
4. Lambda Expression

These are four common ways to initialize a delegate. Now, we see it the context of MathFunction.

Let, MathFunction is referenced using action delegate reference variable:

MathFunction action;

Now, action can be initialized in following ways:

1. action = new MathFunction(Operations.Sum);
2. action = Operations.Sum;
3. action = delegate(double x, double y) { return x + y; }
4. action = (x,y)=>x+y;

Consuming Delegate:

A delegate can be consumed by a class in different ways:

1. Delegate as field of class
2. Delegate as property of class
3. Delegate as parameter of method of class etc.

Example1. Delegate as field of class:

Suppose that there are two classes Class1 and Class2 which have some methods. Let, some of these methods can be encapsulated using a delegate. Now, as a developer, you can create delegate reference variable in Client class and pass the method reference to the delegate variable when you need to invoke any encapsulated method. But another design pattern can be to create delegate reference variable in each class - Class1 and Class2. These classes will use the delegate themselves and the Client class be relived from the burden of delegate initialization. Look at the following code, I have used Arithmetic and Calculus for Class1 and Class2 respectively:

namespace CSharp_Delegates.Example2;
public delegate int MyDelegate(int x, int y);
internal class DelegateAsField
{
    public static void Test()
    {
        Arithmetic arithmetic = new Arithmetic();
        Calculus calculus = new Calculus();
        Console.WriteLine("Sum:{0}",arithmetic.GetSum(20, 330));
        Console.WriteLine("Product:{0}",arithmetic.GetProduct(20, 30));
        Console.WriteLine("Multiply:{0}",calculus.GetMultiply(12, 12));
        Console.WriteLine("Divide:{0}",calculus.GetDivide(12, 4));
    }

}
class Arithmetic
{
    MyDelegate? _delegate;
    public int GetSum(int number1, int number2)
    {
        _delegate = this.Sum;
        return _delegate(number1, number2);
    }
    public int GetProduct(int number1, int number2)
    {
        _delegate = this.Product;
        return _delegate(number1, number2);
    }
    private int Sum(int x, int y)
    {
        return x + y;
    }
    private int Product(int x, int y)
    {
        return x * y;
    }
}

class Calculus
{
    MyDelegate? _delegate;
    public int GetDivide(int number1, int number2)
    {
        _delegate = this.Divide;
        return _delegate(number1, number2);
    }
    public int GetMultiply(int number1, int number2)
    {
        _delegate = this.Multiply;
        return _delegate(number1, number2);
    }
    private int Divide(int x, int y)
    {
        if (y!=0)
        {
            return x / y;
        }
        throw new DivideByZeroException("Zero denominator not allowed");
    }
    private int Multiply(int x, int y)
    {
        return x * y;
    }
}

Example2. Delegate as property of class:

Look at the following code. It is the same code as Example1 but delegate field is replaced by delegate property. Fields are usually private but properties are public in C#. It is on you to decide how you want to use delegate in consuming class.

namespace CSharp_Delegates.Example3;

public delegate int MyDelegate(int x, int y);
internal class DelegateAsProperty
{
    public static void Test()
    {
        Arithmetic arithmetic = new Arithmetic();
        Calculus calculus = new Calculus();
        Console.WriteLine("Sum:{0}", arithmetic.GetSum(120, 330));
        Console.WriteLine("Product:{0}", arithmetic.GetProduct(5, 30));
        Console.WriteLine("Multiply:{0}", calculus.GetMultiply(13, 13));
        Console.WriteLine("Divide:{0}", calculus.GetDivide(12, 6));
    }
}
class Arithmetic
{
    public MyDelegate? _delegate { get; set; }
    public int GetSum(int number1, int number2)
    {
        _delegate = this.Sum;
        return _delegate(number1, number2);
    }
    public int GetProduct(int number1, int number2)
    {
        _delegate = this.Product;
        return _delegate(number1, number2);
    }
    private int Sum(int x, int y)
    {
        return x + y;
    }
    private int Product(int x, int y)
    {
        return x * y;
    }
}
class Calculus
{
    public MyDelegate? _delegate{ get; set; }
    public int GetDivide(int number1, int number2)
    {
        _delegate = this.Divide;
        return _delegate(number1, number2);
    }
    public int GetMultiply(int number1, int number2)
    {
        _delegate = this.Multiply;
        return _delegate(number1, number2);
    }
    private int Divide(int x, int y)
    {
        if (y != 0)
        {
            return x / y;
        }
        throw new DivideByZeroException("Zero denominator not allowed");
    }
    private int Multiply(int x, int y)
    {
        return x * y;
    }
}

Example3. Delegate as parameter of method:

Passing delegate as parameter is very common application. Delegate can be used as callback. Look at the following simple code in which method is passed parameter of delegate type:

namespace CSharp_Delegates.Example1;
public delegate double MathFunction(double number1, double number2);
internal class Operations
{
    public static double Sum(double number1, double number2)
    {
        return number1 + number2;
    }
    public static double Product(double number1, double number2)
    {
        return number1 * number2;
    }
}
public class Client
{
    public static void DoMath()
    {
        DoSomeMath(Operations.Sum);
        DoSomeMath(Operations.Product);
    }
    public static void DoSomeMath(MathFunction action)
    {
        if (action != null)
        {
            double result = action.Invoke(2.0, 1.1);
            Console.WriteLine(result.ToString());
        }
    }
}

In the above code, Client class uses MathFunction delegate as parameter of DoSomeMath method. When this method is called inside DoMath method then, delegate reference variable, action, is passed the method reference (e.g. Operations.Sum).

Till now, what we learnt?

• The delegate in itself does not tell what it can do. The developer has the responsibility to decide what action/functionality to perform with delegate. 
• Delegate is just a reference type with method reference. Looking at delegate defintion, we can have idea what type of data will be passed as parameters to the method and what type of data will be returned but actual data can be observed only at runtime.
• Delegate is initialized by associating/referencing it with some method at compile time.
• When delegate is initialized then at runtime its associated/referenced method is invoked.
• Delegate initialization is all about method encapsulation. It is similar to data encapsulation which occurs when a class is initialized.

Additional Notes:

A delegate can be defined inside a class also. It is not necessary that a delegate must be defined inside namespace as separate independent type.

This is first part of the article. It will be continued for other topics such as

1. Array of delegates
2. Delegate and Interface
3. Delegate and Event
4. Delegate with Generics
5. Multicast
6. Delegate and Callback
7. Delegate and Asynchronous Task

C# Delegate and Event, Additional FAQs

Question1

Delegate is a type in C#. Delegate and event are closely related. Is event is a type in C#?

Yes, in C#, an event is technically a member, not a type itself. It acts as a special form of delegate, providing a way to encapsulate a delegate and control how it’s accessed from outside the containing class.

C# Attribute, Additional FAQs

Question1

Can Attribute based class in C# can be a static class?

No, an attribute class in C# cannot be a static class. In C#, attribute classes must inherit from System.Attribute, and they are instantiated when applied to program elements like classes, methods, properties, etc. Since static classes cannot be instantiated, they cannot be used as attribute classes.

C# How can you call a method of base class in derived class?

In C#, you cannot directly call a private method (or any member) from a base class in a derived class. Private members are not accessible outside the class in which they are defined, even in derived classes. However, if you want to call a method that's marked as protected or internal (or any other access modifier that allows visibility to derived classes), you can call it from the derived class.

C# Difference between IEnumerable and IEnumerator

IEnumerable and IEnumerator are both interfaces in C# that are used to work with collections of data, particularly when you want to iterate (loop) through the elements of a collection. They play different roles in the process of iterating through a collection. Here are the key differences between them:

C# Difference between TryParse and Parse

TryParse and Parse are methods used in C# to convert a string representation of a value into its corresponding data type, such as an integer, floating-point number, or date.

C# Custom Exception

In C#, a custom exception is a user-defined exception that extends the built-in Exception class or any of its derived classes. Creating custom exceptions allows you to handle specific error cases in your application in a more meaningful and organized way.

C# Custom Attribute Example

In C#, custom attributes (also known as custom metadata or annotations) allow you to attach additional information or metadata to various program entities such as classes, methods, properties, and more. These attributes are then accessible at runtime using reflection, which allows you to inspect and manipulate the behavior of your code based on this metadata. Custom attributes are commonly used in scenarios like serialization, validation, and code documentation.

Here's an example of creating a custom attribute in C#:

using System;

// Define a custom attribute called "AuthorAttribute" that can be applied to classes and methods.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class AuthorAttribute : Attribute
{
    public string Name { get; }

    public AuthorAttribute(string name)
    {
        Name = name;
    }
}

// Apply the custom attribute to a class and a method.
[Author("John Doe")]
class MyClass
{
    [Author("Alice Smith")]
    public void MyMethod()
    {
        Console.WriteLine("Hello, world!");
    }
}

class Program
{
    static void Main()
    {
        // Use reflection to access and display the custom attribute values.
        Type myClassType = typeof(MyClass);
        object[] classAttributes = myClassType.GetCustomAttributes(typeof(AuthorAttribute), false);

        if (classAttributes.Length > 0)
        {
            AuthorAttribute classAuthorAttribute = (AuthorAttribute)classAttributes[0];
            Console.WriteLine($"Author of MyClass: {classAuthorAttribute.Name}");
        }

        var myMethod = typeof(MyClass).GetMethod("MyMethod");
        object[] methodAttributes = myMethod.GetCustomAttributes(typeof(AuthorAttribute), false);

        if (methodAttributes.Length > 0)
        {
            AuthorAttribute methodAuthorAttribute = (AuthorAttribute)methodAttributes[0];
            Console.WriteLine($"Author of MyMethod: {methodAuthorAttribute.Name}");
        }
    }
}

In this example:

1. We define a custom attribute called AuthorAttribute that takes a string parameter in its constructor.
2. We apply this custom attribute to both a class (MyClass) and a method (MyMethod) using square brackets.
3. In the Main method, we use reflection to access the custom attribute values for the MyClass and MyMethod. We retrieve the attribute objects and extract the Name property to display the author's name.

When you run this code, it will output:

Author of MyClass: John Doe
Author of MyMethod: Alice Smith

This demonstrates how custom attributes can be used to attach additional information to program entities and retrieve that information at runtime using reflection.

C# Delegates and Events in depth

In C#, delegates and events are related and crucial concepts used for implementing the observer design pattern, enabling a way to provide notifications when certain actions or events occur in a program.

C# Task class, Asynchronous and Parallel Tasks

In C#, tasks are used to represent asynchronous operations. They are part of the Task Parallel Library (TPL) and provide a way to perform work asynchronously on a separate thread. Creating a task in C# involves using the Task class or related methods. Here are the common ways to create a task:

C# Type class and Reflextion

What is use of Type class in C#?

In C#, the Type class is a fundamental class that is a part of the .NET Framework. It represents type declarations and provides various methods and properties to obtain information about types at runtime. The Type class is a crucial part of reflection, which allows you to inspect and manipulate types, methods, properties, and other members of a program dynamically.

C# Enum In Depth

In C#, the Enum class is used to work with enumeration types, which are user-defined value types that consist of a set of named constants. Enumerations provide a way to define a collection of related named constants, which makes the code more readable and maintainable. 

C# Verbatim String Literal

In C#, a verbatim string literal is a way to specify a string without escape sequences, meaning that backslashes are treated literally rather than as escape characters. This is useful when you want to include special characters or a sequence of characters that would otherwise be interpreted as escape sequences.

To create a verbatim string literal, you prefix the string with the "@" symbol. Here's an example:

string path = @"C:\s\name\Documents";

In this example, the backslashes (\) are treated as literal characters and are not interpreted as escape sequences. This is especially helpful for file paths, regular expressions, or any other scenario where you want to include backslashes or other special characters without needing to escape them.

For comparison, the same string without using a verbatim string literal would be written like this:

string path = "C:\\s\\name\\Documents";

Using a verbatim string literal can make your code more readable and easier to work with when dealing with strings that contain many escape characters or backslashes.

C# Different ways to create an instance of class

In C#, there are several ways to create an instance of a class, depending on the specific requirements and design patterns being used. Here are some common ways to create instances of a class:

1. Using the new Keyword:
The most common way to create an instance of a class is using the new keyword followed by the class name, followed by parentheses (if the class has a parameterless constructor).

MyClass myObject = new MyClass(); // Creating an instance using a parameterless constructor

2. Using Constructors with Parameters:
If the class has constructors with parameters, you can use these constructors to initialize the instance.

MyClass myObject = new MyClass("parameter1", 42); // Creating an instance using a constructor with parameters

3. Using Object Initializer:
This approach allows you to set the properties of the object after it's created using an initializer syntax.

MyClass myObject = new MyClass{
Property1 = "value1",      
Property2 = 42   
};

4. Using Factory Methods:
You can define static or instance methods within the class or a separate factory class to create and return instances of the class.

   
public class MyClass
{
  public static MyClass CreateInstance() 
  {
  return new MyClass();
  }
}
MyClass myObject = MyClass.CreateInstance();

5. Using Object Cloning:
If your class implements ICloneable interface or provides a custom cloning mechanism, you can create a new instance by cloning an existing object.

MyClass myObject = originalObject.Clone();

6. Using Activator.CreateInstance:
The Activator class provides a generic method to create instances of a type, even when the type is not known at compile time.

MyClass myObject = Activator.CreateInstance();

7. Using Reflection:
You can use reflection to create an instance of a class dynamically, especially when the class type is determined at runtime.

Type classType = Type.GetType("Namespace.MyClass");  
MyClass myObject = (MyClass)Activator.CreateInstance(classType);

It's important to choose the appropriate approach based on the requirements of your application and the design principles you want to follow.

C# Record Explained

In C#, a record is a feature introduced in C# 9.0 that allows you to define lightweight, immutable data structures in a concise and expressive manner. Records provide a convenient way to define types that are primarily used to store and represent data.

Here are the key aspects and features of records in C#:

1. Immutable by Default:
Records are immutable by default, meaning their values cannot be modified after creation. This is essential for creating reliable and predictable data structures.

2. Data-Centric:
Records are designed to represent data, making them an excellent choice for modeling objects that primarily hold data without behavior.

3. Concise Syntax:
C# records offer a concise syntax for defining properties and initializing their values. You can define a record using the record keyword, followed by the record's name and its properties.

   public record Person(string FirstName, string LastName);

4. Property Definitions:
Properties in a record are defined directly within the record declaration. The properties are implicitly read-only, meaning you cannot assign new values to them once the record is created.

5. Value Equality:
Records automatically implement value equality based on their property values. This means two record instances with the same property values are considered equal.

6. Deconstructor:
Records provide a deconstructor, which allows you to easily destructure a record into its constituent properties.

7. Inheritance and Overriding:
Records can inherit from other classes and interfaces, and you can override methods, including ToString(), GetHashCode(), and Equals().

Here's a simple example of using a record:

public record Person(string FirstName, string LastName);

class Program
{
    static void Main()
    {
        Person person1 = new Person("John", "Doe");
        Person person2 = new Person("John", "Doe");

        Console.WriteLine(person1.Equals(person2));  // Outputs: True

        // Deconstruction
        var (firstName, lastName) = person1;
        Console.WriteLine($"First Name: {firstName}, Last Name: {lastName}");
    }
}

In this example, we define a record Person with two properties (FirstName and LastName). We create two instances of the Person record and demonstrate value equality and deconstruction features.


Custom Constructor in Records

In C#, records are a special kind of type introduced in C# 9.0 that provides a succinct way to declare a type and is often used to model immutable data. Records automatically provide a default constructor, which initializes the properties of the record.

However, records in C# do not allow you to define a custom constructor explicitly. The default constructor is provided by the language and automatically initializes the properties based on the values provided during object creation.

Here's an example of a record in C#:

public record Person(string FirstName, string LastName);

In this example, a Person record is defined with two properties: FirstName and LastName. The default constructor for this record is automatically provided by the compiler.

If you need custom initialization logic for your record, you can still use methods or factory methods to achieve the desired behavior:

public record Person(string FirstName, string LastName)
{
    public Person(string fullName)
    {
        var parts = fullName.Split(' ');
        FirstName = parts.Length > 0 ? parts[0] : string.Empty;
        LastName = parts.Length > 1 ? parts[1] : string.Empty;
    }
}

In this modified example, we have added a custom constructor Person(string fullName) that takes a full name and initializes the FirstName and LastName properties accordingly.

Keep in mind that records are primarily designed for immutability and straightforward data representation, so complex initialization logic is generally better suited for methods or factory methods.

C# Event Definition & Record

Can event be defined in record in C#?

In C#, events cannot be defined directly within a record type. Records are designed to be lightweight data structures that represent immutable values, and they are primarily used for data storage and retrieval. Events, on the other hand, are mechanisms used to provide notifications or callback functionality when something happens in a class or object.

If you need to define events in your C# code, you typically do so within a class rather than a record. Here's an example of how you would define an event within a class:

public class MyClass
{
    public event EventHandler MyEvent;

    public void DoSomething()
    {
        // Trigger the event when something happens
        MyEvent?.Invoke(this, EventArgs.Empty);
    }
}

In this example, MyClass has an event called MyEvent, and you can subscribe to this event and handle its occurrences in other parts of your code.

Records are more suitable for scenarios where you want to define simple data structures with value semantics and automatic implementations of equality, immutability, and other features. Events are typically associated with classes that represent behavior or functionality.

If you need a combination of events and data storage, you can use a class to encapsulate both your data and event-handling logic.

C# What are different ways to call a method?

In C#, methods can be called in various ways depending on the context and the type of method. Here are different ways to call a method in C#:

1. Direct Method Call:
This is the most common way to call a method. You simply specify the method name followed by parentheses and any required arguments.

    methodName(argument1, argument2);

2. Calling Static Methods:
For static methods, you can call the method directly using the class name.

    ClassName.MethodName(argument1, argument2);

3. Calling Instance Methods:
For instance methods, you need to create an instance of the class and then call the method on that instance.

    ClassName instance = new ClassName();

    instance.MethodName(argument1, argument2);

4. Method Chaining:
If a method returns an object of the same class, you can chain method calls together.

    instance.Method1().Method2().Method3();

5. Using Delegates:
Delegates allow you to store and call a reference to a method. You can invoke the delegate to call the method.

    delegateType delegateName = methodName;

    delegateName(argument1, argument2);

6. Using Lambda Expressions:
You can create and call methods using lambda expressions, especially for delegates or functional interfaces.

    delegateType delegateName = (arg1, arg2) => { /* method implementation */ };

    delegateName(argument1, argument2);

7. Using the Invoke Method:
For delegates, you can use the Invoke method to call the referenced method.

    delegateName.Invoke(argument1, argument2);

8. Using Event Handlers:
Event handlers are methods that are called when a specific event occurs. They are usually subscribed to events in the application.

    eventName += methodName; // Subscribe the method to the event

9. Using Named Arguments:
You can specify arguments by their parameter names, allowing you to provide them in a different order or omit some optional parameters.

    methodName(parameter2: value2, parameter1: value1);

These are some of the common ways to call methods in C#. The choice of method calling approach depends on the specific requirements and design of your application.

C# Partial class or Partial types

A partial class in C# allows you to split the definition of a class, struct, interface, or method across multiple files. This can be useful when working on large projects or when using auto-generated code, as it allows for organizing code in a way that separates auto-generated and manually written parts of the class. The partial keyword is used to specify that a class has been divided into parts.

Key Features of Partial Classes

1. Organizational Clarity: Keeps code cleaner by separating different functionalities or generated code from manually written code.
2. Team Collaboration: Multiple team members can work on the same class in different files without merging conflicts.
3. Auto-generated Code: Useful in cases where tools like Visual Studio generate code for you, as in Windows Forms or Entity Framework.

How to Use Partial Classes

To define a partial class, declare it using the partial keyword in each file where the class definition is split. Each file must have the same class name and be in the same namespace.

Example of Partial Class

Suppose you have a class Person split into two files, Person1.cs and Person2.cs:

File: Person1.cs

public partial class Person
{

    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string GetFullName()
    {
        return $"{FirstName} {LastName}";
    }
}

File: Person2.c

public partial class Person
{
    public int Age { get; set; }
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {GetFullName()}, Age: {Age}");
    }
}

Both parts together make up the complete Person class, with FirstName, LastName, Age, and methods GetFullName and DisplayInfo.

Points to Remember

• All parts must use the partial keyword.
• All parts must have the same accessibility level (e.g., public, internal).
• If partial classes contain conflicting members, a compilation error will occur.
• The compiler combines all parts into a single class during compilation.

Use Cases

• Generated Code: Typically used when tools or frameworks generate part of the class.
• Large Classes: Split functionality for better organization, especially in large classes.

Partial classes are mainly used to improve code readability and maintainability, especially in projects where auto-generated code is prevalent or when dealing with large classes.

C# Partial Method Declaration, Implementation and Usage

Partial methods in C# are a feature that allows a method to be defined in one part of a partial class and implemented in another part. Partial classes and methods are often used in code generation scenarios, where some parts of the code are generated automatically and other parts are customized by the developer.

Here are the rules for creating and using partial methods in C#:

1. Partial Methods Declaration:

   Partial methods are declared using the partial keyword in a partial class or struct. The declaration of a partial method contains only the method signature, without an implementation.

partial void MyPartialMethod(int x);

2. Partial Method Implementation:

   The partial method can be implemented in another part of the partial class or struct. The implementation of a partial method is optional, and it's not an error if the partial method is never implemented.

partial void MyPartialMethod(int x)
{
 // Implementation code here
}

3. Usage of Partial Methods:

   Partial methods can be called like any other method within the partial class. If the partial method is not implemented, any calls to it are removed by the compiler at build time, minimizing overhead.

public void SomeMethod()
{
 // Call the partial method
 MyPartialMethod(42);
}

4. Visibility and Modifiers:

   Partial methods can have any visibility modifier (public, private, protected, internal, etc.). They can also have modifiers like static, virtual, abstract, sealed, and override as applicable.

partial void MyPartialMethod(int x);

5. Return Type and Parameters:

   Partial methods can have any return type, including void. They can also have parameters, including optional parameters.

partial void MyPartialMethod(int x, string message = "Default message");

6. Partial Method Signature Constraints:

   The signature (name, return type, and parameters) of a partial method must be the same in both the declaration and the implementation.

partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x) // Valid, matching signature
{
 // Implementation code here
}

7. One Declaration, One Implementation:

   A partial method can have at most one declaration and at most one implementation. If there are multiple declarations or implementations, it will result in a compilation error.

// Error: Multiple partial method declarations with the same name and signature
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x);

// Error: Multiple partial method implementations with the same name and signature
partial void MyPartialMethod(int x)
{
 // Implementation 1
}

partial void MyPartialMethod(int x)
{
 // Implementation 2
}

Partial methods are commonly used in scenarios where generated code needs to call into user-defined code without requiring the user to implement the method if it's not needed.

C# Extension method and its use

Objectives:

• What is Extension Method
• How to create Extension methods 
• How to use Extension Method

Extension methods in C# allow you to add new methods to existing types without modifying the original type or creating a new derived type.

Features of Extension Method

1. It is defined as a member of static class.
2. It is a static method which first parameter's type is the type which extension method is being defined; also this first parameter must be prefixed/qualified with this keyword.
3. It is invoked or called on the instance of the type (as if the this static method is an extension method of the type).

Here's how you can create and use extension methods in C#:

1. Create a static class for extension methods: First, create a static class to contain the extension methods. The class should be static, and the methods should also be static. The class should be in the same namespace as the types you want to extend.

   using System;

   public static class StringExtensions
   {
       public static string Reverse(this string str)
       {
           char[] charArray = str.ToCharArray();
           Array.Reverse(charArray);
           return new string(charArray);
       }
   }
   

In this example, we're creating an extension method called Reverse for the string type.

2. Define the extension method: The extension method is a static method defined in the static class. It takes the type to be extended as the first parameter, prefixed with the this keyword.

3. Using the extension method: You can then use the extension method on instances of the extended type.

   using System;

   class Program
   {
       static void Main(string[] args)
       {
           string originalString = "hello";
           string reversedString = originalString.Reverse();
           Console.WriteLine("Original: " + originalString);
           Console.WriteLine("Reversed: " + reversedString);
       }
   }
   

In this example, we're calling the Reverse extension method on a string instance.

4. Output: The Reverse extension method modifies the behavior of the string type without modifying the original string class.

Original: hello Reversed: olleh

Remember to include the namespace where the extension method class is defined (if it's in a different namespace) or import the namespace to use the extension methods.