100 advanced C# interview questions and answers for 2024

C# is a high-level object-oriented programming language. It is used for building secure and robust applications.

Developed by Microsoft in 2000, C# was invented to match the increasing demand
for web applications.

Some top reasons to use C# are:

• Easy to learn
• Fast development time
• High scalability
• Compiled on multiple computer platforms
• Modularity for easier troubleshooting allows developers to work on multiple objects simultaneously

There are two types of comments in C#:

Single line:
//contains only 1 line of code

Multiple line (/* */):

/*Line 1

Line 2

Last line*/

There are several IDEs for C# development:

• Visual Studio
• Visual Studio Code
• Visual Studio Express

Common Language Runtime (CLR) is a runtime environment that manages the execution of any .NET program.

No. You can’t use multiple catch blocks for same exception in C# because a catch block is preceded by a try block.

C# supports object-oriented programming whereas C supports procedural programming.

Java Virtual Machine (JVM).

Simple Object Access Protocol.

The CLR is a virtual machine component of the .NET Framework. It manages the code execution of .NET programs.

Indexers allow objects to be indexed just like arrays.

There are mainly four types of classes in C#:

• Abstract class
• Partial class
• Sealed class
• Static class

No.

No. C# is a high level programming language whereas C++ is a low level programming language. Another difference is C# compiles to CLR whereas C++ compiles to machine code.

".cs" is used to save C# files.

Curly braces {}

Operators are a set of symbols that tells the compiler to perform an action.

Yes, it is a type-safe programming language.

No, it is not possible to get the array index using the for each loop. To access the array index, you need to use a standard for loop.

Break

Yes, it is possible to inherit a class into another. It is of two types:

• Derived class-child
• Base class-parent

No. Method overriding is a process of calling functions from base class in the derived class. So overriding is not possible in the same class.

Method

Namespaces delegates, interfaces, and structures can be the members of the namespace.

No, you can’t as private virtual methods can’t be accessed outside the class.

Every statement in C# is terminated by a semicolon (;).

Yes.

No.

//

/* is used to begin and */ to end the comment.

type variableName = value;

String

const type constant_name = value;

Class

Yes

The throw statement allows you to manually throw an exception during the execution of a program.

System.UInt32

Public. As the Main() method is called by the runtime, it should be defined as public.

A C# pointer allows the user to store the memory address of another type.

(.) symbol or dot operator.

Variables are containers used to store data values. We can change the value or reuse the variable as many times as we like.

The following four keywords are used for Exception Handling in C#:

• Try - The try block recognizes which block of code has particular exceptions activated.
• Catch - The catch keyword signifies a program for catching an exception using an exception handler.
• Finally - The finally block executes a given block of code whether or not an exception is caught.
• Throw - Using the throw keyword, the program throws an exception in the event of a problem.

Recursion refers to the process of making a function call itself.

Multicasting delegates allow users to invoke multiple callbacks. It can refer to multiple methods and functions having the same signature at one time.

Namespaces are used for differentiating one set of names different from another. They are used to organize code in distinct groups so that one group can be differentiated from another.

Here are the four steps:

• Pre-processing
• Compiling
• Assembling
• Linking

• Public
• Private
• Protected
• Internal
• Protected Internal

Reference or output parameters can be used to return multiple values from a function.

Abstract class acts as a base class and doesn’t have its own objects. It can’t be used for creating objects.

Virtual

It’s the ability of an object to take different forms and behave differently in different cases. It is of two types:

• Compile time polymorphism
• Runtime polymorphism.

The access modifiers are used to define the visibility of classes, methods, properties, and fields.

There are five types of constructors in C#. They are:

• Static constructor
• Default constructor
• Private constructor
• Copy constructor
• Parameterized constructor

Class_Name Object_Name = new Class_Name();

[ ]

String.Length is used to get the count of characters present in a given string. It is a property of the System.String class.

The inequality operator (!=). The syntax is:

public static bool operator != (string? x, string? y);

Dynamic and object type variables are similar in function. Object type variables type checks during the compile time, whereas dynamic type variables at run time.

There are three ways of passing parameters:

• Value parameters
• Reference parameters
• Output parameters.

Using for(;;).

There are four basic data types.

• Char
• Int
• Float
• Double

Keywords are reserved words that have some predefined actions. They are special words that hold special meaning to the compiler.

A jagged array, also called an array of arrays, is a multidimensional array that consists of other arrays of different sizes.

Local variables are referred to as variables that are defined in a code block. They are only visible in the code block they’re declared in.

Inheritance is a way of defining a class (child class) that is allowed to inherit the behavior of the other class (parent class).

C# does not support multiple inheritance because of Name collision.

Dynamic

Read only variables are created using the readonly keyword. Its value can be modified only within a constructor.

Yes, the values of variables can be altered during debugging.

Language-Integrated Query (LINQ) is a .NET Framework. It is used to retrieve information from different kinds of sources.

Constructor is a method that gets executed when a new class object is created. It can be public or private.

Read-only is a runtime constant. Const is a compile-time constant.

Method overloading is a method of having two or more methods with the same name but different parameter lists.

The features of read-only variable are as follows:

• Initialized at runtime
• Can be used with static modifiers
• Only declared at the class level

Dynamic type variable was introduced in C# 4.0. It is used to skip type checking at compile-time. It is created using dynamic keywords. You can store any type of value in a dynamic variable.

Using a statement ensures the object is disposed of as soon as it goes out of scope without needing to write any code.

Nullable types allow you to assign a normal range to null values. You can also assign true or false to null types/

The syntax is:

< data_type> ? <variable_name> = null;

Stream reader and stream writer classes are used for reading and writing actions to a file. Both are inherited from the abstract base class stream.

Overloading- When you have two or more methods in the same scope with the same name but different parameters.

Overriding- It allows you to change the behavior of a method in a subclass or child class.

File handling refers to the management of files. It consists of different actions like creating the file, writing to the file, reading from the file, etc. Read and write are the two operations used in file handling.

Both Boxing and Unboxing are used for converting the type. However, there are some differences.

Boxing - Boxing converts the value type to the object or to the data type of an interface implemented by this particular value type. The CLR boxes a value, in other words, converts the value type to an object. For this, CLR wraps the value in System. Object and store it in the heap area within the domain of the application.

Unboxing - Unboxing extracts the value type from the object or any interface type that has been implemented. For Boxing, implicit code may be used, but for Unboxing explicit code must be used.

Boxing and Unboxing highlight that C# has a unified view of the type system, meaning that all value types can be treated as objects.

The difference between managed and unmanaged code is as follows:

Managed Code - Managed Code is developed within the .NET framework. CLR directly executes such code by using managed code execution. Any language written in the .NET framework is considered to be managed code.

Unmanaged Code - Unmanaged code is any code developed outside the .NET framework. Unmanaged applications are not executed by CLR. Some languages like C++ can write unmanaged applications such as an application for accessing the low-level functions of the operating system. Some examples of unmanaged code include background compatibility with the code of VB, ASP, and COM.

Class and struct both are user-defined data types. However, they have some important differences:

Struct

Struct is a value type in C# that inherits values from System.Value
It is mostly used for small quantities of data
It cannot be inherited to any other type
A Struct cannot have abstract values.

Class

Class is a reference type in C#. Since it refers to objects, it inherits from System.Object
Classes are mostly used for large quantities of data
Classes can be inherited to other classes
Classes can have abstract values.
A default constructor can be created for classes.

Following are the differences between Task and Thread in C#:

Task is an object used in the Task Parallel Library (TPL) to represent an asynchronous operation, while a Thread is a separate path of execution in a program. Tasks are a higher level of abstraction than threads and are used to manage the execution of code in parallel.

Tasks are easier to use and manage than threads, and they can also be used to provide more efficient resource utilization. Threads on the other hand, provide a lower level of abstraction and are used to execute code directly in the processor.

Access specifiers help implement Encapsulation, in C#, is implemented by using access specifiers. A class member’s scope and visibility are defined by these access specifiers.
With public access specifiers, a class can expose its member variables and functions to other objects and functions. Once a member is public, it can be reached from outside the class.
With private access specifiers, a class can hide its member variables and functions from other objects and functions. The private members of a class can be accessed only by functions of the same class. Even instances of the same class do not have access to its private members.
Protected access specifiers are similar to private access specifiers because they cannot be accessed outside the class. However, protected class members can be accessed by any subclass of that class as well. This enables implementing inheritance.

A destructor is a special method in C# that is automatically called when an object is destroyed. It is used to free up any resources that the object may have been using, such as memory or files. Destructors are usually implemented in a class and are denoted by the keyword ~ followed by the class name.

For example, if a class called MyClass was to have a destructor, it would be declared as follows: ~MyClass().

Virtual methods in an interface have no method definition. The methods here are written to be overridden in the derived class and hence, they are publicly available.

The main difference between ref and out keywords in C# is that ref requires that the variable be initialized before being passed to the method whereas out keyword doesn’t require the variable to be initialized before being passed to the method.

The finally block always gets executed if there is an exception or not. When the code is executed in the try block and an exception occurs, control returns to the catch block, and in the end, the finally block gets executed. The finally block therefore can contain closing connections to the database and the release of file handlers.

Output:

79

Output:

500

Output:

11