Dotnet Questions

What is implementation of JWT authentication in asp.net core

JWT (JSON Web Token) authentication is a popular way of implementing authentication in ASP.NET applications. Here are the steps involved in implementing JWT authentication in ASP.NET:

Install the required packages:

First, you need to install the Microsoft.AspNetCore.Authentication.JwtBearer package using NuGet Package Manager.

Configure authentication:

Next, you need to configure authentication in your ASP.NET application by adding the following code to the ConfigureServices method in the Startup.cs file:

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)

.AddJwtBearer(options =>

{

options.TokenValidationParameters = new TokenValidationParameters

{

ValidateIssuer = true,

ValidateAudience = true,

ValidateLifetime = true,

ValidateIssuerSigningKey = true,

ValidIssuer = Configuration["Jwt:Issuer"],

ValidAudience = Configuration["Jwt:Audience"],

IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))

};

});

This code configures the JWT authentication scheme and sets the options for token validation.

Generate a token:

When a user logs in, you need to generate a JWT token and return it to the client. You can use the JwtSecurityTokenHandler class to generate a token, like this:

var tokenHandler = new JwtSecurityTokenHandler();

var key = Encoding.ASCII.GetBytes("your-secret-key");

var tokenDescriptor = new SecurityTokenDescriptor

{

Subject = new ClaimsIdentity(new Claim[]

{

new Claim(ClaimTypes.Name, "username")

}),

Expires = DateTime.UtcNow.AddHours(1),

SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),

SecurityAlgorithms.HmacSha256Signature)

};

var token = tokenHandler.CreateToken(tokenDescriptor);

var tokenString = tokenHandler.WriteToken(token);

Protect routes:

Finally, you need to protect routes in your ASP.NET application by adding the [Authorize] attribute to controllers or actions that require authentication.

The request flow for JWT authentication in ASP.NET is as follows:

The client sends a request to the server with a JWT token in the Authorization header.
The server receives the request and validates the JWT token using the configured options.
If the token is valid, the server allows the request to proceed and executes the requested action.
If the token is invalid or expired, the server returns an HTTP 401 Unauthorized response to the client.

How middleware was implemented in legacy asp.net

In legacy ASP.NET (prior to ASP.NET Core), middleware was implemented using HTTP modules and HTTP handlers.

HTTP modules were used to process HTTP requests and responses in a pipeline similar to the one used in ASP.NET Core. Each HTTP module was responsible for handling one or more aspects of the request and response, such as authentication, authorization, caching, and so on. The order of execution of HTTP modules was determined by their order of registration in the web.config file.

HTTP handlers, on the other hand, were used to generate HTTP responses for specific types of requests, such as ASPX pages or ASMX web services. HTTP handlers could be registered for specific file extensions or MIME types in the web.config file, and they were responsible for generating the HTTP response content.

Both HTTP modules and HTTP handlers could be configured and registered in the web.config file, and they were executed for every HTTP request that matched their criteria.

While HTTP modules and HTTP handlers provided a powerful and extensible way to handle HTTP requests and responses in legacy ASP.NET, they had some drawbacks, such as the need for configuration in the web.config file, limited flexibility, and lack of support for middleware composition and dependency injection. These limitations were addressed in ASP.NET Core, which introduced a more modular and composable middleware pipeline.

In legacy ASP.NET, HTTP modules and HTTP handlers were implemented as .NET classes that implemented the IHttpModule and IHttpHandler interfaces, respectively.

An HTTP module was a class that implemented the IHttpModule interface, which had two methods: Init and Dispose. The Init method was called when the HTTP module was initialized, and it allowed the module to register event handlers for various events that occurred during the request processing pipeline, such as BeginRequest, AuthenticateRequest, AuthorizeRequest, and so on. The Dispose method was called when the HTTP module was disposed, and it allowed the module to release any resources that it had allocated.

Here's an example of an HTTP module that logs the beginning and end of each request:

public class LoggingModule : IHttpModule

{

public void Init(HttpApplication application)

{

application.BeginRequest += (sender, e) =>

{

HttpContext context = ((HttpApplication)sender).Context;

// log the beginning of the request

};

application.EndRequest += (sender, e) =>

{

HttpContext context = ((HttpApplication)sender).Context;

// log the end of the request

};

}

public void Dispose()

{

// release any resources

}

An HTTP handler was a class that implemented the IHttpHandler interface, which had two methods: ProcessRequest and IsReusable. The ProcessRequest method was called when a request was received that matched the criteria of the HTTP handler, and it allowed the handler to generate the response for the request. The IsReusable method indicated whether the HTTP handler could be reused for multiple requests.

Here's an example of an HTTP handler that generates an XML response:

public class XmlHandler : IHttpHandler

{

public bool IsReusable => true;

public void ProcessRequest(HttpContext context)

{

context.Response.ContentType = "text/xml";

context.Response.Write("<root><message>Hello, world!</message></root>");

}

HTTP modules and HTTP handlers could be registered in the web.config file using the <httpModules> and <httpHandlers> elements, respectively. The order in which they were registered determined the order in which they were executed in the request processing pipeline.

To configure an HTTP module in legacy ASP.NET, you need to register it in the <httpModules> section of the web.config file. Here's an example of how to register the LoggingModule class.

<system.web>

</httpModules>

</system.web>

</configuration>

In this example, we're registering an HTTP module called LoggingModule that's defined in the Namespace namespace. The type attribute specifies the fully qualified name of the HTTP module class.

To configure an HTTP handler in legacy ASP.NET, you need to register it in the <httpHandlers> section of the web.config file. Here's an example of how to register the XmlHandler class.

<system.web>

</httpHandlers>

</system.web>

</configuration>

In this example, we're registering an HTTP handler called XmlHandler that will generate the response for requests that match the GET verb and have a .xml file extension. The type attribute specifies the fully qualified name of the HTTP handler class.

Note that in legacy ASP.NET, HTTP modules and HTTP handlers were registered globally for the entire application. They were executed for every HTTP request that matched their criteria. This could have performance implications, especially if you had a large number of HTTP modules and handlers. In ASP.NET Core, middleware is registered per request pipeline and can be scoped to specific routes or controllers, providing more flexibility and better performance.

What is difference in use and run methods in middleware in asp.net core

In ASP.NET Core, the Use and Run extension methods are used to add middleware components to the pipeline, but they have different purposes and behaviors.

The Use method is used to add middleware components that handle the request and can pass it down the pipeline to the next middleware component. The Use method takes a delegate that represents the middleware logic and must invoke the next middleware component in the pipeline using the next parameter.

Here's an example:

app.Use(async (context, next) =>

{

// Middleware logic...

await next();

});

In this example, we're using the Use method to add a middleware component that handles the request and passes it to the next middleware component in the pipeline using the next delegate.

On the other hand, the Run method is used to add middleware components that generate a response directly and don't pass the request to the next middleware component in the pipeline. The Run method takes a delegate that represents the middleware logic and must generate a response using the context parameter.

Here's an example:

app.Run(async context =>

{

// Middleware logic...

await context.Response.WriteAsync("Hello, World!");

});

In this example, we're using the Run method to add a middleware component that generates a response directly using the Response property of the HttpContext.

So, the main difference between Use and Run is that Use passes the request to the next middleware component in the pipeline, while Run generates a response directly and doesn't pass the request to the next middleware component. It's important to use the appropriate method based on the middleware's purpose and behavior.

What is middleware in asp.net core and how to configure it

In ASP.NET Core, middleware is software that sits between the web server and the application, and it's responsible for handling the HTTP request and response. Middleware is used to process, transform, and filter HTTP requests and responses, as they flow through the ASP.NET Core pipeline.

Middleware can be added to the pipeline using the Use extension method in the Configure method of the Startup class. Middleware can perform various tasks such as logging, authentication, authorization, caching, routing, compression, and much more. Each middleware component is responsible for handling one specific task.

Middleware is executed in the order they are added to the pipeline, and they can either process the request and pass it to the next middleware or directly return a response to the client. This way, each middleware component can add, modify or remove headers, change the response content, or even short-circuit the request processing.

Middleware is a powerful feature of ASP.NET Core, and it provides developers with a flexible way to handle HTTP requests and responses in a modular and composable way.

How to configure middleware in asp.net core :

To configure middleware in ASP.NET Core, you can use the Use extension method that's available on the IApplicationBuilder interface. This method takes a Func<HttpContext, Func<Task>, Task> delegate that represents the middleware logic.

Here's an example of how to configure a simple middleware component that logs the request URL:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)

{

app.Use(async (context, next) =>

{

Console.WriteLine($"Request URL: {context.Request.Path}");

await next();

});

// Other middleware components...

}

In this example, we're using the Use method to add a middleware component that logs the request URL to the console. The next parameter is a delegate that represents the next middleware component in the pipeline. In this case, we're invoking it using the await next() statement to pass the request to the next middleware component.

You can add multiple middleware components in the pipeline, and they will be executed in the order they are added. The last middleware component should return a response to the client, either by generating a response directly or by invoking the next delegate and returning the result.

It's important to note that middleware components can modify the request and response objects, add or remove headers, and perform various operations on the request and response stream. Middleware components are a powerful feature of ASP.NET Core, and they provide developers with a flexible way to handle HTTP requests and responses.

What is difference in Ref and Out Parameter

In C#, both ref and out are used to pass arguments by reference instead of by value, but there are some differences between them:

Initialization: The ref parameter must be initialized before it is passed to the method, while the out parameter does not need to be initialized. Instead, the method is responsible for assigning a value to the out parameter before returning.

Return value: A method can return a value through an out parameter, but not through a ref parameter.

Compiler error: The out parameter must be assigned a value inside the method before it returns. If it is not assigned a value, the compiler generates an error. In contrast, the ref parameter does not have to be assigned a value inside the method.

Usage: The ref parameter is used when the method needs to modify the value of the parameter that is passed in, while the out parameter is used when the method needs to return multiple values.

Examples in C#:

// using ref

void AddOne(ref int x)

{

x += 1;

}

int number = 5;

AddOne(ref number);

Console.WriteLine(number); // output: 6

// using out

void Divide(int dividend, int divisor, out int quotient, out int remainder)

{

quotient = dividend / divisor;

remainder = dividend % divisor;

}

int dividend = 10;

int divisor = 3;

int quotient, remainder;

Divide(dividend, divisor, out quotient, out remainder);

Console.WriteLine($"{dividend}/{divisor} = {quotient} remainder {remainder}"); // output: 10/3 = 3 remainder 1

In the above example, ref is used to modify the value of the number parameter, while out is used to return both the quotient and remainder from the Divide method.

What are differences in Partial and RenderPartial HTML Helper Method

In ASP.NET MVC, both @Html.Partial and @Html.RenderPartial are used to render partial views, but there are some differences between them:

Return type: @Html.Partial returns an MvcHtmlString, which can be assigned to a variable or used directly in Razor views. @Html.RenderPartial, on the other hand, writes the partial view's HTML directly to the output stream.

Method signature: @Html.Partial has two overloads: one that takes only the name of the partial view and one that takes a model object as well. @Html.RenderPartial has only one overload, which takes the name of the partial view.

Usage: @Html.Partial is used when you want to embed a partial view inside a view, and the result can be assigned to a variable for further processing. @Html.RenderPartial is used when you want to write the HTML of a partial view directly to the output stream, for example, in a loop.

Here's an example of how to use @Html.Partial and @Html.RenderPartial in a Razor view:

// Syntax example using @Html.Partial

@model List<string>

@foreach (string item in Model)

{

<div>

@Html.Partial("_PartialView", item)

</div>

}

// Syntax example using @Html.RenderPartial

@model List<string>

@foreach (string item in Model)

{

<div>

@Html.RenderPartial("_PartialView", item)

</div>

}

In the above example, @Html.Partial is used to render a partial view _PartialView with a string item as the model object. The result is then embedded inside a <div> tag.

In contrast, @Html.RenderPartial is used to write the HTML of the partial view _PartialView with a string item as the model object directly to the output stream, without any additional tags.

What is difference in Inversion of Control and Dependency Injection

Inversion of Control (IoC) and Dependency Injection (DI) are related concepts in software design and architecture, but they are not the same thing. Here are the differences between the two:

Definition: Inversion of Control (IoC) is a pattern or principle that advocates for decoupling components and their dependencies by inverting the control of the flow of a program from the component to a container or framework. Dependency Injection (DI) is a specific implementation of IoC that involves providing the dependencies of a class from an external source, typically a container or framework.

Relationship: Dependency Injection is a specific technique that is used to implement Inversion of Control. It's one way to achieve IoC, but not the only way.

Scope: Inversion of Control is a broad concept that can be applied to many areas of software design and architecture, such as event-driven programming, template method pattern, and others. Dependency Injection, on the other hand, is more focused and specific to managing the dependencies of a component.

Purpose: Inversion of Control is aimed at improving the modularity, maintainability, testability, and extensibility of a software system by reducing the coupling between components. Dependency Injection, as a form of IoC, specifically aims to reduce coupling by managing dependencies of a component and making it easier to change its behavior or add new features.

In summary, Dependency Injection is a specific implementation of the more general principle of Inversion of Control. Dependency Injection provides an easy and efficient way to implement IoC by enabling the creation of loosely coupled components with their dependencies provided from an external source, which makes the software system more modular, maintainable, testable, and extensible.

Example of Implementing dependency Injection -

here's a simple example of how to implement Dependency Injection in C# using the constructor injection technique:

Let's say we have a Customer class that needs to use a CustomerRepository class to retrieve and save customer data from a database. Instead of instantiating the CustomerRepository class inside the Customer class, we can use Dependency Injection to provide an instance of the CustomerRepository class from outside the Customer class.

Here's how to do it:

public interface ICustomerRepository

{

Customer GetCustomer(int id);

void SaveCustomer(Customer customer);

}

public class CustomerRepository : ICustomerRepository

{

public Customer GetCustomer(int id)

{

// implementation to retrieve customer data from a database

}

public void SaveCustomer(Customer customer)

{

// implementation to save customer data to a database

}

public class Customer

{

private readonly ICustomerRepository _repository;

public Customer(ICustomerRepository repository)

{

_repository = repository;

}

public int Id { get; set; }

public string Name { get; set; }

public void Save()

{

_repository.SaveCustomer(this);

}

public static Customer Get(int id, ICustomerRepository repository)

{

var customer = repository.GetCustomer(id);

return new Customer(repository)

{

Id = customer.Id,

Name = customer.Name

};

}

In this example, we define an interface ICustomerRepository and a class CustomerRepository that implements the interface. The Customer class has a constructor that takes an ICustomerRepository object as a parameter, which is assigned to a private field _repository. The Save method of the Customer class uses the _repository object to save customer data to a database.

In addition, we have a static method Get that takes an ICustomerRepository object as a parameter and uses it to retrieve a customer from the database. This allows us to create a Customer object with a specific ICustomerRepository instance without requiring a default constructor.

To use this setup, we can create an instance of the CustomerRepository class and pass it to the Customer class constructor as follows:

ICustomerRepository repository = new CustomerRepository();

Customer customer = new Customer(repository);

customer.Name = "John";

customer.Save();

In this way, we can achieve dependency injection and have the flexibility to change the implementation of the ICustomerRepository interface without changing the Customer class code.

What are Differences in Asp.net MVC 3, MVC 4 and MVC 5

Here are few differences:

Razor view engine: ASP.NET MVC3 uses the ASPX view engine by default, while MVC4 and MVC5 introduced the Razor view engine, which is more concise and easier to read.

Bundling and Minification: MVC4 introduced the new feature of bundling and minification, which makes it easier to combine and compress JavaScript and CSS files into a single file.

Authentication filters: MVC5 introduced authentication filters that enable developers to apply authentication logic to controller actions or methods. This feature makes it easier to implement authentication logic in a modular and reusable way.

Attribute routing: MVC5 introduced attribute routing, which provides a more intuitive and flexible way to define the URL routing rules. With attribute routing, you can define the route directly in the controller or action method, rather than in a central location.

One ASP.NET: MVC5 introduced the concept of "One ASP.NET," which is a unified development model for web applications. It integrates ASP.NET MVC, Web API, and Web Pages into a single framework, making it easier to develop and maintain web applications.

Bootstrap: MVC5 introduced support for Bootstrap, which is a popular front-end framework for building responsive web applications. With Bootstrap, you can quickly and easily create a modern and professional-looking user interface for your application.

Filter overrides: MVC5 allows developers to override the filters defined in the global filter collection for a specific controller or action method. This feature makes it easier to customize the behavior of filters for specific parts of the application.

Overall, each version of ASP.NET MVC introduced new features and improvements that made it easier to develop web applications. As such, the latest version, MVC5, is generally the best choice for new projects, as it offers the most up-to-date feature

What is Delegate, Anonymous Method and Lambda Expression

A delegate is a type that represents a reference to a method with a specific signature. It is similar to a function pointer in C/C++. A delegate can be used to encapsulate a method call and pass it as an argument to another method or store it as a field or property.

Here's an example:

public delegate int CalculationDelegate(int x, int y);

public class Calculator

{

public int Add(int x, int y)

{

return x + y;

}

public int Multiply(int x, int y)

{

return x * y;

}

public class Program

{

public static void Main(string[] args)

{

Calculator calculator = new Calculator();

CalculationDelegate add = calculator.Add;

int result = add(2, 3); // result = 5

CalculationDelegate multiply = calculator.Multiply;

result = multiply(2, 3); // result = 6

}

An anonymous method is a method without a name that can be defined inline with the code using a delegate. It allows you to define a method without having to create a separate method declaration.

Here's an example:

CalculationDelegate add = delegate (int x, int y)

{

return x + y;

};

int result = add(2, 3); // result = 5

A lambda expression is a concise way to define an anonymous method. It is a shorthand notation that allows you to define a method inline with the code using the => operator. Lambda expressions are typically used with delegates, but they can also be used with other types that define a single method, such as Func and Action.

Here's an example:

CalculationDelegate add = (x, y) => x + y;

int result = add(2, 3); // result = 5

Lambda expressions are often used with LINQ queries, which use functional programming techniques to filter, sort, and transform data.

Why should We Use WCF Over Webservice

WCF (Windows Communication Foundation) is a more versatile and powerful technology than Web Services in .NET, and it offers several benefits over traditional Web Services.

Here are some reasons why you might choose to use WCF over Web Services:

Flexibility: WCF provides a lot of flexibility in terms of communication protocols, message formats, and transport channels. WCF can communicate over HTTP, TCP, MSMQ, and other protocols, and it supports various message formats, including XML, JSON, and binary. This flexibility allows you to use WCF in a wide range of scenarios, from simple web services to complex distributed systems.
Interoperability: WCF is designed to be interoperable with other platforms and technologies. It supports standards-based protocols like SOAP, REST, and WS-* and can communicate with other systems regardless of the technology used. This makes it easier to integrate with legacy systems and other platforms.
Scalability: WCF is designed for scalability and performance. It supports various transport channels, including TCP and MSMQ, which are more scalable than HTTP. It also provides features like message streaming, message buffering, and throttling, which help optimize performance.
Security: WCF provides a comprehensive security model that supports various authentication and authorization mechanisms, such as SSL/TLS, username/password, and Windows authentication. It also supports message-level encryption and signing, which can ensure the confidentiality and integrity of messages.
Extensibility: WCF is highly extensible and customizable. It provides various extension points, such as behaviors, bindings, and contracts, which allow you to modify the behavior and functionality of the service to meet your specific requirements.

Overall, WCF is a more powerful and versatile technology than Web Services in .NET, and it offers several benefits over traditional Web Services. However, WCF also has a steeper learning curve and can be more complex to set up and configure, so it may not be the best choice for simple scenarios or small projects.

What is Difference in Static Class and Singleton

A static class and a singleton are two different design patterns in C# that are used for different purposes.

A static class is a class that can only contain static members (methods, properties, fields). It cannot be instantiated, and all its members are accessible through the class name itself. A static class is typically used to group related utility methods or constants that do not require any state or instance-specific behavior.

Here's an example of a static class:

public static class Calculator

{

public static int Add(int x, int y)

{

return x + y;

}

public static int Multiply(int x, int y)

{

return x * y;

}

A singleton, on the other hand, is a class that can have only one instance throughout the lifetime of the application. It typically has a private constructor to prevent direct instantiation and provides a static method or property to access the singleton instance. A singleton is often used to represent a global state or to provide a centralized point of access to a resource or service.

Here's an example of a singleton:

public class Logger

{

private static Logger instance;

private static readonly object lockObject = new object();

private Logger()

{

// Private constructor to prevent direct instantiation

}

public static Logger Instance

{

get

{

// Double-checked locking to ensure thread-safety

if (instance == null)

{

lock (lockObject)

{

if (instance == null)

{

instance = new Logger();

}

return instance;

}

public void Log(string message)

{

// Logging implementation

}

The main difference between a static class and a singleton is that a static class cannot be instantiated, whereas a singleton can have one instance. A static class is typically used to group related utility methods or constants, while a singleton is often used to represent a global state or to provide a centralized point of access to a resource or service.

What is Use of Static Constructor and When to Use it

A static constructor is a special type of constructor in C# that is used to initialize static data members or to perform any other type of static initialization. It is called automatically by the runtime before the first instance of the class is created or before any static members are accessed.

Here are some use cases for static constructors:

Initializing static data members

If you have static data members in your class that need to be initialized before they are used, you can use a static constructor to perform the initialization. This ensures that the static data members are initialized before any instance of the class is created or before any static members are accessed.

Registering event handlers

If your class needs to register event handlers for static events, you can use a static constructor to perform the registration. This ensures that the event handlers are registered before any instance of the class is created or before any static members are accessed.

Setting up static configuration

If your class needs to read static configuration settings from a file or database, you can use a static constructor to perform the setup. This ensures that the configuration is read before any instance of the class is created or before any static members are accessed.

Performing other types of static initialization

If your class needs to perform any other type of static initialization, such as setting up a static cache or initializing a static database connection, you can use a static constructor to perform the initialization.

It's important to note that a static constructor is only called once, regardless of how many instances of the class are created or how many times static members are accessed. It is also called automatically by the runtime, so you don't need to explicitly call it in your code.

What is Difference in Temp Table and Table Variable

In SQL Server, a temporary table and a table variable are two different types of temporary storage objects that can be used to store data during the execution of a query or a batch.

Here are the main differences between temporary tables and table variables:

Scope

Temporary tables are created in the tempdb database and are visible to all sessions on the same SQL Server instance. Table variables are local to the batch or stored procedure in which they are defined.

Durability

Temporary tables are durable and are not dropped automatically when they go out of scope. You need to explicitly drop them when they are no longer needed. Table variables are not durable and are automatically dropped when they go out of scope.

Indexing

Temporary tables can have indexes and statistics, which can help improve query performance. Table variables do not support indexes, but they can benefit from statistics created on the columns used in queries against them.

Memory usage

Table variables are stored in memory, and their size is limited to the available memory on the server. Temporary tables can be stored in memory or on disk, depending on their size and the memory settings of the server.

Performance

Table variables are generally faster than temporary tables for small datasets, due to their in-memory storage and lack of indexing overhead. However, for larger datasets, temporary tables can be faster due to their ability to use indexes and statistics.

Here's an example of creating a temporary table:

CREATE TABLE #TempTable (

ID INT PRIMARY KEY,

Name VARCHAR(50)

);

INSERT INTO #TempTable (ID, Name)

VALUES (1, 'John'), (2, 'Jane'), (3, 'Bob');

SELECT * FROM #TempTable;

DROP TABLE #TempTable;

And here's an example of creating a table variable:

DECLARE @TableVariable TABLE (

ID INT PRIMARY KEY,

Name VARCHAR(50)

);

INSERT INTO @TableVariable (ID, Name)

VALUES (1, 'John'), (2, 'Jane'), (3, 'Bob');

SELECT * FROM @TableVariable;

What are Action Filters in Asp.net MVC

In ASP.NET MVC, action filters are attributes that can be applied to controller actions or the entire controller itself to modify or enhance the behavior of the action method during its execution. They are used to inject additional processing logic before, during, or after the execution of the controller action.

Action filters can be used for a variety of purposes, such as authentication, authorization, caching, logging, exception handling, and more. They provide a way to intercept the execution of a controller action and add custom logic to it.

there are four types of action filters:

Authorization filters

These filters are used to authenticate the user and check if the user has the required permissions to access a particular action method or controller.

Action filters

These filters are used to execute code before and after an action method is called. They can be used to modify the action method's input or output, perform validation, or add or modify response headers.

Result filters

These filters are used to modify the result of an action method before it is returned to the client. They can be used to modify the response status code, add or modify response headers, or transform the response body.

Exception filters

These filters are used to handle exceptions that occur during the execution of an action method. They can be used to log the exception, modify the response, or redirect the user to an error page.

Action filters can be applied at the controller level or the action level. They can also be applied globally to all controllers and actions using the MVC middleware.

What are Advantages of Dotnet MVC

ASP.NET MVC (Model-View-Controller) is a web development framework that provides a number of advantages over traditional web forms development.

Here are some advantages of using ASP.NET MVC:

Separation of concerns:

The MVC pattern allows for a clear separation of concerns between the application's presentation logic, business logic, and data access logic. This makes it easier to maintain and modify the application code over time.

Testability:

The separation of concerns provided by the MVC pattern also makes it easier to write unit tests for the application. Each component of the MVC pattern can be tested separately, which makes it easier to identify and fix bugs.

Flexibility:

ASP.NET MVC provides developers with a high degree of flexibility in terms of how they structure their application code. This allows developers to create applications that meet the specific needs of their business requirements.

Performance:

ASP.NET MVC applications are generally faster and more lightweight than traditional web forms applications. This is because MVC applications don't require the view state or server-side controls that web forms applications do.

SEO-friendly URLs:

ASP.NET MVC provides built-in support for creating SEO-friendly URLs, which can help improve the search engine rankings of the application.

Support for modern web development techniques:

ASP.NET MVC provides built-in support for modern web development techniques such as AJAX, JSON, and RESTful web services.

Overall, ASP.NET MVC is a powerful and flexible web development framework that provides developers with a number of advantages over traditional web forms development. It is well-suited for building modern, scalable, and maintainable web applications.

What are Triggers and Types of Triggers in SQL Server

In SQL Server, triggers are a type of stored procedure that automatically execute in response to specific data manipulation events, such as insert, update, or delete operations on a table. Triggers can be used to enforce data integrity rules, audit changes to the data, or perform complex business logic.

There are two types of triggers in SQL Server:

DML Triggers:

These triggers fire in response to data manipulation language (DML) statements, such as INSERT, UPDATE, and DELETE. DML triggers can be defined to execute either before or after the DML statement.

DDL Triggers:

These triggers fire in response to data definition language (DDL) statements, such as CREATE, ALTER, and DROP. DDL triggers can be defined to execute either before or after the DDL statement.

DML triggers can be further classified into two types based on when they fire:

After Triggers: These triggers execute after the DML statement has completed, but before any constraints or referential integrity rules are enforced.
Instead of Triggers: These triggers execute instead of the DML statement. They allow you to modify the data or perform custom business logic before the data is inserted, updated, or deleted.

Triggers can be defined at the table level or at the database level. When a trigger is defined at the table level, it only fires in response to data manipulation events on that table. When a trigger is defined at the database level, it fires in response to data manipulation events on any table in the database.

Here are a few examples of triggers in SQL Server:

Implementation as Audit Trigger: This trigger can be used to audit changes to a table. For example, suppose you have a table named "Employee" and you want to track changes to the "Salary" column. You can create a trigger that fires after an update to the "Salary" column and inserts a record into an audit table.

Here's an example of the trigger:

CREATE TRIGGER Audit_Employee_Salary

ON Employee

AFTER UPDATE

BEGIN

INSERT INTO Employee_Audit (EmployeeID, OldSalary, NewSalary, ChangeDate)

SELECT i.EmployeeID, d.Salary, i.Salary, GETDATE()

FROM inserted i

INNER JOIN deleted d ON i.EmployeeID = d.EmployeeID

END

Implementation as Constraint Trigger: This trigger can be used to enforce data integrity rules. For example, suppose you have a table named "Orders" and you want to ensure that the total amount of an order cannot exceed the customer's credit limit. You can create a trigger that fires before an insert or update to the "Orders" table and checks the customer's credit limit.

Here's an example of the trigger:

CREATE TRIGGER Orders_CreditLimit

ON Orders

INSTEAD OF INSERT, UPDATE

BEGIN

IF EXISTS (

SELECT *

FROM inserted i

INNER JOIN Customers c ON i.CustomerID = c.CustomerID

WHERE i.TotalAmount > c.CreditLimit

)

BEGIN

RAISERROR ('Total amount of the order exceeds the customer''s credit limit.', 16, 1)

ROLLBACK TRANSACTION

RETURN

END

INSERT INTO Orders (OrderID, CustomerID, OrderDate, TotalAmount)

SELECT OrderID, CustomerID, OrderDate, TotalAmount

FROM inserted

END

Note that these are just a few above examples of the types of triggers that can be created in SQL Server. The possibilities are endless, and triggers can be used to perform a wide range of tasks depending on your specific needs.

What are Advantages of using Stored procedure instead a Inline Query

Stored procedures and inline queries both serve the purpose of executing SQL statements, but they differ in several aspects.

A stored procedure is a pre-compiled program that is stored in a database and can be executed multiple times with different parameters. It can contain multiple SQL statements and can be called from various applications or client programs. Stored procedures can also be used to encapsulate complex business logic and rules, making it easier to maintain and update the code.

On the other hand, an inline query is a SQL statement that is included in the code of an application or a client program. It is compiled and executed every time it is called, which can result in performance issues for complex queries.

Here are some advantages of using stored procedures over inline queries:

Performance:

Stored procedures are compiled once and stored in the database, which means that subsequent calls are faster than inline queries, as they don't need to be compiled each time. This can result in significant performance improvements, especially for complex queries.

Security:

Stored procedures can be used to control access to the database by granting specific permissions to users or roles. This allows you to limit the actions that can be performed on the database, making it more secure.

Encapsulation:

Stored procedures can encapsulate complex business logic, making it easier to maintain and update the code. This also allows developers to reuse code across multiple applications, reducing development time and improving code quality.

Debugging:

Stored procedures can be debugged using SQL Server Management Studio or other debugging tools, which can make it easier to identify and fix issues.

Overall, stored procedures provide a more secure, efficient, and maintainable way of executing SQL statements, particularly for complex queries or those that are frequently used.

What is Difference in Primary Key and Unique Key

Both Primary Key and Unique Key are used to enforce uniqueness of a column or a group of columns in a database table. However, there are some differences between them.

Primary Key:

A primary key is a column or a combination of columns that uniquely identify a record in a table. It cannot contain null values and there can be only one primary key per table. The primary key is automatically indexed by the database and is used as a foreign key in related tables to establish relationships between them.

Unique Key:

A unique key is a column or a combination of columns that must have unique values. Unlike primary keys, it can contain null values but there can be more than one unique key per table. A unique key is used to enforce the integrity of the data and ensure that there are no duplicate values in the table.

In summary, the main differences between Primary Key and Unique Key are:

A table can have only one primary key, but can have multiple unique keys.
A primary key cannot contain null values, but a unique key can contain null values.
A primary key is used as a foreign key in other tables to establish relationships, while a unique key is used to enforce the integrity of the data and ensure that there are no duplicate values.

Both Primary Key and Unique Key are important in ensuring data integrity and should be carefully chosen based on the specific requirements of the database design.

What is difference in Boxing and Unboxing

In C#, boxing and unboxing are concepts used to convert between value types and reference types.

Boxing:

Boxing is the process of converting a value type into a reference type. This is done by wrapping the value of the value type in an object of the corresponding reference type. For example, when an integer value is boxed, it is wrapped in an object of the System.Object class. The boxed object can then be assigned to a reference type variable or passed as a parameter to a method that expects a reference type.

Unboxing:

Unboxing is the opposite of boxing, and it is the process of converting a reference type that was previously boxed back into its original value type. This is done by extracting the value from the object and assigning it to a value type variable.

Here's an example of how boxing and unboxing work in C#:

int i = 10; // Value type variable

object o = i; // Boxing: i is converted to a reference type object and assigned to o

int j = (int)o; // Unboxing: the value of o is extracted and assigned to a value type variable j

In the above example, the value of the integer variable i is boxed into an object variable o. The value is then unboxed and assigned back to an integer variable j.

It is important to note that boxing and unboxing operations can be expensive in terms of performance, especially when done repeatedly. This is because they involve the creation of new objects on the heap, which can lead to memory allocation and garbage collection overheads. Therefore, it is generally recommended to avoid boxing and unboxing operations as much as possible, and instead use generics or value types directly whenever possible.

What is Difference in Is and As Keywords in C#

As we familiar that value of any type can be treated as an object then in the code it is difficult to determine that stored value in object of which type. If we want to write a logic for specific value type then is and as both keywords help to determine the specific object type.

The is keyword used to check run-time type of an object is compatible and used to check object is type of specific object or not. The is keyword checks whether the value on its left side is a compatible instance of the type on the right side.

object obj = "Hello";

if (obj is string) // Check whether obj contains value, compatible with right side specific type
{
// Do Something
}

Where the as operator used to cast an object to a specific type and it returns null if not able to cast. Good to use as keyword, benefits it does not throw an exception when type casting fails.

Basically mostly the as keyword is used to cast Null-able types. If the specified value is not an instance of the specified type then null is returned always.

string str = obj as string;

if (str != null) // str will contain null if not string
{
// Do Something
}