Generic constraints (where clause) in C Sharp (C#) - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a generic class with a constraint that T must be a class.

C Sharp (C#)

public class Repository<[1]> where T : class { }

Drag options to blanks, or click blank then click option'

AT

BU

CV

DK

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different letter in the constraint than in the generic declaration.

Forgetting to add the where clause after the generic declaration.

The generic type parameter is usually named T. The constraint where T : class means T must be a reference type.

2fill in blank

medium

Complete the code to declare a generic method with a constraint that T must have a parameterless constructor.

C Sharp (C#)

public void CreateInstance<[1]>() where T : new() { T obj = new T(); }

Drag options to blanks, or click blank then click option'

AU

BT

CV

DK

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different letter in the constraint than in the method declaration.

Omitting the new() constraint when creating a new instance.

The generic type parameter T is constrained with new() to require a parameterless constructor.

3fill in blank

hard

Fix the error in the generic class declaration by completing the constraint so that T must inherit from BaseEntity.

C Sharp (C#)

public class Manager<[1]> where T : BaseEntity { }

Drag options to blanks, or click blank then click option'

AU

BK

CV

DT

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different letter in the constraint than in the generic declaration.

Forgetting to specify the base class in the constraint.

The generic type parameter T must be the same in the declaration and the constraint. Here, where T : BaseEntity means T inherits from BaseEntity.

4fill in blank

hard

Fill both blanks to declare a generic method where T must be a struct and U must implement IDisposable.

C Sharp (C#)

public void Process<[1], U>() where [1] : struct where U : [2] { }

Drag options to blanks, or click blank then click option'

AT

BU

CIDisposable

DBaseEntity

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the type parameter names and constraints.

Using a class name instead of an interface for the IDisposable constraint.

The first blank is the generic type parameter T constrained as a struct (value type). The second blank is the interface IDisposable that U must implement.

5fill in blank

hard

Fill all three blanks to declare a generic class where T must be a class, U must inherit from BaseEntity, and V must have a parameterless constructor.

C Sharp (C#)

public class Container<[1], [2], V> where T : class where U : BaseEntity where V : [3] { }

Drag options to blanks, or click blank then click option'

AT

BU

Cnew()

DV

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong parameter names in the constraints.

Forgetting the new() constraint for V.

The generic parameters are T, U, and V. The constraints specify that T is a class, U inherits from BaseEntity, and V has a parameterless constructor (new()).

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