C# – Interview Questions

OOP stands for Object-Oriented Programming. Object-oriented programming is about creating objects that contain both data and functions.

OOP is a programming paradigm that relies on the concept of classes and objects. It is used to structure a software program into simple, reusable pieces of code blueprints (usually called classes), which are used to create individual instances of objects. There are many object-oriented programming languages including C#, JavaScript, C++, Java, and Python.

There are 4 major principles of OOP:

Encapsulation

Encapsulation, in OOP methodology, prevents access to implementation details. Encapsulation is implemented by using access specifiers

Abstraction

Abstraction is a process of hiding the implementation details and displaying the essential features It means that only the required information is visible to the user and the rest of the information is hidden.

Abstraction can be implemented using abstract classes in C#. Abstract classes are base classes with partial implementation.

Polymorphism

This means that an object can have multiple functionalities. Polymorphism allows the same method to execute different behaviors in two ways: method overriding and method overloading.

We can write a code that works on the superclass, and it will work with any subclass type as well.

There are two types of polymorphism: static and dynamic. 

• Static polymorphism is achieved using method overloading (Early Binding). There can be multiple definitions for the same function name. All of these definitions may differ by the number of arguments they contain or the type of these arguments

• Dynamic polymorphism using method overriding (Late Binding). It is implemented using abstract classes and virtual functions.

Inheritance

Inheritance allows a class to inherit the functionality of another class. The original class is known as the base class and the class which inherits the functionality of the base class is the derived class. In derived classes we can reuse the code of existing super classes

There are 3 types un C#:

1. Value Data Types –Value type variables can be assigned a value directly. They are derived from the class System.ValueType. These are integer and floating point based. Some examples of value data types are int, char, float, double, bool, etc.

2. Reference Data Types – These data types contain a reference to the variables and not the actual data. They refer to a memory location. They are derived from the class System.Object. Some build in reference types are object, arrays, dynamic and string.

3. Pointer Data Types – This store the memory address of another data type and the data can be accessed using pointers.

A static constructor is used to initialize any static data, or to perform a particular action that needs to be performed only once. It is called automatically before the first instance is created or any static members are referenced.

• A static constructor doesn’t take access modifiers or have parameters.

• A class or struct can only have one static constructor.

• Static constructors cannot be inherited or overloaded.

• A static constructor cannot be called directly and is only meant to be called by the common language runtime (CLR). It is invoked automatically.

• The user has no control on when the static constructor is executed in the program.

While value types are stored generally in the stack, reference types are stored in the managed heap.

• A Class has both definition and an implementation whereas Interface only has a definition.

• A Class can be instantiated but an Interface cannot be instantiated You can create an instance of an Object that implements the Interface.

• A Class is a full body entity with members, methods along with there definition and implementation. An Interface is just a set of definition that you must implement in your Class inheriting that Interface.

• A class can implement any number of interfaces but a subclass can at most use only one abstract class.

• An abstract class can have non-abstract methods (concrete methods) while in case of interface, all the methods have to be abstract.

• An abstract class can declare or use any variables while an interface is not allowed to do so.

• In an interface all methods definitions are public.

• In an abstract class, we need to use abstract keywords to declare abstract methods, while in an interface we don’t need to use that.

• An abstract class use constructor while in an interface we don’t have any type of constructor

The difference is that int[] is an static data structure that store on the stack a fixed number of integer values, while List<int> is a dynamic data structure that store a random collection of objects.

Represents a collection of key/value pairs that are organized based on the hash code of the key.

Hashtable is a data structure implemented in the .NET Framework in two ways, simple Hashtable in the namespace System.Collections and as generic data structure Dictionary in System.Collections.Generic namespace, it is recommended to use Dictionary instead of Hashtable, the working principle of Hashtable and Dictionary is that construct a hash that is index into an array usually using polynomials.

Represents a collection of keys and values. The Dictionary<TKey,TValue> generic class provides a mapping from a set of keys to a set of values. 

A Dictionary is faster than a Hashtable as it eliminates the boxing and un-boxing overheads.

Sample:

Dictionary<string, string> openWith = new Dictionary<string, string>();
openWith.Add(“txt”, “notepad.exe”);
openWith.Add(“bmp”, “paint.exe”);
openWith.Add(“dib”, “paint.exe”);

Dictionary implements a Hashtable data structure.

A String object is immutable (read-only) and a sequential collection of System.Char objects that represent a string. The maximum size of a String object in memory is 2 GB (about 1 billion characters).

A StringBuilder (System.Text.StringBuilder) represents a mutable string of characters. This class cannot be inherited. The default capacity of this object is 16 characters, and its maximum capacity is more than 2 billion characters.

Do not use a string when you don’t know the number of concatenations or if the number of concatenations are large.

Use a StringBuilder object if you are concatenating an arbitrary number of strings; for example, if you’re using a loop to concatenate a random number of strings of user input. Or in the case of a big loop as in the following.

Ref and out keywords in C# are used to pass arguments within a method or function. Both indicate that an argument/parameter is passed by reference.

Boxing The process of converting from a value type to a reference type.

// Boxing
int num = 123;
Object obj = num;

Unboxing is the process of converting from a reference type to a value type.

// Unboxing
Object obj = 123;
int num = (int)obj;

• The mutable types are those whose data members can be changed after the instance is created. When we change the value of mutable objects, value is changed in same memory.

• Immutable types are those whose data members can not be changed after the instance is created. When we change the value of immutable objects a new memory is created and the modified value is stored in new memory.

String is an immutable type, which means we are creating new memory every time instead of working on existing memory.

The Nullable type allows you to assign a null value to a variable. Nullable types introduced in C#2.0 can only work with value type not with reference type.

The nullable types for Reference Type is introduced later in C# 8.0 in 2019 so that we can explicitly define if a reference type can or can not hold a null value.

Sintax:

Nullable<data_type> variable_name = null;

Or

datatype? variable_name = null;

• The Ad-Hoc polymorphism is called as overloading. This allows function with same name to act in different manner for different types.

• The Inclusion polymorphism is called as subtyping. This allows to point derived classes using base class pointers and references

• The Coercion polymorphism is called as casting. This type of polymorphism occurs when an object or the primitive is cast into some other type.

• The Parametric polymorphism is called as Early Binding. This type of polymorphism allows to use same piece of code for different types.