Archive for the ‘C#’ Category

ASP.NET Core Middleware–Part 1

Posted: November 11, 2019 in .NET, C#
Tags:

In one of my earlier post, I have discussed in details about the ASP.NET Core request processing and the key components involved i.e reverse proxy, ASP.NET Core Web Server and the ASP.NET Core infrastructure and application logic.

image

In this post we will take a bit more deep dive into the ASP.NET Core Infrastructure components. The flow of information for processing an incoming request and generating the response is shown in the figure below:

image

The diagram above is not a very generic one but elaborates the ASP.NET Core Infrastructure and Application Logic component into two, Middleware Pipeline and MVC Middleware. Before getting into any further details let’s try to understand what this Middleware Pipeline is all about.

In the above flow, reverse proxy receives the request and forwards the raw HTTP request to the ASP.NET Core Web Server. ASP.NET Core Web Server passes the raw HTTP request and instantiates the HttpContext object. HttpContext is a class that encapsulates all information pertaining to a HTTP request including information related to the subsequently generated HTTP response. For every incoming HTTP request there is one instance of HttpContext created and passed onto the subsequent component , the Middleware Pipeline in this case.

The ASP.NET Core Middleware is a chain of components that forms a pipeline for processing an HTTP request, generating the response and subsequent processing of the response before being passed back to the ASP.NET Core Web Server. To be more precise it does the following:

  • Accepts an incoming HTTP request , analyzes it and does some processing if required and passes the request to the next component.
  • Accepts an outgoing HTTP response, analyzes it and does some processing if required and passes the response to the previous component or, the ASP.NET Core Web Server.
  • Accepts an incoming HTTP request and generates the response and passes the response to the previous component or, the ASP.NET Core Web Server.These type of middleware components which short-circuits the pipeline i.e generates the response and passes back the response to the previous component instead of the next are called terminal middleware because it prevents the next component from processing the request.

These middleware components can perform a wide array of tasks like logging, exception handling, serving static files etc. The most important amongst these in a ASP.NET Core MVC application is the MVC Middleware which processes requests and generates the HTML and API responses. This is a terminal middleware as shown in the above figure. Similarly for requests to serve a static file , the Static File Middleware acts as the terminal middleware as shown below:

image

.NET Core provides a set of middleware components which needs to be configured through code and also has provision to develop custom middleware components.We will take a look at these in the coming posts.

    Local Functions in C#7.0

    Posted: July 30, 2017 in .NET, C#
    Tags: ,

    The nested functions (methods) or local functions are functions defined inside another function , referred to as the enclosing function. The nested functions are available only within the scope of the enclosing functions. This is nothing new. The nested functions has been there in languages like ALGOL , PASCAL , Lisp , JavaScript for quite sometime and even in modern programming languages like Scala.

    Can we do similar stuff in C#?

    image

    Suppose in the snippet above we want to extract out the computation logic in a separate function. A quick way will be to extract it out to separate private function. But that will be bit confusing, because the scope of the private method will not be restricted to the method Calculate and it will be a class level method. So someone reading the code later, will have difficulty to understand, that my intent was to have this private method only to be used by the Calculate method.

    One way of doing this will be to define an anonymous method within the Calculate method. But here I have to define a delegate (type definition) and create a delegate object (first class object in itself) to cater to my simple need of having just a helper function.

    image

    C#7.0 helps us to achieve this with the feature of local functions , another syntactic sugar coat and added compile time checks. The code below shows how we can define nested local function within another method in C#7.0.

    image

    This local function gets compiled into a compiler generated private method as shown below, without adding any added overhead.

    image

    image

    Deconstruction in C#7.0

    Posted: July 29, 2017 in .NET, C#
    Tags: , ,

    In my earlier blog post related to Tuples, I had used the following two ways for accessing the elements of the tuple.

    image

    image

    The first one is obviously inefficient and to be honest wrong, there is no point calling the method twice. The second one can be simplified further as shown in the snippet below:

    image 

    This is referred to as the deconstruction of the tuple.

    This technique of deconstruction can be now applied to any . NET class/struct , by implementing the Deconstruct method.

    image

    The object instance can be then deconstructed back into three variables as shown below:

    image

    The code shown above is nothing but the syntactic sugar coat. The decompiled code clearly shows the Deconstruct method of the Person class getting invoked and the variables a , b & c does not exists in the complied code. These are replaced by variables declared with names same as the parameters of the Deconstruct method implementation.

    image

    Tuples in C#7

    Posted: July 29, 2017 in .NET, C#
    Tags: , ,

    What is a tuple ? -  A tuple is an ordered group of elements.

    Tuple has been there as a data type in most of the functional programming languages like Lisp , Haskell since their inception.

    For example in Haskell , tuple provides a mechanism to store multiple values together. One key difference with a List is, tuple allows to store multiple values of different data type.

    image

    In C#4.0, Generic Tuple class(es) was introduced, the primary intent was to make it interoperable with languages like Python / F#. This also provided an easy way to return multiple values from a method without defining a separate class or structure.

    image

    The tuple values could be accessed using the Item property of the tuple class as shown below:

    image

    We will tweak the above code as follows:

    image

    We will not be able to modify the element values as these Item properties are read-only making the tuples immutable.

    image

    There are about 8 overloads of Tuple.Create method and 8 Tuple classes allowing us to tuples up to 8 elements.

    So far so good , but if I compare the C# snippet with it is Haskell counterpart it looks cumbersome. It looks kludgy , as if some feature has been artificially dumped into the language.

    This is further improved in C#7 with elegant syntactic sugar coat and the System.ValueTuple structure doing the work in background.

    This feature is now built into the framework (4.7) and if you are using 4.6.2 or earlier,  the package reference to System.ValueTuple needs to be added.

    image 

    Like me , if you are using Visual Studio Code you just need to run the command “dotnet add package "System.ValueTuple" from the Terminal, followed by a “dotnet restore”.

    image

    We can now refactor our earlier code using much simpler and more elegant syntax as shown below:

    image

    The tuple values could be accessed similarly using the Item property as shown below:

    image

    We can further improve this by leveraging the new feature of providing tuple element names.

    image

    These element names are used while accessing the values, making the code more readable.

    image

    Unlike Tuple classes , the ValueTuple structure is mutable and it allows us to modify the values.

    image

    The decompiled ( by dotPeek) shows how ValueTuple structure is doing it’s job. The code below looks quite similar to what we did earlier with Tuple class. The named tuple elements are implemented using the attribute System.Runtime.CompilerServices.TupleElementNames. TupleElementNames stores the element names as a string array.

    image

    image

    C# 6.0 – nameof Operator

    Posted: January 1, 2016 in .NET, C#
    Tags: ,

    In this post, we will discuss about the C# 6.0 nameof operator.

    In the code snippet below we are trying to the details i.e Class & method names whenever a method is invoked. In real life applications we do similar kind of logging using any logging library.

    image

    The issue here is we have used string literals to refer to the class and method names. As the number of methods and corresponding log entries increases it becomes difficult to track these and also typos etc. may creep in creating more clutter.

    In C# 6.0 the nameof operator gives us a provision to get the names of classes, methods,properties, variables etc. in the form of unqualified strings. The changed version of the code using nameof operator is shown below:

    image

    This gives as better manageability as the tools and IDE can have better track of these names now. Suppose I am renaming the class in that case Visual Studio track this down very easily as shown in the figure below

    image

    As obvious this is nothing but a very handy syntactic sugar coat. If we take a look into the IL code, we can easily see nothing heavy duty is going on inside. The compiler is simply replacing the nameof calls by the unqualified string literal name of the class and the method.

     

    image

    Singleton is the most widely known Design Pattern. Singleton makes sure that one only one instance of a class is created and the same instance is used by other programs and classes.An implementation of a Singleton class is shown below:

    (more…)

    new Keyword in C#

    Posted: July 29, 2012 in .NET, C#
    Tags:

    The “new” keyword in C# is one of the most commonly known and used keywords in C#.It is used as an operator for instantiating objects of a class as shown below.

    (more…)