C# : Interview questions (96-100)

Questions:

• How do you invoke a method using reflection in C#?

• What is the purpose of the "dynamic" keyword in C#?

• How do you work with dynamic types in C#?

• What is the "var" keyword in C#?

• What is the purpose of the "out" keyword in C#?

C# : Interview questions (91-95)

Answers:

1. Invoking a Method Using Reflection in C#:

To invoke a method using reflection in C#, you typically follow these steps:

• Get the Type of the class that contains the method using typeof or GetType().

• Use GetMethod to obtain a MethodInfo object representing the method.

• Optionally, use GetParameters to get information about the method's parameters.

• Invoke the method using Invoke on an instance (for instance methods) or null (for static methods), passing in any required parameters.

using System;
using System.Reflection;

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

public class Program
{
    public static void Main()
    {
        Type type = typeof(Calculator);
        object instance = Activator.CreateInstance(type);

        MethodInfo methodInfo = type.GetMethod("Add");
        object[] parameters = { 3, 5 };
        int result = (int)methodInfo.Invoke(instance, parameters);

        Console.WriteLine($"Result of Add method: {result}"); // Output: Result of Add method: 8
    }
}

In this example, MethodInfo.Invoke is used to dynamically invoke the Add method of the Calculator class with parameters 3 and 5.

2. Purpose of the "dynamic" Keyword in C#:

The dynamic keyword in C# enables late binding, allowing you to work with objects in a more flexible and less restrictive manner at runtime. It bypasses static type checking and enables operations that might not be known at compile-time.

3. Working with Dynamic Types in C#:

When you declare a variable as dynamic, the compiler defers type checking until runtime, providing more flexibility in handling objects whose types are not known until runtime or that have properties/methods determined dynamically.

dynamic dynamicVariable = 10;
dynamicVariable = "Hello";

Console.WriteLine(dynamicVariable); // Output: Hello

In this example, dynamicVariable can hold both int and string values, and the compiler resolves the actual type at runtime.

4. The "var" Keyword in C#:

The var keyword in C# is used to declare implicitly typed local variables. The type of the variable is inferred by the compiler based on the assigned value at compile-time.

var number = 10; // Compiler infers int
var message = "Hello"; // Compiler infers string

Console.WriteLine(number); // Output: 10
Console.WriteLine(message); // Output: Hello

Using var reduces redundancy in code without sacrificing type safety, as the compiler still enforces type rules.

5. Purpose of the "out" Keyword in C#:

The out keyword in C# is used in method parameters to indicate that the parameter is passed by reference and is expected to be initialized by the method. It allows a method to return multiple values.

public void Divide(int dividend, int divisor, out int quotient, out int remainder)
{
    quotient = dividend / divisor;
    remainder = dividend % divisor;
}

// Usage
int dividend = 10, divisor = 3;
int resultQuotient, resultRemainder;
Divide(dividend, divisor, out resultQuotient, out resultRemainder);

Console.WriteLine($"Quotient: {resultQuotient}, Remainder: {resultRemainder}"); // Output: Quotient: 3, Remainder: 1

In this example, the Divide method uses out parameters to return both the quotient and remainder of dividing dividend by divisor.

These explanations and examples should provide a clear understanding of invoking methods using reflection, using the dynamic keyword, working with dynamic types, the var keyword for implicitly typed variables, and the out keyword for method parameters in C#.

C# : Interview questions (101-105)