Commonly asked .NET Technical Interview Questions and ANSWERS!

Here are some commonly asked .NET Interview Questions which you can expect in a Technical .NET Interview.

What is CLR?
Common Language Runtime.

• CLR is responsible for managing the execution of .NET programs.
• It invokes just-in-time (JIT) compiler which is responsible for converting IL code to machine code.
• The CLR provides additional services including memory management, type safety and exception handling. Memory management is provided using Garbage collector.

What is CLS?
Common Language Specification.

• Set of basic language features needed by many applications.
• Helps enhance and ensure language interoperability by defining a set of features that developers can rely on to be available in a wide variety of languages

What is Inheritance?
It is one of the most important features of Object Oriented programming that helps in using existing functionality and we do not have to write same code again and again in all classes. (Please refer to my blog post on inheritance for further explanation)

What are Interfaces?
Interfaces define members without implementations. A class can only inherit from only one class but can implement more than one interface. See more information on inheritance below.

What is Polymorphism?
Through inheritance, a class can be used as more than one type; it can be used as its own type, any base types, or any interface type if it implements interfaces. This is called polymorphism.

What is Reflection?
All .NET compilers produce metadata about the types defined in the modules
they produce. This metadata is packaged along with the module (modules in
turn are packaged together in assemblies), and can be accessed by a
mechanism called reflection. The System.Reflection namespace contains
classes that can be used to interrogate the types for a module/assembly.

Does C# support multiple-inheritance?
No.

C# Tutorials: Inheritance

When you derive a class from a base class, the derived class will inherit all members of the base class except constructors.
Example: Let us define a base class “Location”. This class will have two Properties City and State. We will define two methods in this class, one is Get City which will be a virtual method (Derive class can override it) and other will be abstract method getState (Which must be overridden). Here is the code:

Code for Base Class:
using System;
namespace MyCode
{
public abstract class Location
{
/// <summary>
/// This is constructor
/// </summary>
public Location()
{
}
/// <summary>
/// this is Property
/// </summary>
public string City { get; set; }

/// <summary>
/// this is Property
/// </summary>
public string State { get; set; }

/// <summary>
/// getCity
/// </summary>
/// <returns></returns>
/// Virtual means derived class can override it
public virtual string getCity()
{
return City;
}

/// <summary>
/// getState
/// </summary>
/// <returns></returns>
/// abstract means derived class must overide it
public abstract string getState();

}
}
Now we will write two classes that will derive from the base class (Location). One class will override getCity Method and other will not.
Code for Derived Classes:
using System;
namespace MyCode
{
public class IBMCompanyLocation : Location
{
public IBMCompanyLocation()
{
State = “Texas”;
}
/// <summary>
/// getCity
/// </summary>
/// <returns></returns>
public override string getCity()
{
return “Austin”;
}
/// <summary>
/// getState
/// </summary>
/// <returns></returns>
public override string getState()
{
return State;
}
}
}
using System;
namespace MyCode
{
public class MicrosoftCompanyLocation : Location
{
public MicrosoftCompanyLocation()

{
State = “Washington”;
City = “Seattle”;
}
/// <summary>
/// getState
/// </summary>
/// <returns></returns>
public override string getState()
{
return State;
}
}
}