{"componentChunkName":"component---src-pages-author-author-yaml-id-js","path":"/author/hemant-manwani/","result":{"data":{"allMarkdownRemark":{"edges":[{"node":{"id":"a9c5ebcf-965a-556b-9b54-d40934fe1b07","html":"

Introduction

\n

In C# 9.0, there are multiple features introduced. One of them is the Init-Only setters property feature. To use this feature, there are two pre-requisite.

\n
    \n
  1. You should have the .NET 5 SDK installed in your system. If not, you can download and install it from here.
    2. \n
  2. You should have at least a 16.7 version or the latest version of Visual Studio 2019. If not, then you have to update your Visual Studio 2019 to the latest version.
    3. \n
\n

After this setup, you are ready to go with the Init-Only setters property feature.

\n

Before knowing more about this feature, first, we will understand how we are using properties currently in C#.

\n

How we are using the properties currently

\n
public int Id { get; set; }
\n

This is the way how we are using the properties, but whenever if we don't want to change the value of a property outside of a class and make them readable publicly, then we generally define the property as below.

\n
public int Id { get; private set; }
\n

In that case, the Id property can not be set outside of the class, and to set this property, we have to introduce a constructor or a public method that can set the value of the Id field. Like below

\n
public class Company\n{\n    public int Id { get; private set; }\n\n    public Company(int id) // Constructor\n    {\n        Id = id;\n    }\n    public void SetId(int id) //Public method\n    {\n        Id = id;\n    }\n}
\n

Below are the problems which arise by using the above method

\n
    \n
  1. We are not able to set the property value by using the object initialization
    2. \n
  2. If we want to set the property as immutable (Value can not be changed), then we can not achieve this because any public method can change the value of that property, so here the property is mutable (Value can be changed).
    3. \n
\n

To fix those issues, In C# 9.0 Init-Only setters property feature was introduced. Have a look at this.

\n

Init-Only Setters Property

\n

Init-Only setters property gives us the flexibility to set the value of a property by using the object initializer as well the property is also immutable. So that will resolve the above issues, which were with the private set property.

\n
public class Company\n{\n    public int Id { get; init; }\n}
\n
Company comp=new Company{\n    Id=1\n}; // It works fine if we initialize here
\n

As we can, it is perfectly fine to set the value during object initialization.

\n
public class Company\n{\n    public int Id { get; init; }\n\n     public Company(int id)\n    {\n        this.Id = Id;\n    }\n}
\n

We can define the constructor as well to initialize the Init-Only setters property.

\n

If we will try to create a method in the class and want to change the value Init-Only setters property, then it will give us the compile-time error.

\n
public class Company\n{\n    public int Id { get; init; }\n\n    public void SetId(int Id)\n    {\n        this.Id = Id; // Compile-time Error\n    }\n}
\n

Conclusion

\n

In this article, we learned how we are setting the properties in C# currently and the new C# 9.0 feature Init-Only Setters Property. Also, we understood how this feature helps us to set the property value with the object initialization.

\n","frontmatter":{"title":"C# Init-Only Setters Property","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"July 15, 2021","updated_date":null,"tags":["C#","Properties","Init"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/e2d2c98e4cd2dbf38d3e2ddeaba94705/ee604/coverimage.png","srcSet":"/static/e2d2c98e4cd2dbf38d3e2ddeaba94705/69585/coverimage.png 200w,\n/static/e2d2c98e4cd2dbf38d3e2ddeaba94705/497c6/coverimage.png 400w,\n/static/e2d2c98e4cd2dbf38d3e2ddeaba94705/ee604/coverimage.png 800w,\n/static/e2d2c98e4cd2dbf38d3e2ddeaba94705/f3583/coverimage.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/csharp-init-only-setters-property/"}}},{"node":{"id":"9335814f-04d3-5bc1-981f-cda1772f1001","html":"

Introduction

\n

Dictionaries Dictionary<TKey, TValue> is used for storing a key-value pair. It is a generic collection that is defined in the System.Collection.Generic namespace and implements the IDictionary<TKey, TValue> interface.

\n

Create a dictionary

\n

Suppose we want to store the scores of a player in a cricket match, Then we have to save the key as the name of the player and score as value.

\n

To create a dictionary of key and value type as a string and int, respectively, we just simply need to initialize as below.

\n
Dictionary<string, int> dict = new Dictionary<string, int>();\nDictionary<string, int> dict1 = new Dictionary<string, int>(5); // Creates a dictionary with default initial capacity of 5
\n

The first line will create a dictionary with string type of key and int type of value and will have the initial default capacity as well default equality comparer for the key type.

\n

The Second line will create the same dictionary as line 1 except for the initial default capacity. It will create a dictionary with an initial default capacity of 5.

\n

We can create the dictionary by using the different constructors of the dictionary. Here I have talked about the two constructors only.

\n

Add elements

\n

We can add the elements in the dictionary by using add method of it.

\n
dict.Add("Player",42);\ndict.Add("Player1",38);
\n

It will add the elements in the dictionary.

\n

Note: Keys can not be null or duplicate. If we add the duplicate or null as a key, then the application will throw the run time exception, but Values can be null or duplicate.

\n

Traverse

\n

To traverse through a dictionary, we can use a foreach loop or a for a loop.

\n

foreach loop

\n
foreach (var item in dict)\n{\n    Console.WriteLine("Key "+ item.Key +" Value "+ item.Value);\n}
\n

for loop

\n
for (int i = 0; i < dict.Count; i++)\n{\n     Console.WriteLine("Key " + dict.ElementAt(i).Key + " Value " + dict.ElementAt(i).Value);\n}
\n

In the above code, we are using the

\n
    \n
  1. Key Property of dictionary element which will return the Key of the dictionary element.
    2. \n
  2. Value Property of dictionary element, which will return the value of the dictionary element.
    3. \n
  3. Count Property which will return the number of elements in the dictionary.
    4. \n
  4. ElementAt(int index) method of a dictionary, which will return the element at the specified index.
    5. \n
\n

Get/Update specified key's value

\n

To get the specified key's value from the dictionary, we can directly use the key as an index.

\n
Console.WriteLine(dict["Player"]); // Prints 42\nConsole.WriteLine(dict["Player1"]); // Prints 38
\n

To update the specified key's value of the dictionary, we can set it as below.

\n
dict["Player"]=45;\nConsole.WriteLine(dict["Player1"]); // Prints 45
\n

Note:

\n
    \n
  1. It will give the run time exception if the given key is not present in the dictionary, and we try to access the value of that key so we can first check for the key using the ContainsKey(TKey) method of the dictionary which will return true/false if the key is present or not in the dictionary.
    2. \n
  2. Suppose if we want to set the value of a key that is not present in the dictionary, then it will automatically add that element into the dictionary and sets the value of it.
    3. \n
\n

Remove

\n

To remove elements from a dictionary, we can use the below methods.

\n

Remove specific key

\n

To remove a specific key, we can use the Remove(TKey) method of the dictionary.

\n
dict.Remove("Player1"); // Removes Player1 from dictionary
\n

Clear dictionary

\n

To clear all the elements of the dictionary, we can use the Clear() method of the dictionary.

\n
dict.Clear(); // Clears all the elements and count will be 0
\n

Conclusion

\n

In this article, We have learned about some of the basics of dictionaries. Dictionaries help to use to manage data in Key-Value pair, which we can easily access and manipulate the data accordingly.

\n","frontmatter":{"title":"How to create and use the Dictionary in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"May 27, 2021","updated_date":null,"tags":["C#","Dictionary"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/70d1172c5171ae195aeb525bdf6086b3/ee604/coverimage.png","srcSet":"/static/70d1172c5171ae195aeb525bdf6086b3/69585/coverimage.png 200w,\n/static/70d1172c5171ae195aeb525bdf6086b3/497c6/coverimage.png 400w,\n/static/70d1172c5171ae195aeb525bdf6086b3/ee604/coverimage.png 800w,\n/static/70d1172c5171ae195aeb525bdf6086b3/f3583/coverimage.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/how-to-create-and-use-dictionary-csharp/"}}},{"node":{"id":"a250e533-f114-54a8-804e-85bf160a53c3","html":"

Introduction

\n

As we all know that Enums are very commonly used in the C# program. While using the Enums, we should also be aware of how the values are parsed into the Enums. In my earlier article, I have talked about the How to Use Enum in C#.In this article, I will specifically talk about the mistake we can make while using the Enum.TryParse() method.

\n

Let's get started

\n

As we know Enum.Tryparse() method will give us the parsed Enum. Like in the below example

\n
public enum IdentityProtocols\n{\n    SAML,\n    OAuth,\n    OpenID\n}\nvar isEnumParsed=Enum.TryParse("0", true, out IdentityProtocols parsedEnumValue);\nConsole.WriteLine(isEnumParsed?parsedEnumValue.ToString():"Not Parsed");
\n

The above code will print the SAML because the enum is started by default with the value 0.

\n

What happens if we run the below code with the same Enum declaration?

\n
var isEnumParsed=Enum.TryParse("-1", true, out IdentityProtocols parsedEnumValue);\nConsole.WriteLine(isEnumParsed?parsedEnumValue.ToString():"Not Parsed");
\n

As per our understanding isEnumParsed variable should be false, and the above code should print Not Parsed as the value which we are passing in the method is not in the Enum declaration, right?

\n

But here is a catch, isEnumParsed variable have the true value, and the code will print -1.

\n

Why Enum.tryParse() parse int values?

\n

The default type of Enum in C# is int. That's why any valid integer values are parsed by the Enum.TryParse() method irrespective of those integer values are defined in the Enum or not.

\n

We can define the Enum with types like byte, sbyte, etc. Then the Enum.TryParse() will parse those values which will fall in that defined Enum type.

\n

How to overcome this behavior of Enum.TryParse()

\n

To overcome this behavior of Enum.TryParse() we can follow the below approaches.

\n

1. Using Enum.IsDefined() method with Enum.TryParse() method

\n
var isValidEnum = Enum.TryParse("-1", true, out IdentityProtocols parsedEnumValue) && Enum.IsDefined(typeof(IdentityProtocols), parsedEnumValue);\nConsole.WriteLine(isValidEnum ? parsedEnumValue.ToString(): "Not Parsed");
\n

In the above code Enum.IsDefined() will check that the value which we are getting from the Enum.TryParse() method is defined in the Enum declaration or not.

\n

That will give us the proper result, and the above code will print Not Parsed

\n

2.Using Enum.GetNames() method

\n
var value = "-1";\nvar identityProtocolsList = Enum.GetNames(typeof(IdentityProtocols)).ToList();\nConsole.WriteLine(identityProtocolsList.Contains(value) ? value : "Not Parsed");
\n

In this code, checking that value is present or not by getting all the Names from the enum declaration by using Enum.GetNames() method.

\n

This code will print Not Parsed

\n

Note: Here, we will not be able to parse any of the integer values. It will only check the values which are defined in the Enum declaration.

\n

Conclusion

\n

In this article, We have discussed the mistake we can make using the Enum.TryParse() method. This mistake can hurt and can abnormally terminate our program/application. We can use the ways I have mentioned in this article to overcome so that our program/application can run smoothly.

\n","frontmatter":{"title":"How Enum.TryParse() works in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"April 28, 2021","updated_date":null,"tags":["C#","Enum"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/51a037c87d4168dfe8b48e7169c2e0ed/ee604/coverimage.png","srcSet":"/static/51a037c87d4168dfe8b48e7169c2e0ed/69585/coverimage.png 200w,\n/static/51a037c87d4168dfe8b48e7169c2e0ed/497c6/coverimage.png 400w,\n/static/51a037c87d4168dfe8b48e7169c2e0ed/ee604/coverimage.png 800w,\n/static/51a037c87d4168dfe8b48e7169c2e0ed/f3583/coverimage.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/how-enum-tryparse-works-in-csharp/"}}},{"node":{"id":"9a9a855c-4731-5db3-ac57-425689c2ed44","html":"

A list is a set of index-accessible objects that provides functionality for searching, sorting, and manipulating list items. C# List class represents a collection of strongly typed objects that can be accessed by using the index. In this article, we learn how to work with lists in C# using the C# List class to add, remove, and search items in a collection of objects using List class methods and properties.

\n

What is List in C#?

\n

List<T> class in C# cotains a strongly typed list of objects. It provides functionality to create a list of objects, add list items, search, sort and manipulate list items. In List<T>, T is the type of objects like int, string, or any user-defined object.

\n

List<T> is required when we have multiple items with the same object, like data of student's marks or data of various subject's names (string). In that case, we can use List<T> to maintain that data into a list.

\n

List<T> comes under the System.Collection.Generic namespace and the index start from 0.

\n

How to Create a List?

\n

We can create a list by calling the List<T> constructor; It takes an argument of int type that is the list's capacity. If we do not define the capacity, then the list size will be dynamic and every time an element is added, the list size is increased. The list can be created using the below syntax.

\n
List<int> lst=new List<int>(); // list with dynamic capacity\nList<int> lstCapacity=new List<int>(10); // list with capacity of 10 elements
\n

As we have discussed above, Here T is the type of object for which we have to create the list. The type is int in the above code, which means we can store the int type of variable's value.

\n

Note: If we have created the list using the capacity value and when more than the defined capacity elements are added, the list size will automatically increase.

\n

Add elements into a list

\n

We can add elements directly into when we have created a list or add elements after creating a list. I will discuss both methods here.

\n
    \n
  1. Create list
    2. \n
\n
List<int> lst = new List<int>\n{\n    1,2,3,4,5,6\n};
\n
    \n
  1. Add items after creating list
    2. \n
\n
List<int> lst = new List<int>();\nlst.Add(1);\nlst.Add(2);\nlst.Add(3);\nlst.Add(4);\nlst.Add(5);\nlst.Add(3);
\n

Properties of a list

\n

The list has mainly two properties.

\n
    \n
  1. Capacity- This property tells the capacity of a list, which means how many elements a list can contain.
    2. \n
\n
List<int> lst = new List<int>();\nConsole.WriteLine(lst.Capacity); //Prints 0-- Default\nList<int> lst1 = new List<int>(5);\nConsole.WriteLine(lst1.Capacity); // Prints 5
\n
    \n
  1. Count- This property tells that how many elements are there in a list
    2. \n
\n
List<int> lst = new List<int>(5);\nConsole.WriteLine(lst.Count); // Prints 0\nlst.Add(1);\nlst.Add(2);\nConsole.WriteLine(lst.Count); //Prints 2
\n

Read all elements of a list

\n

To get all the elements of a list, we have to loop through the list. We can use for or foreach loop to get the elements. Below is the code to get all the elements using both the loops and print the element's values.

\n
    \n
  1. \n

    Using a foreach loop

    \n
    2. \n
\n
foreach (var item in lst)\n{\n    Console.WriteLine(item);\n}
\n
    \n
  1. \n

    Using for loop

    \n
    2. \n
\n

In this method, we have to run the loop till the last element of the list. For that, I have used the Count property of the list

\n
for (int i = 0; i < lst.Count; i++)\n{\n    Console.WriteLine(lst[i]);\n}
\n

Both the methods will give the same output. I am taking the above list example so the result will be

\n

Output:

\n
1\n2\n3\n4\n5\n3
\n

Remove element from a list

\n

To remove items from a list, we can use various list methods.

\n
    \n
  1. Remove(T item)- This method removes the first occurrence of an element from a list. We have to pass the element into this method as a parameter.
    2. \n
\n
lst.Remove(3); // Removes the fist occurance of element 3
\n
    \n
  1. RemoveAll(Predicate<T> match)- This method removes all elements from a list that matches the condition defined by the specified predicate. We have to pass the predicate as a parameter.
    2. \n
\n
lst.RemoveAll(x=>x==3); // Removes all the elements 3
\n
    \n
  1. RemoveAt(int index)- This method removes the element from the given index. We have to pass the index as a parameter.
    2. \n
\n
lst.RemoveAt(0); // Removes 0th index element from a list
\n
    \n
  1. RemoveRange(int index, int count)- This method removes the element from the given index to the specified count. We have to pass the starting index and count as a parameter.
    2. \n
\n
lst.RemoveRange(0,2); // Removes element 1,2 because the starting index is 0 and count is 2
\n
    \n
  1. Clear()- This method clears all the elements from a list.
    2. \n
\n
lst.Clear(); // Removes all elements from a list
\n

Conclusion

\n

In this article, we have discussed the basics of List<T>, properties, and some methods. The main advantage of using the list is that it is faster and it is more friendly because it gives us many inbuilt methods to use and do the manipulation according to ourselves. If you want to learn more about C# here is an article written by me on How to Work with Nullable Types in C#

\n","frontmatter":{"title":"How to Create List in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"February 25, 2021","updated_date":null,"tags":["C#","List"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.3333333333333333,"src":"/static/90961274d154a2d133945ce7dcb461ed/14b42/coverimage.jpg","srcSet":"/static/90961274d154a2d133945ce7dcb461ed/f836f/coverimage.jpg 200w,\n/static/90961274d154a2d133945ce7dcb461ed/2244e/coverimage.jpg 400w,\n/static/90961274d154a2d133945ce7dcb461ed/14b42/coverimage.jpg 800w,\n/static/90961274d154a2d133945ce7dcb461ed/47498/coverimage.jpg 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/list-csharp/"}}},{"node":{"id":"29d676bb-9ec4-548f-89a3-447188669cd9","html":"

\nIn C#, We have majorly two types of data types Value and Reference type. We can not assign a null value directly to the Value data type. In this case, C# 2.0 provides us the Nullable types to assign a value data type to null.

\n

What is Nullable types?

\n

As described above, The Nullable types used to assign the null value to the value data type. That means we can assign a null value directly to a variable of the value data type. We can declare null value using Nullable<T> where T is a type like an int, float, bool, etc.

\n

Nullable types represent the Null value as well the actual range of that data type. Like the int data type can hold the value from -2147483648 to 2147483647 but a Nullable int can hold the value null and range from -2147483648 to 2147483647

\n

How to declare Nullable types

\n

There are two ways to declare Nullable types.

\n
Nullable<int> example;
\n

OR

\n
int? Example;
\n

Properties of Nullable types

\n

Nullable types have two properties.

\n
    \n
  1. HasValue
    2. \n
  2. Value
    3. \n
\n

HasValue: This property returns a bool value based on that if the Nullable variable has some value or not. If the variable has some value, then it will return true; otherwise, it will return false if it doesn’t have value or it’s null.

\n
Nullable<int> a = null;\nConsole.WriteLine(a.HasValue); // Print False\nNullable<int> b = 9;\nConsole.WriteLine(b.HasValue); // Print True
\n

Value: This property gives the value of the Nullable type variable. If the variable has some value, it will return the value; else, it will give the runtime InvalidOperationException exception when the variable value is null.

\n
Nullable<int> a = null;\nConsole.WriteLine(a.Value); // Gives run time exception of type 'InvalidOperationException'
\n
Nullable<int> b = 9;\nConsole.WriteLine(b.Value); // Print 9
\n

Method of Nullable types

\n

GetValueOrDefault(): This method returns the actually assigned value of the Nullable type variable if the value is not null, and if the variable value is null, then it will give the default value of that data type. Here is the example code

\n
Nullable<int> a = 9;\nConsole.WriteLine(a.GetValueOrDefault()); // Returns 9
\n
Nullable<int> a = null;\nConsole.WriteLine(a.GetValueOrDefault()); // Returns 0
\n

Rules of using Nullable types:

\n

To use the Nullable type as a local variable, it should be declared first; it will give a compile-time error. This rule is similar to the value data type.

\n
int? b;\nConsole.WriteLine(b.Value); //Compile time error 'use of unassigned local variable b'
\n

If the Nullable variable is a property in a class and after that, if we are accessing that Nullable variable, then it will not give any error because, in the class variable, it is declared as null automatically.

\n
class Test\n{\n     public int? B;\n}\nclass Program\n{\n    static void Main(string[] args)\n    {\n        Console.WriteLine(new Test().B); // No compile time error\n    }\n}
\n

null coalescing operator (??)

\n

We can not assign the Nullable type variable value to the non-nullable type variable directly. As in the example below, if we try to assign the value, it will give the compile-time error.

\n
int? a = 10;\nint b = a;//Compile time error `Cannot implicitly convert type 'int?' to 'int'. An explicit conversion exists (are you missing a cast?)`
\n

Note: We can use compare operators == and != operator with Nullable type variables and non Nullable type variables.

\n

For the Nullable variable, we can use the null coalescing operator (??) to check if the variable value is null or not. Then we can assign the non-nullable type variable value according to that. This operator can be used when we are unsure that at run time if that Nullable variable's value is changed according to our logic or not. Here is an example of that

\n
int? a=null;\nint b=a?? 10;\nConsole.WriteLine(b);  // Prints 10
\n

In the above example, if the variable a value is null,, it will assign the value 10 to b variable. In that case, b is assigned with value 10, and the printed value will be 10.

\n

Conclusion

\n

In this article, We have discussed the Nullable types, and it's properties and methods. The main advantage of using the Nullable types is that we can store the Null value in a column of a database using this type. If you want to learn more about C# here is an article written by me on How to Use Enum in C#

\n","frontmatter":{"title":"How to Work with Nullable Types in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"January 29, 2021","updated_date":null,"tags":["C#","Nullable"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/683771faa7dbd78039f0a89ea94ad469/14b42/coverimage.jpg","srcSet":"/static/683771faa7dbd78039f0a89ea94ad469/f836f/coverimage.jpg 200w,\n/static/683771faa7dbd78039f0a89ea94ad469/2244e/coverimage.jpg 400w,\n/static/683771faa7dbd78039f0a89ea94ad469/14b42/coverimage.jpg 800w,\n/static/683771faa7dbd78039f0a89ea94ad469/9842e/coverimage.jpg 900w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/nullable-csharp/"}}},{"node":{"id":"0099d97a-fedc-5e4a-bad6-5a1c122dae72","html":"

Enum is a typed constant that is specified for the new data form of Enumeration. An effective way to describe a set of named integral constants assigned to a variable is to include a Typesafe enumeration. Enums make the code more readable and less vulnerable to mistakes. If you have a set of functionally important and unchanged values, Enums are useful for developers.

\n

Enums' key benefit is to make it possible in the future to adjust values. Enums are a robust alternative to the short String or Int constants used to describe sets of similar objects in far older APIs.

\n

Sometimes we must use the constant variable in our application to not be changed throughout the application. One of the methods to declare the continuous variables are Enum. Let's discuss it.

\n

Using Enum in C Sharp

\n

Enum is the short form of Enumeration. Enum consumes less memory and space because they are value types, which means they store memory value. Also, Enums are strongly typed named constants.

\n

Enums written by developers are used in the .NET system to develop numeric constants. A numeric value must be allocated to all the members of an enum. Here are the main points about Enums:

\n\n

Enums are of two types in C#

\n

Simple Enum - The members of this enum contain a single value.

\n

Flags Enum - The members of this enum contain multiple values or multiple values combined using a bitwise OR operator. These enums are often used for bitwise operators.

\n

Here we will talk about the Simple Enum only.

\n

How to declare an Enum

\n

Enum is declared by the enum keyword followed by the enum name and then its enum members. Like an example below

\n
public enum Vehicle\n{\n    Car,\n    Bike=3,\n    Truck,\n    Taxi,\n}
\n

In the above code, an enum for the Vehicle is created. The enum values are started from 0 by default if we do not assign them the values and incremented by 1 for the next enum member.

\n

That means the Car enum has the value 0 and the Bike enum assigned the value 3 that means the Bike enum now has the value 3 and the next enums are incremented by 1 means Truck and Taxi enum have the value 4 and 5 respectively.

\n

By default, the type for enum elements is int. We can set different type by adding a colon like an example below.

\n
public enum Vehicle: byte\n{\n    Car,\n    Bike=3,\n    Truck,\n    Taxi,\n}
\n

The different types which can be set are sbyte, byte, short, ushort, uint, ulong, and long.

\n

Get the value of an Enum

\n

To get the value of enum we can simply typecast it to its type. In the first example, the default type is int so we have to typecast it to int. Also, we can get the string value of that enum by using the ToString() method as below.

\n
Console.WriteLine((int)VehicleEnum.Car);\nstring vehicle = Vehicle.Bike.ToString();\nConsole.WriteLine(vehicle);
\n

Output:

\n
0\nBike
\n

Parse the string value into an Enum

\n

For parsing the string value into enum we have 2 methods

\n
    \n
  1. Enum.Parse(Type enumType,string value) - This method directly parses the string representation of the name or numeric value of enum member into enumType object. If the string representation of the name is not found, then it will give the exception.
    2. \n
\n
Console.WriteLine(Enum.Parse(typeof(Vehicle),"Car"));
\n

Output:

\n
Car
\n
    \n
  1. Enum.TryParse(string? value,out enumType result) - This method gives the result in bool value. if the string representation of the name or numeric value of enum member into enumType object is parsed, then the result will be true, and the parsed value will be in the out variable. If the string value is not parsed, then the result will be false.
    2. \n
\n
Enum.TryParse("0",out Vehicle value);\nConsole.WriteLine(value);
\n

Output:

\n
Car
\n

Note - Both the methods also have overload methods.

\n

Check if a string value is defined in the Enum

\n

We can check if a given integral value, or its name as a string, exists in a specified enum.

\n
Console.WriteLine(Enum.IsDefined(typeof(Vehicle), 0));
\n

OR

\n
Console.WriteLine(Enum.IsDefined(typeof(Vehicle), "car"));
\n

Output:

\n
True
\n

Loop through all the Enum

\n

For looping through the enums you can write the below code -

\n
foreach (var data in Enum.GetNames(typeof(Vehicle)))\n{\n    Console.WriteLine(data+" - "+ (int)Enum.Parse(typeof(Vehicle), data));\n}
\n

Here Enum.GetNames(Type enumType) method is used, which retrieves an array of the names from the specified enum.

\n

Output:

\n
Car - 0\nBike - 3\nTruck - 4\nTaxi - 5
\n

Call an enum by the integral value

\n

We can call the enum member by its integral value. If there is no corresponding value related to that integral value, then it will print that integral value.

\n
 Console.WriteLine((Vehicle)3);
\n

Output

\n
Bike
\n

Conclusion

\n

The advantages of using enums are that they are very easy to use and represented as strings but processed as integers. Enums are easy to maintain and improve code readability because they provide symbolic named constants, which means you need to remember the names, not the integer values.

\n

If you want to learn more about C programming, here is another article written on C# Exceptions and Exception Handling in C# I hope you learn something new today and will going to try it out, if you have any questions feel free to drop a comment below.

\n","frontmatter":{"title":"How to Use Enum in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"December 18, 2020","updated_date":null,"tags":["C#","Enum"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/438545712e629112915b48eb3d068821/14b42/coverimage.jpg","srcSet":"/static/438545712e629112915b48eb3d068821/f836f/coverimage.jpg 200w,\n/static/438545712e629112915b48eb3d068821/2244e/coverimage.jpg 400w,\n/static/438545712e629112915b48eb3d068821/14b42/coverimage.jpg 800w,\n/static/438545712e629112915b48eb3d068821/9842e/coverimage.jpg 900w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/enum-csharp/"}}},{"node":{"id":"718766d9-5212-5183-9801-6d911f42e6d2","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":{"title":"How to send emails in C#/.NET using SMTP","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"November 19, 2020","updated_date":null,"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"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/how-to-send-emails-through-csharp-dotnet-using-smtp/"}}},{"node":{"id":"24fa8a72-329f-51bd-b86d-64a850530273","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":{"title":"Exceptions and Exception Handling in C#","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"September 29, 2020","updated_date":null,"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"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/exception-handling-in-csharp/"}}},{"node":{"id":"ee1d95f0-3d9b-5563-adc3-96257e4b7b61","html":"

In this blog, we learn how to implement the AntiXssMiddleware in .NET Core. First, we will understand about the cross-site scripting.

\n

Cross-Site Scripting(XSS)

\n

Cross-site scripting is a security vulnerability and a client-side code injection attack. In this attack, the malicious script is injected into legitimate websites.\nCross-site scripting allows an attacker to act like a victim user and to carry out the actions that the user can perform. The attacker can access the user's data as well.

\n

Implement AntiXssMiddleware in .NET Core

\n

Step 1: Create Asp.NET Core Web Application project in Visual Studio.

\n

Step 2: Select type as API in the next step and create the project. You will find a default controller which is created in the controller folder named as WeatherForecastController.cs

\n

Step 3: Now create a new folder named Middleware in the root directory.

\n

Step 4 : Create a new file AntiXssMiddleware.cs in that Middleware folder.

\n

Step 5: Now add the Newtonsoft.json package into your solution

\n

By doing the above steps you will have below structure in your solution.

\n

\n \n \"Solution\n

\n

Step 6: Now edit the AntiXssMiddlewars.cs file and paste below code.

\n
using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing System.Linq;\nusing System.Net;\nusing System.Text;\nusing System.Text.RegularExpressions;\nusing System.Threading.Tasks;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.AspNetCore.Http;\nusing Newtonsoft.Json;\n\nnamespace AntiXssMiddleware.Middleware\n{\n    public class AntiXssMiddleware\n    {\n        private readonly RequestDelegate _next;\n        private ErrorResponse _error;\n        private readonly int _statusCode = (int)HttpStatusCode.BadRequest;\n\n        public AntiXssMiddleware(RequestDelegate next)\n        {\n            _next = next ?? throw new ArgumentNullException(nameof(next));\n        }\n\n        public async Task Invoke(HttpContext context)\n        {\n            // Check XSS in URL\n                if (!string.IsNullOrWhiteSpace(context.Request.Path.Value))\n                {\n                    var url = context.Request.Path.Value;\n\n                    if (CrossSiteScriptingValidation.IsDangerousString(url, out _))\n                    {\n                        await RespondWithAnError(context).ConfigureAwait(false);\n                        return;\n                    }\n                }\n\n                // Check XSS in query string\n                if (!string.IsNullOrWhiteSpace(context.Request.QueryString.Value))\n                {\n                    var queryString = WebUtility.UrlDecode(context.Request.QueryString.Value);\n\n                    if (CrossSiteScriptingValidation.IsDangerousString(queryString, out _))\n                    {\n                        await RespondWithAnError(context).ConfigureAwait(false);\n                        return;\n                    }\n                }\n\n                // Check XSS in request content\n                var originalBody = context.Request.Body;\n                try\n                {\n                    var content = await ReadRequestBody(context);\n\n                    if (CrossSiteScriptingValidation.IsDangerousString(content, out _)) \n                    {\n                            await RespondWithAnError(context).ConfigureAwait(false);\n                            return;\n                    }\n                    await _next(context).ConfigureAwait(false);\n                }\n                finally\n                {\n                    context.Request.Body = originalBody;\n                }\n        }\n\n        private static async Task<string> ReadRequestBody(HttpContext context)\n        {\n            var buffer = new MemoryStream();\n            await context.Request.Body.CopyToAsync(buffer);\n            context.Request.Body = buffer;\n            buffer.Position = 0;\n\n            var encoding = Encoding.UTF8;\n\n            var requestContent = await new StreamReader(buffer, encoding).ReadToEndAsync();\n            context.Request.Body.Position = 0;\n\n            return requestContent;\n        }\n\n        private async Task RespondWithAnError(HttpContext context)\n        {\n            context.Response.Clear();\n            context.Response.Headers.AddHeaders();\n            context.Response.ContentType = "application/json; charset=utf-8";\n            context.Response.StatusCode = _statusCode;\n\n            if (_error == null)\n            {\n                _error = new ErrorResponse\n                {\n                    Description = "Error from AntiXssMiddleware",\n                    ErrorCode = 500\n                };\n            }\n\n            await context.Response.WriteAsync(_error.ToJSON());\n        }\n    }\n\n    public static class AntiXssMiddlewareExtension\n    {\n        public static IApplicationBuilder UseAntiXssMiddleware(this IApplicationBuilder builder)\n        {\n            return builder.UseMiddleware<AntiXssMiddleware>();\n        }\n    }\n\n\n    /// <summary>\n    /// Imported from System.Web.CrossSiteScriptingValidation Class\n    /// </summary>\n    public static class CrossSiteScriptingValidation\n    {\n        private static readonly char[] StartingChars = { '<', '&' };\n\n        #region Public methods\n\n        public static bool IsDangerousString(string s, out int matchIndex)\n        {\n            //bool inComment = false;\n            matchIndex = 0;\n\n            for (var i = 0; ;)\n            {\n\n                // Look for the start of one of our patterns \n                var n = s.IndexOfAny(StartingChars, i);\n\n                // If not found, the string is safe\n                if (n < 0) return false;\n\n                // If it's the last char, it's safe \n                if (n == s.Length - 1) return false;\n\n                matchIndex = n;\n\n                switch (s[n])\n                {\n                    case '<':\n                        // If the < is followed by a letter or '!', it's unsafe (looks like a tag or HTML comment)\n                        if (IsAtoZ(s[n + 1]) || s[n + 1] == '!' || s[n + 1] == '/' || s[n + 1] == '?') return true;\n                        break;\n                    case '&':\n                        // If the & is followed by a #, it's unsafe (e.g. S) \n                        if (s[n + 1] == '#') return true;\n                        break;\n\n                }\n\n                // Continue searching\n                i = n + 1;\n            }\n        }\n\n        #endregion\n\n        #region Private methods\n\n        private static bool IsAtoZ(char c)\n        {\n            return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');\n        }\n\n        #endregion\n\n        public static void AddHeaders(this IHeaderDictionary headers)\n        {\n            if (headers["P3P"].IsNullOrEmpty())\n            {\n                headers.Add("P3P", "CP=\\"IDC DSP COR ADM DEVi TAIi PSA PSD IVAi IVDi CONi HIS OUR IND CNT\\"");\n            }\n        }\n\n        public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)\n        {\n            return source == null || !source.Any();\n        }\n        public static string ToJSON(this object value)\n        {\n            return JsonConvert.SerializeObject(value);\n        }\n    }\n\n    public class ErrorResponse\n    {\n        public int ErrorCode { get; set; }\n        public string Description { get; set; }\n    }\n\n}
\n

In the above file we have created the method for checking the Xss in QueryParam, RequestUri and RequestBody.

\n

Here we have different methods which are as follows:-

\n

ReadRequestBody which is used for reading the RequestBody.

\n

RespondWithAnError which is used for returning the error.

\n

IsDangerousString which is checking if there is any dangerous string like any script in the given string.

\n

Step 7: Edit the Startup.cs file and add below line in Configure method.

\n
app.UseAntiXssMiddleware();
\n

Step 8 : After editing the Startup.cs file will look like below

\n
using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing AntiXssMiddleware.Middleware;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.AspNetCore.Hosting;\nusing Microsoft.AspNetCore.HttpsPolicy;\nusing Microsoft.AspNetCore.Mvc;\nusing Microsoft.Extensions.Configuration;\nusing Microsoft.Extensions.DependencyInjection;\nusing Microsoft.Extensions.Hosting;\nusing Microsoft.Extensions.Logging;\n\nnamespace AntiXssMiddleware\n{\n    public class Startup\n    {\n        public Startup(IConfiguration configuration)\n        {\n            Configuration = configuration;\n        }\n\n        public IConfiguration Configuration { get; }\n\n        // This method gets called by the runtime. Use this method to add services to the container.\n        public void ConfigureServices(IServiceCollection services)\n        {\n            services.AddControllers();\n        }\n\n        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.\n        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)\n        {\n            if (env.IsDevelopment())\n            {\n                app.UseDeveloperExceptionPage();\n            }\n\n            app.UseHttpsRedirection();\n            app.UseAntiXssMiddleware();\n            app.UseRouting();\n            app.UseAuthorization();\n            app.UseEndpoints(endpoints =>\n            {\n                endpoints.MapControllers();\n            });\n        }\n    }\n}
\n

Step 9: Now build and run the solution.

\n

As we run the default API which is https://localhost:44369/weatherforecast we will get the below response.

\n
[\n    {\n        "date": "2020-08-21T11:58:40.0289718+05:30",\n        "temperatureC": 27,\n        "temperatureF": 80,\n        "summary": "Sweltering"\n    },\n    {\n        "date": "2020-08-22T11:58:40.0289896+05:30",\n        "temperatureC": 21,\n        "temperatureF": 69,\n        "summary": "Cool"\n    },\n    {\n        "date": "2020-08-23T11:58:40.0289899+05:30",\n        "temperatureC": -20,\n        "temperatureF": -3,\n        "summary": "Hot"\n    },\n    {\n        "date": "2020-08-24T11:58:40.0289901+05:30",\n        "temperatureC": 21,\n        "temperatureF": 69,\n        "summary": "Sweltering"\n    },\n    {\n        "date": "2020-08-25T11:58:40.0289902+05:30",\n        "temperatureC": 2,\n        "temperatureF": 35,\n        "summary": "Balmy"\n    }\n]
\n

Now if we inject any script in the above url like https://localhost:44369/weatherforecast<script></script> we will get the response as

\n
{\n    "ErrorCode": 500,\n    "Description": "Error from AntiXssMiddleware"\n}
\n

Note:

\n
    \n
  1. The default port may be different when you run the project. So change the port accordingly.
    2. \n
  2. You can customize the error message according to your need.
    3. \n
\n

Conclusion

\n

In this blog, we learnt about how to implement AntiXssMiddlware in ASP.NET Core Web Application Project. We have implemented the AntiXssMiddleware in API's QueryParam, ReuqestUri and RequestBody. So if any script is injected in QueryParam, RequestUri or RequestBody then it will give the error.

\n","frontmatter":{"title":"Implement AntiXssMiddleware in .NET Core Web","author":{"id":"Hemant Manwani","github":"hemant404","avatar":null},"date":"August 26, 2020","updated_date":null,"tags":["C#","ASP.NET"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/813c7a5a008113481ac2c05836830d14/ee604/antixss.png","srcSet":"/static/813c7a5a008113481ac2c05836830d14/69585/antixss.png 200w,\n/static/813c7a5a008113481ac2c05836830d14/497c6/antixss.png 400w,\n/static/813c7a5a008113481ac2c05836830d14/ee604/antixss.png 800w,\n/static/813c7a5a008113481ac2c05836830d14/f3583/antixss.png 1200w,\n/static/813c7a5a008113481ac2c05836830d14/5707d/antixss.png 1600w,\n/static/813c7a5a008113481ac2c05836830d14/eeb1b/antixss.png 1920w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Hemant Manwani","slug":"/engineering/anti-xss-middleware-asp-core/"}}}]},"authorYaml":{"id":"Hemant Manwani","bio":"Hemant Manwani is a Software Engineer at LoginRadius who is interested in how the web works and developer tools that make working with web easier.","github":"hemant404","stackoverflow":null,"linkedin":"hemant-manwani-1a035478","medium":null,"twitter":null,"avatar":null}},"pageContext":{"id":"Hemant Manwani","__params":{"id":"hemant-manwani"}}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}