Generics

Question 1

What is a “generic” in programming?

1. A fixed data type
2. A way to duplicate code
3. A feature that allows code to work with any data type
4. A method for run-time error checking

Answer 1

3. A feature that allows code to work with any data type.

Question 2

What does “parametric polymorphism” refer to in generics?

1. Using specific types in all functions
2. Allowing code to work with multiple data types
3. Type casting at runtime
4. Only using integer types

Answer 2

2. Allowing code to work with multiple data types

Question 3

Why are generics useful for collections?

1. They avoid the need for casting
2. They allow faster computation
3. They use less memory
4. They require fewer methods

Answer 3

1. They avoid the need for casting

Question 4

Which of the following is a valid generic list declaration for integers in C#?

1. List<string> myList = new List<string>();</string></string>
2. List<int> myList = new List<int>();</int></int>
3. Array<int> myList = new Array<int>();</int></int>
4. var myList = List<int>();</int>

Det som är efter “;” är en bug. Går ej att få bort

Answer 4

2. List<int> myList = new List<int>();</int></int>

Question 5

What is a type parameter in a generic?

1. A method parameter
2. A placeholder for a specific data type
3. A return type
4. A variable in the generic function

Answer 5

2. A placeholder for a specific data type

(Explanation: List<int> intList = new List<int>();
In this example, T in List<T> is the type parameter, which is replaced with int when creating intList. This allows List to work with any type, not just integers).</T></int></int>

Bug efter “).”

Question 6

Fill in the blank: Generics maintain ____.

1. dynamic type safety
2. runtime type safety
3. static type safety
4. none of the above

Answer 6

3. static type safety

Question 7

Which keyword in C# is used for generic constraints?

1. extends
2. implement
3. where
4. with

Answer 7

3. where

(Explanation: Generic constraints restrict the types that can be used as arguments for type parameters. For example, if you want to ensure that a type parameter T implements a particular interface, you can use the where keyword in C#. Here’s an example:

public class Repository<T> where T : IEntity
{
// T must implement IEntity interface
}</T>

In this case, T must be a type that implements the IEntity interface, so you can’t use a type that does not meet this constraint).

Question 8

What will this code output?
List<int> numbers = new List<int> { 1, 2, 3 };
foreach (var num in numbers)
Console.Write(num);</int></int>

1. 1 2 3
2. 1, 2, 3
3. 1; 2; 3
4. 123

Answer 8

4. 123

Question 9

What type would replace <T> in List<T> if creating a list of strings?</T></T>

1. int
2. object
3. string
4. float

Answer 9

3. string

Question 10

What would be the output of this code snippet?
csharp Pair<int, string> pair = new Pair<int, string>(10, “Apples”);
Console.WriteLine(pair);

1. (10, Apples)
2. (10 Apples)
3. (int, string)
4. (Pair)

Answer 10

1. (10, Apples)

Question 11

True or False: Every type can be converted into a generic type.

1. True
2. False

Answer 11

2. False

(Explanation: Not all types can be made generic because some types rely on very specific, concrete details of other types that generics are not designed to accommodate. For example, certain types in C# are constrained by fixed behavior or requirements that don’t make sense in a generic context, like those that need specific numeric or primitive operation).

Question 12

Which of the following statements correctly defines a generic class in C#?

1. class MyClass<T> { }</T>
2. class MyClass<> { }
3. generic class MyClass { }
4. MyClass<T> { class }</T>

Answer 12

1. class MyClass<T> { }</T>

Question 13

In which case would a generic method with <T> be useful?</T>

1. When all methods need to work only with strings
2. When the same logic applies to multiple data types
3. When only integer operations are needed
4. When casting is required frequently

Answer 13

2. When the same logic applies to multiple data types

Question 14

What will this code snippet output?
csharp List<string> words = new List<string>(); words.Add("Hello");
words.Add("World");
foreach (var word in words)
Console.Write(word);</string></string>

1. HelloWorld
2. Hello, World
3. World Hello
4. Hello; World

Answer 14

1. HelloWorld

Question 15

What is the primary benefit of generics over using object type in collections?

1. More memory efficient
2. Ensures type safety at compile-time
3. Allows dynamic typing
4. Simplifies code structure

Answer 15

2. Ensures type safety at compile-time

Question 16

Which syntax is used to add a constraint on a type parameter?

1. class MyClass<T : constraint> { }
2. class MyClass<T> { }</T>
3. class MyClass(constraint T) { }
4. class MyClass constraint T { }

Answer 16

1. class MyClass<T : constraint> { }

Question 17

Given Pair<T1, T2>, what does T1 and T2 represent?

1. Method names
2. Actual types for the instance
3. Generic type parameters
4. Base class names

Answer 17

3. Generic type parameters

Question 18

Which of the following describes a constructed generic type?

1. Pair<T1, T2>
2. Pair<int, string>
3. List<>
4. object

Answer 18

2. Pair<int, string>

(Explanation: A constructed generic type is a generic type where the “type parameters” have been specified with actual types. For instance, List<int> is a constructed generic type because T has been replaced with int. int is called the "type argument". By contrast, List<T> is a generic type definition with T as a placeholder for an actual type that will be provided when the list is created).</T></int>

Question 19

What happens if you try to add an integer to a List<string>?</string>

1. Compile-time error
2. No error
3. Run-time error
4. Warning only

Answer 19

1. Compile-time error

Question 20

What is the purpose of type inference in generics?

1. To automatically determine the type at runtime
2. To simplify the syntax by determining the type automatically
3. To allow explicit typing in all instances
4. To provide optional typing for variables

Answer 20

2. To simplify the syntax by determining the type automatically

(Explanation: Type inference in generics allows the compiler to automatically determine the type parameter based on the arguments provided, without requiring you to explicitly specify the type. This simplifies the syntax and improves readability. For example:

var numbers = new List<int> { 1, 2, 3 };</int>

Here, C# automatically infers that numbers is a List<int> based on the type of elements inside the list, making the code shorter and clearer).</int>

Question 21

What is covariance in generics?

1. Allowing assignment to a more specific type
2. Allowing assignment to a more general type
3. Allowing assignment of numeric types only
4. Allowing any type to be assigned

Answer 21

2. Allowing assignment to a more general type

(Explanation: Covariance allows you to assign a more specific type to a more general type. For example, you can assign IEnumerable<string> to IEnumerable<object> because string is a more specific type than object. Covariance is commonly used in interfaces and delegates where this flexibility can avoid additional casting.</object></string>

IEnumerable<string> strings = new List<string> { "hello", "world" };
IEnumerable<object> objects = strings; // Covariance allows this assignment</object></string></string>

).

Question 22

In which scenario would covariance be useful?

1. When assigning List<int> to List<double></double></int>
2. When assigning IEnumerable<string> to Enumerable<object></object></string>
3. When assigning object to string
4. When assigning List<int> to List<object></object></int>

Answer 22

2. When assigning IEnumerable<string> to Enumerable<object></object></string>

(Explanation: Covariance is particularly useful in scenarios where you want to work with a collection of objects in a general way, even if the collection originally contained more specific types. For example, if you want to pass a List<string> to a method that accepts IEnumerable<object>, covariance allows this without requiring a cast or new list.</object></string>

void PrintObjects(IEnumerable<object> items)
{
foreach (var item in items)
{
Console.WriteLine(item);
}
}</object>

IEnumerable<string> words = new List<string> { "apple", "banana" };
PrintObjects(words); // Covariance allows this to work</string></string>

).

Question 23

What is contravariance in generics?

1. Allowing assignment from a more specific type to a general type
2. Allowing assignment from a more general type to a more specific type
3. Allowing two generic types to be assigned freely
4. Allowing reference types to be assigned as value types

Answer 23

2. Allowing assignment from a more general type to a more specific type

(Explanation: Contravariance is the opposite of covariance; it allows assigning a more general type to a more specific type. This is primarily used in generic delegates where you might want a method that accepts a broader type to handle a narrower one. Contravariance is often seen in event handlers or situations where an action applies to a base class but can accept derived classes.

Action<object> printObject = obj => Console.WriteLine(obj);
Action<string> printString = printObject; // Contravariance allows this assignment
printString("Hello"); // Works fine, even though printObject expects object</string></object>

).

Question 24

Which constraint enforces that a type parameter must have a parameterless constructor?

1. where T : struct
2. where T : class
3. where T : new()
4. where T : static

Answer 24

3. where T : new()

(Explanation: The new() constraint ensures that a type parameter has a parameterless constructor. This is useful if you need to instantiate the generic type within the class or method. For instance, if you’re creating new instances of T within a method, the compiler needs to know T has a parameterless constructor.

public class Factory<T> where T : new()
{
public T CreateInstance()
{
return new T(); // Valid because of the `new()` constraint
}
}</T>

).

Question 25

How does the .NET runtime handle generics for reference types?

1. By duplicating code for each type
2. By resolving types at runtime
3. By converting all generics to object
4. By compiling each generic instance separately

Answer 25

2. By resolving types at runtime

(Explanation: The .NET runtime handles generics differently for reference and value types. For reference types, the runtime reuses the same generic code, only substituting the type parameter when necessary. This approach minimizes memory use and ensures that generics maintain type safety without duplicating code.

Example: If you have List<int> and List<string>, the runtime will use the same generic implementation for both lists, only swapping in int and string as needed rather than creating separate code for each. This helps generics stay efficient while still providing type safety).</string></int>