DEV Community: Jai

Mini Profiler

Jai — Wed, 01 Jan 2020 10:03:14 +0000

In an ever-growing software world, many times we as a developer feel it would be better if we can monitor the performance cost of our development, live. It is really helpful to figure out the performance issue early as it can save both time and cost to the organizations. MiniProfiler helps us in solving the performance problem and gives the developer more control over testing and finding the root cause after deploying code in the Test and Production environment.

As per mini-profiler website:

MiniProfiler is a library and UI for profiling your application. By letting you see where your time is spent, which queries are run, and any other custom timings you want to add, MiniProfiler helps you debug issues and optimize performance.
The default setup is for every page to have an indicator so performance is always on your mind, like this:

Any custom timings (like queries) can be expanded in detail as well:

Now lets see the above in action. We will use a sample app build using Asp .Net core MVC along with SQL server local DB.

About our app:
1. Our app contains a web api call on page load
2. On submit we will insert data into the database(I am using a SQL local DB. I have shared the script in git repo)
3. Once the project is set let us start with miniprofiler configuration
Install nuget miniprofiler.aspnetcore.mvc on your web project

Add below highlighted lines in ConfigureServices():

There are many other configurations which can be used as per project requirement, but I am going with minimal configuration.

Add below highlighted lines in Configure()

Modify _ViewImport view with below code:

Now we are good to test our web app. As you can see below our popup is displayed on the bottom left as we have configured in ConfigureServices()

On load, we are making an API call and we can see the details of how much time the API is taking.

Note: Please use a pipeline to better control the HTTP calls as it is not possible to configure miniprofiler for each call.

Also when we click on the Try button on the home page we are making a DB call

In case we need more details of our SQL calls, add miniprofiler.entityframeworkcore nuget package to your Web project:

Now if we reload the application we can see in detail what DB calls are happening by clicking on SQL time taken.

In case if you are using ADO .Net and not using EnityFramework, it is easy to modify the data access layer and use ProfiledDbConnection to return the DbConnection object. Please refer to code snippet.

public DbConnection GetConnection()
{
    DbConnection connection = new System.Data.SqlClient.SqlConnection("...");
    return new StackExchange.Profiling.Data.ProfiledDbConnection(connection, MiniProfiler.Current);
}

Generally, we tend to have a large functionality that is broken into multiple methods, we can still use miniprofiler to figure out which particular method is causing trouble.

Nuget required: miniprofiler.aspnetcore

using (StackExchange.Profiling.MiniProfiler.Current.Step("Method1 begins"))
{
    //Method1()
}

using (StackExchange.Profiling.MiniProfiler.Current.Step("Method2 begins"))
{
    //Method2()
}

using (StackExchange.Profiling.MiniProfiler.Current.Step("Method3 begins"))
{
    //Method3()
}

How to secure the information?

Now as we know,

We need to display this information only to our DEV teams. Now we can control the access using Roles information present in HttpContext as shown below.

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
            services.AddSingleton<UtilityToolContext>();
            services.AddMiniProfiler(profiler => {
                profiler.PopupRenderPosition = StackExchange.Profiling.RenderPosition.BottomLeft;
                profiler.PopupShowTimeWithChildren = true;
                profiler.ResultsAuthorize = (request) => request.HttpContext.User.IsInRole("DEV");
            }).AddEntityFramework();
        }

Is it fast to be used in large applications?

In case if you are worried about its performance in production, please note that MiniProfiler was designed by the team at Stack Overflow. It is in production use there and on the Stack Exchange family of sites.

Git Repo: https://github.com/jai00271/MiniProfiler

References:

https://miniprofiler.com/

https://miniprofiler.com/dotnet/

https://miniprofiler.com/dotnet/HowTo/ProfileSql

FAQ Knowledge Base with Azure Bot Service and Integration with Microsoft teams

Jai — Tue, 01 Oct 2019 01:56:10 +0000

Before jumping into configuration let us understand the core concept first. For successful integration we will need to understand few features and its usage.

What is cognitive services?

Cognitive Services provides the best suite for having an interactive, automated model of an application. It helps to build powerful intelligence into applications to enable natural and contextual interactions.

Microsoft Cognitive Services provide us the ability to build apps with powerful algorithms using just a few lines of code. It works across devices and platforms, and with continuous enhancement, it's easy to set up.

Cognitive Services (preview) comes with a series of APIs, which can be used to enable natural and contextual interaction within your applications. Cognitive Services offers Language, Speech, Vision, Search, and Knowledge APIs.

Why ChatBots?

It works 24/7 and never calls sick. More and more businesses and marketers are adopting chatbots to enhance productivity and collaboration which can improve the efforts of a whole team. Read here for more info

What is QnA Maker?

QnA Maker is a cloud-based API service that creates a conversational, question and answer layer over your data. QnA Maker enables you to create a knowledge-base(KB) from your semi-structured content such as Frequently Asked Question (FAQ) URLs, product manuals, support documents and custom questions and answers.

What is Azure Bot Service?

Azure Bot Service is Microsoft's artificial intelligence (AI) chatbot offered as a service on the Azure cloud service marketplace. Azure Bot Service offers the ability to add intelligent agents that are capable of conversation without having to commit the resources to develop one's own AI.

Now with above knowledge lets jump on setting up our QnAMaker.

Step 1: Login into https://www.qnamaker.ai and click on Create a knowledge base.

Step 2: Create a QnA service in Microsoft Azure. When you click on it you will be redirected to Azure. Here we to sign up first in case if your account doesn't exist. Post successful sign up now we will need to create our Azure QnA service for our KB(KnowledgeBase). (In our example we will use QnAMakerChatBot as name going forward instead of QnAMakerChatBot1)

Step 3: Connect your QnA service to your KB. After performing above step you can click on refresh button and you will notice Azure QnA Service is populated with above details.

Step 4: Name your KB. The knowledge base name is for your reference and you can change it at anytime.

Step 5: Populate your KB. you can skip this for now. We will cover this in step 7.

Step 6: Create your KB. Click on create your KB.

Step 7: Once our KB is created its time to power our KB with some data. There are multiple ways to add data to your KB such as URL, document, Excel, TXT. You can feed the data here to your KB. Once data is loaded you can click on Save and train.

Step 8: Once your KB is trained its time to publish the data to Azure. You can publish data by clicking Publish button. Post successful publish you can view the Postman and Curl details and now you can invoke your KB using Postman.

Step 9: Click on Create Bot and you will be redirected to Web App Bot screen with most of the details automatically pre-populated.

Note: It is advisable to Create Microsoft App ID.

Step 10: Now since we have created our web app we can go ahead and test it. Go to All Resources and select your Web App bot. You will be presented with many options. We need to choose test in Web Chat and we can test our Bot here.

Step 11: Now its time to integrate our Bot with other services like Microsoft Teams, skype, slack etc. In this example we will integrate our Bot with Microsoft teams.

Step 12: After selecting Microsoft Teams you will see 3 options: Messaging, Calling and Publish. Here we will use Messaging and click on save.

Now you can go back to channels and select Microsoft teams and it will open it in your system with integrated Bot. You can chat with your Bot now.

Reference:

A-look-at-cognitive-services

Azure-Bot-Service

QnAMaker

Microsoft Azure Cognitive Services: QnA Maker by Jesse Dietrichson

CNN: General terms and their meaning

Jai — Thu, 18 Jul 2019 00:56:36 +0000

This blog is continuation of:

Convolution Neural Network: Background & Basics

Jai ・ Apr 28 '19

#dnn #cnn #ai #machinelearning

After publishing the above blog, I received feedback on sharing some basic concepts of CNN. So I tried listing general concepts used in CNN.

Architectural Basics

How to decide the number of layers in neural network?

Are we moving towards global minima without putting any overhead on our model.
Is our model effective and optimized in terms of time and memory consumption.

Explain MaxPooling?

Let's break the question into 2 parts:

What is MaxPooling?

MaxPooling concept is used when we have to reduce the number of layers without losing important features in the image.

Why should we use them?

When we want to reduce the parameters in our network as with each layer addition to the network we are increasing the parameters and our network is becoming computationally expensive. If we use MP on 400x400 image and use 2x2 matrix to reduce the image, its size will reduce to 200x200 thus reducing many layers as compared to convolution.

What is 1x1 Convolutions?

So we generally increase channel in order 32, 64, 128, 512, 1024, 2048 and reset here to 32 and starts again. But the problem with this approach is that these 32 complex and rich channels which we formed after merging 512 channel needs to remove some feature which is not useful for our network. If we use 3x3 to perform this channel reduction from 512 channel to 32 channel it will re-evaluate and gives new channel, but with 1x1 it will combine the 512 channels and give us 32 channels which won't let the noise such as the background to carry forward. An example would be like if your input image is a face, 3x3 will fetch 2 eyes separately whereas 1x1 will fetch both the eyes saying they always appear together. So when we want to reduce the number of channels we will use 1x1 instead of 3x3. Also a point to remember that 1x1 is computationally very cheap as it is only seeing 1 o/p kernel x n channel at a time instead of 9 o/p kernel x n channel blocks. Check out below image to understand it better.

What is 3x3 Convolutions?

An image is processed in multiple steps to extract Edges, texture, gradient, parts of object and object itself. Now to move from 1 step to another we need to process the image in such a way that they extract features from the previous layer just like how when we grow in age we use our experience before taking any decision. (read my first blog for better understanding)

What is Receptive Field?

So when we convolve on an image we reduce the image by 2 dimensions. For example, a 5x5 image after one convolution of 3x3 will become 3x3 in size. Now if we convolve on this 3x3 image again it will result in 1x1. Now using this 1x1 image actually I can see my 5x5 image. Let us check out below image and imagine them like a window. If you are standing after the last layer which is layer 3 and we open that 1x1 window you can see 3x3 which is 9 pixels and if I now open that 3x3 window you can see all 5x5 which is 25 pixel. So here the local receptive field for the layer 2 is 3(size of the matrix visible from 1 pixel) and for the layer 3, it will be 5(size of the matrix visible)

What is SoftMax?

Softmax assigns decimal probabilities to each class in a multi-class problem. All the probabilities must add up to 1. Softmax is implemented just before the output layer. Softmax layer must have the same number of nodes as the output layer.

What is Learning Rate?

LR determines how fast we want to move towards global/ local minima. Less value leads to small steps towards minima causing excessive delay in the process while high value means big steps and you might overshoot and never reach minima.

What are Kernels and how do we decide the number of kernels?

We have multiple options when it comes to kernels like 1x1, 3x3, 11x11. But we prefer 3x3 kernel as it has become standard across the industry(read my first blog for better understanding).

What is Batch Normalization?

Batch Normalization fixes covariate shift(distribution of feature is different in different parts of training/ test data) in Neural network by normalizing the output of the layers.

The neural network learns by correcting its weight and biases during backpropagation. Now a slight change in starting layer will cause a ripple effect in the next layers which causes a delay in training as the entire network needs to be trained again.
Normalization is a concept of bringing everyone on the same scale to perform the better calculation. For example, if someone asks you how people joined today's meeting, you might reply saying somewhere around 10 people instead of saying 5 men, 5 women joined.
Batch normalization adds a normalization "layer" between each layers. Normalization has to be done separately for each input neuron over 'mini-batches' and not altogether with all dimensions.

What is Image Normalization?

When we are working with images we always won't get the data as we want to train our model. Many time we have to improvise and make changes to the input images and this is called normalization. So according to wiki, Normalization is a process that changes the range of pixel intensity values. Applications include photographs with poor contrast due to glare, for example. Normalization sometimes called contrast or histogram stretching. In more general fields of data processing, such as digital signal processing, it is referred to as dynamic range expansion. The purpose of dynamic range expansion in the various applications is usually to bring the image, or other types of signal, into a range that is more familiar or normal to the senses, hence the term normalization.

What is the ideal position of MaxPooling?

Maxpooling is preferred minimum after 2 convolution layers. MP helps in reducing the number of parameters in the network.

What is the Concept of Transition Layers and what is the position of Transition Layer?

Transition layer which is the combination of [convolution + pooling] which is just a way of downsampling the representations calculated by dense blocks to the end as we move from 512x512 to 256x256 to 128x128 and so on. So in simple words decision on reducing/ increasing mathematical complexity of model happens in transition layers.

What is the number of Epochs and when to increase them?

How many times the neural network will see the entire dataset is called epochs. For example, if the neural network runs 10 times on 60000 datasets, you will say my epochs are 10. We specify epochs when we train our model like(here epoch is 10):

model.fit(X_train, Y_train, nb_epoch=10)

What is DropOut?

We want our neural network to be effective and the best way to know if your neural network has learned the right features and not memorized the data, then we remove some neurons and run the network again. If results are good that means our network is well trained and if your network performance degrades that means some neuron learned the wrong feature/ memorized data and dictating terms in taking decision by the model. So to summarize, dropout is a regularization technique for reducing overfitting in neural networks.

When do we introduce DropOut, or when do we know we have some overfitting?

When our model is doing well on training data but performing poor on test/ real data we know our model overfits. Some neurons in your network might have learned some feature which might be the deciding factor in image recognition. Due to this your entire network depends upon 1 particular neuron which is wrong. With dropout, we drop some random neurons from the network and retrain the network so that all the neuron are equally and well trained.

When do we stop convolutions and go ahead with a larger kernel or some other alternative (which we have not yet covered)

When we are processing high-quality images where extracting features is computationally very expensive and we can't process image with normal 3x3 convolutions or incase we have performed MaxPooling.

How do we know our network is not going well, comparatively, very early?

When our result after a first epoch is far from target number we know we started wrong and need to change things before retraining. Let us consider MNSIT example. If the result of our first epoch is somewhere around 92% we are targeting 99.5% then we are sure we won't touch 99.5% after n epochs as we have put wrong step forward since beginning.

What is batch size, and effects of batch size?

The teacher said you will have 6 test of 1 hour during the whole year and each test will have 30 questions. Here 6 is the epoch and 30 is the batch size. Now the test is of 1 hour and if the teacher gives 120 questions to write, will you be able to do it? It will require you to probably write with both hands :) Let's use the same concept in the neural network. Larger batch size requires more memory power but decrease processing time whereas small batch size means less memory required but more processing time.

When to add validation checks?

Ever wondered why we have so many tests before that final exam? It helps you figure out whether you are on the right track or not. When we get fewer marks in a test we know we have a problem here and we need to improve in this area/ layer(neural net). Validation checks are similar to that and we need to know the accuracy of our model after every epoch run instead of knowing it in the end after complete training and waiting for full training to get over to know the accuracy.

LR schedule and concept behind it?

Your learning rate determines how soon you want to reach your minima. If chosen less value the process might take more time to reach minima whereas if the value is chosen more it might overshoot and never reach minima.

What is is the difference between Adam vs SGD?

Gradient descent aka batch Gradient Descent is the most common method used to optimize deep learning networks. As per the white paper:

Gradient descent is a way to minimize an objective function J(θ) parameterized by a model’s
parameters θ ∈ (R^d) by updating the parameters in the opposite direction of the gradient of the objective function ∇θJ(θ) w.r.t. to the parameters. The learning rate η determines the size of the steps we take to reach a (local) minimum. In other words, we follow the direction of the slope of the surface created by the objective function downhill until we reach a valley

In code, batch gradient descent looks something like this:
for i in range ( nb_epochs ):
    params_grad = evaluate_gradient ( loss_function , data , params )
    params = params - learning_rate * params_grad

SGD is a variance of gradient descent. SGD unlike GD performs a paramtere update for each training example.

for i in range ( nb_epochs ):
np.random.shuffle ( data )
  for example in data :
     params_grad = evaluate_gradient ( loss_function , example , params )
     params = params - learning_rate * params_grad

SGD fluctuation:

Recently many new optimizers became famous and one such optimizer is Adam. Adaptive Moment Estimation(Adam) is another method that compute adaptive learning rates for each parameter. It reaches minima faster than SGD and is also efficient in memory consumption. Read here for more info

SGD WhitePaper

Adam WhitePaper

Credit to Image Sources:
1x1 Convolution
Receptive field
Softmax
Batch Normalization
Transition Layers
Learning Rate
Learning Rate

How to link my own blog post in another blog

Jai — Wed, 17 Jul 2019 02:02:53 +0000

Hi All,

I am writing blog post which is continuation of old blog. How can I refer my old blog again. Please share the possible ways of implementing this.

Security in Insecure world

Jai — Wed, 26 Jun 2019 01:25:59 +0000

With growing usage of IT in day to day life, there are chances of misusing any available online services. According to economics times Over 15,700 Indian websites were reported hacked this year up to November 2018. So with the given dynamics lets see what all options we have to protect our resources. But before jumping to solutions and type of protection available let's get familiar with some common terminologies. Let's get started...

Image Source

Relying Party: A relying party (RP) is a computer term used to refer to a server providing access to a secure software application. Or we may say RP is a website or other entity on the Internet that uses an identity provider to authenticate a user who wants to log in.

Claims: Claims contains the information that we passed to the application like Name, Age, etc post authentication.

Image Source

Identity : Are you the right person trying to access the application. For example, whenever you enter the office premise you need to show your batch to enter the premise.

Identity Provider (IDP): Is the term for a server that authenticates a user (the server is connected to some account SQL database, AD, etc.). In India, Aadhaar is used as IDP to confirm our Identity.

Authentication Vs Authorization: Authentication verifies you are who you say you are whereas Authorization decides if you have the permission to access a resource. Authorization occurs post authentication is successful.

Only an IDP can perform user authentication

Service Provider: SP is an entity which is providing service. As we can see in below example here we are trying to protect an SP which has a trust established with an IDP. So whenever someone tries to access the service provided by Service provider they need to be authenticated against the IDP and post successful authentication the user can the resource. In a real-world example, we can think of SP as google drive and IDP as google. So to access google drive you need to log in with your Google credentials first.

Image Source

Federation Provider: FP is often used for a server that receives a SAML Token from another server. And then forwards it to the next Relying Party. For example, In case if you have forgotten your office Id card in home and the security personal stops you on the gate. Instead of asking you puzzles to confirm your Identity he federates/ redirects you to the main office to get temporary Id card for the day.

Identity And Access Management: IAM refers to a framework of policies and technologies for ensuring that the proper people in an enterprise have the appropriate access to technology resources. Also called identity management (IdM), IAM systems fall under the overarching umbrella of IT security.

Image Source

In the real world, the best example is your Aadhar/ Green Card. When you present your Aadhar/ Green Card to the bank to prove that you are you, the bank (service provider) is trusting that the Aadhaar/ Green Card(identity provider) has properly vetted you with birth certificates, social security cards, or other identity information. Because of this trust, or federation, you don't have to carry all of these documents with you everywhere and prove to every single person that you are you. They trust the Aadhaar/ Green Card to have taken the appropriate steps to prove your identity.

Now since we have got some basic clarity on the security terminologies, let deep dive into more real-world challenges and the solutions available to overcome those challenges.

What is the basic component of IAM and what IAM system should include?

Basic components of IAM:

How the individuals are identified in a system?
How roles are identified in a system and how do we provide the roles to the users?
How we will manage the roles of users?
Assigning levels of access to individuals or groups of individuals
Protecting sensitive data like PCI(credit cards info) within the system and securing the system itself.

IAM system should include all the necessary controls and tools to capture and record the above features.

Image Source

What is Roles Based Management?

RBA helps us to manage the necessary permission for an authenticated user. Example: Using our employee office Id cards we can easily enter most of the floors but we can't enter server rooms. In case if you are a developer and you have access to server rooms, I think it's time to talk to your security team to strengthen the RBA policies :-)

Image Source

What is Single Sign-On (SSO)?

Imagine our condition if Google starts asking us to punch in our credentials every time we use any of their services. Our condition will be something like below. We surely don't want to ask users for credentials every time they use any of our services. Even if we own 10 applications, we should authenticate users only once and let them use all 10 applications.

Image Source

SSO is a user authentication service that allows a user to enter his credentials once and be able to access multiple applications. For example, if we want to access google drive or google album or google contacts, we need to login into our google account once and we can access all of them without entering the password every time. Please refer below image for better understanding.

Image Source

What is SAML and how it works?

Now we are clear that we should ask users to enter their credentials only once even if they want to access our multiple applications. But how will we know it is the same user? For example, we have 2 application A and B and user enter credential to access application A and now wants to access application B. We need to have a mechanism to let application B bypass authentication and handle validation internally without popping up the login screen to the user.

SAML stands for Security Assertion Markup Language. It is an open standard that allows Identity Provider (IDP) to pass authorization credentials to service providers (SP).

SAML Provider is a system that helps a user access a service they need. There are primary 2 types of SAML providers:

Service Provider: A service provider needs authentication from the IDP to grant authorization to the user.
Identity Provider: An identity provider performs the authentication that the end user is who they say they are and sends that data to the service provider along with the user’s access rights for the service.

Image Source

SAML works by passing information about users, logins, and attributes between the identity provider and service providers. Each user logs in once to Single Sign-On with the identity provider, and then the identity provider can pass SAML attributes to the service provider when the user attempts to access those services. The service provider requests the authorization and authentication from the identity provider. Since both of those systems speak the same language – SAML – the user only needs to log in once.

Each identity provider and service provider need to agree upon the configuration for SAML. Both ends need to have the exact configuration for the SAML authentication to work.

What is OAuth and how it works?

OAuth(Open Authorization) is an open standard for token-based authentication and authorization on the internet. An end user talks to their identity provider, and the identity provider generates a cryptographically signed token which it hands off to the application to authenticate the user. The application trusts the identity provider. As long as that trust relationship works with the signed assertion, you’re good to go. The diagram below shows how this works.

Image Source

Below is an example of OAuth:

Image Source

There are multiple features provided by OAuth like:

Scopes and Consent
Actors
Clients
Tokens
Authorization Server
Flows

Please refer Blog for more info.

When we had SAML, why we need OAuth?

SAML is basically a session cookie in your browser that gives you access to web apps. It’s limited in the kinds of device profiles and scenarios you might want to do outside of a web browser. Now we have modern web and native application development platforms. There are Single Page Applications (SPAs) like Gmail/Google Inbox, Facebook, and Twitter. They have different behaviors than your traditional web application because they make AJAX (background HTTP calls) to APIs. Mobile phones make API calls too, as do TVs, gaming consoles, and IoT devices. SAML SSO isn’t particularly good at any of this.

What is Service Provider (SP) initiated Single Sign-On (SSO) Flow?

When the service provider generates an request which is send to Identity provider as the first step in the federation process and the IDP responds with a SAML response we call this SP initiated flow. Refer below Image

Processing steps:

The user requests access to a protected SP resource. The request is redirected to the federation server to handle authentication.
The federation server sends an HTML form back to the browser with a SAML request for authentication from the IdP. The HTML form is automatically posted to the IdP’s SSO service.
If the user is not already logged on to the IdP site or if re-authentication is required, the IdP asks for credentials (e.g., ID and password) and the user logs on.
Additional information about the user may be retrieved from the user data store for inclusion in the SAML response. (These attributes are predetermined as part of the federation agreement between the IdP and the SP)
The IdP’s SSO service returns an HTML form to the browser with a SAML response containing the authentication assertion and any additional attributes. The browser automatically posts the HTML form back to the SP. NOTE: SAML specifications require that POST responses be digitally signed.
(Not shown) If the signature and assertion are valid, the SP establishes a session for the user and redirects the browser to the target resource.

What is Identity Provider (IDP) initiated Single Sign-On (SSO) Flow?

When the federation process is initiated by the Identity provider by sending an SAML response to the service provider. Refer below Image

Processing steps:

A user has logged on to the IdP.
The user requests access to a protected SP resource. The user is not logged on to the SP site.
Optionally, the IdP retrieves attributes from the user data store.
The IdP’s SSO service returns an HTML form to the browser with a SAML response containing the authentication assertion and any additional attributes. The browser automatically posts the HTML form back to the SP.

Image Source

Let us look at real world example to understand above

SP Initiated SSO

Monika the user: "Hey Hari, show me your project report"

Hari the SP: "Hey, I'm not sure who you are yet. We have a process here so you go get yourself verified with Nithya the IdP first. I trust her."

Nithya the IdP: "I see Hari sent you here. Please give me your credentials."

Monika the user: "Hi I'm Monika. Here are my credentials."

Nithya the IdP: "Hi Monika. Looks like you a genuine user"

Nithya the IdP: "Hey Hari. Monika is authenticated user and here's some additional information about her. You do whatever you want from here."

Hari the SP: "Ok cool Nithya. Monika, Here you go!"

IDP initiated SSO

Monika the user: "Hey Nithya. I want to view Hari's project details. But Security is tight over there."

Nithya the IdP: "Hey Hari. I trust Monika. She is genuine user and here's some additional information about her. You do whatever you want from here."

Hari the SP: "Ok cool Nithya. Monika, Here you go!"

Reference:

Identity And Access Management (IAM)

Enterprise IAM features

SP Vs IDP Initiated SSO

SP Initiated Vs IDP Initiated

C# features from 5.0, 6.0 and 7.0

Jai — Thu, 30 May 2019 14:09:31 +0000

As we know recently c# version 8.0 was launched and it is still in preview as I write this article. Its final version will be released together with .NET Core 3.0. Unlike all the versions of the language so far, not all features of C# 8.0 will be available in the .NET framework. I'll update this blog once version 8.0 is available.

I thought of listing some key features of c# from 5.0, 6.0 and 7.0. I have added Github link also for reference with all the features implementation.

https://github.com/jai00271/CSharpFeatures

Before starting I sincerely want to thank Microsoft and various websites/bloggers.

Fyi I am using asp .Net core 2.2 for all projects.

Let's see how C# has evolved over the years.

Credit: Image Source

C# 5.0 features

Async and await

Async

The keyword is useful for an asynchronous function. If the user specifies the async keyword before the function user needs to call the function asynchronously.

Await

The await keyword is useful when the user calls the function asynchronously.

private static async void Feature1_AsyncAwait()
{
    await DBProcess();
}

private static Task DBProcess()
{
    return Task.Run(() =>
                    {
                        System.Threading.Thread.Sleep(7000);
                    });
}

Caller Information

You can fetch caller info using Caller attribute. It is useful for debugging, tracing, etc purpose.

Three different attribute types are used in the caller information.

CallerFilePath: It is used to set information about the caller source code file
CallerMemberName: It is used to set the information about the caller member name
CallerLineNumber: It is used to set the information about the line number of the caller

public static void Feature2_CallerInformation([CallerMemberName] string name = null, [CallerLineNumber] int line = -1, [CallerFilePath] string path = null)
{
    Console.WriteLine("Caller Name: {0}", name);
    Console.WriteLine("Caller FilePath: {0}", path);
    Console.WriteLine("Caller LineNumber: {0}", line);
}

Output:
-------------------------------------------------------------------
Caller Name: Main
Caller FilePath: C:\Users\User_Name\CSharp5\Program.cs
Caller LineNumber: 13

C# 6.0 features

Using Static

Now to use any static method we don't have to use class name. We can declare namespace with static keyword for that class.

using static System.Console;

public static void Feature1_UsingStatic()
{
    //Check namespace declaration: using static System.Console;
    WriteLine("We are using Console.WriteLine() to print this line!");
}

Auto Property Initializer

Instead of creating properties with default get; and set; we can organize them better by assigning default values. We can also make a property readonly by removing set; while property declaration.

public class Employee
{
    public Employee()
    {
        Salary = 111;
    }
    public string Name { get; set; } = "Jai";
    public int Age { get; set; } = 30;
    public int Salary { get; } = 222;
}

In the above example Salary is readonly and it can't be modified except Employee constructor.

public static void Feature2_AutoPropertyInitializer()
{
    Employee employee = new Employee();
    WriteLine(employee.Name);
    WriteLine(employee.Age);
    WriteLine(employee.Salary);
}

Now in case if you try to set values for the salary you will get below error:

Dictionary Initializer

When using dictionaries, sometimes you want to initialize them with values just as you can do with arrays and lists using "=". We can now do it using something called dictionary initializers which work very similar to array initializers.

public static void Feature3_DictionaryInitializer()
{
    Dictionary<int, string> dictionary = new Dictionary<int, string>()
    {
        [1] = "Amar",
        [2] = "Akbar",
        [3] = "Anthony"
    };
    dictionary[4] = "Siddhu";
    foreach (var item in dictionary)
    {
        WriteLine("Dictionary key is: {0} and value is: {1}", item.Key, item.Value);
    }
}
Output:
-------------------------------------------------------------------
Dictionary key is: 1 and value is: Amar
Dictionary key is: 2 and value is: Akbar
Dictionary key is: 3 and value is: Anthony
Dictionary key is: 4 and value is: Siddhu

nameOf Expression

This feature is very useful for developers. If you notice above, in all WriteLine methods we have been mentioning Id in string and trying to print the values. Why not use the property name itself and make our life easy.

public static void Feature4_NameOfExpression()
{
    Employee employee = new Employee();
    WriteLine("{0} : {1}", nameof(employee.Name), employee.Name);
    WriteLine("{0} : {1}", nameof(employee.Age), employee.Age);
    WriteLine("{0} : {1}", nameof(employee.Salary), employee.Salary);
}
Output:
-------------------------------------------------------------------
Name : Jai
Age : 30
Salary : 111

Exception filters

Exception filters allow us to specify a condition within a catch block so if the condition will return true then the catch block is executed else it won't.

public static void Feature5_ExceptionFilters()
{
    int denominator = 0;

    try
    {
        WriteLine(3 / denominator);
    }
    catch (DivideByZeroException exception) when (denominator == 2)
    {
        WriteLine("If catch executed");
    }
    catch (Exception exception)
    {
        WriteLine(exception.Message);
    }
}

Await In Catch And Finally Block

Now you can have async calls from catch and finally block. This is very useful as sometime we may want to perform some operation like writing logs, caching, DB calls without blocking the execution.

public static async void Feature6_AwaitInCatchAndFinallyBlock()
{
    int denominator = 0;

    try
    {
        WriteLine(3 / denominator);
    }
    catch (DivideByZeroException exception)
    {
        await FromCatch();
    }
    finally
    {
        await FromFinally();
    }
}

private static async Task FromCatch()
{
    WriteLine("Inside Catch Async call");
}

private static async Task FromFinally()
{
    WriteLine("Inside Finally Async call");
}
Output:
-------------------------------------------------------------------
Inside Catch Async call
Inside Finally Async call

Null Conditional Operator

Instead of checking null condition in the traditional way, we can make use of in-line null-conditional operator. This operator helps in removing lot of null's and if conditions.

public class Customer
{
    public int ItemNo { get; set; } = 123;
    public string Name { get; set; } = "Jai";
    public Order Order { get; set; } = new Order();
}
public class Order
{
    public int OrderId { get; set; } = 321;
    public string ProductName { get; set; } = "TShirt";
    public string Description { get; set; } = null;
}
public static void Feature7_NullConditionalOperator()
{
    Customer customer = new Customer();
    WriteLine(customer?.Name);
    WriteLine(customer?.Order?.ProductName);
    WriteLine(customer?.Order?.Description ?? "No description provided");
}
Output:
-------------------------------------------------------------------
Jai
TShirt
No description provided

Expression–Bodied Methods

Incase your method just contains one line, you can use expression body method using lambda expression.

public static void Feature8_ExpressionBodiedMethods()
{
    WriteLine(PrintMessage());
}
private static string PrintMessage() => "Have a great day!";

Format Strings Using Interpolation

Now you don't need to format string using string.Format(). Trust me this feature has saved lot of my time and I don't have to worry about maintaining format while writing logs statement in code.

public static void Feature9_FormatStringsUsingInterpolation()
{
    Employee employee = new Employee();
    WriteLine($"Name is: {employee.Name}, age is: {employee.Age}");
}

C# 7.0 features

out variables

You can declare out values inline as arguments to the method where they're used.

Credit: Image Source

public static void Feature1_OutVariable()
{
    string s = "28-May-2019";
    if (DateTime.TryParse(s, out DateTime date))
    {
        WriteLine(date);
    }
    WriteLine(date);
}

Local Functions

Now we can have local functions instead of multiple separate private function.

public static void Feature2_LocalFunctions()
        {
            void PrintHi()
            {
                WriteLine("Hi");
            }
            void PrintHello()
            {
                WriteLine("Hello");
            }
            PrintHi();
            PrintHello();
        }

Tuples (with types and literals)

Return multiple values from a method is now a common practice, we generally use custom datatype, out parameters, Dynamic return type or a tuple object but here C# 7.0 brings tuple types and tuple literals for you it just return multiple values/ multiple type inform of tuple object.

public static void Feature3_Tuples()
{
    (string, string, string) PrintDetails()
    {
        //read EmpInfo from database or any other source and just return them
        string name = "Jai";
        string address = "India";
        string moto = "learning";
        return (name, address, moto); // tuple literal
    }

    var empInfo = PrintDetails();
    WriteLine($"employee info is {empInfo.Item1} {empInfo.Item2} {empInfo.Item3}");
}

Tuples are very useful thing where you can replace hash table or dictionary easily, even you can return multiple values for a single key, Additionally you can use it instead of List where you store multiple values at single position.

.NET also has a Tuple type (See here) but it is a reference type and that leads to performance issue, but C# 7.0 bring a Tuple with value type which is faster in performance and a mutable type.

Pattern Matching

Is pattern matching is a new feature which can used for checking conditions. Pattern matching supports a lot of patterns like Type Pattern, Constant Pattern, Var Pattern, Recursive Pattern, Property Pattern & Property Sub-pattern, Switch Statement, Match Expression, Case expression, Throw expression, De structuring assignment, Testing Nullable, Arithmetic simplification, Tuple decomposition, Complex Pattern, Wildcard Pattern etc.

public static void Feature4_PatternMatching_If()
{
    int denominator = 0;

    if (denominator is 0)
    {
        WriteLine("Inside If");
    }
}

Switch pattern helps a lot as it uses any datatype for matching additionally 'case' clauses also can have its pattern so it bit flexible implementation. In below sample switch case checks pattern and call 'Multiply' method

public class Employee
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Gender { get; set; }
    }
    public class Department : Employee
    {
        public string DeptName { get; set; }
        public int Year { get; set; }
    }

    public class Performance : Employee
    {
        public string Comment { get; set; }
        public string Bonus { get; set; }
    }
    public static void Feature4_PatternMatching_Switch()
        {
            Employee p = new Employee();
            Department d = new Department()
            {
                DeptName = "IT",
                Year = 2006
            };
            Performance a = new Performance()
            {
                Name = "Jai",
                Age = 30,
                Gender = "Male",
                Bonus = "Sometimes",
                Comment = "generic Comment"
            };

            SwitchCase(a);
            SwitchCase(d);
            SwitchCase(p = null);

            void SwitchCase(dynamic instance)
            {
                switch (instance)
                {
                    case Employee performer when (performer.Age == 30):
                        WriteLine($"The performer {performer.Name}");
                        break;
                    default:
                        WriteLine("Not found");
                        break;
                    case null:
                        WriteLine("Argument Null Exception");
                        //throw new ArgumentNullException(nameof(a));
                        break;
                }
            }            
        }
Output:
-------------------------------------------------------------------
The performer Jai
Not found
Argument Null Exception

Ref returns and locals

Earlier we only had option to use ‘ref’ keyword while passing a parameter to a method. Now with C# 7.0, we can also use ‘ref’ for returning a variable from a method i.e. a method can return variable with reference. We can also store a local variable with reference.

public static void Feature5_RefLocalsAndReturns()
        {
            int[] arr = { 2, 4, 6, 8, 9 };
            ref int oddNum = ref GetFirstOddNumber(arr);

            WriteLine($"Odd Number: {oddNum}");

            ref int GetFirstOddNumber(int[] numbers)
            {
                for (int i = 0; i < numbers.Length; i++)
                {
                    if (numbers[i] % 2 == 1)
                    {
                        return ref numbers[i];
                    }
                }
                throw new Exception("odd number not found");
            }
        }

Throw Expressions

You can throw exceptions in code constructs that previously weren't allowed because throw was a statement. No need of try catch, Hurray!

public static void Feature6_ThrowExpressions()
        {
            var denominator = 0;
            WriteLine(Divide(denominator));

            double Divide(int denom)
            {
                var numerator = 3;
                return denom != 0 ? numerator / denom : throw new DivideByZeroException();
            }
        }

Generalized async return types

Methods declared with the async modifier can return other types in addition to Task and Task<T>.

Returning a Task object from async methods can introduce performance bottlenecks in certain paths. Task is a reference type, so using it means allocating an object. In cases where a method declared with the asyncmodifier returns a cached result, or completes synchronously, the extra allocations can become a significant time cost in performance critical sections of code. It can become costly if those allocations occur in tight loops.

The new language feature means that async method return types aren't limited to Task, Task<T>, and void. The returned type must still satisfy the async pattern, meaning a GetAwaiter method must be accessible. As one concrete example, the ValueTask type has been added to the .NET framework/ Core to make use of this new language feature:

public static void Feature7_GeneralizedAsyncReturnTypes()
        {
            NoReturn();
            WriteLine("Returned value is: " + WithReturn().Result);

            async ValueTask NoReturn()
            {
                await Task.Delay(1);
            }

            async ValueTask<int> WithReturn()
            {
                await Task.Delay(1);
                return 1;
            }
        }

There is a major difference between Task and ValueTask. The Task is a reference type and requires heap allocation. The ValueTask is a value type and is returned by value – meaning, no heap allocation. It’s recommended to use ValueTask when there is a high probability that a method won’t have to wait for async operations. For example, if a method returns cached or predefined results. This can significantly reduce the number of allocations and result in big performance improvement.

Expression-Bodied Members

C# 6 introduced expression-bodied members for member functions, and read-only properties. C# 7.0 expands the allowed members that can be implemented as expressions. In C# 7.0, you can implement constructors, finalizers, and get and set accessors on properties and indexers.

// Expression-bodied constructor
public ExpressionMembersExample(string label) => this.Label = label;

// Expression-bodied finalizer
~ExpressionMembersExample() => Console.Error.WriteLine("Finalized!");

private string label;

// Expression-bodied get / set accessors.
public string Label
{
    get => label;
    set => this.label = value ?? "Default label";
}

Thanks for reading.

Convolution Neural Network: Background & Basics

Jai — Sun, 28 Apr 2019 02:24:46 +0000

Background

DNN - When the great minds said all humans should look within themselves to find the answers of most difficult problems, we never took it seriously. Now interestingly most of the AI is built around replicating GOD's most beautiful wonder which is us. Scientist and researchers are still in awe of how our minds work and it performs such complex operation with such ease. DNN which stands for Deep Neural Network is a similar approach in trying to replicate how our brain functions. So throughout the series(yes this is just the beginning), we will be learning about DNN that means whatever we will learn going forward is a branch of DNN.

Today we will discuss Images and CNN. But before that let me ask you a question, have you ever thought how modern photo apps like Instagram provides those filters? What is the logic behind those filters? Let's find the answer.

CNN - Convolution neural network is a branch of DNN through which we process images and try to learn the pattern so that we can make a better prediction in the future. FYI Though it is famous for Image progressing it can be used in other scenarios as well. Now lets again take the example of our brain, do you know how our brain process Images? It uses an edge detector to detect the edges and forms an image based on that. So when an Images comes to the brain it uses edge detector to find the edges and then those edges are converted to part of an object and then in the final step they are converted to object.

Let's take another example, have you ever try reading something when it is dark? CNN also works in the same way. You move your torch from left to right to read lines and same logic goes behind convolution as well.

Convolution is a technique where we try to reduce the size of an image without losing key/important features of it. Well, it makes sense to do so because if we are detecting whether an Image is of CAT or DOG, what is the whole point of doing it in the original image which might be of MB's.

Above is a 3x3 convolution on a 5x5 matrix and the result is a 3x3 matrix(In case 3x3 convolution/ filter the result matrix is always 2 less than the original matrix, for example, if we have a 7x7 matrix and run a convolution matrix of 3x3 over it, we will have a 5x5 matrix).

Now, we will try answering some important questions like:

What are Channels and Kernels (according to EVA)?

Kernels: A unit. You can think of it as an atom(the smallest particle of a chemical element that can exist).

Channels: Collection of kernels. you can think of it as a molecule(Every combination of atoms is a molecule).

In CNN dictionary, Kernel = filters = feature detector.

Why should we only (well mostly) use 3x3 Kernels?

We will split this question into 2 parts:

a. How to choose between smaller and larger filter size?
b. Why 3x3 and not any other filter like 5x5?

a. How to choose between smaller and larger filter size?

Smaller filter looks at very few pixels at a time hence it has small receptive field. Where as large filter will look at lot of pixel hence it will have large receptive field
When we work with smaller filters, we focus on every minute details and capture smaller complex features from Image, where as when we work with larger filters we tends to search for generic features which will give us basic components.
After capturing smaller/ minute features from Image we can make use of them later in the processing. We loose this benefit with large filters as they focus on generics not specific features.

b. Why 3x3 and not any other filter like 5x5 or 7x7?

Less filter less computation, big filter more computation.
It learns large complex features easily, where as large filters learns simple features.
Output Layers will be less when we use 3x3 filters as compared to 5x5 or bigger filters.
Also since there will be more output layers when using 3x3 filters more memory will be required to store them as compared to 5x5 or bigger filters.

How many times do we need to perform 3x3 convolution operation to reach 1x1 from 199x199 (show calculations)

We need to perform 100 iterations. So let do it:

199, 197, 195, 193, 191,
189, 187, 185, 183, 181,
179, 177, 175, 173, 171,
169, 167, 165, 163, 161,
159, 157, 155, 153, 151,
149, 147, 145, 143, 141,
139, 137, 135, 133, 131,
129, 127, 125, 123, 121,
119, 117, 115, 113, 111,
109, 107, 105, 103, 101,

99, 97, 95, 93, 91,

89, 87, 85, 83, 81,

79, 77, 75, 73, 71,

69, 67, 65, 63, 61,

59, 57, 55, 53, 51,
49, 47, 45, 43, 41,

39, 37, 35, 33, 31,

29, 27, 25, 23, 21,

19, 17, 15, 13, 11,

9, 7, 5, 3, 1

Repo: https://github.com/jai00271/Deep-Neural-Network.git

Please share your valuable feedback, to help me write better.

Net Core important Features implementation

Jai — Tue, 09 Apr 2019 23:12:52 +0000

As .Net core(version used here is 2.1) is becoming popular day by day, here are some projects I created which might come handy. (added comments in the code for better understanding). Whichever functionality you want to test just set those web API project as startup project and you are good to go.

Repository: https://github.com/jai00271/AspCoreGuide

1. Extending Service and cors implementation:

In this project, we moved all the service injection logic to a different class. We should avoid putting all service injection logic inside ConfigureServices method. Also when we are using .Net core with the client-side project like Angular or react we should take care of cors issue as well.

Project Name: BasicProjectSetup

2. Log implementation:

This project contains an implementation of logging feature provided by default with .Net core.

Project Name: LoggingImplementation

3. Entity Framework implementation:

This project contains 2 things:

a. How to Entity framework with SQL server
b. Implementation via Repository design pattern

Nugets used: Microsoft.EntityFrameworkCore.SqlServer, Microsoft.EntityFrameworkCore.Tools (Project: EFImplementation.Repository)

Folder Name: EFImplementation

refer this for more understanding of EF implementation in .Net core

4. Error handling:

This project contains 3 things:

a. Custom Log implementation by extending NLog.Extensions.Logging
b. Built in .Net core middleware implementation
c. Custom middleware implementation

Folder Name: Errorhandling

Nugets usd: NLog.Extensions.Logging(Project: LoggerService)

5. Implementing Swagger in Web API

This project contains swagger implementation.

Project Name: SwaggerImplementation

Nuget used: Swashbuckle.AspNetCore(Project: SwaggerImplementation)

6. Working with XUnit Test Framework

This project helps in understanding how XUnit framework works.

Folder Name: XUnitTest

Nuget used: Microsoft.AspNetCore.App(Project: Learn.UnitTest)

Repository: https://github.com/jai00271/AspCoreGuide

Refernce article

Code: https://code-maze.com
Cover Image: Image source

Please share your valuable feedback, as it will help me write better :)

What is the objective of Object-Oriented Programming

Jai — Sun, 07 Apr 2019 00:21:19 +0000

When someone asks us what is OOPS, we start our explanation with pillars of OOPS like abstraction, polymorphism, encapsulation, and Inheritance. In this article, we will take a step back and understand Object-oriented first before covering its pillars.s.

According to Wiki, Object Oriented (of a programming language) using a methodology which enables a system to be modelled as a set of objects which can be controlled and manipulated in a modular manner.

Still analyzing? Well, let us understand this in simpler words. Object-oriented is a software design in which we can simply group data its data types and methods under a single package. Here we will be dealing with 2 main terms:

Class: Class is a blueprint of data and functions or methods.
Objects: Objects are an instance of a class.

Here we can treat the home as a class which contains properties as people living in it and their actions as methods. Similar description in c# language can be represented as:



public class Home

{
        public string P1 { get; set; }
        public string P2 { get; set; }

        public void Paint()
        {

        }
}

Now home is a general class which can be used to represent families. For example, if someone wants to create Mr. C. V. Raman or Mr. Kalam house all they need is to create an object of this class and they can set the properties and invoke the method.



class Program
{
   static void Main(string[] args)
   {
      Home ramanHome = new Home();
      ramanHome.P1 = "Mr. C. V. Raman";
      ramanHome.P2 = "Mrs. Lokasundari Ammal";
      ramanHome.Paint(ramanHome.P1, ramanHome.P2);

      Home kalamHome = new Home();
      KalamHome.P1 = "Mr. A. P. J. Abdul Kalam";
      KalamHome.P2 = "None";
      KalamHome.Paint(ramanHome.P1, ramanHome.P2);
   }
}

Now if you notice we used the same Home class to describe 2 entities. Similarly to define other homes all we need is to create an instance of the home class and set the properties.

Hope the concept like Class and object are clear. Now, let us take a look at the pillars of OOPS, I'll just provide the basic definitions as there are enough articles available on the internet describing these pillars.

Abstraction: Abstraction is a process of hiding the implementation details and showing only functionality to the user.

Encapsulation: Wrapping of data and function in a single unit is called encapsulation. We hide the data from the outer world and doesn't allow the outer world to access them directly. This is known as data hiding.

Polymorphism: Polymorphism means the ability to take more than one form.

Inheritance: Inheritance is the process by which objects of one class acquire the properties of objects of another class.

Please do share your valuable feedback.

Programming with Delegates

Jai — Mon, 01 Apr 2019 02:06:59 +0000

So What are Delegates in English? Delegate means a person sent or authorized to represent others, in particular, an elected representative sent to a conference. Now we keep hearing the news that delegates of the two countries met and discussed some underlying issues. Similarly, Delegates are nothing more than communication between two entities where some information can be exchanged among the entities.

According to Wiki, In object-oriented programming, delegation refers to evaluating a member (property or method) of one object (the receiver) in the context of another original object (the sender). In the c# programming world, a callback is tied to an event and when an event occurs a callback method is fired using a delegate. For example, when you click on a button an event is triggered and a corresponding callback action is executed. But how did the program understood which callback to execute? It is done via Delegates. A delegate holds the reference(delegates are also called function pointer because of the same reason) of methods and can be used to chain callback methods.

Delegate in c# is defined as:

[modifier] delegate [return_type] delegate_name;

Example:

public delegate int GoForestGo(int G, int F, int G);

modifier: It is the required modifier which defines the access of delegate and it is optional to use.
delegate: It is the keyword which is used to define the delegate.
return_type: It is the type of value returned by the methods which the delegate will be going to call. It can be void. A method must have the same return type as the delegate.
delegate_name: It is the user-defined name or identifier for the delegate. parameter_list: This contains the parameters which are required by the method when called through the delegate.

Below is an example of a simple delegate where we are creating a class and declaring a delegate which will take a number and perform the print operation. Let us declare a method LetsPrint which is printing all the numbers which are divisible by 2. We are invoking a callback for every success scenario and printing the number.

public delegate void CallBack(int i);

public class Program
{
    private static void Main(string[] args)
    {
        NewClass instance = new NewClass();
        instance.LetsPrint(CallBack);
    }

    private static void CallBack(int i)
    {
        Console.WriteLine(i);
    }
}

public class NewClass
{
    public void LetsPrint(CallBack obj)
    {
        for (int i = 0; i < 100; i++)
        {
            if (i % 2 == 0)
            {
                obj(i);
            }
        }
    }
}

Multicast Delegates

A delegate can hold the reference of one or more methods. Now in our above example, our delegate was holding only one reference of a callback method, but when a delegate holds more than one reference it is called multicast delegates. Have a look to the below code snippet:

public delegate void CallBack(int i);

public class Program
{
    private static void Main(string[] args)
    {
        NewClass instance = new NewClass();
        CallBack callBack = null;

        callBack = CallBack_Method1;
        callBack += CallBack_Method2;

        instance.LetsPrint(callBack);
    }

    private static void CallBack_Method1(int i)
    {
        Console.WriteLine("Callback1: " +i);
    }
    private static void CallBack_Method2(int i)
    {
        Console.WriteLine("Callback2: " + i);
    }
}

public class NewClass
{
    public void LetsPrint(CallBack obj)
    {
        for (int i = 0; i < 10; i++)
        {
            if (i % 2 == 0)
            {
                obj(i);
            }
        }
    }
}

In the above example, we are invoking 2 callbacks by chaining them together. Similarly, we can chain multiple callbacks to a delegate. We are invoking LetsPrint and passing chained delegates which will be executed after every successful execution.

I hope you have understood the concept of delegates and callbacks after reading the article. Please do share your valuable feedback.