Generic constraints (where clause) in C Sharp (C#) - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Output of generic method with class constraint

Consider this C# generic method with a where clause restricting T to classes:

public void PrintTypeName<T>() where T : class { Console.WriteLine(typeof(T).Name); }

What will be printed when calling PrintTypeName<string>()?

C Sharp (C#)

PrintTypeName<string>();

A String

B string

C System.String

D class

💡 Hint

Remember that typeof(T).Name returns the exact type name with correct casing.

In C#, typeof(string).Name returns 'String' with capital S because it reflects the CLR type name, not the C# keyword.

📝 Syntax

intermediate

Identify the invalid generic constraint syntax

Which of the following generic method declarations has a syntax error in its where clause?

A void Method<T>() where T : struct {}

B void Method<T>() where T : new() {}

C void Method<T>() where T : int {}

D void Method<T>() where T : class, new() {}

💡 Hint

Check if the constraint type is a valid generic constraint type.

You cannot use a concrete type like 'int' as a generic constraint. Constraints must be class, struct, interface, or new().

🧠 Conceptual

advanced

Understanding multiple generic constraints

Given the generic class declaration:

class Repository<T> where T : class, IDisposable, new() {}

Which of the following statements is true about T?

A T must be a class but does not need to implement IDisposable.

B T can be any type that implements IDisposable, including structs.

C T must be a value type with a parameterless constructor.

D T must be a reference type that implements IDisposable and has a parameterless constructor.

💡 Hint

Look carefully at all constraints combined with commas.

The where clause requires T to be a class (reference type), implement IDisposable, and have a parameterless constructor.

🔧 Debug

advanced

Why doesn't this generic method modify the caller's variable?

Examine this method:

void Save<T>(T item) where T : new() { var instance = new T(); item = instance; }

Why doesn't this code modify the original item passed by the caller?

C Sharp (C#)

void Save<T>(T item) where T : new() { var instance = new T(); item = instance; }

A Because method parameters are passed by value, so the assignment inside the method does not affect the caller's variable.

B Because T must be a class to use 'new T()'.

C Because 'item' is a method parameter and cannot be assigned to inside the method.

D Because 'new()' constraint requires T to have a parameterless constructor but T might be abstract.

💡 Hint

Think about how method parameters behave in C#.

In C#, method parameters are passed by value by default. Reassigning 'item' inside the method changes only the local copy and does not affect the variable in the calling code.

❓ optimization

expert

Optimizing generic constraints for performance

You have a generic method:

public void Process<T>(T item) where T : class { /* ... */ }

Which change to the where clause can improve performance by allowing the compiler to optimize better?

A Add <code>new()</code> constraint to allow object creation.

B Change to <code>where T : struct</code> to avoid null checks.

C Remove the constraint entirely to allow any type.

D Add <code>class, new()</code> constraints to allow object creation and reference type optimizations.

💡 Hint

Value types avoid null checks and boxing, improving performance.

Using where T : struct restricts T to value types, which are stored on the stack and avoid null checks and boxing, improving performance.