使用委托C#

Question

我是代表们的新手,我想知道第一个代码和第二个代码之间的差异

我上课了

public class FindPerson
{
    public int Age;
    public string Name;
    public string Surname;

    public FindPerson(string name, string surname, int age)
    {
        this.Age = age;
        this.Surname = surname;
        this.Name = name;
    }

    public override string ToString()
    {
        return "Name=" + this.Name + " Surname=" + this.Surname + ", Age=" + this.Age.ToString();
    }
}

第一个代码

public void Test2()
{
    List<FindPerson> lst = new List<FindPerson>();

    lst.Add(new FindPerson("Alex","Sweit",31));
    lst.Add(new FindPerson("Alex2", "Sweit", 30));
    lst.Add(new FindPerson("Alex3", "Sweit", 34));

    FindPerson iam = lst.Find(a => a.Name.Equals("Alex"));
}

第二个代码:

public void Test2()
{
    List<FindPerson> lst = new List<FindPerson>();

    lst.Add(new FindPerson("Alex","Sweit",31));
    lst.Add(new FindPerson("Alex2", "Sweit", 30));
    lst.Add(new FindPerson("Alex3", "Sweit", 34));

    FindPerson iam2 = lst.Find(new Predicate<FindPerson>(delegate(FindPerson find)
    {
        return find.Name.Equals("Alex");
    }));
}

我正在学习使用代表,但目前尚不清楚.

Answer 1

这基本上是一回事.

该delegate() { }语法被引入在C#2.0,而lambda语法是在引入C#3.0.它们的设计考虑了不同的目标,但服务于同一目的.

让我引用Eric Lippert(这是他排名前十的最差C#功能的第7位):

我认为所有相关人员都会同意,对于基本相同的东西,有两个不一致的语法是不幸的.但是,C#坚持使用它,因为现有的C#2.0代码仍然使用旧的语法.

C#2.0语法的"沉重感"在当时被看作是一种好处.想法是用户可能会对嵌套方法的这一新功能感到困惑,并且设计团队希望在那里调用一个明确的关键字,并将嵌套方法转换为委托.没有人能够看到未来知道在几年内需要更轻量级的语法.

现在你不会delegate() { }在新代码中看到语法被用得多,因为几乎每个人都喜欢更轻的lambda =>语法.

new Predicate<FindPerson>只需明确键入委托,不再需要委托.它曾经是C#1 IIRC的强制性要求.在大多数情况下可以推断出它可以省略(在需要时可以参见此处的示例).

它的存在是由于lambda由引擎盖下的类实例表示,在这种特殊情况下Predicate<T>是该类."原始"lambda本身是无类型的,但它可以隐式转换为任何兼容的委托类型.

例如,Predicate<FindPerson>在此示例中是兼容的委托类型,但也是如此Func<FindPerson, bool>.同样的lambda也可以转换为Expression<Func<FindPerson, bool>>,但这是完全不同的事情.这就是为什么你不能用var fn = (int x) => x;C#写的原因,因为fn不能仅从这个表达式中推断出类型.

作为回顾,这些都是等价的:

// Compact lambda
lst.Find(a => a.Name.Equals("Alex"))

// Explicitly typed parameter
lst.Find((FindPerson a) => a.Name.Equals("Alex"))

// Explicit delegate type
lst.Find(new Predicate<FindPerson>(a => a.Name.Equals("Alex")))

// Combination of the two above
lst.Find(new Predicate<FindPerson>((FindPerson a) => a.Name.Equals("Alex")))

// Explicit delegate type through casting
lst.Find((Predicate<FindPerson>)(a => a.Name.Equals("Alex")))

// Lambda block
lst.Find(a => { return a.Name.Equals("Alex"); })

// Delegate block
lst.Find((Predicate<FindPerson>)(delegate(FindPerson a) { return a.Name.Equals("Alex"); }))

// ... etc