Explore topic-wise InterviewSolutions in Current Affairs.

Inheritance means acquiring some of the properties from a master CLASS. 

Here, class C can inherit properties from Class A and Class B. Here is an example of inheritance: 

Also, C# doesn’t support multiple inheritances. 
Instead, you can use interfaces to inherit the properties using the class name in the signature.

An array is a collection of similar variables clubbed together under one common name. While ARRAYLIST is a collection of OBJECTS that can be indexed individually. With ArrayList you can access a number of features like dynamic MEMORY allocation, adding, searching, and sorting items in the ArrayList. 

• When declaring an array the size of the items is FIXED therefore, the memory allocation is fixed. But with ArrayList, it can be increased or DECREASED dynamically.
• Array belongs to system.array namespace while ArrayList belongs to the system.collection namespace.
• All items in an array are of the same datatype while all the items in an ArrayList can be of the same or different data types.
• While arrays cannot accept null, ArrayList can accept null values.

For ex.:

In C# collections, defining any kind of object is termed okay which compromises C#’s basic rule of type-safety. Therefore, generics were INCLUDED to type-safe the code by allowing re-use of the data processing ALGORITHMS. Generics in C# mean not LINKED to any specific data type. Generics reduce the load of using boxing, unboxing, and typecasting OBJECTS. Generics are always defined INSIDE angular brackets <>. To create a generic class, this syntax is used:

Here, GenericList<float> is a generic class. In each of these instances of GenericList<T>, every occurrence of T in the class is substituted at run time with the type argument. By substituting the T, we have created three different type-safe using the same class. 

Extension methods help to add new methods to the existing ones. The methods that are added are STATIC. At times, when you want to add methods to an existing class but don’t PERCEIVE the right to modify that class or don’t hold the rights, you can create a new static class containing the new methods. Once the extended methods are declared, bind this class with the existing one and see the methods will be added to the existing one.

Output:

Method Name: M1

Method Name: M2

Method Name: M3

Method Name: M4

Method Name: M5

C# ref keywords pass arguments by reference and not value. To use the ‘ref’ keyword, you need to explicitly mention ‘ref’. 

C# out keywords pass arguments within methods and functions. 
‘out’ keyword is used to pass arguments in a method as a reference to return multiple values. Although it is the same as the ref keyword, the ref keyword needs to be initialised before it is passed. Here, The out and ref keywords are useful when we WANT to return a value in the same variables that are passed as an ARGUMENT. 

LET’s dig into the differences between an abstract class and an interface:

• Abstract classes are classes that cannot be instantiated ie. that cannot create an object. The interface is like an abstract class because all the METHODS inside the interface are abstract methods.
• Surprisingly, abstract classes can have both abstract and non-abstract methods but all the methods of an interface are abstract methods.
• Since abstract classes can have both abstract and non-abstract methods, we need to use the Abstract keyword to declare abstract methods. But in the interface, there is no such need.

An abstract class has constructors while an interface ENCOMPASSES none. 

Ex.

Abstract class:

Interface:

Managed code lets you run the code on a managed CLR runtime ENVIRONMENT in the .NET framework. 
Managed code runs on the managed runtime environment than the operating system itself. 
Benefits: Provides various services like a garbage collector, exception handling, etc. 

UNMANAGED code is when the code doesn’t run on CLR, it is an unmanaged code that works outside the .NET framework. 
They don’t provide services of the high-level languages and therefore, run WITHOUT them. Such an EXAMPLE is C++. 

Class is an entity that ENCAPSULATES all the PROPERTIES of its objects and instances as a single unit. C# has FOUR types of such classes:

• Static class: Static class, defined by the keyword ‘static’ does not allow inheritance. Therefore, you cannot create an object for a static class.

Sample code:

• Partial class: Partial class, defined by the keyword ‘partial’ allows its members to partially divide or share source (.cs) files.
• Abstract class: Abstract classes are classes that cannot be instantiated where you cannot create objects. Abstract classes work on the OOPS concept of abstraction. Abstraction helps to extract essential DETAILS and hide the unessential ones.
• Sealed class: Sealed classes are classes that cannot be inherited. USE the keyword sealed to restrict access to users to inherit that class. 
   

Garbage collection is the process of freeing up memory that is captured by unwanted objects. When you create a class object, automatically some memory space is allocated to the object in the HEAP memory. Now, after you perform all the ACTIONS on the object, the memory space occupied by the object becomes waste. It is necessary to FREE up memory. Garbage collection happens in THREE cases:

• If the occupied memory by the objects exceeds the pre-set threshold value.
• If the garbage collection method is called
• If your SYSTEM has low physical memory

CLR handles PROGRAM execution for VARIOUS languages INCLUDING C#. The architecture of CLR handles MEMORY management, garbage collection, security handling, and LOOKS like: 

You would ALWAYS know C being the procedural language while C# is a more object-oriented language. The biggest difference is that C# SUPPORTS automatic garbage collection by Common Language RUNTIME (CLR) while C does not. C# primarily needs a .NET FRAMEWORK to execute while C is a platform-agnostic language.