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.

Practice

1. What is the purpose of the where clause in C# generic constraints?

easy

A. To limit the types that can be used with a generic type parameter

B. To define a new generic type

C. To create a database connection string

D. To specify the return type of a method

Solution

1. Step 1: Understand generic constraints

   The where clause restricts which types can be used with a generic type parameter.

2. Step 2: Identify the purpose of the where clause

   It ensures only types meeting certain conditions (like implementing an interface) are allowed.

3. Final Answer:

   To limit the types that can be used with a generic type parameter -> Option A

4. Quick Check:

   Generic constraints = limit types [OK]

Hint: Think of where as a filter for allowed types [OK]

Common Mistakes:

• Confusing where with method return types
• Thinking where defines new types
• Using where for database queries

2. Which of the following is the correct syntax to constrain a generic type T to be a class in C#?

easy

A. where T : new()

B. where T : struct

C. where T : class

D. where T : interface

Solution

1. Step 1: Recall constraint keywords

   class means the type must be a reference type (class).

2. Step 2: Match syntax to constraint

   where T : class correctly restricts T to reference types.

3. Final Answer:

   where T : class -> Option C

4. Quick Check:

   Class constraint uses class keyword [OK]

Hint: Remember: class means reference type, struct means value type [OK]

Common Mistakes:

• Using struct to mean class
• Confusing new() with class constraint
• Writing interface as a constraint keyword

3. Consider this code snippet:

class Repository<T> where T : IEntity { public void Save(T item) { item.Save(); } }
interface IEntity { void Save(); }

What will happen if you try to create Repository<string>?

medium

A. Compile-time error because string does not implement IEntity

B. Runs successfully and calls string.Save()

C. Compile-time error because string is a value type

D. Runs successfully but does nothing

Solution

1. Step 1: Check the constraint on T

   T must implement IEntity.

2. Step 2: Verify if string implements IEntity

   string does not implement IEntity, so it violates the constraint.

3. Final Answer:

   Compile-time error because string does not implement IEntity -> Option A

4. Quick Check:

   Constraint violation = compile error [OK]

Hint: Check if type meets interface constraint before using [OK]

Common Mistakes:

• Assuming string automatically meets interface constraints
• Thinking it runs but does nothing
• Confusing value and reference types here

4. Identify the error in this generic class declaration:

class DataManager<T> where T : new, class { }

medium

A. The new constraint should be new() with parentheses

B. The order of constraints is incorrect; class must come before new()

C. There is no error; this is valid syntax

D. The class constraint cannot be combined with new()

Solution

1. Step 1: Recall correct order of constraints

   In C#, class or struct constraints must come before new().

2. Step 2: Analyze given declaration

   The declaration has new before class, which is invalid.

3. Final Answer:

   The order of constraints is incorrect; class must come before new() -> Option B

4. Quick Check:

   Constraint order matters: class before new() [OK]

Hint: Remember: class or struct first, then new() [OK]

Common Mistakes:

• Placing new() before class
• Omitting parentheses in new()
• Thinking constraints order does not matter

5. You want to create a generic repository class that only accepts types which are classes, implement IDisposable, and have a parameterless constructor. Which is the correct declaration?

hard

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

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

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

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

Solution

1. Step 1: Understand constraint order rules

   class must come first, then interfaces, then new().

2. Step 2: Check each option's order

   class Repository<T> where T : class, IDisposable, new() { } follows correct order: class, IDisposable, new().

3. Step 3: Verify all constraints are included

   class Repository<T> where T : class, IDisposable, new() { } includes all required constraints correctly.

4. Final Answer:

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

5. Quick Check:

   Correct order: class, interfaces, new() [OK]

Hint: Order constraints: class, interfaces, then new() [OK]

Common Mistakes:

• Placing new() before class
• Mixing order of interfaces and class constraint
• Omitting required constraints