Explore topic-wise InterviewSolutions in .

No, STRUCTS do not SUPPORT INHERITANCE, but they can IMPLEMENT INTERFACES.

No, structs do not support inheritance, but they can implement interfaces.

1. ABSTRACTION
2. Inheritance
3. ENCAPSULATION
4. Polymorphism

1. Abstraction
2. Inheritance
3. Encapsulation
4. Polymorphism

No, SEALED CLASS cannot be USED as a BASE class. A compile time ERROR will be generated.

No, sealed class cannot be used as a base class. A compile time error will be generated.

Abstract classes can be used to FORCE derived classes to provide NEW method IMPLEMENTATIONS for virtual methods. An example is SHOWN below.
public class BaseClass
{
public virtual void Method()
{
// Original Implementation.
}
}
public abstract class AbstractClass : BaseClass
{
public abstract OVERRIDE void Method();
}
public class NonAbstractChildClass : AbstractClass
{
public override void Method()
{
// New implementation.
}
}

When an abstract class inherits a virtual method from a base class, the abstract class can override the virtual method with an abstract method. If a virtual method is declared abstract, it is still virtual to any class inheriting from the abstract class. A class inheriting an abstract method cannot access the original implementation of the method. In the above example, Method() on class NonAbstractChildClass cannot call Method() on class BaseClass. In this way, an abstract class can force derived classes to provide new method implementations for virtual methods.

Abstract classes can be used to force derived classes to provide new method implementations for virtual methods. An example is shown below.
public class BaseClass
{
public virtual void Method()
{
// Original Implementation.
}
}
public abstract class AbstractClass : BaseClass
{
public abstract override void Method();
}
public class NonAbstractChildClass : AbstractClass
{
public override void Method()
{
// New implementation.
}
}

When an abstract class inherits a virtual method from a base class, the abstract class can override the virtual method with an abstract method. If a virtual method is declared abstract, it is still virtual to any class inheriting from the abstract class. A class inheriting an abstract method cannot access the original implementation of the method. In the above example, Method() on class NonAbstractChildClass cannot call Method() on class BaseClass. In this way, an abstract class can force derived classes to provide new method implementations for virtual methods.

ABSTRACT METHODS are methods that only the DECLARATION of the METHOD and no IMPLEMENTATION.

Abstract methods are methods that only the declaration of the method and no implementation.

A sealed class is a class that cannot be inherited from. This means, If you have a class CALLED Customer that is marked as sealed. No other class can inherit from Customer class. For EXAMPLE, the below code generates a compile time error "MainClass cannot derive from sealed type Customer. USING System;

A sealed class is a class that cannot be inherited from. This means, If you have a class called Customer that is marked as sealed. No other class can inherit from Customer class. For example, the below code generates a compile time error "MainClass cannot derive from sealed type Customer. using System;

No, ABSTRACT classes are INCOMPLETE and you cannot create an INSTANCE of an abstract class.

No, abstract classes are incomplete and you cannot create an instance of an abstract class.

YES, Hidden BASE class methods can be accessed from the derived class by CASTING the instance of the derived class to an instance of the base class as shown in the example below.
using System;
PUBLIC class BaseClass
{
public virtual void METHOD()
{
Console.WriteLine("I am a base class method.");
}
}
public class DerivedClass : BaseClass
{
public new void Method()
{
Console.WriteLine("I am a child class method.");
}
public static void Main()
{
DerivedClass DC = new DerivedClass();
((BaseClass)DC).Method();
}
}

Yes, Hidden base class methods can be accessed from the derived class by casting the instance of the derived class to an instance of the base class as shown in the example below.
using System;
public class BaseClass
{
public virtual void Method()
{
Console.WriteLine("I am a base class method.");
}
}
public class DerivedClass : BaseClass
{
public new void Method()
{
Console.WriteLine("I am a child class method.");
}
public static void Main()
{
DerivedClass DC = new DerivedClass();
((BaseClass)DC).Method();
}
}

Use the new KEYWORD to hide a base class METHOD in the DERIVED class as shown in the EXAMPLE below.
using System;
public class BASECLASS
{
public virtual void Method()
{
Console.WriteLine("I am a base class method.");
}
}
public class DerivedClass : BaseClass
{
public new void Method()
{
Console.WriteLine("I am a child class method.");
}
public static void Main()
{
DerivedClass DC = new DerivedClass();
DC.Method();
}
}

Use the new keyword to hide a base class method in the derived class as shown in the example below.
using System;
public class BaseClass
{
public virtual void Method()
{
Console.WriteLine("I am a base class method.");
}
}
public class DerivedClass : BaseClass
{
public new void Method()
{
Console.WriteLine("I am a child class method.");
}
public static void Main()
{
DerivedClass DC = new DerivedClass();
DC.Method();
}
}

No, Fields INSIDE a CLASS cannot be virtua. Only METHODS, properties, events and indexers can be VIRTUAL.

No, Fields inside a class cannot be virtua. Only methods, properties, events and indexers can be virtual.

A VIRTUAL METHOD MUST have a BODY where as an ABSTRACT method should not have a body.

A virtual method must have a body where as an abstract method should not have a body.

A DERIVED class can OVERRIDE a BASE class member only if the base class member is declared as virtual or ABSTRACT.

A derived class can override a base class member only if the base class member is declared as virtual or abstract.

Polymorphism allows you to invoke derived class METHODS through a base class reference during run-time. An example is shown below.
using System;
PUBLIC class DrawingObject
{
public virtual void Draw()
{
Console.WriteLine("I am a drawing object.");
}
}
public class Triangle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Triangle.");
}
}
public class Circle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Circle.");
}
}
public class Rectangle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Rectangle.");
}
}
public class DrawDemo
{
public static void Main()
{
DrawingObject[] DrawObj = new DrawingObject[4];
DrawObj[0] = new Triangle();
DrawObj[1] = new Circle();
DrawObj[2] = new Rectangle();
DrawObj[3] = new DrawingObject();
FOREACH (DrawingObject drawObj in DrawObj)
{
drawObj.Draw();
}
}
}

Polymorphism allows you to invoke derived class methods through a base class reference during run-time. An example is shown below.
using System;
public class DrawingObject
{
public virtual void Draw()
{
Console.WriteLine("I am a drawing object.");
}
}
public class Triangle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Triangle.");
}
}
public class Circle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Circle.");
}
}
public class Rectangle : DrawingObject
{
public override void Draw()
{
Console.WriteLine("I am a Rectangle.");
}
}
public class DrawDemo
{
public static void Main()
{
DrawingObject[] DrawObj = new DrawingObject[4];
DrawObj[0] = new Triangle();
DrawObj[1] = new Circle();
DrawObj[2] = new Rectangle();
DrawObj[3] = new DrawingObject();
foreach (DrawingObject drawObj in DrawObj)
{
drawObj.Draw();
}
}
}

All TYPES in .Net inherit from SYSTEM.object directly or indirectly. Because of this inheritance, every type in .Net inherit the ToString() method from System.Object class. Consider the example below.

using System;
public class MainClass
{
public static void Main()
{
int Number = 10;
Console.WriteLine(Number.ToString());
}
}

In the above example Number.ToString() method will correctly give the string representaion of int 10, when you call the ToString() method.

If you have a Customer class as SHOWN in the below example and when you call the ToString() method the OUTPUT doesnot make any sense. Hence you have to override the ToString() method, that is inherited from the System.Object class.

using System;
public class Customer
{
public string FirstName;
public string LastName;
}
public class MainClass
{
public static void Main()
{
Customer C = new Customer();
C.FirstName = "David";
C.LastName = "BOON";
Console.WriteLine(C.ToString());
}
}

The code sample below shows how to override the ToString() method in a class, that would give the output you want.

using System;
public class Customer
{
public string FirstName;
public string LastName;
public override string ToString()
{
return LastName + ", " + FirstName;
}
}
public class MainClass
{
public static void Main()
{
Customer C = new Customer();
C.FirstName = "David";
C.LastName = "Boon";
Console.WriteLine(C.ToString());
}
}

Conclusion : If you have a class or a struct, make sure you override the inherited ToString() method.

All types in .Net inherit from system.object directly or indirectly. Because of this inheritance, every type in .Net inherit the ToString() method from System.Object class. Consider the example below.

using System;
public class MainClass
{
public static void Main()
{
int Number = 10;
Console.WriteLine(Number.ToString());
}
}

In the above example Number.ToString() method will correctly give the string representaion of int 10, when you call the ToString() method.

If you have a Customer class as shown in the below example and when you call the ToString() method the output doesnot make any sense. Hence you have to override the ToString() method, that is inherited from the System.Object class.

using System;
public class Customer
{
public string FirstName;
public string LastName;
}
public class MainClass
{
public static void Main()
{
Customer C = new Customer();
C.FirstName = "David";
C.LastName = "Boon";
Console.WriteLine(C.ToString());
}
}

The code sample below shows how to override the ToString() method in a class, that would give the output you want.

using System;
public class Customer
{
public string FirstName;
public string LastName;
public override string ToString()
{
return LastName + ", " + FirstName;
}
}
public class MainClass
{
public static void Main()
{
Customer C = new Customer();
C.FirstName = "David";
C.LastName = "Boon";
Console.WriteLine(C.ToString());
}
}

Conclusion : If you have a class or a struct, make sure you override the inherited ToString() method.

Parse method throws an EXCEPTION if the string you are trying to parse is not a valid number where as TryParse returns false and does not throw an exception if PARSING FAILS. Hence TryParse is more EFFICIENT than Parse.

Parse method throws an exception if the string you are trying to parse is not a valid number where as TryParse returns false and does not throw an exception if parsing fails. Hence TryParse is more efficient than Parse.

To determine whether a STRING represents a numeric value use TryParse method as shown in the example below. If the string contains nonnumeric characters or the numeric value is too large or too small for the particular type you have SPECIFIED, TryParse returns false and sets the out parameter to zero. OTHERWISE, it returns true and sets the out parameter to the numeric value of the string.

string str = "One";
int i = 0;
if(int.TryParse(str,out i))
{
Console.WriteLine("Yes string contains Integer and it is " + i);
}
else
{
Console.WriteLine("string does not CONTAIN Integer");
}

To determine whether a String represents a numeric value use TryParse method as shown in the example below. If the string contains nonnumeric characters or the numeric value is too large or too small for the particular type you have specified, TryParse returns false and sets the out parameter to zero. Otherwise, it returns true and sets the out parameter to the numeric value of the string.

string str = "One";
int i = 0;
if(int.TryParse(str,out i))
{
Console.WriteLine("Yes string contains Integer and it is " + i);
}
else
{
Console.WriteLine("string does not contain Integer");
}

1. OBJECTS of type StringBuilder are MUTABLE where as objects of type SYSTEM.STRING are immutable.
2. As StringBuilder objects are mutable, they offer better performance than string objects of type System.String
3. StringBuilder CLASS is present in System.Text namespace where String class is present in System namespace.

1. Objects of type StringBuilder are mutable where as objects of type System.String are immutable.
2. As StringBuilder objects are mutable, they offer better performance than string objects of type System.String
3. StringBuilder class is present in System.Text namespace where String class is present in System namespace.

USING STRING.empty as SHOWN in the EXAMPLE below.
string EmptyString = string.empty;

Using string.empty as shown in the example below.
string EmptyString = string.empty;

STRING str = null;
Console.WriteLine(str.Length);
The above code will compile, but at RUNTIME System.NullReferenceException will be THROWN

string str = null;
Console.WriteLine(str.Length);
The above code will compile, but at runtime System.NullReferenceException will be thrown

The "@" symbol is the verbatim string literal. Use verbatim strings for convenience and better READABILITY when the string text contains backslash characters, for example in file PATHS. Because verbatim strings PRESERVE new line characters as part of the string text, they can be used to initialize multiline strings. Use double quotation marks to EMBED a quotation mark INSIDE a verbatim string. The following example shows some common uses for verbatim strings:

string ImagePath = @"C:\Images\Buttons\SaveButton.jpg";
//Output: C:\Images\Buttons\SaveButton.jpg

string MultiLineText = @"This is multiline Text written to be in three lines.";
/* Output:
This is multiline Text written to be in three lines.
*/

string DoubleQuotesString = @"My Name is ""Vankat.""";
//Output: My Name is "Vankat."

The "@" symbol is the verbatim string literal. Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Use double quotation marks to embed a quotation mark inside a verbatim string. The following example shows some common uses for verbatim strings:

string ImagePath = @"C:\Images\Buttons\SaveButton.jpg";
//Output: C:\Images\Buttons\SaveButton.jpg

string MultiLineText = @"This is multiline Text written to be in three lines.";
/* Output:
This is multiline Text written to be in three lines.
*/

string DoubleQuotesString = @"My Name is ""Vankat.""";
//Output: My Name is "Vankat."

string str1 = "Hello ";
string str2 = s1;
str1 = str1 + "C#";
System.Console.WriteLine(s2);

The output of the above code is "Hello" and not "Hello C#". This is BCOS, if you create a REFERENCE to a string, and then "modify" the original string, the reference will continue to point to the original OBJECT INSTEAD of the new object that was created when the string was modified.

string str1 = "Hello ";
string str2 = s1;
str1 = str1 + "C#";
System.Console.WriteLine(s2);

The output of the above code is "Hello" and not "Hello C#". This is bcos, if you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified.

String objects are immutable MEANS, they cannot be CHANGED after they have been created. All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. In the following example, when the contents of s1 and s2 are CONCATENATED to form a single string, the two original strings are unmodified. The += operator creates a new string that CONTAINS the combined contents. That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a REFERENCE to it.

string s1 = "First String ";
string s2 = "Second String";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: First String Second String.

String objects are immutable means, they cannot be changed after they have been created. All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. The += operator creates a new string that contains the combined contents. That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

string s1 = "First String ";
string s2 = "Second String";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: First String Second String.

STRING OBJECTS are IMMUTABLE.

String objects are immutable.

STRING keyword is an alias for Syste.String class. THEREFORE, System.String and string keyword are the same, and you can use WHICHEVER naming convention you prefer. The String class provides many methods for safely creating, manipulating, and COMPARING strings.

string keyword is an alias for Syste.String class. Therefore, System.String and string keyword are the same, and you can use whichever naming convention you prefer. The String class provides many methods for safely creating, manipulating, and comparing strings.

Yes,Since ARRAY TYPE implements IEnumerable, you can USE foreach iteration on all arrays in C#.

Yes,Since array type implements IEnumerable, you can use foreach iteration on all arrays in C#.

System.Array.

System.Array.

ARRAYS are REFERENCE TYPES.

Arrays are reference types.

A JAGGED ARRAY is an array of ARRAYS.

A jagged array is an array of arrays.

1. Single-Dimensional
2. MULTIDIMENSIONAL
3. JAGGED

1. Single-Dimensional
2. Multidimensional
3. Jagged

An array is a DATA STRUCTURE that contains several VARIABLES of the same TYPE.

An array is a data structure that contains several variables of the same type.

Boxing is used to store value types in the garbage-collected heap. Boxing is an implicit conversion of a value TYPE to the type object or to any interface type IMPLEMENTED by this value type. Boxing a value type allocates an object INSTANCE on the heap and copies the value into the new object. Due to this boxing and UNBOXING can have performance impact.

Boxing is used to store value types in the garbage-collected heap. Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Boxing a value type allocates an object instance on the heap and copies the value into the new object. Due to this boxing and unboxing can have performance impact.

No, UNBOXING is an EXPLICIT CONVERSION.

No, unboxing is an explicit conversion.

YES, BOXING happens IMPLICITLY.

Yes, boxing happens implicitly.

InvalidCastException.

InvalidCastException.

The is and as operators can be used to cast from ONE reference type to ANOTHER WITHOUT the risk of throwing an EXCEPTION.

The is and as operators can be used to cast from one reference type to another without the risk of throwing an exception.

Explicit CONVERSION as shown below.
//Create a new derived type.
Car C1 = new Car();
// Implicit conversion to BASE type is safe.
Vehicle V = C1;

// Explicit conversion is REQUIRED to cast BACK to derived type. The CODE below will compile but throw an exception at run time if the right-side object is not a Car object.
Car C2 = (Car) V;

Explicit conversion as shown below.
//Create a new derived type.
Car C1 = new Car();
// Implicit conversion to base type is safe.
Vehicle V = C1;

// Explicit conversion is required to cast back to derived type. The code below will compile but throw an exception at run time if the right-side object is not a Car object.
Car C2 = (Car) V;

ChildClass CC = new ChildClass();
ParentClass PC = new ParentClass();

Implicit Conversion. For REFERENCE types, an implicit conversion always exists from a class to any one of its DIRECT or indirect base classes or interfaces. No special SYNTAX is necessary because a derived class always CONTAINS all the MEMBERS of a base class.

ChildClass CC = new ChildClass();
ParentClass PC = new ParentClass();

Implicit Conversion. For reference types, an implicit conversion always exists from a class to any one of its direct or indirect base classes or interfaces. No special syntax is necessary because a derived class always contains all the members of a base class.

1. Explicit conversions require a CAST operator where as an implicit converstion is done AUTOMATICALLY.
2. Explicit conversion can LEAD to DATA loss where as with implicit conversions there is no data loss.

1. Explicit conversions require a cast operator where as an implicit converstion is done automatically.
2. Explicit conversion can lead to data loss where as with implicit conversions there is no data loss.

Implicit conversions: No special SYNTAX is required because the conversion is TYPE safe and no data will be lost. Examples include conversions from smaller to larger INTEGRAL types, and conversions from derived classes to base classes.

Explicit conversions: Explicit conversions require a cast operator. The source and destination variables are COMPATIBLE, but there is a risk of data LOSS because the type of the destination variable is a smaller size than (or is a base class of) the source variable.

Implicit conversions: No special syntax is required because the conversion is type safe and no data will be lost. Examples include conversions from smaller to larger integral types, and conversions from derived classes to base classes.

Explicit conversions: Explicit conversions require a cast operator. The source and destination variables are compatible, but there is a risk of data loss because the type of the destination variable is a smaller size than (or is a base class of) the source variable.

Converting a variable of one data TYPE to another data type is CALLED casting. This is also called as data type CONVERSION.

Converting a variable of one data type to another data type is called casting. This is also called as data type conversion.

1. Value types are stored on the stack where as reference types are stored on the MANAGED heap.
2. Value type variables directly contain their values where as reference variables holds only a reference to the location of the OBJECT that is created on the managed heap.
3. There is no heap allocation or garbage collection overhead for value-type variables. As reference types are stored on the managed heap, they have the over head of object allocation and garbage collection.
4. Value Types cannot inherit from ANOTHER class or struct. Value types can only inherit from interfaces. Reference types can inherit from another class or INTERFACE.

1. Value types are stored on the stack where as reference types are stored on the managed heap.
2. Value type variables directly contain their values where as reference variables holds only a reference to the location of the object that is created on the managed heap.
3. There is no heap allocation or garbage collection overhead for value-type variables. As reference types are stored on the managed heap, they have the over head of object allocation and garbage collection.
4. Value Types cannot inherit from another class or struct. Value types can only inherit from interfaces. Reference types can inherit from another class or interface.

CLASS
DELEGATE
ARRAY
INTERFACE.

Class
Delegate
Array
Interface.

ENUM
STRUCT

Enum
Struct

System.ValueType.

System.ValueType.

YES, VALUE TYPES are SEALED.

Yes, Value types are sealed.

REFERENCE TYPE

Reference type

VALUE TYPE.

Value Type.

1. VALUE Types
2. REFERENCE Types

1. Value Types
2. Reference Types

You use the STRUCT, CLASS, interface, and enum constructs to create your own custom types. The .NET Framework class library itself is a collection of custom types PROVIDED by Microsoft that you can use in your own APPLICATIONS.

You use the struct, class, interface, and enum constructs to create your own custom types. The .NET Framework class library itself is a collection of custom types provided by Microsoft that you can use in your own applications.

1. int
2. FLOAT
3. BOOL

1. int
2. float
3. bool