C# : Interview questions (66-70)
Questions :
How do you pass parameters to a method by reference in C#?
What is the difference between "ref" and "out" keywords in C#?
Explain the concept of boxing and unboxing in C#.
What are generics in C#?
How do you define a generic class in C#?
C# : Interview questions (61-65)
Answers :
1. Passing Parameters by Reference in C#:
To pass parameters by reference in C#, you use the ref or out keywords. This allows the method to modify the argument's value, and the changes will be reflected outside the method.
public void ModifyValue(ref int number)
{
number = number * 2;
}
// Usage
int myNumber = 5;
ModifyValue(ref myNumber);
Console.WriteLine(myNumber); // Output: 10
In this example, the ModifyValue method doubles the value of myNumber. The ref keyword ensures that the change is reflected outside the method.
2. Difference Between "ref" and "out" Keywords in C#:
ref: Requires that the variable be initialized before it is passed to the method. The method can read and modify the variable's value.
public void RefExample(ref int number)
{
number = number + 10;
}
// Usage
int myNumber = 5;
RefExample(ref myNumber); // myNumber must be initialized before passing
Console.WriteLine(myNumber); // Output: 15
out: Does not require that the variable be initialized before it is passed to the method. The method must assign a value to the variable before the method returns.
public void OutExample(out int number)
{
number = 10;
}
// Usage
int myNumber;
OutExample(out myNumber); // myNumber does not need to be initialized before passing
Console.WriteLine(myNumber); // Output: 10
3. Boxing and Unboxing in C#:
Boxing and unboxing are processes that convert a value type to an object type (boxing) and vice versa (unboxing).
Boxing: Converting a value type to an object type, which stores the value on the heap.
int value = 123;
object boxedValue = value; // Boxing
Unboxing: Extracting the value type from an object type, which requires explicit casting.
object boxedValue = 123;
int value = (int)boxedValue; // Unboxing
4. Generics in C#:
Generics allow you to define classes, methods, and data structures with a placeholder for the type of data they store or use. This enables type safety, code reuse, and performance improvements.
5. Defining a Generic Class in C#:
A generic class is defined using a type parameter in angle brackets (<>). This type parameter can be used throughout the class to define members that work with the specified type.
public class GenericClass<T>
{
private T data;
public GenericClass(T value)
{
data = value;
}
public T GetData()
{
return data;
}
public void SetData(T value)
{
data = value;
}
}
// Usage
GenericClass<int> intInstance = new GenericClass<int>(10);
Console.WriteLine(intInstance.GetData()); // Output: 10
GenericClass<string> stringInstance = new GenericClass<string>("Hello");
Console.WriteLine(stringInstance.GetData()); // Output: Hello
In this example, the GenericClass<T> is a generic class that can work with any data type specified when creating an instance of the class. The type parameter T is used for the class member data and the methods GetData and SetData.