How to Use where (Generic Type Constraint)
What Is the “where” Constraint
The “where” constraint is a generic type constraint in C# that allows developers to specify the type parameter that a generic type can represent. The constraint is specified using the “where” keyword followed by the type parameter and the constraint, the syntax for using the “where” constraint is as follows:
{
// Class implementation
}
Here the “ClassName” represents the name of the class with a generic type parameter “T”. The “where” keyword specifies the constraint for the type parameter, and the “constraint” is the type that the type parameter must represent.
Let’s take an example of a generic class that accepts a type parameter and returns the minimum value from an array of values. Here the code uses the “where” constraint to specify that the type parameter must be a numeric type:
public class MinValue<T> where T : struct, IComparable, IConvertible
{
public T GetMinValue(T[] array)
{
if (array == null || array.Length == 0) {
throw new ArgumentException("Array cannot be null or empty");
}
T min = array[0];
for (int i = 1; i < array.Length; i++) {
if (array[i].CompareTo(min) < 0) {
min = array[i];
}
}
return min;
}
}
public class Program
{
public static void Main()
{
int[] intArray = { 1, 2, 3, 4, 5 };
MinValue<int> intMinValue = new MinValue<int>();
int intMin = intMinValue.GetMinValue(intArray);
Console.WriteLine("Minimum value of intArray: {0}", intMin);
double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };
MinValue<double> doubleMinValue = new MinValue<double>();
double doubleMin = doubleMinValue.GetMinValue(doubleArray);
Console.WriteLine("Minimum value of doubleArray: {0}", doubleMin);
}
}
Here, we have defined a generic class “MinValue” that accepts a type parameter “T” and returns the minimum value from an array of values. Next, we have used the “where” constraint to specify that the type parameter must be a struct, implement the IComparable interface, and implement the IConvertible interface. This constraint ensures that only numeric types are allowed as type parameters.
Conclusion
The “where” constraint in C# is a powerful feature that allows developers to enforce type safety and prevent errors during runtime. By using this constraint, you can specify the set of types that a generic type parameter can represent. This article has provided an overview of the “where” constraint in C# and demonstrated how to use it with a code.
Source: linuxhint.com