CSharp Interview Questions and Answers
Question - 101 : - What is the difference between String and StringBuilder in C#?
Answer - 101 : -
The major difference between String and StringBuilder is that String objects are immutable while StringBuilder creates a mutable string of characters. StringBuilder will make the changes to the existing object rather than creating a new object.
StringBuilder simplifies the entire process of making changes to the existing string object. Since the String class is immutable, it is costlier to create a new object every time we need to make a change. So, the StringBuilder class comes into picture which can be evoked using the System.Text namespace.
In case, a string object will not change throughout the entire program, then use String class or else StringBuilder.
For ex:
string s = string.Empty;
for (i = 0; i < 1000; i++)
{
s += i.ToString() + " ";
}
Here, you’ll need to create 2001 objects out of which 2000 will be of no use.
The same can be applied using StringBuilder:
StringBuilder sb = new StringBuilder();
for (i = 0; i < 1000; i++)
{
sb.Append(i); sb.Append(' ');
}
Question - 102 : - What is Reflection in C#?
Answer - 102 : -
Reflection in C# extracts metadata from the datatypes during runtime.
To add reflection in the .NET framework, simply use System.Refelction namespace in your program to retrieve the type which can be anything from:
- Assembly
- Module
- Enum
- MethodInfo
- ConstructorInfo
- MemberInfo
- ParameterInfo
- Type
- FieldInfo
- EventInfo
- PropertyInfo
Question - 103 : - What are the different ways in which a method can be Overloaded in C#?
Answer - 103 : -
Overloading means when a method has the same name but carries different values to use in a different context. Only the main() method cannot be overloaded.
In order to overload methods in C#,
Change the number of parameters in a method, or
Change the order of parameters in a method, or
Use different data types for parameters
In these ways, you can overload a method multiple times.
For ex.
public class Area {
public double area(double x) {
double area = x * x;
return area;
}
public double area(double a, double b) {
double area = a * b;
return area;
}
}
Here, the method Area is used twice. In the first declaration, one argument is used while in the second one, there were two arguments are used. Using different parameters in the same method, we were able to overload the method area().
Question - 104 : - Difference between the Equality Operator (==) and Equals() Method in C#?
Answer - 104 : -
Although both are used to compare two objects by value, still they both are used differently.
For ex.:
int x = 10;
int y = 10;
Console.WriteLine( x == y);
Console.WriteLine(x.Equals(y));
Output:
True
True
Equality operator (==) is a reference type which means that if equality operator is used, it will return true only if both the references point to the same object.
Equals() method: Equals method is used to compare the values carried by the objects. int x=10, int y=10. If x==y is compared then, the values carried by x and y are compared which is equal and therefore they return true.
Equality operator: Compares by reference
Equals(): Compares by value
Question - 105 : - What are Indexers in C#?
Answer - 105 : -
Indexers are called smart arrays that allow access to a member variable. Indexers allow member variables using the features of an array. They are created using the Indexer keyword. Indexers are not static members.
For ex. Here the indexer is defined the same way.
{
get{
// return the value from the specified index of an internal collection
}
set{
// set values at the specified index in an internal collection
}
}
Question - 106 : - What is the difference between late binding and early binding in C#?
Answer - 106 : -
Late binding and early binding are examples of one of the primary concepts of OOPS: Polymorphism.
For ex: one function calculateBill() will calculate bills of premium customers, basic customers, and semi-premium customers based on their policies differently. The calculation for all the customer objects is done differently using the same function which is called polymorphism.
When an object is assigned to an object variable in C#, the .NET framework performs the binding.
When the binding function happens at compile-time, it is called early binding. It investigates and checks the methods and properties of the static objects. With early binding, the number of run-time errors decreases substantially and it executes pretty quickly.
But when the binding happens at runtime, it is called late binding. Late binding happens when the objects are dynamic (decided based on the data they hold) at run-time. It is slower as it looks through during run-time.
Question - 107 : - What are partial classes in C#?
Answer - 107 : -
Partial classes implement the functionality of a single class into multiple files. These multiple files are combined into one during compile time. The partial class can be created using the partial keyword.
public partial Clas_name
{
// code
}
You can easily split the functionalities of methods, interfaces, or structures into multiple files. You can even add nested partial classes.