C# Where关键字

1.  泛型约束（Generic Constraints）

在泛型类、接口或方法的定义中，where关键字用于指定类型参数的约束。这些约束可以确保类型参数具有某些特定的属性。例如它是一个类、实现了某个接口、是另一个类型的派生类、具有无参构造函数等。

1.1  泛型约束条件表

约束名称	详情
T：struct	类型参数必须是值类型，可指定除Nullable以外的任何值类型
T: class	类型参数必须是引用类型，包括任何类、接口、委托或数组类型
T: new()	类型参数必须具有无参构造函数（且访问保护等级为public），当与其他约束一同使用时，new()约束必须最后指定
T: <基类名称>	类型参数必须是指定的基类或派生自指定的基类
T:<接口名称>	类型参数必须是指定的接口或实现指定的接口，可指定多个接口约束，接口约束也可是泛型

1.2  各约束条件使用代码示例

1.2.1  T: struct

public class MyClass<T> where T : struct  
{  
    // 在这里，T 必须是值类型  
    public void MyMethod(T item)  
    {  
        // ...  
    }  
}

1.2.2  T: class

public class MyClass<T> where T : class  
{  
    // 在这里，T 必须是引用类型  
    public void MyMethod(T item)  
    {  
        // ...  
    }  
}

1.2.3  T: new()

public class MyClass<T> where T : new()  
{  
    //在这里，T 必须具有无参构造函数
    //这个约束允许在泛型类内部创建类型参数类型的新实例
    public T CreateNewInstance()  
    {  
        return new T(); // 调用无参构造函数  
    }  
}

1.2.4  T: <基类名称>

public class BaseClass  
{  
    // 基类成员  
    public void BaseMethod()  
    {  
        // ...  
    }  
}  
  
public class DerivedClass1 : BaseClass  
{  
    // DerivedClass1特有的成员  
}  

public class MyClass<T> where T : BaseClass  
{  
    //在这里，T 必须是指定的基类或派生自指定的基类
    // 泛型方法，接受T类型的参数  
    public void MyMethod(T item)  
    {  
        item.BaseMethod(); // 调用基类的方法  
        // 这里可以添加更多逻辑，针对T类型（即BaseClass或其派生类）  
    }  
}  

1.2.5  T: <接口名称>

public interface IMyInterface  
{  
    void MyInterfaceMethod();  
}  
  
public class MyClass<T> where T : IMyInterface  
{  
    //在这里，T 必须是指定的接口或实现指定的接口
    public void UseInterfaceMethod(T item)  
    {  
        item.MyInterfaceMethod(); // 调用接口方法  
    }  
}

1.2.6  组合约束

1.2.6.1  class & 接口

public interface IMyInterface  
{  
    void MyInterfaceMethod();  
}  
  
public class MyClass<T> where T : class, IMyInterface  
{  
    // 在这里，T 必须是引用类型并实现IMyInterface接口  
    public void UseInterfaceMethod(T item)  
    {  
        item.MyInterfaceMethod(); // 调用接口方法  
    }  
}

1.2.6.1  基类 & 具有无参构造

public class MyBaseClass  
{  
    public MyBaseClass() { } // 无参构造函数  
}  
  
public class MyClass<T> where T : MyBaseClass, new()  
{  
    // 在这里，T 必须是MyBaseClass或其派生类，并且有一个无参构造函数  
    public T CreateNewInstance()  
    {  
        return new T(); // 调用无参构造函数  
    }  
}

2.  LINQ查询中的条件过滤

LINQ（Language Integrated Query----语言集成查询）提供了一种强大的查询能力，允许你以声明式的方式对集合（如数组、列表等）进行查询和操作。where关键字在LINQ查询中用于指定过滤条件，以筛选出满足特定条件的元素。

示例：查询列表中的元素

假设你有一个Person类，包Name和Age属性

public class Person  
{  
    public string Name { get; set; }  
    public int Age { get; set; }  
}  

  

现在有Person对象的列表，如果你想要找出所有年龄大于30岁的人，你可以使用LINQ的where子句来实现：

public class MyClass  
{  
    public List<Person> people = new List<Person>  
    {  
        new Person { Name = "张三", Age = 10 },  
        new Person { Name = "李四", Age = 20 },  
        new Person { Name = "王五", Age = 30 },
        new Person { Name = "赵六", Age = 40 },
        new Person { Name = "随便", Age = 50 },
        new Person { Name = "编个名", Age = 60 },
        new Person { Name = "V TheShow", Age = 200 },
    };  
  
    var olderPeople = from p in people  
                      where p.Age > 50
                      select p;  
    public void WriteFilterPeople()
    {
        foreach (var person in olderPeople)  
        {  
            Console.WriteLine(person.Name + " is " + person.Age + " years old.");  
        }  
    }

    //或者使用Lambda表达式
    var olderPeopleLambda = people.Where(p => p.Age > 50);  
    
    public void WriteFilterPeopleLambda()
    {
        foreach (var person in olderPeopleLambda)  
        {  
            Console.WriteLine(person.Name + " is " + person.Age + " years old.");  
        }  
    }
    //上面的两种方式的输出均为
    /*
    编个名 is 60 years old.
    V TheShow is 200 years old.
    */
    
}