Explore topic-wise InterviewSolutions in .

When we want to store any object to a memory, a database, or a file, it needs a special process known as Serialization. 

Serialization is the process of converting an object into a different form to store it on to a file, database, or memory. The purpose of Serialization is to transfer the object and its state across the network and recreate it successfully when needed.

The reverse of Serialization is known as Deserialization.

There are many types of serialization in C#, such as:

• 
  Binary serialization: To save the state of the object in binary format.  This is done using classes defined in the System.Runtime.Serialization namespace.


• 
  Soap Serialization: To save the state of the object in binary format, with the use of network-related communication.


• 
  XML Serialization: To save the state of the object in XML format. This is done using classes defined in the System.Xml.Serialization namespace.


• 
  JSON Serialization: To save the state of the object in JSON format.  This is done using classes defined in the System.Text.Json namespace.

There are some third-party serialization formats as well that are supported in C#, such as MessagePack (msgpack).

If you are planning to go for an interview in C# with 5+ years of experience, then you will need to be ready for some aggressive, in-depth, and out-of-the-box questions. However, with proper knowledge, brush up on your experience and expertise, and proper preparation, you can easily crack any interview. 

Useful Resources:

• OOPs Interview Questions


• .NET Interview Questions


• ASP.NET Interview Questions


• MVC Interview Questions

If we want to prevent any class from being inherited, it can be done with the help of a sealed keyword. So using a sealed keyword, a class denies the ability to create any child entity of this class, thereby calling itself a sealed class. If by mistake, a child of a sealed class is tried to be made, a compile-time error will occur.

Compilation error:

During multi-threading, when a thread is inside a critical section, it must not be removed or stopped until it is completed. To implement this feature, lock statements are used in C# which prevents other threads from entering a locked code (currently in the critical section), until the object is released.

This example shows how a local Mutex object is used to synchronize access to a protected resource.

The above code is a simple example to show how Mutex locks a resource and only that thread can release the Mutex.

MuTex refers to Mutual Exclusion and as the name suggests, Mutex works on the mutual exclusion principle to lock out any other thread requesting for a resource whose access is already given to some thread. Mutex acts as a flag mechanism that prevents any second thread from accessing a resource, except for the thread which is currently working on it.

Unlike other synchronization mechanisms in C#, such as Auto Reset Event which can give the exclusive access of a resource to any thread that calls the set() method, Mutex remembers the thread that gets the resource access, and only that same thread can reset it, thereby giving the true mutual exclusion synchronization. If the thread differs, a mutex exception is thrown.

AutoResetEvent is used to unlock a single thread when multiple threads are in a waiting blocked state, whereas ManualResetEvent is used to unlock multiple threads at once during similar instances.

AutoResetEvent also calls the Reset() method by itself to unblock the thread under consideration, whereas while using ManualResetEvent, the Reset() method has to be called manually after the use of set() method.

Shared variables in C# are not thread-safe. It means that any operation on a variable can be corrupted due to multiple threads. To prevent these dirty reads, C# allows the use of interlocked functions to change the value of shared variables in multithreading code.

Interlocked functions only support int, long, double and float data types, as shown by some of the examples below:

1) Add(ref int address1, int value): Interlocked function to add a value into an int variable safely.

2) Increment(ref int address1): Interlocked function to increment value of an int variable safely by 1.

3) Decrement(ref int address1): Interlocked function to decrement value of an int variable safely by 1.

4) Exchange(ref int address1, int value): Interlocked function to replace the value of an int variable safely.

5) CompareExchange(ref int address1, int newValue, int toBeValue): Interlocked function to replace the value of an int variable safely only if the existing value is equal to passed toBeValue.

Enum is a primitive data type in C# used to define numeric constants in the .NET framework. Starting from 0, all the elements of the enum are given constant values, each increasing by 1.

For example, if we declare an enum for days of the week, the first element (Sunday) will get the value 0, the next element (Monday) will get the value 1, and so on till Saturday, which will get the value 6.

To access any element, all you need to do is just pass the value of the element alongside enum’s variable, such as:

Both dispose() and finalize() methods are used for unallocating and freeing up resources but:

• dispose() method is called explicitly by the user, whereas finalize() method is called the system’s garbage collector at the end of execution.


• dispose() method is defined in the IDisposable interface, whereas the finalize() method is defined in the Object class.


• dispose() method is a part of the developer’s code, whereas finalize() method is a system-defined default method and not a part of the developer’s code.

For C# 5:

For C# 6.0:

In the configuration file, just use the targetFramework attribute to specify the version of ASP.NET that your application is targeting.

Below is the syntax used:

Framework targeting in C# is used to mention the version of the .NET framework that the project is intended to run upon.

Framework targeting helps guarantee that the application uses only functionality that is available in the specified framework version. 

Reflection is the process of describing the metadata of types, methods, and fields in a code.

Some of the major use of Reflection in C#:

• Load assemblies at the given runtime


• Help to learn about the definition of entities like class, or enumeration by groups


• Get to know about fields, properties, constructors, events, and methods in a Class


• Helps to learn about the properties of entities such as their types, read-only status, etc.


• Helps in getting and setting a property’s value


• Helps to learn about an entity’s attributes.

Method hiding or Method shadowing is used to hide the implementation of the base class method under the shadow of the child class method, with the help of a new keyword.

This is done to clear the ambiguity when the child class has a method with the same name as that of the base class and hence helps in abstraction.

The output will be:

Explanation:

The correct value of the above code will be “4 4 4 4” and not “1 2 3 4”. Let us see why.

We are creating a delegate of functions using statement 

So the loop will traverse for all values as v, i.e. 1, 2, 3, till 4. Now when ()=>v is used, it means to return the latest value of variable v, and not the value when delegate was created. Therefore when the methods run, the last value assigned to v was 4, so the methods will be called using value 4 each time, and hence the output will be 

“4
4
4
4”

As the name suggests, access modifiers are keywords that define the scope of entities in a C# code, as to which point an entity can be accessed from its point of creation.

In particular, there are 4 access modifiers in C#: public, protected, internal, and private.

Encapsulation is done with the help of access modifiers in C#: public, private, protected, and default.

Encapsulation is the process of binding an entity with its implementation with the aim of data hiding. It is done to hide the irrelevant details from a user, and show only the process which the user needs. By doing so, we hide the implementation details of entities and thereby help users to understand the higher-level design of the code easily, without getting bothered about the implementation details.

Encapsulation has some hidden advantages as well which make it the need of the hour for every software developer such as preventing accidental corruption, unauthorized access to entities, etc.

In C# Arrays have a fixed size, which means that once an array is created of some size, it cannot be dynamically increased or decreased in size. The CLR (Common Language Runtime) in C#, stores the strings as an array of characters. So whenever we delete or add a character or characters to a string, the original arrays of characters are fixed, and hence a new array of characters is created to accommodate the change. This is known as the immutability of strings in C#.

• 
  ref keyword is used to pass an already initialized variable to a method as a reference type, facilitating bi-directional data passing.

Example 1:

The above program will generate the below output:

• Whereas out keyword is used to pass a variable as an empty container that can store multiple values to a method as a reference type. out keyword allows uni-directional data passing, as the container passed using out keyword doesn’t need to be initialized beforehand.

Example 2: Let’s see if and how the data flows when out keyword is used:

The above program will generate the below error:

Example 3: Now let us try to see what happens when we initialize some value to an out parameter.

The above program will generate the below output:

Some of the important input-output classes are:

In C#, if you don’t specify any access specifier against a constructor, that constructor is by default specified as a public constructor by the compiler.

If you want to create a Private constructor explicitly, it can be declared in C# with the help of a private keyword placed before the constructor name in its signature, as shown below:

However, to create an instance of a class with a private constructor is a tricky thing. To do so, the Singleton class is used. Singleton class is a class that has only one instance. Below is the example to create an instance of a class with a private constructor, with the help of the Singleton class.

Like functions, a class can have any number of constructors. But unlike functions, all the constructors will have the same name, the name of the class, but different parameter signatures. In other words, you can create as many valid overloads of a constructor, as you want.

Base Constructor is always called first in C#, followed by Derived class constructor.

No, in C#, it is necessary to define properly which constructor you are trying to call to instantiate a class and what arguments are being passed. So you cannot override a constructor in C#.

Example: Below example will lead to a compilation error.

However, you can overload a constructor in C#, for sure.

A delegate is a reference type entity that is used to store the reference of a method. So whenever you need to call a method, you can easily use the delegate by initializing a pointer to that method, thereby helping to implement Encapsulation.

Delegates in C# are similar to function pointers in C/C++ and can be used to pass methods as arguments to other methods, chained together, or even can be used to call methods on events.

• An object pool is a container built to keep the most used objects for faster access and use.


• An object pool is based on the object pool design pattern in which instead of every time creating objects when needed, commonly used objects are created beforehand and kept in an easily accessible location. This is done to reduce the cost of the application as creating objects can use a lot of resources and can sometimes lead to the slowness of the .NET application. 


• The objects of the pool are returned to the pool, once the use is over, thus making it efficient to reuse them. If the object is not in the pool, it is then created when needed as a normal object.

The public access modifier in C# states the compiler that the element is accessible by any other element in the same or other class.

When a member in C# has the Static access modifier in front of it, such as static method, static variable, or static parameters,  it means that the element has global access and any other element can access it using class directly. You don't need to create an instance of the class to access that element. The compiler stores the address of the method as the entry point and uses this information to begin execution before any objects are created.