标签: lambda

在下面的例子中,特别是在函数的第二个语句中,什么是传递给lambda函数的'n'参数.通过代码的上下文,我假设它指向数字列表.但我怎么能明确地知道这一点,而不必从代码的上下文中猜测.

//simple example of lambda expression.
public static void SimpleLambdExpression()
{
    List<int> numbers = new List<int>{1,2,3,4,5,6,7};
    var evens = numbers.FindAll(n => n % 2 == 0);
    var evens2 = numbers.FindAll((int n) => { return n % 2 == 0; });
    ObjectDumper.Write(evens);
    ObjectDumper.Write(evens2);
}

我们试图找出基本情况下单元测试的重点,如下面的代码所示.为这个有益的单元测试吗？我们不是试图测试实体框架.我们只是想确保lambda表达式做它应该做的...我们的想法是我们将使用DI传递IQIeryable的SOMETHING.在实践中它将是EF但是用于单元测试并且将是POCO对象/集合.这有道理吗？我们刚刚开始并希望在超出此基本代码之前掌握这些概念.

   public class CongressRepository
{
    CongressDb_DevEntities context = new CongressDb_DevEntities();

    CongressRepository(DbContext db)
    {
        context = (CongressDb_DevEntities) db;
    }

    public IQueryable<tMember> GetAllMembers
    {
        get { return context.tMembers; }
    }

    public IQueryable<tMember> GetVotingMembers
    {
        get { return context.tMembers.Where(x => x.age > 18); }
    }
}

我有一个活动类:

def Event:
    def __init__(self, start, end, rule, location, summary):
        ...
        #start, end, and rule are datetime.datetime objects
        #location and summary are strings

我有一系列事件,我想排序start,然后location

目前我正在对它们进行排序start:

events.sort(key=lambda e: e.start)

如何按开始后按位置(字母数字,因为它是一个字符串)排序？

我有下面的代码,但我很困惑如何使用"Select"关键字将lambda表达式绑定到字符串列表.但是,如果我想调用的方法有两个或更多参数我的问题是如何使lambda表达式

    //this code below is error
    //List<TwoWords> twoWords = stringlist.Select(CreateTwoWords(1,2)) 
    //                      .ToList();

class Program
{
    public class TwoWords
    {
        public string word1 { get; set; }
        public string word2 { get; set; }

        public void setvalues(string words)
        {
            word1 = words.Substring(0, 4);
            word2 = words.Substring(5, 4);
        }

        public void setvalues(string words,int start, int length)
        {
            word1 = words.Substring(start, length);
            word2 = words.Substring(start, length);
        }
    }

    static void Main(string[] args)
    {
        List<string> stringlist = new List<string>();
        stringlist.Add("word1 word2");
        stringlist.Add("word3 word4");

        //i …

我想对组,语言和TestEnum的所有可能组合运行GetResults().如何使用lambda表达式重新编写此代码以避免使用foreach循环？

    public enum TestEnum
    {
        ONE,
        TWO,
        THREE
    }

    public static void Test1()
    {
        List<string> groups = new List<string>() { "group1", "group2", "group3", "group4" };
        List<string> languages = new List<string>() { "EN-CA", "FR-CA" };
        List<string> results = new List<string>();

        foreach (string group in groups)
        {
            foreach (string language in languages)
            {
                foreach (TestEnum enumval in Enum.GetValues(typeof(TestEnum)))
                {
                    results.Add(GetResult(group, language, enumval));
                }
            }
        }

    }
    public static string GetResult(string group, string language, TestEnum enumval)
    {
        return group + language + enumval.ToString(); …

我必须创建一个模板,其返回值是指向某个lambda函数的指针(由模板参数决定).

编译反馈:

error: no matching function for call to ‘laptr(int)’

代码有什么问题？如何解决问题？

#include <iostream>

using namespace std;

template <typename T>
T laptr(int par);

int main(){
    laptr(1);
    return 0;
}

///////////

template <typename T>
T laptr(int par)
{
    if (par == 1)
    {
        int p1 = [](int a, int b)->int{return a*b; };
        return p1;
    }
    else
    {
        double p2 = [](double a, double b)->double{return a + b; };
        return p2;
    }
}

如何使用lambda表达式在C#中乘以两个序列？例如,如果我有{1,2}和{3,4},我想要结果{3,4,6,8}.

基本上我想要一个可以回归的代表.我有一个非常简单的减少我理论上想要的东西:

int i =0;
var x = () => 
{
    if (i > 10)
        return null;

    ++i;
    Debug.Log("keep going");
    return x;
};

var y = x;

while ((y = y()) != null) ;

当然,预期的输出是在控制台中看到"继续"10次.我只是想知道这种语言是否可行(我知道我可以通过for循环实现相同的目标).例如,使用与上面非常相似的代码在JavaScript中进行操作是微不足道的,但我不能让编译器在C#中配合.我认为失败的原因是无法正确描述"x"的类型(Func<Func<Func...,你需要类似前向声明的东西.

我是明确构建LINQ表达式的新手,我试图通过使用Aggregate和Expression.AndAlso来弄清楚如何将IEnumerable >>组合成单个Expression>.

我觉得我越来越近了,但我显然错过了一些东西.

public static Expression<Func<T, bool>> CombineExpressions<T>(
IEnumerable<Expression<Func<T, bool>>> expressions)
{

  if (expressions == null || expressions.Count() == 0)
  {
    return t => true;
  }
  var combined = expressions
                .Cast<Expression>()
                .Aggregate((a, b) => Expression.AndAlso(a, b));

  ParameterExpression pe = Expression.Parameter(typeof(T), "x");

  return Expression.Lambda<Func<T, bool>>(combined, pe);
}

当我调用此方法时,我得到以下异常:

System.ArgumentException: 
       Expression of type 'System.Func`2[SomeEntity,System.Boolean]'
       cannot be used for return type 'System.Boolean'

请帮忙!

我可以使用以下任一方法:

var alert = new Action<string>((s) => MessageBox.Show(s));

// Or

Action<string> alert = (s) => MessageBox.Show(s);

// Or

Action<string> alert = new Action<string>((s) => MessageBox.Show(s));

从C#编译器生成的代码的角度来看,它们之间有什么区别吗？或者只是品味问题？