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.

C# : Interview questions (71-75)