C#函数编写

关于用C#编写代码的简单问题。这样写函数有什么价值吗

Func<int, int> add2 = x => x + 2;

---

我发现第二个示例更容易阅读，或者我缺少了第一个函数如此编写的一个非常具体的原因？

第一个可以被视为相当于一个函数指针，它可以是空的，只是等待接收一个“委托”。在本例中，它的实现已经用lambda表达式声明了。第二个是实际的常规函数，它也可以作为参数传递给具有等效模板类型的

Func

：

int add2(int x)
{
    return x + 2;
}

int main()
{   
    Func<int, int> add2Func = add2;
    // Invoking:
    int retVal = add2Func.Invoke(10); // will call the add2 function
}

intadd2（intx）
{
返回x+2；
}
int main（）
{   
Func add2Func=add2；
//援引：
int retVal=add2Func.Invoke（10）；//将调用add2函数
}

第一个指针可以被视为相当于一个函数指针，在等待接收“委托”时，该指针可以为空。在本例中，它的实现已经用lambda表达式声明了。第二个是实际的常规函数，它也可以作为参数传递给具有等效模板类型的

Func

：

int add2(int x)
{
    return x + 2;
}

int main()
{   
    Func<int, int> add2Func = add2;
    // Invoking:
    int retVal = add2Func.Invoke(10); // will call the add2 function
}

intadd2（intx）
{
返回x+2；
}
int main（）
{   
Func add2Func=add2；
//援引：
int retVal=add2Func.Invoke（10）；//将调用add2函数
}

第一个是函数对象，而第二个只是函数/方法。区别在于第一个是.Net平台的对象hirachy中的对象，而后一个只是该hirachy中没有的函数。但据我所知，在第二种情况下，只要你需要自动装箱，C#就会为你自动装箱。另一个区别可能是反射api中这些函数的外观。第一个只是一个带有函数值的变量，第二个实际上是api中的函数。

第一个是函数对象，而第二个只是函数/方法。区别在于第一个是.Net平台的对象hirachy中的对象，而后一个只是该hirachy中没有的函数。但据我所知，在第二种情况下，只要你需要自动装箱，C#就会为你自动装箱。另一个区别可能是反射api中这些函数的外观。第一个代码只是一个带有函数值的变量，第二个代码实际上是api中的函数。

这两个代码（假设它们都在方法之外）的含义不同。第一个声明类型为

Func

（接受

int

并返回

int

的委托）的字段，并为其指定lambda表达式。第二个只声明一个带有主体的普通方法。不同之处在于（第一个是字段，第二个是方法），如果是字段，则可以更改

add2

的值

Lambda表达式很有用，因为它们写起来很短，使用类型推断来确定参数的类型（

x

），若不指定为块，则隐式返回值。这就是为什么它们主要用于LINQ，因为它们可以很好地适应一条线。还有第二种语法，匿名方法，如下所示：

Func<int, int> add2 = delegate(int x)
{
    return x + 2;
};

Func add2=委托（int x）
{
返回x+2；
};

匿名方法有一个建议，您可以省略参数（

委托{…}

），并且它匹配任何委托类型。

这两个代码（假设它们都在方法之外）的含义不同。第一个声明类型为

Func

（接受

int

并返回

int

的委托）的字段，并为其指定lambda表达式。第二个只声明一个带有主体的普通方法。不同之处在于（第一个是字段，第二个是方法），如果是字段，则可以更改

add2

的值

Lambda表达式很有用，因为它们写起来很短，使用类型推断来确定参数的类型（

x

），若不指定为块，则隐式返回值。这就是为什么它们主要用于LINQ，因为它们可以很好地适应一条线。还有第二种语法，匿名方法，如下所示：

Func<int, int> add2 = delegate(int x)
{
    return x + 2;
};

Func add2=委托（int x）
{
返回x+2；
};

---

匿名方法有一个建议，可以省略参数（

delegate{…}

），并且它匹配任何委托类型。

有时最好使用

Func

而不是静态函数声明

示例：您有一个将对象从Type1转换为Type2的通用方法

public Tout Convert<Tin, Tout>(Tin obj, Func<Tin, Tout> convertFunc)
{
   return convertFunc(obj);
}

public Tout Convert（田纳西州，Func convertFunc）
{
返回函数（obj）；
}

class1obj=newclass1（）；
Class2 convertedObject=Convert（obj，x=>newclass2（））；

---

有什么好处？Lambda表达式更短，代码更可读

有时最好使用

Func

而不是静态函数声明

示例：您有一个将对象从Type1转换为Type2的通用方法

public Tout Convert<Tin, Tout>(Tin obj, Func<Tin, Tout> convertFunc)
{
   return convertFunc(obj);
}

public Tout Convert（田纳西州，Func convertFunc）
{
返回函数（obj）；
}

class1obj=newclass1（）；
Class2 convertedObject=Convert（obj，x=>newclass2（））；

---

有什么好处？Lambda表达式更短，代码更可读

是的，正如其他人所说，严格地说，你在谈论两件不同的事情。但您的问题仍然是相关的，因为在不同的情况下，您经常需要在使用lambda编写一些代码或编写正式方法之间做出选择

选择主要是风格问题。我要说的是，有时候，有些人过度使用lambda风格仅仅是因为他们想变得聪明，想看看他们能在pos这样的小空间里放多少代码

List<int> list = new List<int> { 6, 3, 9, 2, 6, 9, 7, 11, -4 };
IEnumerable<int> processedList = list.Where(FilterByNumber).OrderBy(OrderByNumber);

private bool FilterByNumber(int i)
{
    return i % 2 == 0;
}

private int OrderByNumber(int i)
{
    return i;
}

Func<int, int> add2 = x => x + 2;

Expression<Func<int, int>> add2 = x => x + 2;

something.Select(x => x + 2);

int add2(int x)
{
  return x + 2;
}

var parExp = Expression.Parameter(typeof(int), "x");
var lamda = Expression.Lambda<Func<int, int>>(
    Expression.Add(parExp, Expression.Constant(2, typeof(int))), parExp);

var lastModAndTag = await ctx.Pending
  .Select(pn => new {pn.Modified, pn.Tag})
  .Union(ctx.Preferences.Select(pr => new {pr.Modified, pr.Tag}))
  .OrderByDescending(dt => dt.Modified).FirstOrDefaultAsync();

private class DateAndTag // Can't use anonymous types as we have to pass method boundaries.
{
  public DateTime Modified { get; set; }
  public string Modified { get; set; }
}
private static DateAndTagFromPending(Pending pn)
{
  return new DateAndTag{Modified = pn.Modified, Tag = pn.Tag};
}
private static DateAndTagFromPreference(Preference pr)
{
  return new DateAndTag{Modified = pr.Modified, Tag = pr.Tag};
}
private static DateTime GetModified(DateAndTag dt)
{ //it's possible to get the property into a method or delegate with reflection, but that's even worse.
  return dt.Modified;
}
//and now in the calling code;
var lastModAndTag = ctx.Pending
  .Select(DateAndTagFromPending)
  .Union(ctx.Preferences.Select(DateAndTagFromPreference))
  .OrderByDescending(GetModified).FirstOrDefault();

Func<int, int> addX = val => val + x; // x is from outside of this step.

Func<int, int> addX = delegate(int val)
{
  return val + x;
};