20 Most Important C# Interview Questions

C# Interview Questions

Hackr.io.

Spread the Knowledge

Debuting back in 2000, C# has succeeded in becoming one of the leading programming languages. As a multi-paradigm programming language, C# also has some features of functional programming that takes its usefulness and versatility to a step further.

C# Interview Questions

In the following section, we have enlisted 20 of the most important C# interview questions. These questions will prepare you for your next C# interview in addition to enhancing your C# knowledge and letting you evaluate your current C# understanding.

Q: How will you differentiate between a Class and a Struct?

A: Although both class and structure are user-defined data types, they are different in several fundamental ways. A class is a reference type and is thus stored on the heap. Struct, on the other hand, is a value type and is, therefore, stored on the stack.

While the structure doesn’t support inheritance and polymorphism, the class provides support for both. A class can be of abstract type but a structure can’t.

All members of a class are private by default, while members of a struct are public by default. Another distinction between class and struct is on the basis of memory management. The former supports garbage collection while the latter doesn’t.

Q: Compare Virtual methods and Abstract methods.

A: Any Virtual method must have a default implementation and it can be overridden in the derived class using the override keyword. On the contrary, an Abstract method doesn’t have an implementation and it resides in the abstract class.

It is compulsory that the derived class implements the abstract method. Though not necessary, an override keyword can be used here.

Q: What are Namespaces in C#?

A: Namespaces are used for organizing large code projects. The most widely used namespace in C# is System. Namespaces are created using the namespace keyword. It is possible to use one namespace in another, known as Nested Namespaces.

Q: What are I/O classes in C#? Define some of the most commonly used ones.

A: The System.IO namespace in C# consists of several classes used for performing various file operations, such as creation, deletion, closing, and opening. Some of the most frequently used I/O classes in C# are:

  • File – Manipulates a file
  • Path – Performs operations related to some path information
  • StreamReader – Reads characters from a stream
  • StreamWriter – Writes characters to a stream
  • StringReader – Reads a string buffer
  • StringWriter – Writes a string buffer

Q: What do you understand by regular expressions in C#? Write a program that searches a string using regular expressions.

A: Regular expression is a template for matching a set of input. It can consist of constructs, character literals, and operators.

Regex is used for string parsing as well as replacing the character string. Following code searches a string “C#” against the set of inputs from the languages array using Regex:

static void Main(strong[] args)
{
string[] languages = {“C#”, “Python”, “Java”};
foreach(string s in languages)
{
if(System.Text.RegularExpressions.Regex.IsMatch(s,“C#”))
{
Console.WriteLine(“Match found”);
}
}
}

Q: Give a detailed explanation of Delegates in C#.

A: Delegates are variables that hold references to methods. It is a function pointer of reference type. Both the Delegate and the method to which it refers can have the same signature. All Delegates are derived from the

System.Delegate namespace.

Following example demonstrates declaring a delegate:

public delegate AddNumbers(int n);

After declaring a delegate, the object must be created of the delegate using the new keyword, such as:

AddNumbers an1 = new AddNumbers(number);

The Delegate offers a kind of encapsulation to the reference method, which gets internally called when a delegate is called. In the following example, we have a delegate myDel that takes an integer value as a parameter:

public delegate int myDel(int number);
public class Program
{
public int AddNumbers(int a)
{
Int Sum = a + 10;
return Sum;
}
public void Start()
{
myDel DelgateExample = AddNumbers;
}
}

Q: Explain Reflection in C#.

A: The ability of code to access the metadata of the assembly during runtime is called Reflection. A program reflects upon itself and uses the metadata to:

  • Inform the user, or
  • Modify the behavior

All classes and methods that manage the information of all the loaded types and methods are contained in the System. Reflection namespace. Reflection is implemented in 2 steps:

  • Get the type of the object, then
  • Use the type to identify members, such as properties and methods

Q: Name some of the most common places to look for a Deadlock in C#.

A: For recognizing deadlocks, one should look for threads that get stuck on one of the following:

  • .Result, .GetAwaiter().GetResult(), WaitAll(), and WaitAny() (When working with Tasks)
  • Dispatcher.Invoke() (When working in WPF)
  • Join() (When working with Threads)
  • lock statements (In all cases)
  • WaitOne() methods (When working with AutoResetEvent/EventWaitHandle/Mutex/Semaphore)

Q: Define Serialization and its various types in C#.

A: The process of converting some code into its binary format is known as Serialization in C#. Doing so allows the code to be stored easily and/or written to a disk or some other storage device. We use Serialization when there is a strict need of not losing the original form of the code.

A class that is marked with the attribute [Serializable] gets converted to its binary form. A stream that contains the serialized object and the System.Runtime.Serialization namespace can have classes for serialization. Serialization in C# is of three types:

  • Binary Serialization – Faster and demands less space, it converts any code into its binary form. Serialize and restore public and non-public properties.
  • SOAP – It produces a complete SOAP compliant envelope that is usable by any system capable of understanding SOAP. The classes pertaining to this type of serialization reside in System.Runtime.Serialization.
  • XML Serialization – Serializes all the public properties to the XML document. In addition to being easy to read, the XML document can be manipulated in several formats. The classes in this type of serialization reside in System.sml.Serialization.

Note: – Retrieving the C# code back from the binary form is known as Deserialization.

Q: Give a brief explanation on Thread Pooling in C#.

A: A collection of threads is termed as a Thread Pool in C#. Such threads can be used for performing tasks without disturbing the execution of the primary thread.

After a thread belonging to a thread pool completes execution, it returns to the thread pool. Classes that manage the thread in the thread pool, and its operations, are contained in the System.Threading.ThreadPool namespace.

Q: Is it possible to use this keyword within a static method in C#?

A: A special type of reference variable, this keyword is implicitly defined with each non-static method and constructor as the first parameter of the type class in which it is defined.

Static methods don’t belong to a particular instance. Instead, they exist without creating an instance of the class and are called with the name of the class.

Because this keyword returns a reference to the current instance of the class containing it, it can’t be used in a static method. Although we can’t use this keyword within a static method, we can use it in the function parameters of Extension Methods.

Q: What can you tell us about XSD file in C#?

A: XSD denotes XML Schema Definition. The XML file can have any attributes, elements, and tags if there is no XSD file associated with it.

The XSD file gives a structure for the XML file, meaning that it determines what, and also the order of, the elements and properties that should be there in the XML file.

Note: – During serialization of C# code, the classes are converted to XSD compliant format by the Xsd.exe tool.

Q: What do you mean by Constructor Chaining in C#?

A: Constructor chaining in C# is a way of connecting two or more classes in a relationship as an inheritance. Every child class constructor is mapped to the parent class constructor implicitly by using the base keyword in constructor chaining.

Q: Explain different states of a Thread in C#?

A: A thread in C# can have any of the following states:

  • Aborted – The thread is dead but not stopped
  • Running – The thread is executing
  • Stopped – The thread has stopped execution
  • Suspended – The thread has been suspended
  • Unstarted – The thread is created but has not started execution yet
  • WaitSleepJoin – The thread calls sleep, calls wait on another object, and calls join on some other thread

Q: Why do we use Async and Await in C#?

A: Processes belonging to asynchronous programming run independently of the main or other processes. In C#, Async and Await keywords are used for creating asynchronous methods.

Q: What is an Indexer in C# and how do you create one?

A: Also known as an indexed property, an indexer is a class property allowing accessing a member variable of some class using features of an array. Used for treating an object as an array, indexer allows using classes in a more intuitive way.

Although not an essential part of the object-oriented programming, indexers are a smart way of using arrays. As such, they are also called smart arrays.

Defining an indexer enables creating classes that act like virtual arrays. Instances of such classes can be accessed using the [] array access operator. The general syntax for creating an indexer in C# is:

< modifier > <
return type > this[argument list] {
get {
// the get block code
}
set {
// the set block code
}
}

Q: What is the Race condition in C#?

A: When two threads access the same resource and try to change it at the same time, we have a race condition.

It is almost impossible to predict which thread will succeed in accessing the resource first. When two threads try to write a value to the same resource, the last value written is saved.

Q: What do you understand by Get and Set Accessor properties?

A: Made using properties, Get and Set are called accessors in C#. A property enables reading and writing to the value of a private field. Accessors are used for accessing such private fields.

While the Get property is used for returning the value of a property, the Set property is used for setting the value.

Q: Give a detailed explanation of the differences between ref and out keywords.

A: In any C# function, there can be three types of parameters, namely in, out and ref. Although both out and ref are treated differently at the run time, they receive the same treatment during the compile time. It is not possible to pass properties as an out or ref parameter.

Following are the various differences between ref and out keywords:

  • Initializing the Argument or Parameter – While it is not compulsory to initialize an argument or parameter before passing to an out parameter, the same needs to be initialized before passing it to the ref parameter.
  • Initializing the Value of the Parameter – Using ref doesn’t necessitate for assigning or initializing the value of a parameter before returning to the calling method. When using out, however, it is mandatory to use a called method for assigning or initializing a value of a parameter before returning to the calling method.
  • Usefulness – When the called method is also required for modifying the passed parameter, passing a parameter value by Ref is useful. Declaring a parameter to an out method is appropriate when multiple values are required to be returned from a function or method.
  • Initializing a Parameter Value in Calling Method – It is a compulsion to initialize a parameter value within the calling method while using out. However, the same is optional while using the ref parameter.
  • Data Passing – Using out allows for passing data only in a unidirectional way. However, data can be passed in a bidirectional manner when using ref.

Q: What is Singleton Design Patterns in C#? Explain their implementation using an example.

A: A singleton in C# is a class that allows the creation of only a single instance of itself and provides simple access to that sole instance. Because the second request of an instance with a different parameter can cause problems, singletons typically disallow any parameters to be specified.

Following example demonstrates the implementation of Singleton Design Patterns in C#:

namespace Singleton {
class Program {
static void Main(string[] args) {
Calculate.Instance.ValueOne = 10.5;
Calculate.Instance.ValueTwo = 5.5;
Console.WriteLine("Addition : " + Calculate.Instance.Addition());
Console.WriteLine("Subtraction : " + Calculate.Instance.Subtraction());
Console.WriteLine("Multiplication : " + Calculate.Instance.Multiplication());
Console.WriteLine("Division : " + Calculate.Instance.Division());
Console.WriteLine("\n----------------------\n");
Calculate.Instance.ValueTwo = 10.5;
Console.WriteLine("Addition : " + Calculate.Instance.Addition());
Console.WriteLine("Subtraction : " + Calculate.Instance.Subtraction());
Console.WriteLine("Multiplication : " + Calculate.Instance.Multiplication());
Console.WriteLine("Division : " + Calculate.Instance.Division());
Console.ReadLine();
}
}
public sealed class Calculate {
private Calculate() {}
private static Calculate instance = null;
public static Calculate Instance {
get {
if (instance == null) {
instance = new Calculate();
}
return instance;
}
}
public double ValueOne {
get;
set;
}
public double ValueTwo {
get;
set;
}
public double Addition() {
return ValueOne + ValueTwo;
}
public double Subtraction() {
return ValueOne - ValueTwo;
}
public double Multiplication() {
return ValueOne * ValueTwo;
}
public double Division() {
return ValueOne / ValueTwo;
}
}
}

A Singleton Design Pattern ensures that a class has one and only one instance and provides a global point of access to the same. There are numerous ways of implementing the Singleton Design Patterns in C#. Following are the common characteristics of a Singleton Pattern:

  • A public static means of getting the reference to the single instance created
  • A single constructor, private and parameter-less
  • A static variable holding a reference to the single instance created
  • The class is sealed

That sums up the list of the top 20 C# interview questions. How many of the answers did you know already? Let us know via comments.

Check out these best C# tutorials to enhance your C# understanding further.

People are also reading:

Related Posts

Your email address will not be published. Required fields are marked *

*