Generic constraints (where clause) in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the where clause in C# generics?

The where clause sets rules on the types that can be used as generic arguments, ensuring they meet certain requirements like implementing an interface or having a parameterless constructor.

beginner

Which of these is a valid generic constraint in C#?

Examples include where T : class (reference type), where T : struct (value type), where T : new() (has parameterless constructor), or where T : SomeInterface (implements interface).

intermediate

Explain the constraint where T : new().

It means the generic type <code>T</code> must have a public parameterless constructor, so you can create instances of <code>T</code> inside the generic class or method.

intermediate

Can you use multiple constraints on a single generic type parameter? How?

Yes. You separate constraints with commas in the where clause, for example: where T : class, ISomeInterface, new() means T must be a reference type, implement ISomeInterface, and have a parameterless constructor.

beginner

What happens if you try to use a type that does not meet the generic constraints?

The code will not compile. The compiler checks the constraints and gives an error if the type argument does not satisfy them.

What does where T : struct mean in a generic constraint?

A T must be a value type

B T must be a reference type

C T must have a parameterless constructor

D T must inherit from a class

where T : struct restricts T to value types like int, double, or structs.

Which constraint ensures the generic type has a parameterless constructor?

A where T : new()

B where T : class

C where T : struct

D where T : IDisposable

where T : new() requires a public parameterless constructor.

How do you specify that a generic type must implement an interface IMyInterface?

A where T inherits IMyInterface

B where T implements IMyInterface

C where T : IMyInterface

D where T : class

The syntax is where T : IMyInterface to require implementation.

Can you combine multiple constraints on one generic type parameter?

A No, only one constraint is allowed

B Yes, but only two constraints max

C Only if they are interfaces

D Yes, separated by commas

Multiple constraints are separated by commas in the where clause.

What will happen if you use a type that does not meet the generic constraints?

A Code compiles but throws runtime error

B Code does not compile

C Code runs but behaves unpredictably

D Code compiles with warning

The compiler enforces constraints and will not compile code that violates them.

Describe how to use the where clause to restrict a generic type to reference types that implement an interface and have a parameterless constructor.

Think about combining constraints separated by commas.

Explain why generic constraints are useful when writing generic classes or methods.

Consider what happens if you try to use a type that doesn't fit the expected pattern.

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