在C#中，Where关键字主要有两种用途

1、在泛型约束中限制类型参数

2、在LINQ查询中筛选数据

本文主要介绍where关键字在在泛型约束中的使用

       泛型定义中的 where 子句指定对用作泛型类型、方法、委托或本地函数中类型参数的参数类型的约束。通过使用 where 关键字和泛型约束，可以创建更安全、更灵活的泛型类和方法的实现。

使用的对象

Where可以对类、方法、委托和接口使用。

类的使用，例如C#中常用的List<T>

方法的使用，

public void MyFunc<T>() where T:struct

委托的使用

public delegate void MyDelete<T>() where T : class;

接口的使用

约束分类

约束	说明
where T : struct	T必须是值类型，如int,double等
where T : class	T必须是引用类型，如string,List<T>等
where T : new()	T必须有无参构造函数，即T参数可以通过使用new关键字创建实例。当与其他约束一起使用时，new() 约束必须最后指定。
where T : 基类	T 必须继承自某个基类
where T : 接口	T 必须实现某个接口
where T : U	T 必须派生自 U

where T : struct

public class MyClass<T> where T : struct
{public T Value { get; set; }
}

例子：

// 只接受值类型的泛型方法
public class ValueCalculator<T> where T : struct
{public T Add(T a, T b){return (dynamic)a + (dynamic)b; // 简单示例，实际中需要更安全的实现}
}// 使用示例
class Program
{static void Main(){var intCalc = new ValueCalculator<int>();Console.WriteLine(intCalc.Add(5, 3)); // 输出 8// 下面这行会编译错误，因为 string 是引用类型// var stringCalc = new ValueCalculator<string>();}
}

where T : class

public class MyClass<T> where T : class
{public T Value { get; set; }
}

例子 

public class Repository<T> where T : class, new()
{private List<T> items = new List<T>();public T CreateItem(){var newItem = new T(); // 可以实例化，因为有 new() 约束items.Add(newItem);return newItem;}public void DisplayCount(){Console.WriteLine($"Items count: {items.Count}");}
}// 使用示例
class Program
{class Customer{public string Name { get; set; }}static void Main(){var repo = new Repository<Customer>();var customer = repo.CreateItem();customer.Name = "John Doe";repo.DisplayCount(); // 输出 Items count: 1}
}

where T : new()

public class Factory<T> where T : new()
{public T CreateInstance(){return new T();}
}

where T : 基类

public class AnimalShelter<T> where T : Animal
{public void Shelter(T animal){animal.Feed();}
}

where T : 接口

public class Sorter<T> where T : IComparable<T>
{public void Sort(T[] array){Array.Sort(array);}
}

 例子

using System;// 定义一个接口
public interface IDisplayable
{void Display();
}// 实现接口的类
public class Product : IDisplayable
{public string Name { get; set; }public void Display(){Console.WriteLine($"Product: {Name}");}
}// 使用 where 约束确保 T 实现 IDisplayable
public class DisplayManager<T> where T : IDisplayable
{public void Show(T item){item.Display(); // 安全调用，因为知道 T 有 Display 方法}
}// 使用示例
class Program
{static void Main(){var product = new Product { Name = "Laptop" };var manager = new DisplayManager<Product>();manager.Show(product);}
}

where T : U

public class DerivedContainer<T, U> where T : U
{// T 必须继承自 U 或实现 U（如果 U 是接口）
}

 例子

public class Animal
{public virtual void MakeSound(){Console.WriteLine("Some animal sound");}
}public class Dog : Animal
{public override void MakeSound(){Console.WriteLine("Bark!");}
}// 约束 T 必须继承自 Animal
public class AnimalShelter<T> where T : Animal
{public void LetAnimalMakeSound(T animal){animal.MakeSound(); // 可以调用 Animal 的方法}
}// 使用示例
class Program
{static void Main(){var shelter = new AnimalShelter<Dog>();shelter.LetAnimalMakeSound(new Dog()); // 输出 "Bark!"}
}

多重约束

可以为类型参数指定多个约束

需要注意的是：当与其他约束一起使用时，new() 约束必须最后指定。

public class MyClass<T> where T : class, IDisposable, new()
{}

多个类型参数的约束

对于多个类型参数，每个都可以有自己的约束：

 public class MyClass<TKey, TValue>where TKey : IComparable<TKey>where TValue : class,new(){}

约束的优点

1、增强类型安全 - 编译器可以在编译时捕获类型不匹配的错误。

2、减少运行时转换 - 避免不必要的类型检查和转换。

3、启用更多操作 - 知道类型参数具有某些特性（如特定方法或构造函数）后，可以在泛型代码中 使用这些特性。

4、不会对性能产生可测量的影响。

总结：合理使用泛型约束可以显著提高代码质量和安全性，但应该避免过度使用导致不必要的复杂性。在大多数情况下，优点远大于缺点，特别是在开发库代码或框架时。