{"componentChunkName":"component---src-templates-tag-js","path":"/tags/net/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":4,"edges":[{"node":{"fields":{"slug":"/engineering/why-we-rebuilt-loginradius-dot-net-core-apis-with-go/"},"html":"

Introduction

\n

Currently, the LoginRadius Identity Platform processes more than 100K requests per second. As our developer and enterprise customers grow, we should be able to scale our APIs to handle staggering loads of requests per second. It won’t be surprising if our APIs have to serve a million requests per second in the future.

\n

Generally, we add more instances, CPU, or memory for supporting high request volumes. However, it has been burdening our infrastructure budget and maintenance.

\n

So, we’re focused on reducing the cost of compute capacity by improving efficiency. In this engineering update, we share our experience with a highly effective, low-risk, large-scale performance and cost optimization with Go.

\n

LoginRadius production environment consists of 30+ microservices backed by a cloud-native infrastructure. Most of these services are written in .NET and Node.js. In Q1 2021, we explored the possibilities of improving the performance of our services and optimizing costs.

\n

How LoginRadius Has Been Handling High RPS Throughput?

\n

LoginRadius tech stack consists of 30+ microservices. We have different microservices for each business service like Authentication, Web SSO, Federated SSO, etc.

\n\n

1) Architecture

\n

Core Applications: Multiple microservices instances for Authentication, Account API, Analytics API, Risk-based Authentication, Backend Jobs, Integrations, and much more,

\n

Data Storage: MongoDB, Elasticsearch, Redis, and PostgreSQL clusters are used to store a range of datasets for various applications and functionalities.

\n

Queues: Amazon Kinesis Data Streams, Amazon Simple Notification Service (SNS), Amazon Simple Queue Service (SQS), and Azure Queue Storage.

\n

Other Services: Services for rate-limiting, bcrypt clusters, feature flags, and more.

\n

Routing: AWS load balancers (ALB, NLB, and ELB from AWS) and some nodes running NGINX as a proxy.

\n

2) Availability

\n

We've been utilizing a multi-cloud and multi-region architecture for years based on our and our customers’ data and privacy compliance requirements. However, as our usage (and load) grew with maintenance costs, we relied more on AWS resources.

\n\n

This is the basic architecture of the environment in the US:

\n

\n \n \n

\n

The above diagram shows two cloud regions — US East and US West.

\n

When requests come:

\n\n

So, how do we maintain high availability?

\n

Every availability zone has operating instances of all services (including databases). If one availability zone is down, we still have two availability zones.

\n

3) Scaling

\n

We are using a two-pronged scaling approach as scaling based on resource utilization (CPU & Memory) alone is not practical.

\n
    \n
  1. Traffic-based scaling
    2. \n
  2. Based on CPU & Memory utilization
    3. \n
\n

Why Scaling Was Challenging?

\n

Once, our multi-tenant application received a sudden spike in API requests — from thousands of requests to millions. Usually, adding new infrastructure to the existing pool takes around 60 seconds. And application deployment and start-up time were about 90 seconds. Plus, considering other possible delays in scaling, we can lose about 5 minutes for scaling up.

\n

Further, adding the time to gather metrics and make the scaling decision, the total delay can be ~6 minutes. This process can impact all multi-tenant customers' critical applications because user authentication and authorization are essential.

\n

We keep Scaling Buffers to support this kind of scenario.

\n
\n

Scaling Buffers: During the Scale-up Time, the Scaling Buffer is the service's highest predicted traffic spike. Depending on the scaling strategy, we store several types of the buffer.

\n
\n

Usually, we set a one million requests concurrency buffer. And based on the traffic pattern, our scaling automation triggers the scaling.

\n

Why Our Platform Performance Was Good, But Not Great?

\n

Our Platform performance is good. We can quickly handle millions of requests, and our application platform was scalable but not great. Minding the kind of growth we’re expecting, we wanted to improve and prepare our platform for the future.

\n

Challenges in the Existing Platform

\n

1) Startup Time

\n

No. of requests can fluctuate within a few seconds if not minutes or hours, especially with specific events such as holiday shopping, promotional events, Black Friday, etc. So, in the event of traffic spikes, application startup time plays a significant role in scaling.

\n

Our application startup time was around 90 seconds, so whenever scaling was happening due to high traffic, scaling took more time. That's why we needed to improve the application startup time.

\n

2) Cost

\n

We used hundreds of AWS c5.2xlarge instances in a production environment to handle daily traffic. During certain events such as holiday shopping and Black Friday, we doubled our infrastructure according to expected traffic with a 20~30% buffer. We kept a high buffer because scaling took time with the existing .NET Core services. As a result, infrastructure cost was burdening as we were inefficiently deploying cloud infrastructure.

\n

3) Lack of Flexibility and Customization

\n

We designed our Identity Platform a few years ago. Since then, the technology landscape has dramatically improved and optimized in recent years.

\n

Also, current technology platforms available to build and support our product (Identity Platform) are limited. So, it is crucial to align functionality with proper technology capabilities.

\n

We were facing challenges in customization. It was inflexible and limiting to deliver the required outcomes in more complex situations and use cases.

\n

The Road to Lightning Performance, Thanks to Go

\n

Why Go?

\n

We did a lot of research to choose the appropriate programming language for our application. We needed a language that would be simple to understand and learn, easy to maintain, and has high concurrency. Our research ended with Go due to its amazing qualities.

\n

Let's take a closer look. Why choose Go? What makes Go such an excellent development language? What distinguishes it from the competition?

\n

Let's get to the bottom of this by looking at what makes Go special.

\n

Go — Background

\n

Go is an open-source programming language developed by Google's Rob Pike, Robert Griesemer, and Ken Thompson. It was initially released in 2009. It has several enhancements and additions based on the C syntax to properly control memory use, manage objects, and enable static or strict typing along with concurrency.

\n

1) Concurrency

\n

Concurrent code can be executed in parallel by separate computer cores or in sequence. Most programming languages lack concurrent execution when working with multiple threads. They often slow down programming, compiling, and execution.

\n

Go works with goroutines that are lightweight, low-cost threads. And Go channels allow goroutines to communicate with one another.

\n

Sequential Processes Communication: They are very similar to threads in Java but lightweight, and the cost of creating them is meager.

\n

2) Performance

\n

Go's core value is simplicity: it builds quickly, runs quickly, and is simple to learn. To help speed things up, there are no classes or type inheritance. This makes it easier to build a market-ready product quickly. Furthermore, its simplicity allows for quick and simple maintenance.

\n

3) Standard Library

\n

Go has an excellent standard library that includes a large number of built-in essential type functions and packages that are both practical and straightforward to use: I/O, encoding and decoding, manipulating raw bytes, network utility functions, parsing, debugging, and a lot more are all made simple by particular packages. Testing support is also included in the standard library, so no other dependencies are required.

\n

4) Easy to Learn

\n

Go has a simpler syntax than other languages and is simple to learn. The syntax of Go is somewhat similar to the C language. Developers can begin with Go in a couple of hours, but they need to spend time understanding best coding practices, especially understanding goroutines for concurrency.

\n

Benchmarking API Performance Gains

\n

We run benchmarks on our API so that the performance insights help us make decisions about the tech stack. It will paint a clearer picture of where we stand compared to our existing tech stack and what areas need improvement or immediate attention.

\n

We did multiple stress tests on our high usage APIs built separately with .NET Core(Old) and Go (new).

\n

We are using Kubernetes to deploy and manage our microservices and application infrastructure and deploy our application microservices across multiple Pods.

\n

Stress Test Scenario

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Test ItemValue
Instance Typec5.2xlarge on AWS
No. of Instances20
Reverse ProxyNGINX
Concurrent Requests20K per second
Duration5 minutes
Stress Test ToolGatling
\n

We deployed both applications in the same infrastructure and did the same stress test.\nGolang application has performed much better.

\n

Existing Application Matrix — .NET Core

\n
\n \n \n \"Requests\n \n
Graph - 1(a): Requests and Responses per Second (.NET Core)
\n
\n \n
\n \n \n \"API\n \n
Graph -1(b): API Response Time (.NET Core)
\n
\n
\n \n \n \"Overall\n \n
Graph - 1(c): Overall Matrix (.NET Core)
\n
\n

You can see some errors in Graph - 1(a) after ramping up to 15K users. Also, response time is increasing, as seen in Graph - 1(b).

\n

The application can recover after a couple of seconds, and after that, the application cannot respond. Application scaling is taking time. And existing infra cannot handle this spike, so the application crashes after 18K RPS.

\n

New Application Matrix — Go

\n

We did the same stress test with the new Go application. It is easily able to handle this kind of concurrency without any issue.

\n
\n \n \n \"Requests\n \n
Graph - 2(a): Requests and Responses per Second (Go)
\n
\n \n
\n \n \n \"Overall\n \n
Graph - 2(c): Overall Matrix (Go)
\n
\n

The Go application can easily handle 20K ramp-up requests per second without any issue, as shown in Graph -2(a).

\n

You can see in Graph - 2(b) what the response time was after 2 min 47 sec for a couple of seconds. The Go application was scaling during that time. It is scaling quickly, so it is not impacting API request performance, and, also, the application can recover response API time as expected.

\n

Conclusion

\n

In this article, you have learned how we have achieved better API performance by rebuilding them in Go, which were previously built in .NET Core. And you have understood our approach to this transition and how it increased the API performance of the LoginRadius Identity Platform.

\n

Leverage LoginRadius Identity Platform to build authentication functionality for your web and mobile apps. Sign up for a free LoginRadius account here

\n","frontmatter":{"date":"June 06, 2022","updated_date":null,"title":"Why We Re-engineered LoginRadius APIs with Go?","tags":["Go","API",".NET","LoginRadius"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/b63787a6ecfda78c022020fe03233557/ee604/high-performance-identity-apis.png","srcSet":"/static/b63787a6ecfda78c022020fe03233557/69585/high-performance-identity-apis.png 200w,\n/static/b63787a6ecfda78c022020fe03233557/497c6/high-performance-identity-apis.png 400w,\n/static/b63787a6ecfda78c022020fe03233557/ee604/high-performance-identity-apis.png 800w,\n/static/b63787a6ecfda78c022020fe03233557/f3583/high-performance-identity-apis.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Vijay Singh Shekhawat","github":"code-vj","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/how-to-send-emails-through-csharp-dotnet-using-smtp/"},"html":"

Introduction

\n

Hello Everyone, In this article, we will learn how to send emails in .NET/C# using SMTP. As sometimes, it is required to send emails to the users of the application. Email communication is considered a good way to communicate with the users of the application. There are different ways to send emails in .NET, but here we will talk about SMTP.

\n

What is SMTP?

\n

SMTP stands for Simple Mail Transfer Protocol. It is a communication protocol for electronic mail transmission. Mail servers and other message transfer agents use SMTP to send and receive mail messages. The Key Features of SMTP are it is considered a reliable server for sending emails, and it delivers the email more easily and quickly as it is developed from a simple platform.

\n

Prerequisites

\n\n

Let's start

\n

In the implementation part, we will first create a .NET Core class library, and then we will use that library in the .NET Core console app.

\n

Step 1 - Create a .NET Core Console App project in IDE.

\n

Step 2 - Add a .NET Core class library in the created solution.

\n

Step 3 - Create a new class file in the class library and name it as MailArguments.cs. Add the arguments fields in this file, which will be used in sending the email.

\n
 public string MailTo { get; set; }\n public string Bcc { get; set; }\n public string Name { get; set; }\n public string Subject { get; set; }\n public string Message { get; set; }\n public string SmtpHost { get; set; }\n public string Password { get; set; }\n public int Port { get; set; }\n public string MailFrom { get; set; }
\n

Step 4 - Create a new class file in the class library; name it ExtensionMethods.cs. Here we will add the extension methods, which will be helpful to put the validation while sending the emails.

\n
 public static bool IsNotNullOrEmpty<T>(this IEnumerable<T> value)\n {\n     return value != null && value.Any(); // This will return true if the value is not null and not empty\n }\n public static bool IsNotNullOrEmptyOrWhiteSpace(this string value)\n {\n     return !(string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value)); // This will return true if the string value is not null, not empty and not contains any white space\n }\n public static bool IsNotNull(this object value)\n {\n     return value != null; // This will return true if the object value is not null\n }
\n

Resolve missing references.

\n

Step 5 - Create a new static class file in the class library name it as Mail.cs. In this class add a static method with try and catch block.

\n
 public static Tuple<bool, string> SendEMail(MailArguments mailArgs, List<Attachment> attachments, bool isSsl, Dictionary<string, string> headers){\n try{\n\n }\n catch (Exception ex){\n     var msg = ex.Message;\n     return Tuple.Create(false, msg);\n }\n }
\n

Resolve missing references.

\n

In this method, we are returning the Tuple<bool, string> which returns the status of the email sent and a message from the method in case of failure and success.

\n

Step 7 - Add below lines of code which will help create the NetworkCredentials for SMTP in the created method SendEmail.

\n
 var networkCredential = new NetworkCredential\n {\n     Password = mailArgs.Password,\n     UserName = mailArgs.MailFrom\n };
\n

Here we are using NetworkCredential class to set the UserName and Password.

\n

Step 8 - Add below lines of code, which will be used to initiate a message, subject, and IsBodyHtml.

\n
 var mailMsg = new MailMessage\n {\n     Body = mailArgs.Message,\n     Subject = mailArgs.Subject,\n     IsBodyHtml = true // This indicates that message body contains the HTML part as well.\n };\n mailMsg.To.Add(mailArgs.MailTo);
\n\n

Step 9 - Add the below lines of code to check and add the Headers, BCC, and Attachments. Here we have used the earlier created extension methods to add the validation.

\n
 if (headers.IsNotNullOrEmpty() )\n {\n     foreach (var header in headers)\n     {\n         mailMsg.Headers.Add(header.Key, header.Value);\n     }\n }\n if (mailArgs.Bcc.IsNotNullOrEmptyOrWhiteSpace())\n {\n     string[] bccIds = mailArgs.Bcc.Split(',');\n     if (bccIds.IsNotNullOrEmpty())\n     {\n         foreach (var bcc in bccIds)\n         {\n             mailMsg.Bcc.Add(bcc);\n         }\n     }\n }\n if (attachments.IsNotNull())\n {\n     foreach (var attachment in attachments)\n     {\n         if (attachment.IsNotNull())\n         {\n             mailMsg.Attachments.Add(attachment);\n         }\n     }\n }
\n

Step 10 - Add below the line of code to create a new email address using the From and Name fields of MailArguments class.

\n
 mailMsg.From = new MailAddress(mailArgs.MailFrom, mailArgs.Name);
\n

Step 11 - Add below lines of code to create a new SMTP client and use the send method of that client. When the email is successfully sent then we are creating a new tuple for sending the success message with a true flag that will indicate mail is sent.

\n
 var smtpClient = new SmtpClient(mailArgs.SmtpHost)\n {\n     Port = Convert.ToInt32(mailArgs.Port),\n     EnableSsl = isSsl,\n     DeliveryMethod = SmtpDeliveryMethod.Network,\n     UseDefaultCredentials = false,\n     Credentials = networkCredential\n };\n smtpClient.Send(mailMsg);\n return Tuple.Create(true, "Email Sent Successfully.");
\n

Here we are initializing the below variables for the SMTP client.

\n\n

Step 12 - In the Program.cs, which will be in the console app project, we will initialize and add the Mail arguments which are required to send an email.

\n

Step 13 - Before that add the reference of the class library which we have created above in your console app by doing the below steps

\n
Right-click on the console app project->Click on Add->Click on Reference->Select the created class library project.
\n

Step 14 - In the main method, add the below lines to initialize the arguments. Here I am using Gmail's SMTP server port and host address.

\n
 var mailArgs = new MailArguments\n {\n     MailFrom = "<--From mail address from where mail should be sent-->",  \n     Password = "<--From mail address password-->",  \n     Name = "<--From mail address name-->",\n     MailTo = "<--To mail address to where mail should be received-->", \n     Subject = "<--Subject of the email-->",                             \n     Message = "<--Message body of the email can contains HTML as well-->",                                           \n     Port = 587,                                                         \n     SmtpHost = "smtp.gmail.com",                                                                     \n     Bcc = "<--BCC email id's separated by semicolon (;)-->"             \n };\n List<Attachment> lstAttachments=new List<Attachment>\n {\n     new Attachment("<--Path of the attachment-->>",MediaTypeNames.Image.Gif) //MediaType and Path of the attachment here I have selected Gif Image we have MediaTypeNames Application/Image/Text\n };\n\n Dictionary<string, string> dictHeaders = new Dictionary<string, string>\n {\n     { "<--Key of the header-->", "<--Values of the header-->" }\n };
\n

Resolve missing references.

\n

You have to initialize all the variables as described above. From and Password will be the Gmail's account email id and password respectively because we are using Gmail's SMTP server.

\n

In the attachment, I have used the MediaTypeNames.Image.Gif, which is used for Gif Images. There are different constructors for the attachment class. For reference, you can read from here- Attachment Class. Attachments are not necessary to be passed. You can pass null in the SendMail method below.

\n

Headers are custom headers that will be sent with the email. It is not necessary to pass these headers. You can pass null in the SendMail method below.

\n

Step 15 - Add the below line of code to call the SendMail method of the class library.

\n
 Console.WriteLine(Mail.SendEMail(mailArgs, lstAttachments, true, dictHeaders).Item2);
\n

Note

\n

Here we have used Gmail's SMTP server to send emails (From Mail Address) so we have to enable the Less Secure Apps in our from mail address account by enabling Allow less secure apps else we will get the error from Gmail's SMTP server (The SMTP server requires a secure connection or the client was not authenticated. The server response was: 5.7.0 Authentication Required.)

\n

Conclusion

\n

In this article, we have learned about how to How to send emails through C#/.NET using SMTP. We have used the class library to initiate in the console app to send a mail to the particular emailId.The complete code for this blog can be found at Github Repo.

\n","frontmatter":{"date":"November 19, 2020","updated_date":null,"title":"How to send emails in C#/.NET using SMTP","tags":[".NET","C#","SMTP"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.3333333333333333,"src":"/static/00f36310a70961d9fef484d82409d136/14b42/coverimage.jpg","srcSet":"/static/00f36310a70961d9fef484d82409d136/f836f/coverimage.jpg 200w,\n/static/00f36310a70961d9fef484d82409d136/2244e/coverimage.jpg 400w,\n/static/00f36310a70961d9fef484d82409d136/14b42/coverimage.jpg 800w,\n/static/00f36310a70961d9fef484d82409d136/47498/coverimage.jpg 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hemant Manwani","github":"hemant404","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/exception-handling-in-csharp/"},"html":"

C# and the .NET CLR use exceptions to show that an error condition has arisen during program execution. C# programs are under constant threat of running into some sort of problem. As a program’s complexity grows, the probability that something odd would happen during its execution also gets higher.

\n

In this blog, we will go through the basics of Exception and Exception handling. We will also look at how we can achieve exception handling using try, catch, and finally blocks and how to create your own custom exceptions.

\n

Exception

\n

The errors which we are getting at the run time of the application is called an exception.

\n

If any exception is coming into our application then the application is abnormally terminated. The Application is not considered as a good application if any exception is coming and it is not handled.

\n

Every time when we are developing an application and it got successfully build without any errors. Then this happens

\n

\n \n \n

\n

For that, it is good practice to use exception handling.

\n

Common .NET Exceptions :

\n

Below are the common .NET exceptions which we can see on a regular basis of coding.

\n

System.NullReferenceException – Occurs when calling a method on a null object reference

\n

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

\n

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

\n

System.OutOfMemoryException – Occurs when the app runs out of memory

\n

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

\n

System.InvalidOperationException - Occurs when a method call is invalid for the object's current state

\n

System.ArgumentException - Occurs when one of the arguments provided to a method is not valid

\n

Exception Handling

\n

The process of handling any run time error is called exception handling. The exception handling is performed to maintain the normal flow of the application.

\n

In C# we can achieve this using the below techniques:

\n

Try,Catch & Finally blocks

\n

This is a very basic Exception handling technique in which try, catch, and finally, blocks are used.

\n

try block: In this block the code is written which may cause the exception. If any exception is thrown then the corresponding catch block is executed.

\n

catch block: In this block the exception is caught which means if an exception is thrown from the try block then we write the code to handle or log it.

\n

finally block: In this block we write the certain code which we want to execute if an exception is thrown or not. For example: disposing of an object or closing the database connection.

\n

Exception Handling after using try, catch blocks

\n

\n \n \n

\n

Note: Multiple finally blocks are not allowed. Also, the finally block cannot have the return, continue, or break keywords. It doesn't let control leave the finally block.

\n

In C#, both catch and finally blocks are optional. The try block can exist either with one or more catch blocks or a finally block or with both catch and finally blocks. The try block without a catch or finally block will give a compile-time error.

\n

If there is no exception occurred inside the try block, the control directly transfers to the finally block. We can say that the statements inside the finally block are executed always.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x)\n{\n// Code for handling the exception\n}\nfinally\n{\n//Any cleanup code\n}
\n

Multiple Catch blocks

\n

We can use the multiple catch blocks when we are not sure which type of exception will be thrown by the code. So that will help to catch the multiple types of exceptions.

\n
try{\n// Code which can cause an exception.\n}\ncatch(ArithmeticException ex)\n{\n// Code for handling the exception\n}\ncatch(IndexOutOfRangeException ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Catch multiple exceptions in the single catch block

\n

We can use the generic exception class as well to catch all types of exception in that case we have to write the catch block as below:

\n
try{\n// Code which can cause an exception.\n}\ncatch(Exception ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Note: Multiple catch blocks with the same exception type are not allowed. A catch block with the base Exception type must be the last block.

\n

Exception Filters

\n

In C# 6.0 a new feature is introduced to handle the exception which is called the Exception Filters. This feature will allow you to handle more specific exceptions in catch blocks so that you can write the code specific to the exception condition.

\n

Like before C# 6.0 We had to catch any exception and handle it. Now in C# 6.0, we can handle the exception specific to the condition.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x) when(\n    //some condition\n)\n{\n// Code for handling the exception\n}\ncatch(Type x) when (\n    //some condition\n)\n{\n \n}\nfinally\n{\n//Any cleanup code\n}\n
\n

Nested try-catch

\n

C# allows nested try-catch blocks. When using nested try-catch blocks, an exception will be caught in the first matching catch block that follows the try block where an exception occurred.

\n
static void Main(string[] args)\n{\n    int divider = 0;\n \n    try\n    {\n        try\n        {\n            var result = 1/divider;\n        }\n        catch(Exception ex)\n        {\n            Console.WriteLine("Inner catch block");\n        }\n    }\n    catch(Exception ex)\n    {\n        Console.WriteLine("Outer catch block");\n    }\n    \n}
\n

An inner catch block will be executed in the above example because it is the first catch block that handles all exception types.

\n

If there is not an inner catch block that matches with raised exception type, then the control will flow to the outer catch block until it finds an appropriate exception filter.

\n

Throw an Exception

\n

C# allows throwing an exception. The throw keyword is used for that purpose. One of the benefits of throwing an exception can be when a problem occurs in the middle of the complicated method execution because handling that situation in that complicated method would make that method even more complex. Then we should throw an exception and let the catch block to handle it.

\n

The throw keyword can only be used with the Exception object except for the catch block. It will be discussed in the next section.

\n
try\n{\n    //throw exception\n    throw new Exception();\n}\ncatch (Exception ex)\n{\n    //some code to hadle the exception\n}
\n

Note: The throw keyword is used to throw or create the new exception. If the throw keyword is used and if there is any catch block then the catch block will be executed next.

\n

Rethrow an Exception

\n

When an exception is caught in the catch block, we can do some operations and then re-throw the exception. Rethrow an exception means calling the throw keyword without an exception object inside a catch block.

\n

Here is the point to note that if we follow the below approach to rethrow the exception then the proper stack trace will not be maintained means it will not point out that actually where the exception occurred it will show in the stack trace the line number from which the exception is rethrown.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw ex;//Exception is rethrown with the exception object\n}
\n

Now if we follow the below approach then the proper stack trace will be maintained with maintaining the exact line number where the exception actually occurred.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw;//Exception is rethrown with the exception object\n}
\n

User-defined Exceptions

\n

User-defined exceptions are those exceptions that are not defined by the programming language. In C# we can create our own custom exceptions(User-defined exceptions)

\n

C# exceptions are defined as classes, just like any other C# object. All exceptions are inherited from a base System.Exception class. There are many common exceptions that you can use within your own code.

\n

Creating your own C# custom exceptions is helpful only when you are going to catch that specific type of exception and handle it differently.

\n
    class Program\n    {\n        static void Main(string[] args)\n        {\n            try\n            {\n                //throw user defined exception\n                throw new CustomException("Custom exception thrown");\n            }\n            catch (Exception ex)\n            {\n                Console.WriteLine("Exception caught here" + ex.ToString());\n            }\n        }\n    }\n    class CustomException : Exception\n    {\n        //User-defined exception which inherits base class Exception\n        public CustomException(string message)\n        {\n            Console.WriteLine("User defined exception");\n        }\n    }
\n

Exception Handling Best Practices

\n

Log Exception

\n

It is considered a good practice to log all the exception which are coming into our application. The main benefit of logging exceptions that we can know exactly what are the conditions on which the code is failing instead of asking from the user that what inputs he has provided we can log all the required information and use that data to solve the error.

\n

In many cases, we just ignore the catch block by writing nothing in it. There are some .NET libraries available for logging purposes like NLog, Serilog, etc.

\n

We can log exception into the catch block. Every exception is coming into our application is crucial as they are critical to finding the problems in the code.

\n
try\n{\n   //Some code\n}\ncatch (Exception ex)\n{\n   //Log Exception here!!!\n   Log.Error(ex); // log the inputs provided by the user or any specific condition\n}
\n

First Chance & Second Chance Exception

\n

The first chance exception is mainly designed for debugging purposes. Like whenever an exception occurs it first goes to the debugger giving the first chance to you and then to the program/application. If that exception is unhandled in the program/application then it gets back to the debugger giving a second chance to you to do something with your code before and after the application itself decides to do.

\n

It gives you visibility into every .NET exception being thrown.

\n

We can enable the first chance exception in the Visual Studio by going into the\nDebug > Windows > Exception Settings > check next to \"Common Language Runtime Exceptions\"

\n

You can also select the exceptions you want the debugger to break automatically in the above setting.

\n

Conclusion

\n

In this blog, we learned about the basics of Exception, Exception Handling, and some best practices of exception handling. Use of the exception handling with its best practices in the application will help the application to run smoother and without any bad user experience.

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"title":"Exceptions and Exception Handling in C#","tags":["C#","Exception","Exception Handling",".NET","Exception Handling Best Practices"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5748031496062993,"src":"/static/b5a34dc9602000bd64f40c7d59f9d286/ee604/csharplogo.png","srcSet":"/static/b5a34dc9602000bd64f40c7d59f9d286/69585/csharplogo.png 200w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/497c6/csharplogo.png 400w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/ee604/csharplogo.png 800w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/f3583/csharplogo.png 1200w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/5707d/csharplogo.png 1600w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/5c6e9/csharplogo.png 1650w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hemant Manwani","github":"hemant404","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/using-nuget-to-publish-net-packages/"},"html":"

NuGet is a free and open-source package manager for the .NET ecosystem. We can create and install packages using NuGet client tools. All of the .NET packages are hosted for publishing and consumption on a central package repository known as NuGet Gallery.

\n

Prerequisites

\n\n

Create a class library project

\n

For a .NET package to be published in the NuGet Gallery, it should be a valid class library project. The following instructions can be used to create a simple class library project:

\n\n

For a real useful NuGet package, you should write necessary code which can be used by others to develop applications. However, a class library from the template is sufficient to create a package.

\n

Configure Package Properties

\n
    \n
  1. Go to Project > Properties, select Package tab.
    2. \n
  2. Provide a unique identifier for your package and fill out other required properties. For a description of various properties, please visit here. The properties provided at this stage will be defined in .nuspec manifest that is created by Visual Studio for the project.
    3. \n
  3. To view the properties directly in the project file, right-click the project in Solution Explorer and select Edit AppLogger.csproj.
    4. \n
\n

Run the pack command

\n
    \n
  1. Set the configuration to Release.
    2. \n
  2. Right click the project in Solution Explorer and select the Pack command.
    3. \n
  3. Visual Studio builds the project and creates the .nupkg file. Please note that the built package is in bin\\Release\\netstandard2.0 as befits the .NET Standard 2.0 target.
    4. \n
\n

Acquire API Key

\n
    \n
  1. Sign in to your nuget.org account or create an account if it doesn’t already exist.
    2. \n
  2. Select your user name on the top right, then select API Keys.
    3. \n
  3. Select Create, provide a name for your key, select Select Scopes > Push.
    4. \n
  4. Under API Key, enter * for Glob pattern, then select Create.
    5. \n
  5. After the key is created, select Copy to retrieve the access key needed for publishing the package.
    6. \n
\n

Important: Save your key in a secure location because you cannot copy the key again later on. If you return to the API key page, you need to regenerate the key to copy it.

\n

Publish with nuget push

\n
    \n
  1. Open Command Prompt.
    2. \n
  2. Change to the folder containing the .nupkg file.
    3. \n
  3. \n

    Run the following command, specifying your package name and replacing the key value with your API key:

    \n
    nuget push &lt;PACKAGE-NAME&gt;.nupkg &lt;API-KEY&gt; -Source https://api.nuget.org/v3/index.json
    \n
    4. \n
  4. nuget.exe displays the results of the publishing process.
    5. \n
\n

Manage the published package

\n

You can view your published package in your profile on nuget.org. Select Manage Packages to see the one that was just published. It might take a while for your package to be visible in search results.

\n

If you want to unlist the package and hide it from search results, follow the steps listed below:

\n
    \n
  1. On nuget.org, select your user name on top right, then select Manage Packages.
    2. \n
  2. Find the package to be unlisted under Published and select the trash can icon on the right.
    3. \n
  3. On the next page, clear the box labeled List (package-name) in search results and select Save.
    4. \n
\n","frontmatter":{"date":"June 28, 2018","updated_date":null,"title":"Using NuGet to publish .NET packages","tags":["NuGet",".NET"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1,"src":"/static/61bc9402fec623803bf04d21e948e84a/2a4de/desdev.png","srcSet":"/static/61bc9402fec623803bf04d21e948e84a/69585/desdev.png 200w,\n/static/61bc9402fec623803bf04d21e948e84a/497c6/desdev.png 400w,\n/static/61bc9402fec623803bf04d21e948e84a/2a4de/desdev.png 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Hitesh Pamnani","github":null,"avatar":null}}}}]}},"pageContext":{"tag":".NET"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}