C# : Interview questions (71-75)

Questions:

• What is a generic method?
• Explain the use of constraints in generics.
• What is covariance and contravariance in generics?
• What are anonymous types in C#?
• How do you implement anonymous methods in C#?

C# : Interview questions (66-70)

Answers:

1. What is a Generic Method?

A generic method in C# is a method that is defined with a type parameter. This allows the method to operate on different data types without needing to be rewritten for each type. Generic methods provide type safety, reduce code duplication, and improve performance.

public class Utilities
{
    public void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
}

// Usage
int x = 1, y = 2;
Utilities utilities = new Utilities();
utilities.Swap(ref x, ref y);
Console.WriteLine($"x: {x}, y: {y}"); // Output: x: 2, y: 1

In this example, the Swap method is a generic method that can swap the values of two variables of any type.

2. Use of Constraints in Generics:

Constraints in generics are used to restrict the types that can be used as arguments for a type parameter. This ensures that the type arguments meet certain requirements, providing more control over the behavior of generic classes and methods.

public class Utilities
{
    // Constraint to ensure T implements IComparable<T>
    public T Max<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

// Usage
Utilities utilities = new Utilities();
int maxInt = utilities.Max(10, 20);
string maxString = utilities.Max("apple", "banana");
Console.WriteLine($"Max Int: {maxInt}, Max String: {maxString}"); // Output: Max Int: 20, Max String: banana

In this example, the Max method has a constraint that ensures the type parameter T implements IComparable<T>, allowing the method to compare values of type T.

3. Covariance and Contravariance in Generics:

• Covariance: Allows a generic type to be assigned to another generic type with a more derived type parameter. It is applicable to reference types and is denoted using the out keyword.

IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // Covariance

• Contravariance: Allows a generic type to be assigned to another generic type with a less derived type parameter. It is applicable to reference types and is denoted using the in keyword.

Action<object> actionObject = (object obj) => Console.WriteLine(obj);
Action<string> actionString = actionObject; // Contravariance

In these examples, covariance allows an IEnumerable<string> to be assigned to an IEnumerable<object>, and contravariance allows an Action<object> to be assigned to an Action<string>.

4. Anonymous Types in C#:

Anonymous types in C# provide a way to create a new type without explicitly defining it. They are primarily used for convenience in scenarios where defining a new type would be overkill, such as in LINQ queries.

var person = new { Name = "John", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}"); // Output: Name: John, Age: 30

In this example, an anonymous type with properties Name and Age is created and assigned to the variable person.

5. Implementing Anonymous Methods in C#:

Anonymous methods in C# provide a way to define inline methods without having to explicitly declare them. They are primarily used in delegate assignments and event handling.

delegate void PrintDelegate(string message);

class Program
{
    static void Main()
    {
        PrintDelegate print = delegate (string message)
        {
            Console.WriteLine(message);
        };

        print("Hello, world!"); // Output: Hello, world!
    }
}

In this example, an anonymous method is assigned to the print delegate, which prints a message to the console.

Alternatively, you can use lambda expressions, which provide a more concise syntax for anonymous methods:

PrintDelegate print = (message) => Console.WriteLine(message);
print("Hello, world!"); // Output: Hello, world!

Both approaches achieve the same result but lambda expressions offer a cleaner and more readable syntax.

C# : Interview questions (71-75)