C# Questions Part 1

1. What is a class?

A class is a template to create an object. It contains properties as well as methods.
Whereas an Object is a real-time entity, consisting of state (look & feel) and behavior (what it does)

1
2
3
4
5
6
7
8
9
10
11
12
public class Student
{
   //data members
   public int rollNumber { get; set; }
   public string fullName { get; set; }
 
   //method
   public void PrintDetails()
   {
      //code of method
   }
}

2. What are the main concepts of OOPs?

Encapsulation, abstraction, polymorphism, and inheritance are the main concepts of object-oriented programming.

3. Explain Encapsulation

Encapsulation is a process of wrapping functions and data members together in a class. It is like a capsule, a single unit.

Encapsulation is to prevent the unauthorized or unwanted change of data from outside of the function.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
   class User
    {
        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   
            u.Name = "Denis";
            // set accessor will invoke             
            u.Address = "Germany";
            // get accessor will invoke             
            Console.WriteLine("Name: " + u.Name);
            // get accessor will invoke             
            Console.WriteLine("Location: " + u.Address);
            Console.WriteLine("\nPress Enter Key");
            Console.ReadLine();
        }
    }

4. What is abstraction?

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

A rider knows the color, name, and model of the bike. Still, he does not know the internal engine and exhaust functionality.

So abstraction focuses on providing access to a specific functionality without exposing how that functionality works internally.

5. What is polymorphism?

Polymorphism means the same method but a different implementation.

2 types of polymorphism.

Compile-time polymorphism – achieved by method overloading

1
2
3
4
5
6
7
8
9
10
11
12
public class cellphone
{
        //function with the same name but different parameters.
        public void Typing()
        {
            Console.WriteLine("Using keypad");
        }
        public void Typing(bool isSmartPhone)
        {
            Console.WriteLine("Using qwerty keyboard");
        }
}

Run time polymorphism – achieved by method overriding

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    public class CellPhone 
    { 
        public virtual void Typing() 
        { 
            Console.WriteLine("Using keypad"); 
        } 
    }
    public class SmartPhone : CellPhone
    {         
        //method override         
        public override void Typing()         
        {             
            Console.WriteLine("Typing function from child class");         
        } 
    }

6. What is Inheritance in C#?

When we create a class that can inherit the data members and the methods of another class (Parent class), it is called inheritance.

The class that inherits the properties and method is called a child class, derived class, or subclass.

A class from which the child class inherits its properties and methods is a parent class or base class.

Note: C# doesn't support multiple inheritance using classes, like Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
 
public class A
{
   private int value = 1337;
   public class B : A
   {
       public int GetValue()
       {
           return this.value;
       }
   }
}
public class InheritanceExample
{
    public static void Main(string[] args)
    {
        var b = new A.B();
        Console.WriteLine(b.GetValue());
    }
}

Output will be 1337, even though Class B doesn’t directly have any value.

7. 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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//Class
 
     public class Employee
     {
        //private members
        private string fName { get; set; }
        private string lName { get; set; }
 
        //  Method (function in a class)
        public void Display()
        {
            Console.WriteLine("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();
            employee.SetName("John", "Grande");
            employee.Display();
        }
 
    }

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

A constructor is like a method with the same name as the class. 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 different constructor types.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 public class Student
    {
        private int rollNumber { get; set; }
        private string fullName { get; set; }         
        
        //default constructor          
        public Student()          
        {                     
        }          
        
        //parameterized constructor          
        public Student(int rNum, string fName)          
        {              
            this.rollNumber = rNum;              
            this.fullName = fName;          
        }          
        
        // private constructor
        private ClassName()
        {
        }

        //static constructor          
        static Student()          
        {                       
        }          
        
        //copy constructor          
        public Student(Student student)          
        {              
            rollNumber = student.rollNumber;              
            fullName = student.fullName;          
        }   
    }

Static constructor: Used to initialize any static members of a class.

Static members are shared among all instances of the class.

No Parameters: Unlike instance constructors, static constructors cannot have parameters.

No access modifiers: They are implicitly private.

Automatic Invocation: The static constructor is automatically invoked by the runtime before any static members are accessed or any static methods are called, and it's guaranteed to execute only once.

Order of Execution: If a class has both an instance constructor and a static constructor, the static constructor is executed before the instance constructor.

Private constructor: Used to prevent direct creation of an object using the new keyword. An example can be the Singleton design pattern, Static classes (all constructors are private), and Classes with only static members.

Copy constructor: Used to create a new object by copying the values from an existing object of the same type.

9. What is a destructor in C#?

The Destructor clears out the memory to free up resources. It is managed automatically by the garbage collector. System.GC.collect() is called internally for this purpose. However, if required, it can be done explicitly using a destructor.

1
2
3
4
5
6
7
8
    public class Purchase
    {         
        //Syntax to write a destructor.         
        ~Purchase()         
        {             
        //code here to release resources.
        }
    }

10. Is C# code managed or unmanaged code?

C# is managed code.

Managed code is code that is written in languages such as C#, Visual Basic.NET, or F# and is executed by the Common Language Runtime (CLR) in the .NET Framework or .NET Core.

The CLR provides various services such as automatic memory management (garbage collection, allocation, and deallocation), exception handling, and security enforcement.

On the other hand, unmanaged code typically refers to code that is written in languages like C or C++, where the programmer has direct control over memory and other system resources.

11. What are value types and reference types?

Based on memory allocation, data types can be value types and reference types.

Value types:

Store the value in a stack
Classified in

Structs: bool, byte, int, long, short, float, double, char, decimal, struct,
Enums

Reference types:

Store the value in the heap and its reference in the stack
Classified in

String, array, dynamic, object, class, interface, and delegates

Note: Arrays can store elements of either value types or reference types, depending on the type of elements they hold.

12. What are namespaces, and are they 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 a class in a namespace.

1
2
3
4
5
6
7
8
9
10
namespace demoapp
{
    class SomeClass
    {
        public static void someMethod()
        {
            Console.WriteLine("Creating my namespace");
        }
    }
}

13. Explain the types of comments in C # with examples.

There are three types of comments in C #.

Single line comments - //
Multiline comments - /* ... */
XML comments - ///

14. What is an interface? Give an example.

An interface is another form of an abstract class that has only abstract public methods, and 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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
     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
        }
     }

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

If we want to implement multiple interfaces with the same method name, then we cannot directly implement the body of the function. We have to explicitly provide the name of the interface to implement the body of the method. In this way, the compiler decides which interface methods we are referring to, and this resolves the issue.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
     interface myInterface1
     {
        void Print();
     }
     interface myInterface2
     {
        void Print();
     }
     class Student: myInterface1, myInterface2
     {
        void myInterface1.Print()
        {
            Console.WriteLine("For myInterface1 !!");
        }
 
        void myInterface2.Print()
        {
            Console.WriteLine("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 it 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.

Example of a virtual method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class CellPhone
     {
        public virtual void Typing()
        {
            Console.WriteLine("Using old keypad");
        }
     }
 
    public class SmartPhone: CellPhone
     {
        public override void Typing()
        {
            Console.WriteLine("Using qwerty keyboard");
        }
}

Example of an abstract method.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public abstract class CellPhones
     {
        //no default implementation
        public abstract void Typing();
     }
 
     public class OldPhones: CellPhones
     {
        //function override
        public override void Typing()
        {
            Console.WriteLine("Using keypad");
        }
     }
 
     public class SmartPhones: CellPhones
     {
        //function override
        public override void Typing()
        {
            Console.WriteLine("Using Qwerty keyboard");
        }
}

17. What is method overloading and method overriding?

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.

Both method overloading and overriding are types of polymorphism.

18. What is the static keyword?

We use the “static” keyword to create:

static class,
static method,
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 an instance of that class. That class can be used directly like ClassName.methodName.

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 = Setting.fetchDefault();
     }

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

No, we cannot use “this” with the static class or methods because this represents the current object instance of a class, and static classes/members do not have instances.

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

Constant:

Must be initialized at the time of declaration and cannot be changed afterward
They are implicitly static and belong to the class, making them accessible using the class name without creating an instance

Read-only:

Can be initialized either at the time of declaration or in the constructor of the class
Once initialized, their values cannot be changed.
They are instance-specific and belong to a particular object of the class. They can only be accessed using an instance of the class.

Here is an example of constants.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 
            Console.WriteLine("The value of myvar: {0}", myvar);
            Console.WriteLine("The value of str: {0}", str);
        }
    }
}

Here is an example of read-only.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
 
namespace demoapp
{
    class MyClass
    {
        // readonly variables 
        public readonly int myvar1;
        public readonly int myvar2;
        // Values of the readonly 
        // variables are assigned 
        // Using a constructor 
        public MyClass(int b, int c)
        {
            myvar1 = b;
            myvar2 = c;
            Console.WriteLine("Display value of myvar1 {0}, " +
             "and myvar2 {1}", myvar1, myvar2);
        }
 
        // Main method 
        static public void Main()
        {
            MyClass obj1 = new MyClass(100, 200);
        }
    }
}

Note:
Use constants when we have values known at compile-time that should not change, and use read-only fields when we need to set the value at runtime but want to prevent further modifications after initialization.

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 a System.String class, for example.

1
2
3
4
5
6
7
8
9
10
11
12
13
using System;
namespace demoapp
{
    class StringClass
    {
        public static void Main(String[] args) {
            string val = "Hello";
            //creates a new instance of the string 
            val += "World";
            Console.WriteLine(val);
        }
    }
}

StringBuilder is a mutable object. It means that it creates a new instance every time for operations like adding a string (append) or replacing a string (replace). It uses the old object only for any of the operations done to the string and thus increases the performance. It uses a System.Text.StringBuilder class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Text;
 
namespace demoapp
{
    class StringClass
    {
        public static void Main(String[] args) {
            StringBuilder val = new StringBuilder("Hello");
            val.Append("World");
            Console.WriteLine(val);
        }
    }
}

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

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.

An example of the break statement.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
                }
                Console.WriteLine("The number is " + i);
                Console.ReadLine();
            }  //control will jump here after the break statement.
        }
    }
}

Here is the same example with a continue statement.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
                }
                Console.WriteLine("The number is " + i);
                Console.ReadLine();
            }
        }
    }
}

23. What are boxing and unboxing?

Conversion of a value type to a reference type (object) is called boxing.
In the Boxing process, a value type is allocated on the heap rather than the stack

1
2
3
4
5
6
7
8
9
10
11
12
For Example:
namespace demoapp
{
    class Conversion
    {
        public void DoSomething()
        {
            int i = 10;
            object o = i;
        }
    }
}

Unboxing is the conversion of a reference type to a value type.
In the unboxing process, an unboxed value is allocated to a variable in the stack rather than the heap.

1
2
3
4
5
6
7
8
9
10
11
namespace demoapp
{
    class Conversion
    {
        public void DoSomething()
        {
            object o = 222;
            int i = (int)o;
        }
    }
}

24. What is a sealed class?

Classes are created as sealed classes when there is no need to inherit from that class further.

1
2
3
4
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. So we cannot have a method with the same name or a variable with the same name in two different partial class files.

26. What is enum?

An enum is a set of Constants
To create an enum, the “enum” keyword is used, and the enum items are listed with a comma, directly inside a namespace, class, or structure
An enum is a value type
Used to assign constant names to a group of integer values
The default underlying type of an enum is int
The default value for 1st element is zero and gets incremented by 1
Enum is converted into an abstract class behind the scenes

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

If values are not assigned to enum members, then the compiler will assign an integer value to each member starting with ZERO by default

Explicit casting is required to convert from an enum type to its underlying integral type

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

Dependency injection is a design pattern
Achieved using interfaces (classes can communicate through interfaces rather than concrete classes)
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 us easily test

There are 3 ways to achieve dependency injection.

Constructor Injection:

In constructor injection, we can pass the dependency class object through 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.

Setter or 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.

28. The “using” statement.

There are 2 purposes for using keywords in C #:

Using directive
Using statement: Ensures that the DISPOSE() method of the class object is called even if an exception occurs.

All the resources used inside the code block get disposed of once the code block completes execution.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
     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()
        {
            Console.WriteLine("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))
            {
                myBook.Print();
            }
        }
      }

Using keyword can be used with any class that is inherited from the IDisposable class. For e.g., StreamReader, SQLConnection

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

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

Public: Can be accessed anywhere without any restrictions
Protected: Access is limited to the class, which inherits this class.
Internal: Can be accessed only within the current assembly.
Private: Cannot be accessed outside.

1
2
3
4
5
6
7
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
Derive from System.Delegate class
Declared using the delegate keyword followed by a function signature
Delegates have a signature as well as a return type. A function assigned to delegates must fit with its 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.
Used for implementing events and call-back methods.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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)
        {
            Console.WriteLine("Number: {0,-12:N0}", num);
        }
        public static void PrintMoney(int money)
        {
            Console.WriteLine("Money: {0:C}", money);
        }
    }
}

31. What are the different types of delegates?

Single Delegate: A single Delegate can invoke a single method.
Multicast Delegate:

Delegate who holds the reference of multiple methods and can invoke it.
We can add a method in the delegate instance using the + operator, and we can remove a method using the – operator.
All the methods are invoked in sequence as they are assigned.

Generic Delegate: .Net Framework 3.5 introduces Generic delegates. There is no need to create an instance in a generic delegate.

1
2
3
4
5
6
7
Print printNumDel = PrintNumber;
Print printMonDel = PrintMoney;
// MultiCast Delegate
Print multiPrintDel = printNumDel + printMonDel;
multiPrintDel(100);        
multiPrintDel = printNumDel - printMonDel;
multiPrintDel(100);