C# 将lambda作为委托传递给方法_C#_Delegates

C# 将lambda作为委托传递给方法

C# 将lambda作为委托传递给方法,c#,delegates,C#,Delegates,我是c#的新手，我对代表感到非常困惑。我知道，一旦我们需要将具有不同条件的相同签名方法传递给一个方法，就应该使用它们我有一门课： public class Turbines { public string Turname { get; set; } public double TurID { get; set; } public double Production { get; set; } public double Availability { get;

我是c#的新手，我对代表感到非常困惑。我知道，一旦我们需要将具有不同条件的相同签名方法传递给一个方法，就应该使用它们

我有一门课：

public class Turbines
{
    public string Turname { get; set; }
    public double TurID { get; set; }

    public double Production { get; set; }

    public double Availability { get; set; }
}

我初始化这个类：

List<Turbines> newTur = new List<Turbines>
{
    new Turbines { Turname="inUK", TurID=1245, Production=1452.22, Availability=52.12 },
    new Turbines { Turname="InUS", TurID=125, Production=1052.22, Availability=92.12 }
};

List newTur=新列表
{
新涡轮机{Turname=“inUK”，TurID=1245，产量=1452.22，可用性=52.12}，
新涡轮机{Turname=“InUS”，TurID=125，生产量=1052.22，可用性=92.12}
};

现在，如果我想获得Availability>90%的Turnames，下一次生产量>1300的Turnames，我可以有一个方法并向它传递一个委托

有人能告诉我如何创建方法和委托吗？

只需应用这段代码即可

var result = newTur.Where(each => each.Availability > 90 && each.Turnames > 1300);

只需简单地应用这段代码

var result = newTur.Where(each => each.Availability > 90 && each.Turnames > 1300);

委托是将方法（包括lambda）作为参数传递的一种方式：

   var selection = MyFilter( newTur , t => t.Availability > 90);


IENumerable<Turbines> MyFilter(IENumerable<Turbines> source, Func<Turbines, bool> filter)
{
   return source.Where(filter);
}

语法很复杂，

bool b=ProductionOver1300（atrbine）

是一个正常的函数调用。省去获取委托的参数：

Func f=ProductionOver1300f
现在是一个委托变量，您可以执行bool b=f（atrbine）
委托是将方法（包括lambda）作为参数传递的一种方式：
   var selection = MyFilter( newTur , t => t.Availability > 90);


IENumerable<Turbines> MyFilter(IENumerable<Turbines> source, Func<Turbines, bool> filter)
{
   return source.Where(filter);
}

语法很复杂，bool b=ProductionOver1300（atrbine）
是一个正常的函数调用。省去获取委托的参数：Func f=ProductionOver1300f
现在是一个委托变量，您可以执行bool b=f（atrbine）
您的问题并不完全清楚，因此我将尝试解释一些基本概念
首先，由于您有一个列表
，并且列表
实现了IEnumerable，因此可以使用。
此方法作用于IEnumerable
，并将签名为Func
的谓词作为参数。您可以通过多种方式传递此参数，两种更常见的方式是1）使用lambda和2）使用经典方法：
public class YourClass
{
    public void YourMethod()
    {
        List<Turbines> newTur = new List<Turbines>
        {
            new Turbines { Turname = "inUK", TurID = 1245, Production = 1452.22, Availability = 52.12 },
            new Turbines { Turname = "InUS", TurID = 125, Production = 1052.22, Availability = 92.12 }
        };

        // 1) passing filter as a lambda
        IEnumerable<Turbines> filteredListWithLambda = newTur.Where(t => t.Availability > 90.0 && t.Production > 1300);

        // 2) passing filter as a method
        IEnumerable<Turbines> filteredListWithMethod = newTur.Where(Filter);
    }

    private bool Filter(Turbines turbines)
    {
        return turbines.Availability > 90.0 && turbines.Production > 1300;
    }
}

你问的问题还不完全清楚，所以我将尝试解释一些基本概念
首先，由于您有一个列表
，并且列表
实现了IEnumerable，因此可以使用。
此方法作用于IEnumerable
，并将签名为Func
的谓词作为参数。您可以通过多种方式传递此参数，两种更常见的方式是1）使用lambda和2）使用经典方法：
public class YourClass
{
    public void YourMethod()
    {
        List<Turbines> newTur = new List<Turbines>
        {
            new Turbines { Turname = "inUK", TurID = 1245, Production = 1452.22, Availability = 52.12 },
            new Turbines { Turname = "InUS", TurID = 125, Production = 1052.22, Availability = 92.12 }
        };

        // 1) passing filter as a lambda
        IEnumerable<Turbines> filteredListWithLambda = newTur.Where(t => t.Availability > 90.0 && t.Production > 1300);

        // 2) passing filter as a method
        IEnumerable<Turbines> filteredListWithMethod = newTur.Where(Filter);
    }

    private bool Filter(Turbines turbines)
    {
        return turbines.Availability > 90.0 && turbines.Production > 1300;
    }
}

您需要谓词
委托。此委托表示具有以下签名的方法：
bool Method(Turbine turbine)

您应该编写如下方法：
 var selection2 = MyFilter( newTur , ProductionOver1300);


bool ProductionOver1300(Turbines t)  // matches  Func<Turbines, bool> 
{
   return t.Production > 1300;
} 

public class YourClass
{
    public void YourMethod(double availability, int production)
    {
        List<Turbines> newTur = new List<Turbines>
        {
            new Turbines { Turname = "inUK", TurID = 1245, Production = 1452.22, Availability = 52.12 },
            new Turbines { Turname = "InUS", TurID = 125, Production = 1052.22, Availability = 92.12 }
        };

        IEnumerable<Turbines> filteredListWithLambda = newTur.Where(t => t.Availability > availability && t.Production > production);
    }
}

public List<Turbine> GetTurbines(Predicate<Turbine> predicate) {
    var list = new List<Turbine>();
   foreach (var turbine in newTur) {
       if (predicate(turbine)) {
           list.Add(turbine);
       }
   }
   return list;
}

可以使用lambda表达式重写该方法：
var list = GetTurbines(turbine => turbine.Availability > 90);

=>
前面的单词turbine
是参数名称。=>
之后的所有内容都是您返回的值
希望你现在明白这是怎么回事了
事实上，您刚刚通过创建GetTurbine
重新发明了轮子。在System.Linq.Enumerable
中有一个名为的扩展方法，其中
，基本上是一样的：
var list = newTur.Where(turbine => turbine.Availability > 90).ToList();

您需要谓词
委托。此委托表示具有以下签名的方法：
bool Method(Turbine turbine)

您应该编写如下方法：
 var selection2 = MyFilter( newTur , ProductionOver1300);


bool ProductionOver1300(Turbines t)  // matches  Func<Turbines, bool> 
{
   return t.Production > 1300;
} 

public class YourClass
{
    public void YourMethod(double availability, int production)
    {
        List<Turbines> newTur = new List<Turbines>
        {
            new Turbines { Turname = "inUK", TurID = 1245, Production = 1452.22, Availability = 52.12 },
            new Turbines { Turname = "InUS", TurID = 125, Production = 1052.22, Availability = 92.12 }
        };

        IEnumerable<Turbines> filteredListWithLambda = newTur.Where(t => t.Availability > availability && t.Production > production);
    }
}

public List<Turbine> GetTurbines(Predicate<Turbine> predicate) {
    var list = new List<Turbine>();
   foreach (var turbine in newTur) {
       if (predicate(turbine)) {
           list.Add(turbine);
       }
   }
   return list;
}

可以使用lambda表达式重写该方法：
var list = GetTurbines(turbine => turbine.Availability > 90);

=>
前面的单词turbine
是参数名称。=>
之后的所有内容都是您返回的值
希望你现在明白这是怎么回事了
事实上，您刚刚通过创建GetTurbine
重新发明了轮子。在System.Linq.Enumerable
中有一个名为的扩展方法，其中
，基本上是一样的：
var list = newTur.Where(turbine => turbine.Availability > 90).ToList();

在本例中，您希望在两个不同的时间从同一集合（列表）中获得两个不同的结果。最基本的方法是在该集合中定义返回结果的方法，例如一个方法返回可用性>90%的结果，另一个方法返回的结果的产量>1300。但是这样做，您就失去了请求的动态特性，并使集合中的方法变得繁杂——这意味着每次您需要更改此条件时，您都需要修改集合并添加新方法
为了解决这个问题，我们有委托——委托的作用就像函数指针一样。因此，基本上不是在容器中编写新方法，而是将一段代码作为对象传递，该对象决定从集合中选择哪些元素。这种方法被称为“控制反转”
所以，为了获得可用性，您可以调用List.Where并向其传递一个函数，该函数告诉它是否包含特定的对象
Func<Turbines, bool> availabilityFunc = delegate (Turbines t)
{
    return t.Availability > 90;
};
var result = newTur.Where(availabilityFunc);

在本例中，您希望在两个不同的时间从同一集合（列表）中获得两个不同的结果。最基本的方法是在该集合中定义返回结果的方法，例如一个方法返回可用性>90%的结果，另一个方法返回的结果的产量>1300。但是这样做，您就失去了请求的动态特性，并使集合中的方法变得繁杂——这意味着每次您需要更改此条件时，您都需要修改集合并添加新方法
为了解决这个问题，我们有委托——委托的作用就像函数指针一样。因此，基本上不是在容器中编写新方法，而是将一段代码作为对象传递，该对象决定从集合中选择哪些元素。这种方法被称为“控制反转”
所以，为了获得可用性，您可以调用List.Where并向其传递一个函数，该函数告诉它是否包含特定的对象
Func<Turbines, bool> availabilityFunc = delegate (Turbines t)
{
    return t.Availability > 90;
};
var result = newTur.Where(availabilityFunc);

你是说newTur.Where（t=>t.Availability>90.0&&t.Production>1300）？@ChristianKiewiet为了更好地理解委托，我想请你告诉我如何创建一个方法来分别传递这些条件newTur是一个实现i的列表