Explore Course

What is C#?

C#, released in 2000, is a C-based programming language used for everything from desktop
applications to web services. Today, C# is one of the most popular programming languages in
the world — and it’s a language that is highly sought after in the programming field.

C# differs from C++ in a few major ways. The most obvious is that C# is a component-based
language, whereas C++ is an object-oriented language. C# is considered to be more heavyweight
than C++, but it’s used in many modern systems, such as game development kits.

Beginner C# Interview Questions and Answers

1. What is a class?

A class is a template to create an object. It contains properties as well as methods. We can

create many instances of objects from a single class.

Below is an example of a class:

public class Student

//data members

public int rollNumber { get; set; }

public string fullName { get; set; }

//function

public void PrintDetails()

//login of function

}
2. What are the main concepts of object-oriented programming?

Encapsulation, abstraction, polymorphism, and inheritance are the main concepts of object-
oriented programming. Be prepared to describe each of these. Object-oriented programming
differs from procedural programming insofar as procedural programming happens
chronologically, step-by-step, whereas object-oriented programming is far more flexible.

3. What is an object?

An object is an instance of a class through which we access the functions of that class. We can
use the “new” keyword to create an object. A class that creates an object in memory holds
information about the functions, data members, and behavior of that class.

See the syntax of an object below.

//Class

public class Employee

//private members

private string fName { get; set; }

private string lName { get; set; }

//function

public void Display()

[Link]("Full name is {0} {1}", fName, lName);

public void SetName(string firstName, string lastName)

fName = firstName;

lName = lastName;

}
 }

class Program

static void Main(string[] args)

//this is object

Employee employee = new Employee();

[Link]("John", "Grande");

[Link]();

4. What is a constructor, and what are its different types?

A constructor is like a method with the same name as the class, but it is a unique method. Even
if it is not created, the compiler creates a default constructor in memory at the time of creating
an object of the class.

The constructor is used to initialize the object with some default values.

Default constructor, parameterized constructor, copy constructor, static constructor, and private
constructor are all different constructor types.

Below are examples of different constructor types.

public class Student

private int rollNumber { get; set; }

private string fullName { get; set; }

//default constructor

public Student()
 {

//code goes here

//parameterized constructor

public Student(int rNum, string fName)

[Link] = rNum;

[Link] = fName;

//static constructor

static Student()

//code goes here

//copy constructor

public Student(Student student)

rollNumber = [Link];

fullName = [Link];

5. What is a destructor in C#?

A destructor clears out the memory to free up resources and is managed automatically by the
garbage collector. [Link]() is called internally for this purpose. However, if required,
it can be done explicitly using a destructor.

public class Purchase

//Syntax to write a destructor.

~Purchase()

//code here to release resources.

6. Is C# code managed or unmanaged code?

C# is managed code because Common Language Runtime compiles the code to intermediate
language code. C++ would provide examples of unmanaged code. Managed code simply refers
to code that has its execution managed by the runtime.

7. What are value types and reference types?

We can categorize variables into value type and reference type. Variables of value type contain
the value directly while a reference type variable contains the reference of the memory address
where the value is stored actually in the memory.

Bool, byte, int, char, and decimal are value types.

String, class, delegates are reference types.

Below is the pictorial representation of the value type.

Below is the pictorial representation of the reference type.

8. What is a namespace and is it compulsory?

A namespace is a way of organizing classes of the same group or functionality under the same
name. We can call it a module. Although it is not compulsory to put class in a namespace.

Refer to the syntax below.

namespace demoapp

class SomeClass

public static void someMethod()

[Link]("Creating my namespace");

9. Explain types of comments in C# with examples.

There are three types of comments in C#.

 Single line comments

  Multiline comments

 XML comments

An example of a single-line comment is:

//Hey, this is a single line comment

An example of a multiline comment is:

/*This is a multiline comment

written in two lines2*/

An example of an XML comment is:

10. Please explain encapsulation.

Encapsulation is a process of wrapping function and data members together in a class; it’s like a
capsule, a single unit.

Encapsulation prevents an unauthorized or unwanted change of data from outside of the

function. It is used for better control and standardization of your code.

Below is an example of encapsulation.

class User

private string address;

private string name;

public string Address

get

return address;

set

address = value;
 }

public string Name

get

return name;

set

name = value;

class MyProgram

static void Main(string[] args)

User u = new User();

// set accessor will invoke

[Link] = "Ravi";

// set accessor will invoke

[Link] = "New Delhi";

// get accessor will invoke

[Link]("Name: " + [Link]);

// get accessor will invoke

 [Link]("Location: " + [Link]);

[Link]("\nPress Enter Key");

[Link]();

11. What is an abstraction?

Abstraction is the method of exposing only the required features of the class and hiding
unnecessary information.

We can try to understand it with the example of a motorbike:

A rider knows the color, name, and model of the bike. Still, they do not know the internal engine
and exhaust functionality. Likewise, abstraction focuses on providing access for a specific
functionality without exposing how that functionality works internally.

12. What is polymorphism?

Polymorphism means the same method but different implementation. There are two types of
polymorphism.

1. Compile-time polymorphism is achieved by method overloading as seen in the example

below.

public class cellphone

//function with the same name but different parameters.

public void Typing()

[Link]("Using keypad");

public void Typing(bool isSmartPhone)

[Link]("Using qwerty keyboard");

 }

2. Run time polymorphism is achieved by method overriding as seen in the example

below.

public class CellPhone

public virtual void Typing()

[Link]("Using keypad");

public class SmartPhone : CellPhone

//method override

public override void Typing()

[Link]("Typing function from child class");

13. Define an interface and show an example.

An interface is another form of an abstract class that has only abstract public methods. These
methods only have the declaration and not the definition. A class implementing the interface
must have the implementation of all the methods of the interface.

For example:

interface IPencil

{
 void Write(string text);

void Sharpen(string text);

class Pencil : IPencil

public void Write(string text)

//some code here

public void Sharpen(string text)

//some code here

public class CellPhone

public virtual void Typing()

[Link]("Using keypad");

14. What is inheritance?

A class can inherit data members and methods from another class, which is known as its parent
class. The class that inherits properties and methods will be called a child class, derived class, or
subclass. Some properties can be overridden in the derived class.

The ability to inherit characteristics from classes makes the entire process of managing classes
much easier, as you can create subclasses that are customized. The originating class will be
called either a parent class or base class.

Refer to the below example:

class Mobile // base class (parent)

public void call()

[Link]("calling...!");

class Nokia : Mobile // derived class (child)

public string modelName = "Nokia";

class MyProgram

static void Main(string[] args)

// Create a myNokia object

Nokia myNokia = new Nokia();

 // Calls the call() method (From the Mobile class) on the myNokia object

[Link]();

Intermediate C# Programming Questions

15. How would you implement multiple interfaces with the same method name in the same
class?

To implement multiple interfaces with the same method name, you would avoid
implementation within the body of the function. Instead, you would explicitly provide the name
of the interface to the body of the method. The compiler will understand which interface
methods are being referred to, therefore resolving the issue.

This can be seen in the following example:

interface myInterface1

void Print();

interface myInterface2

void Print();

class Student : myInterface1,

myInterface2

void [Link]()

[Link]("For myInterface1 !!");

}
 void [Link]()

[Link]("For myInterface2 !!");

16. What is the virtual method and how is it different from the abstract method?

A virtual method must have a default implementation, and we can override this virtual method
using the override keyword in the derived class.

The abstract method is without implementation and is created inside the abstract class only. In
the case of an abstract class, the class derived from the abstract class must have an
implementation of that abstract method.

Here’s an example of virtual method:

public class CellPhone

public virtual void Typing()

[Link]("Using old keypad");

public class SmartPhone : CellPhone

public override void Typing()

[Link]("Using qwerty keyboard");

}
Here’s an example of an abstract method:

public abstract class CellPhones

//no default implementation

public abstract void Typing();

public class OldPhones : CellPhones

//function override

public override void Typing()

[Link]("Using keypad");

public class SmartPhones : CellPhones

//function override

public override void Typing()

[Link]("Using Qwerty keyboard");

17. What is method overloading and method overriding?

Both method overloading and overriding are a type of polymorphism.

  Method overloading is when we have a function with the same name but a different
signature.

 Method overriding is when we override the virtual method of a base class in the child
class using the override keyword.

18. What is the static keyword?

We use the static keyword to create a static class, a static method, or static properties.

When we create a static class there can be only static data members and static methods in that
class.

Static means that we cannot create the instance of that class. That class can be used directly like
[Link].

When there is a need for special functions, which are typical for all the instances of other
classes, then we use static class.

For example, there is a requirement to load some default application-level values. We create a
static class with static functions. That class is then accessible to all other classes without
creating any instance. It also shares the same data with all the classes.

Refer to the below example:

public static class Setting

public static int fetchDefault()

int maxAmount = 0;

//code to fetch and set the value from config or some file.

return maxAmount;

public class Sales

{
 //not required to create an instance.

int maxAmount = [Link]();

19. Can we use “this” with the static class?

No.

“This” cannot be used with a static class because we can only use static variables and static
methods in the static class.

20. What is the difference between constants and read-only?

There are a few differences:

C# (programming language) students also learn

Unity Game Development Fundamentals 2D Game Development 3D Game

Development .NET [Link] Core Object-Oriented Programming (OOP) C (programming
language) Programming Fundamentals Game Design [Link] [Link] MVC Microsoft Visual
Studio Entity Framework

 Constant variables have to be assigned a value at the time of declaration only, and we
cannot change the value of that variable throughout the program.

 We can assign the value to the read-only variable at the time of declaration or in a
constructor of the same class.

Here is an example of constants:

using System;

namespace demoapp

class DemoClass

// Constant fields

public const int myvar = 101;

public const string str = "staticstring";

 // Main method

static public void Main()

// Display the value of Constant fields

[Link]("The value of myvar: {0}", myvar);

[Link]("The value of str: {0}", str);

Here is an example of read-only:

using System;

namespace demoapp

class MyClass

// readonly variables

public readonly int myvar1;

public readonly int myvar2;

// Values of the readonly

// variables are assigned

// Using constructor

public MyClass(int b, int c)

myvar1 = b;

myvar2 = c;
 [Link]("Display value of myvar1 {0}, " +

"and myvar2 {1}", myvar1, myvar2);

// Main method

static public void Main()

MyClass obj1 = new MyClass(100, 200);

21. What is the difference between string and string builder in C#?

A string is an immutable object. When we have to do some actions to change a string or append
a new string it clears out the old value of the string object, and it creates a new instance in
memory to hold the new value in a string object. It uses [Link] class, for example.

using System;

namespace demoapp

class StringClass

public static void main(String[] {

string val = "Hello";

//creates a new instance of the string

val += "World";

[Link](val);

}
}

StringBuilder is a mutable object, meaning that it creates a new instance every time for the
operations like adding string (append), replace string (replace). It uses the old object only for
any of the operations done to the string and thus increases the performance. It uses
[Link] class, for example.

using System;

using [Link];

namespace demoapp

class StringClass

public static void main(String[] {

StringBuilder val = new StringBuilder("Hello");

[Link]("World");

[Link](val);

The output of both the program is the same, “Hello World.”

22. Explain the “continue” and “break” statement.

We can use continue and break statements in a loop in C#. Using a break statement, we can
break the loop execution, while using the continue statement, we can break one iteration of the
loop.

Here’s an example of the break statement:

using System;

namespace demoapp

class LoopingStatements
 {

public static void main(String[] args)

for (int i = 0; i <= 5; i++)

if (i == 4)

break; //this will break the loop

[Link]("The number is " + i);

[Link]();

} //control will jump here after the break statement.

Here is the same example with a continue statement:

using System;

namespace demoapp

class LoopingStatements

public static void main(String[] args)

for (int i = 0; i <= 5; i++)

if (i == 4)
 {

continue;// it will skip the single iteration

[Link]("The number is " + i);

[Link]();

23. What are boxing and unboxing?

Conversion of value type datatype to reference type (object) datatype is called boxing.

For example:

namespace demoapp

class Conversion

public void DoSomething()

int i = 10;

object o = i;

Unboxing is the conversion of reference type datatype to value type.

For example:

namespace demoapp
{

class Conversion

public void DoSomething()

object o = 222;

int i = (int)o;

24. What is a sealed class?

We use a “sealed” keyword to create a sealed class. Classes are created as a sealed class when
there is no need to inherit that further or when there is a need to restrict that class from being
inherited.

Refer to the syntax below.

public sealed class MyClass

//properties and methods

25. What is a partial class?

There is a feature in the C# language to divide a single class file into multiple physical files. To
achieve this, we have to use the “partial” keyword. At compile time, it is logically one file only;
we cannot have a method with the same name or a variable with the same name in two
different partial class files.

Here, to facilitate the developers to break down the big class files into multiple small physical
files, this feature is provided.

26. What is enum?

The “enum” keyword is frequent across many languages. An enum is a type of value. It serves as
a collection of related constants, which are referred to as an enumerated list.

An enum can be int, float, double, or byte. But if it’s not an int, explicit casting is required.

The .NET framework enum can be used to create a numeric constant. Int is the default of the
enumeration element. By default, the first enumerator has the value 0, and each successive
enumerator is increased by 1, much like an array.

Refer to the below syntax:

enum Day { Sat, Sun, Mon, Tue, Wed, Thu, Fri };

27. What is dependency injection, and how can it be achieved?

Dependency injection is a design pattern. Instead of creating an object of a class in another class
(dependent class) directly, we are passing the object as an argument in the constructor of the
dependent class. It helps to write loosely coupled code and helps to make the code more
modular and easy to test.

There are three ways to achieve dependency injection:

 Constructor injection: This is the most commonly used Injection type. In constructor
injection, we can pass the dependency into the constructor. We have to make sure that
we do not have a default constructor here, and the only one should be a parameterized
constructor.

 Property injection: There are cases when we need the default constructor of a class, so
in that case, we can use property injection.

 Method injection: In method injection, we need to pass the dependency in the method
only. When the entire class does not require that dependency, there is no need to
implement constructor injection. When we have a dependency on multiple objects, then
instead of passing that dependency in the constructor, we pass that dependency in the
function itself where it is required.

28. Please explain the “using” statement.

The keyword “using” is used to define the scope of the resources used in that using statement
block. All the resources used inside the using code block get disposed of once the code block
completes execution.

Refer to the below example.

class Books : IDisposable

 {

private string _name { get; set; }

private decimal _price { get; set; }

public Books(string name, decimal price)

_name = name;

_price = price;

public void Print()

[Link]("Book name is {0} and price is {1}", _name, _price);

public void Dispose()

throw new NotImplementedException();

class Students

public void DoSomething()

using (Books myBook = new Books("book name", 12.45))

 {

[Link]();

29. What are the access modifiers? Explain each type.

Access modifiers are keywords used to provide accessibility to a class, member, or a function.

Below are its types:

 Public: Can be accessed anywhere without any restriction

 Protected: Access is limited up to the class, which inherits this class

 Internal: Can be accessed only within the current assembly

 Private: Cannot be accessed outside

Syntax of access modifier:

public class Product

public void Print()

//code to print something.

30. What are delegates?

Delegates are like function pointers, it is a reference data type that holds the reference of a
method. We use delegates to write generic type-safe functions. All delegates derive from
[Link].

A delegate can be declared using the delegate keyword followed by a function signature, as
shown below.

These are the characteristics of delegates:

  Delegates derive from the [Link] class

 Delegates have a signature as well as return type. A function assigned to delegates must
be fit with this signature

 Delegates can point to instance methods or static

 Delegate objects, once created, can dynamically invoke the methods it points to at
runtime

 Delegates can call methods synchronously and asynchronously

Refer to the below example:

Empower your team. Lead the industry.

Get a subscription to a library of online courses and digital learning tools for your organization
with Udemy Business.

Request a demo

using System;

namespace demoapp

class DelegateClass

// declare delegate

public delegate void Print(int value);

static void Main(string[] args)

// Print delegate points to PrintNumber

Print printDel = PrintNumber;

// or

// Print printDel = new Print(PrintNumber);

 printDel(100000);

printDel(200);

// Print delegate points to PrintMoney

printDel = PrintMoney;

printDel(10000);

printDel(200);

public static void PrintNumber(int num)

[Link]("Number: {0,-12:N0}", num);

public static void PrintMoney(int money)

[Link]("Money: {0:C}", money);

31. What are the different types of delegates?

There are three types of delegates:

 Single delegates can invoke a single method

 Multicast delegates can invoke multiple methods. The delegate method can do
multicasting. We can add a method in the delegate instance using + operator, and we
can remove a method using – operator. All the methods are invoked in sequence as they
are assigned.
  Generic delegates are introduced by .Net Framework 3.5. There is no need to create an
instance in a generic delegate.

32. What is an array? Explain single and multi-dimensional arrays.

The array stores the value of the same type. It is a collection of variable stores into a memory
location.

For example:

int[] marks = new int[3] { 25, 34, 89 };

A single-dimensional array is a linear array. Single-dimensional array stores variables in a single

row. The above example is a single-dimensional array.

Arrays can have more than one dimension. Multi-dimensional arrays are also called rectangular
arrays.

For example:

int[,] numbers = new int[3, 2] { { 1, 2 }, { 2, 3 }, { 3, 4 } };

33. What is the difference between the [Link]() and [Link]() ?

Using the Clone() method, we can create a new array object containing all the elements of the
original array and using the CopyTo() method. All the items of existing array copies into another
existing array. Both ways create a shallow copy.

34. What is the difference between array and ArrayList?

An array and ArrayList are similar. When you want to store items of the same type, you can use
an array. An array has a fixed size. When you want to store any type of data, we use an ArrayList.
An ArrayList doesn’t have a fixed size.

Refer to the example of an array and ArrayList:

using [Link];

namespace demoapp

class Sample

//Array and Araraylist.

public void ArrayFunction()

 {

string[] country = new string[3];

country[0] = "USA"; //only string value can be added

country[1] = "Denmark";

country[2] = "Russia";

//can store different data types

ArrayList arraylist = new ArrayList();

[Link](3);

[Link]("USA");

[Link](false);

35. What is a jagged array in C#?

A jagged array is like a nested array where each element of a jagged array is an array in itself.
The item of a jagged array can be of different dimensions and sizes.

A jagged array is a special type of array introduced in C#. A jagged array is an array of an array in
which the length of each array index can differ.

Refer to the below example:

namespace demoapp

public class JaggedArrayClass

public void ShowJaggedArray()

int[][] jaddedArray = new int[2][];

 jaddedArray[0] = new int[3] { 1, 2, 3 };

jaddedArray[1] = new int[4] { 1, 2, 3, 4 };

36. What is the difference between struct and class?

Class and struct are both user-defined but have significant differences.

A struct inherits from [Link] type, thus it’s a value type. Structs are preferable when
there is a small amount of data. A structure cannot be abstract. There is no need to create an
object with a new keyword. Struct does not have permission to create any default constructor.

Syntax of struct:

struct MyStruct

public int MyProperty1 { get; set; }

public int MyProperty2 { get; set; }

A class is a reference type in C#, and it inherits from the [Link] Type. When there is a
large amount of data, classes are used. We can inherit one class from another class. A class can
be an abstract type.

37. What is the difference between “throw” and “throw ex”?

The “throw” statement will keep the original error stack of the previous function, while the
“throw ex” statement will retain the stack trace from the throw point. Usually, it’s advised to
use “throw” because it provides exact error information and trace data.

38. Explain the difference between “finally” and “finalize block”?

These are two different concepts, though they sound similar:

  Finally is a code block part of execution handling. This code block executes irrespective
of whether the exception occurs or not.

 Finalize is a method called just before garbage collection. The compiler calls this method
automatically when not called explicitly in code.

Thus, finally is related to execution handling, whereas finalize is used relative to garbage
collection.

39. Explain var and dynamic.

We can declare the var type of a variable without specifying the .net data types explicitly. The
compiler automatically detects the type of a variable at the compile-time based on the value
assigned to it. We cannot declare a var type variable without assigning a value to it. The value of
the var type variable cannot be changed later in the code.

Dynamic is the opposite of var. We can change the value of a variable of type dynamic in the
code later. It also decides the type of the variable based on the value assigned to it.

Like at the time of creating a variable of type dynamic, a value of integer type is assigned to it,
then also in the code further, we can assign a string type value to that variable. It holds the last
changed value and acts like the data type of the latest values it holds.

Let us see the example to understand it in more detail.

public class Bike

dynamic someValue = 21;

public Bike()

//assigned string value later

someValue = "Hello";

In the above example, if we declare the variable “someValue” to type var instead of dynamic, it
throws an error. The reason for that error is that in the next line, we changed the value of the
variable and assigned a string value.
Advanced C# Programming Questions

40. What are Anonymous types in C#?

Sometimes we may need to create a new type without defining it. This will be known as an
anonymous type. This is helpful when there is a need to define read-only properties in a single
object without defining each type.

Here, a compiler generates type and is accessible only for the current block of code.

Refer to the below example.

public class SomeClass

public void print()

var anonymousData = new

FirstName = "John",

SurName = "lastname"

};

[Link]("First Name : " + [Link]);

41. What is multithreading, and what are its different states?

Any code block in C# runs in a process called a thread. A thread is the execution path of the
program. Simple applications can run on a single thread, but today’s programs frequently use
multithreading. Multithreading divides the execution of the process among multiple threads to
execute it simultaneously and, consequently, more efficiently.

Through multithreading, we can run more than a single task at a time. Programs are more
efficient and fast. But we also need to understand how threads work.

Each thread has its lifecycle, which includes various states of thread:
  Unstarted State: In this state, the compiler creates the instance of the thread but waits
for the start method.

 Started: It is the state when the thread is ready to run and waiting for the CPU cycle.

 Not Runnable State: A thread is not executable in the below conditions.

o When we call the “sleep” or “wait” method.

o I/O operations block the thread.

42. How is exception handling done in C#?

Exception handling is managed through a try, catch, finally, and throw model. These are the
keywords used throughout the model.

Below is the explanation of each keyword:

 Try: We keep the code in the try block for which we want to handle the exception.

 Catch: When any exception occurs in a try block, then it is caught in a catch block with
the help of an exception handler.

 Finally: To execute a code block irrespective of error, we place that code in the finally
block to get executed.

 Throw: Throws an exception when an issue occurs.

Below is the example of exception handling:

public class SomeClass

public void GetData()

try

//write some code here

catch (Exception)

{
 throw;

finally

/*code to execute in the last

like dispose objects and resource*/

43. What are custom exceptions?

Custom exceptions are used for errors that are being caught per user requirements rather than
built into the compiler. Custom exceptions are an easy way to instance user-defined exceptions.

Refer to the below example:

public class Purchase

public void DoPurchase(int quantity)

if (quantity == 0)

//this will throw error here with the custom message

throw new Exception("Quantity cannot be zero");

44. What is LINQ in C#?

LINQ refers to Language INtegrated Query. LINQ is a method of querying data using .NET
capabilities and a C# syntax that’s similar to SQL.
The advantage of LINQ is that we can query different sources of data. The data source could be
either a collection of objects, XML files, JSON files, in-memory data or lists or database objects.
We can easily retrieve data from any object that implements the IEnumerable<T> interface.

Below is the syntax of LINQ.

public class Devices

public void GetData()

List<string> mobiles = new List<string>() {

"Iphone","Samsung","Nokia","MI"

};

//linq syntax

var result = from s in mobiles

where [Link]("Nokia")

select s;

45. What is serialization?

When we want to send an object through a network, then we have to convert that object into a
stream of bytes. Serialization is the process of converting an object into a stream of bytes. To
facilitate the object for serializable, it should implement ISerialize Interface. The process of de-
serialization is the reverse process of creating an object from a stream of bytes.

46. What are generics in C#?

Generics in C#:

 increase performance.

 increase type safety.

  reduce repeated code.

 make reusable code.

Using generics, we can create collection classes. It is preferred to use

[Link] namespace instead of classes such as ArrayList in the
[Link] namespace to create a generic collection.

Generics encourage the usage of parameterized types as seen in the example below:

using System;

namespace demoapp

//We use < > to specify Parameter type

public class GFG<T>

//private data members

private T data;

//using properties

public T value

/using accessors

get

return [Link];

set

[Link] = value;

}
 }

//vehicle class

class Vehicle

//Main method

static void Main(string[] args)

//instance of string type

GFG<string> company = new GFG<string>();

[Link] = "Tata motors";

//instance of float type

GFG<float> version = new GFG<float>();

[Link] = 6.0F;

//display Tata motors

[Link]([Link]);

//display 6

[Link]([Link]);

47. What is reflection?

Reflection is a particular class in C# used to access the metadata of the assembly or the class.

The following information can be retrieved using reflection:

 Assembly name

 Class name

 Method name

 Object type

 It Identifies properties and methods.

48. How to use nullable types?

A null value can be assigned to a variable in C#. These types are called nullable types. Most
variable types are nullable types.

Example below:

namespace demoapp

class Calculate

int? number = null;

public Calculate(int num)

number = num;

public void DoCalculation()

if ([Link])

//do something
 }

49. Which is the parent class of all classes which we create in C#?

This is a simple question to answer:

[Link].

50. Explain code compilation in C#.

A programmer writes code that is readable to people. That code is then fed into a C# compiler.
The C# compiler will compile the code into efficient, machine-readable, managed code, known
as bytecode. Then, the Just in Time Compiler (JIT) will compile the bytecode into native or
machine language. When the program is run, it is this code that will be directly executed by the
CPU.

51. What is a hashtable in C#?

A hashtable is a collection of pairs, generally “keys” and “values.” Frequently, you will hear
about “hashtables” in regards to passwords; a password hash can be created for a given
password. But a hashtable itself is just a general-purpose collection of key objects and value
objects, in which the values have to be accessed using the keys; they cannot be accessed
otherwise.

52. How can you create a derived class object from a base class?

This is a trick question! You cannot. A derived class will inherit variables and methods from the
base class. Further, a derived class can have only a single base class. You would need to do your
work with your base class directly.

53. What is an immutable string?

An immutable string is an object that cannot be changed, although you can change the
reference to it. In general, an immutable string should be used whenever you have a constant
that absolutely should not be changed. However, you should use this trick sparingly because an
immutable string may throw an error if you try to change it later.

54. What is reflection in C#?

Reflection refers to methods and processes by which a system is able to look at and modify
itself. In C#, reflection would refer to inspecting the contents of a system. It needs to be
included manually within C# through the “[Link]” namespace. Reflection is
particularly useful to debugging tools.

55. What is a generic class?

A generic class is a class that can handle any type. This is unique because most classes follow
strict typing; you have to declare a type, and that type has to be consistent. Defining a generic
class would go as follows:

class dataStore<T> {

public T data {

get; set;

56. What is the params keyword, and how to use it?.

By using the params keyword, you can specify a method parameter that takes a variable number
of arguments. The parameter type must be a single-dimensional array.

public static void CalcListSum(params int[] list)

int sum =0

for (int i = 0; i < [Link]; i++)

sum+=list[i];

[Link]("The sum is " + sum);

57. What is NuGet?

NuGet is a package manager for developers. It enables developers to share and consume useful
code. A NuGet package is a single ZIP file that bears a .nupack or .nupkg filename extension and
contains .NET assemblies and their needed files.

58. What are DLL files, and what are the advantages of using them?
A DLL is a library that contains code and data that can be used by more than one program at the
same time. Each program can use the functionality that is contained in a DLL. This helps
promote code reusability and efficient memory usage.

By using a DLL, a program can be modularized into separate components. Because the modules
are separate, the load time of the program is faster. And a module is only loaded when that
functionality is requested.

Additionally, updates are easier to apply to each module without affecting other parts of the
program. When these changes are isolated to a DLL, you can apply an update without needing
to build or install the whole program again.

59. What does POCO mean?

POCO stands for Plain Old CLR Objects. A POCO is a class that doesn’t depend on any
framework-specific base class. It is like any other normal .NET class. Hence the name Plain Old
CLR Objects. These POCO entities (also known as persistence-ignorant objects) support most of
the same LINQ queries as Entity Object derived entities.

60. What is a DTO?

A Data Transfer Object (commonly known as a DTO) is usually an instance of a POCO (plain old
CLR object) class used as a container to encapsulate data and pass it from one layer of the
application to another. You would typically find DTOs being used in the service layer (backend)
to return data back to the presentation layer (frontend).

Referring to the above questions and answers gives us in-depth knowledge of all essential
concepts of C# language. These technical answers can help to sharpen our knowledge and help
to increase our comprehension of the language. If you need to brush up on C#, a bootcamp or
refresher course can help.

Page Last Updated: November 2021