Top 50 C# Interview Questions and Answers (2023)

Medium Level C# Interview Question

Let's begin with some medium-level C# Interview questions and answers.

16. What is the difference between a struct and a class in C#?

Ans: The difference between a struct and class in C# is:

17. What is a lambda expression in C#?

Ans: A lambda expression in C# is a shorthand syntax for creating anonymous functions. It allows you to define a method in place without declaring a separate delegate or named method. A lambda expression can be assigned to a delegate type or passed as a parameter to a method that expects a delegate. 

Two types of lambda expressions are:

a. Expression lambda

input => expression;

b. Statement lambda

input => { statements };

Example

using System;
public class Example
{
    public static void Main(string[] args)
    {
        List<int> n = new List<int> {5, 6, 4, 1, 9, 2};


var c = n.Count( a =>
                {
                    return a == 4;
                });


Console.WriteLine(c);
    }
}

Explanation:

The lambda expression in the above program is inside the Count query - a => { return a== 4; }. The Count counts the number of items and will return a boolean as output.

Lambda expressions provide a more concise and readable way to write inline code and can be used to simplify event handling, iteration, and LINQ (Language Integrated Query) operations.

18. What is the difference between an abstract class and an interface in C#?

Ans: The difference between a abstract class and interface in C# is:

19. What is LINQ in C#?

Ans: LINQ (Language Integrated Query) is a feature in C# that allows you to write SQL-like queries against various data sources, including arrays, lists, and databases. LINQ provides a unified way to access and manipulate data, making it easier to write and maintain code that works with different types of data sources.

20. Differentiate between a stack and a queue in C#?

Ans: The difference between a stack and a queue in C# is:

21. What is the difference between a value type and a reference type in C#?

Ans: In C#, value types directly store their data, while reference types store a reference to an object in memory. When a value type is assigned to a variable, a new instance of the value type is created in memory, containing a copy of the data. 

Some of the value data types are:

• byte.
• int.
• char.
• long.
• short.

Example:

There is a variable of integer type x = 50. The System stores 50 at some hypothetical location in the memory space allocated for the integer variable x.

On the other hand, reference types store a reference to the memory location where the object is stored rather than storing the data directly. This means that when a reference type is assigned to a variable, it is a reference to the same object in memory rather than a new instance.

Some of the referenced data types are:

• Arrays.
• Class.
• String.
• Delegate.

Example:

Suppose str = “Hello Ninjas”, the system selects the hypothetical location in memory for the variable str. The value of the str is the memory address of the actual location of the data. Hence the reference type stores the address of the location of the actual value. 

22. What is the difference between null and non-nullable types in C#?

Ans: A nullable type in C# can be assigned a value of either its type or null, while a non-nullable type cannot be assigned a value of null and must always have a value of its type. Nullable types are useful when a value may not always be present, while non-nullable types are used for values that must always have a value.

23. Which are the access modifiers available in C#?

Ans: In C#, there are five access modifiers that control the accessibility of classes, members, and other elements in a program:

1. public: The member or class is accessible from anywhere in the program.
    
2. private: The member or class is accessible only within the same class.
    
3. protected: The member or class is accessible within the same class and in derived classes.
    
4. internal: The member or class is accessible within the same assembly (a unit of deployment in . NET).
    
5. protected internal: The member or class is accessible within the same assembly and in derived classes.

24. What is the difference between dispose() and finalize() methods in C#?

Ans: The Dispose method in C# is an explicit method that the user can call to release resources held by an object. The Finalize method is an implicit method that the garbage collector automatically calls to release resources when an object is no longer needed. The Dispose method is preferred over the Finalize method as it allows for more immediate and efficient resource management.

25. What is the difference between method overloading and method overriding in C#?

Ans: In C# method overloading involves creating multiple methods with the same name but different parameters in the same class. Method overriding involves creating a method in a derived class with the same name, return type, and parameters as a method in the base class. 

Overloading allows for multiple methods with the same name to perform different operations. In contrast, overriding allows for a derived class to provide its own implementation of a method in the base class.

Example of Method Overloading:

using System;  
namespace Application  
{  
    class Overloading  
    {  
        public int mul(int x, int y)  
        {  
            return (x*y);  
        }  
        public int mul(int x, int y, int z)  
        {  
            return (x*y*z);  
        }  
 
         
        static void Main(string[] args)  
        {  
            Overloading obj = new Overloading();  
            Console.WriteLine("First method : " + obj.mul(1, 2));  
            Console.WriteLine("Second method :" + obj.mul(5, 2, 5));  
            
            Console.ReadLine();  
        }  
    }  
}  

Output

First method : 2

Second method :50

Explanation:

In the above program, we use two methods with the same name but with different parameters. So the compiler automatically calls the method with two integers parameters when you call mul(1, 2). While the same with the other method, mul(4.5, 2, 5), which has three parameters of double data type. 

Example of Method Overriding

using System;  
namespace Application  
{  
    class Overriding  
    {  
        public virtual int mul(int x, int y)  
        {  
            return (x * y);  
        }  
    }  
    class Childbase: Overriding  
    {  
        public override int mul(int x, int y)  
        {  
            if (x <= 0 || y <= 0)  
            {  
                
                
                x = Convert.ToInt32(Console.ReadLine());  
                 
                y = Convert.ToInt32(Console.ReadLine());  
            }  
            return (x * y);  
        }  
    }  
    class Example  
    {  
        static void Main(string[] args)  
        {  
            Overriding obj = new Overriding();  
            Console.WriteLine("First Method :" + obj.mul(8, 8));  
            obj = new Childbase();  
            Console.WriteLine("Second Method :" + obj.mul(-6, 3));  
            Console.WriteLine("Second Method :" + obj.mul(7, 3));  
            Console.ReadLine();  
        }  
    }  
} 

Output

First Method :64

Second Method :0

Second Method :21

Explanation:

In the above example, two methods with the same name are created in the “Overriding” and “Childbase” class. In the “Overriding” class, the method multiplies the two numbers with less than zero value. But the “Childbase” class method checks for the negative value.

26. What are the differences between ref and out keywords?

27. What are extension methods in C#?

Extension methods are a feature in C# that allow you to add methods to an existing class without modifying the class itself. Extension methods are defined as static methods in a static class, and they must be in the same namespace as the class being extended.

To use an extension method, you simply need to call it as if it were an instance method of the extended class. The first parameter of the extension method specifies the class being extended, and it is preceded by the this keyword. This tells the compiler that the method is an extension method and should be called as if it were a member of the extended class.

28. Does C# support multiple inheritances?

C# does not support multiple inheritances traditionally, where a class can inherit from multiple base classes. This is because multiple inheritance can lead to problems with ambiguity and complexity in the class hierarchy.

Instead, C# uses interfaces to provide similar functionality to multiple inheritance, which is an interface. An interface defines a contract that a class must implement but does not provide any implementation details.

29. What are the different types of comments in C#?

Various types of comments in C# are as follows:

• XML comments 
  Example: ///This is an XML comment
   
• Single Line comments
  Example: //This is a single-line comment
   
• Multi-line comments
  Example: /* This is a multi-line comment */

30. List the steps of compiling a C# code.

Steps involved while compiling a C# code include the following:

• Compilation of Source Code
   
• Clubbing of Assembly code with the newly created code
   
• Loading of CLR(Common Language Runtime).
   
• Execution of assembly code through CLR.

Advanced Level C# Interview Questions

Below are some hard-level interview questions and answers. 

31. What are generics in C#.NET?

Ans: Generics in C#.NET is a feature that allows the creation of reusable code by creating classes, methods, and data structures that work with various data types without the need for duplicating code. Generics can parameterize a type or method by one or more data types, making the code more flexible and efficient. 

Generics provide type safety and enable better performance by avoiding the need for boxing and unboxing of value types. Generics are commonly used in collections, such as lists and dictionaries, as well as in algorithms and other areas of C# programming.

32. Mention different ways in which a method can be overloaded.

Ans: Different ways by which a method can be overloaded are:

• Change the order of parameters in a method.
   
• Change the number of parameters in a method.
   
• Use different data types for parameters.
   

Example

using System;
namespace Overloading {
    public class Addition {
        public double sum(double a, double b) {
            double sum = a + b;
            return sum;
        }

        public double sum(double a, double b, double c) {
            double sum = a + b + c;
            return sum;
        }
    }

    class Example {
        public static void Main(string[] args) {
            Addition obj = new Addition();
            double a = 3.3;
            double b = 4.9;
            double s = 1.2;
            double sum = obj.sum(a, b, s);
            Console.WriteLine("Total sum: " + sum);

            double c = 3.3;
            double d = 6.3;
            double add = obj.sum(c, d);
            Console.WriteLine("Sum: " + add);
        }
    }
}

Output

Total sum: 9.4

Sum: 9.6

Explanation:

In the above example, the method sum is defined two times. First it contains two arguments to find the sum of two numbers, and second, it is defined with three arguments to find the sum of the three numbers.

33. Differentiate between early and late binding in C#.

Ans: Both early and late binding are examples of polymorphism concepts. Polymorphism enables a language to use the same name in many ways. For instance, the Add method can combine integers, doubles, and decimals.

The two types of polymorphism are:

Compile time polymorphism - Overloading or Early Binding.

Runtime polymorphism - Overriding or Late Binding.

Early Binding

In this, there are multiple methods with the same name but different parameter types(data types).

Example

using System;

namespace Overloading {
    public class Addition {
        public double sum(double a, double b) {
            return a + b;
        }

        public string sum(string a, string b) {
            return a + " " + c;
        }
    }

Late Binding

In this, there will be the same method name with the same number of parameters but not in the same class. Therefore we bind at the runtime in the child class. That’s the reason it is called late binding.

Example

using System;

namespace Overriding {
   class Addition {
      

      public sum( int a, int b) {
       return a + b;
      }

   }

   class ChildClass: Addition {
     
      public sum( int a, int b) {
       return a + b;
      }
   }

34. What are partial classes, and what is their use in C#?

Ans: Partial classes are a special feature in C# that implements the functionality of a single class into multiple physical files. When the application is compiled, all these multiple files are combined into a single class file. The partial keyword is used to split the class definition. 

Syntax

public partial Class_Name  
{
       // code
}

Partial classes in C# provide several advantages, including:

• Organizing code.
• Code reuse.
• Separation of concerns.
• Generated code.

Example

There are two files “Ninjas1” and “Ninjas2” that contain the “Ninjas” class.

Ninjas1.cs

public partial class Ninjas {
    private string name;
    private int age;
 
    public Geeks(string name, int age)
    {
        this.name = name;
        this.age = age;
    }
}

Ninjas2.cs

public partial class Ninjas {
    public void print()
    {
        Console.WriteLine("Name is : " + name);
        Console.WriteLine("Age is : " + age);
    }
}

Below is the main class “Ninjas”, here the main method is not included.

public partial class Ninjas {
    private string name;
    private int age;
 
    public Geeks(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public void print()
    {
        Console.WriteLine("Name is : " + name);
        Console.WriteLine("Age is : " + age);
    }
}

35. How would you force Garbage Collection?

Ans: In C# Garbage Collection is a process that is managed by the .NET runtime, which automatically frees up memory that is no longer being used by the application. However, in certain cases, manually forcing Garbage Collection may be necessary.

In C#, you can use the GC.Collect() method to manually force Garbage Collection. The GC.Collect() method triggers the Garbage Collection process immediately rather than waiting for the .NET runtime to perform it automatically.

36. How would you create a responsive UI without impacting users in C#?

Ans: To create a responsive UI without impacting users in C#, there are a few techniques that can be used:

1. Use asynchronous programming: Asynchronous programming enables the UI to remain responsive while background tasks are running. For example, you can use the async and await keywords to run long-running tasks in the background without blocking the UI thread.
    
2. Use multithreading: By creating and managing multiple threads, you can offload heavy processing from the UI thread and keep the UI responsive. However, it's important to synchronize access to shared data across threads to avoid race conditions and other threading issues. 
    
3. Use background workers: The BackgroundWorker class in C# provides a simple way to run long-running tasks in the background while keeping the UI responsive. It uses a separate thread to execute the task and provides events to report progress and completion.

37. What is the difference between a string and a StringBuilder in C#?

Ans: A string is an immutable data type, meaning you cannot change its value once you create a string. On the other hand, a StringBuilder is a mutable data type, allowing you to change its value and append new characters to it. 

StringBuilder is more efficient for concatenating strings or making multiple modifications to a string, as it does not create a new string instance for each change.

So if you want a string object not to change anywhere in the code then use string class otherwise StringBuilder.

Example of string object

using System;
namespace Application{
   class Example {
      public static void Main(String[] args){
          string s = "Coding ";
          s += "Ninjas";
          Console.WriteLine(s);
          
      }

     }
   }

Output

Coding Ninjas

Example of StringBuilder

using System;
using System.Text;


   class Example {
      public static void Main(){
          StringBuilder s = new StringBuilder("");
          s.Append("Coding ");
          s.Append("Ninjas");
          Console.WriteLine(s);
          
      }
   }

Output

Coding Ninjas

38. Why is the singleton pattern referred to as an anti-pattern in C#?

Ans: The Singleton pattern is often referred to as an anti-pattern in C# because it can introduce several issues and limitations that make code difficult to maintain and test. Some of the reasons why the Singleton pattern is considered an anti-pattern are:

1. Global state: The Singleton pattern creates a global instance that is shared across the application. This can make it difficult to maintain and test since changes to the Singleton can affect the behavior of other parts of the application.
    
2. Tight coupling: The Singleton pattern can create tight coupling between different parts of the application since the Singleton instance is often accessed directly from other classes. 
    
3. Inflexibility: The Singleton pattern can be inflexible since it provides a single instance of an object that cannot be easily substituted or extended. This can make it difficult to adapt to changing requirements or to implement different behaviors for testing or other purposes.
    
4. Testing challenges: The Singleton pattern can be difficult to test since it introduces a global state that can affect the behavior of other tests. It can also be difficult to substitute or mock the Singleton instance for testing purposes.

39. What is a virtual method in C#?

One of the features of object-oriented programming is Polymorphism. It allows you to use the same function to perform different actions according to your needs. 

In C#, you can use the virtual keyword to declare a method as a virtual method in a class. 

Now, if you inherit from this base class having a virtual method, then in the child class, you can override the virtual method using the override keyword, i.e., you can add the other implementation of the same method in the child class different from the parent class.

Example of virtual method in the base class:

public class Base
{
	public virtual void virtualMethod() {
		//Method implementation
	}
}

public class Derived : Base
{
	public override void virtualMethod() {
		//New implementation of virtualMethod
	}
}

40. List the features of read-only variables in C#.

The features of read-only variables in C# are as follows:

• They are initialized at runtime.
   
• They can be declared only at the class level.
   
• They can be used with static modifiers.
   
• The value of a readonly variable cannot be changed or reassigned.

41. What are stream reader and stream writer classes in C#?

The stream reader and stream writer classes inherit from the abstract base class “stream.” 

The abstract class Stream is used for writing and reading bytes from a text file.

Stream writer is used for writing to a file, while the stream reader is used for reading from a file. 

Some of the methods present in the:

• Stream Reader Class: Close(), Peek(), and Read(). 
   
• Stream Writer Class: Close(), Flush(), Write(bool value), WriteLine(), etc. 

42. What do you mean by boxing and unboxing in C#?

Boxing and unboxing are used for type conversion in C#. 

C# treats all the value types as objects. This feature of C# is emphasized by boxing and unboxing.

• Boxing
  It converts the value type to an object or the interface’s data type implemented by the current value type.CLR performs the boxing of the value type and wraps the value in the System.object, and saves it in the heap area of the application domain. 
  It may use implicit code.
   
• Unboxing
  Unboxing does the opposite of boxing, i.e., extracts the value type from the object or interface. It uses explicit code.

43. Differentiate between Task and Thread in C#.

The thread represents a separate program execution path, while a task represents an asynchronous operation. 

The task is used in the TPL(Task Parallel Library) and manages the parallel execution of code. It is easier to manage and use tasks in comparison to threads. 

Tasks provide a higher level of abstraction, while thread provides a lower level of abstraction.

Tasks help in the efficient utilization of resources than threads.

There can be multiple processes running simultaneously for a task. While a thread can have only one task at a time.

It is faster to create a task over a thread.

You can cancel a task in progress using cancellation tokens, but the thread does not support cancellation.

44. What is finally block in C#?

The finally block is used while handling exceptions in the code.

As we know, we use a try-and-catch block to handle exceptions. If an exception occurs while executing the try block, control reaches the catch block, and after that, control is transferred to the finally block. So, in the end, the finally block gets executed. 

Some of the most common uses of the finally block include releasing file handlers,  closing connections to the database, etc. 

Syntax of a general try-catch-block having a finally block is as follows:

try {
   // code block to be cheked for exception
} 
catch( ExceptionName e ) {
   // error handling code
} 
finally {
   // statements to be executed always
}

45. How do you implement exception handling in C#?

We use the following elements while implementing exception handling in C#:

• try block
  It consists of code for which we need to check the exception.
   
• catch block
  It is used for catching an exception and contains the code which will be executed once the exception occurs.
   
• finally block
  It consists of code that is always executed irrespective of whether the exception occurs or not.
   
• throw
  It is responsible for throwing an exception whenever it occurs instead of handling it.

46. What are dynamic type variables in C#?

As the name itself suggests, dynamic type variables can store data of any type. 

Type checking for such variables takes place at run time. 

You can define a dynamic type variable using a dynamic keyword in C#. 

Example:

dynamic newDynamicVariable = 2;

In most cases, the compiler compiles the dynamic variables to object types. But the final type is resolved only at runtime on the basis of their assigned value. 

If, after assigning one type of value, you reassign it to some other value of different type, then this type conversion takes place implicitly.

Example:

dynamic newDynamic1 = “hi”;
newDynamic1 = 10;
int s = newDynamic1;

47. Explain Anonymous types in C#.

You can create a new type without defining them beforehand using anonymous types in C#. 

It is a reference type, and you can define it using the var keyword. 

Anonymous types in C# can have multiple properties, all of which are read only. Basically, you can use it to bundle some read only properties in a single unit.

The difference between a C# class and anonymous types is that the classes can have fields and methods also, but anonymous types can only have properties.

You can access the anonymous type and its properties inside the method where it is defined. Therefore, its accessibility scope is limited.

Example:

var newAnonymousType {
property1 = “pr1”,
property2 = “pr2”
}

It is also possible to use nested anonymous types in C#. 

48. How is encapsulation implemented in C#?

Encapsulation is one of the most important and widely used feature of object oriented programming in C#. 

You can implements encapsulation in C# using various access modifiers like:

• Public
  The public access modifier is used to expose a member of a class like class variables or functions to other classes or objects. This implies that you can access the public members of a class from outside the class.
   
• Private
  The private access modifier conceals the class members like variables and functions from external world like other classes or objects. The private members of a class can only be accessed by the functions of same class.
   
• Protected
  If you declare a class member as protected, then the children classes can access it. Thus, it is useful while implementing inheritance in object oriented programming as it allows to reuse the protected members like functions or variables.

49. Differentiate between constant and readonly in C#.

The values of the constant and readonly variables cannot be changed once assigned. 

But the only difference between them is that the const variables need to be initialized when defined, whereas the readonly variables can be defined at the runtime.

The following table summarizes the differences between the constant and readonly variables in C#. 

50. What is the use of the yield keyword in C#?

Following are the uses of the yield keyword in C#:

• It is used for performing stateful iteration.
• It helps to perform a custom iteration over a collection like lists, arrays, etc.
• Using the yield keyword moves the control back and forth between the caller function and source and vice versa.
   

You can use the yield keyword in two forms:

• yield return
  It is used for returning expressions at each iteration.
   
• yield break
  It is used for terminating the iteration.

Frequently Asked Questions

What is C# and why C#?

C# is a modern general-purpose programming language developed by Microsoft. It is an object-oriented programming language. C# is a robust language mainly used to develop high-level software. C# strongly supports object-oriented paradigms with high versatility and community. It supports cross-platform development, which makes it highly usable.  

What is the main function of C#?

The main function of C# is to provide high support to object-oriented concepts and help in building robust, versatile, scalable, and cross-platform independent applications. 

Is C# and .NET same?

No, C# and .NET are not the same, although both are developed by Microsoft. C# is an object-oriented programming language, whereas .NET is a framework with support to multiple programming languages, and C# is one of the languages that can be used with the .NET framework to develop applications. 

Conclusion

In this article, we have discussed C# interview questions and their answers in three categories: easy, medium, and hard. You can also check out our other interview questions blogs:

• Jenkins interview questions
• Excel Interview Questions
• SAP FICO Interview Questions 
• CSS Interview Questions
• SQL Query Interview Questions
• MySQL Interview Questions
• MongoDB Interview Questions
• Manual testing interview questions

Happy Learning!