标签: lambda

我正在尝试构建一个为给定对象分配多个属性的Expression,但是在调用已编译的委托之后,它会继续NullReferenceException在lambda体内抛出一个:

var a = Expression.Parameter(typeof(A), "a");
var b = Expression.Parameter(typeof(B), "b");
var c = Expression.Parameter(typeof(C), "c");

LabelTarget returnTarget = Expression.Label(typeof(A));
GotoExpression returnExpression =
    Expression.Return(returnTarget, a, typeof(A));
LabelExpression returnLabel = Expression.Label(
    returnTarget, Expression.Constant(null, typeof(A)));

var expression = Expression.Lambda<Func<A, B, C, A>>(
    Expression.Block(
        typeof(A),
        new[] { a, b, c },
        Expression.Assign(
            Expression.Property(a, typeof(A).GetProperty("B")),
            b),
        Expression.Assign(
            Expression.Property(a, typeof(A).GetProperty("C")),
            c),
        returnExpression,
        returnLabel
    ), 
    a, b, c);

Func<A, B, C, A> func = expression.Compile();

// Calling func throws a NullReferenceException
A result = …

假设函数将两个不同类型的变量作为其输入(例如,一个变量在C语言中为int,一个变量在C语言中为char)并返回一个变量Int.

如果此函数被编码为Haskell或lambda演算代码,函数的类型将如何？

所以假设函数有类型Int -> (Char -> Char) -> Int.这意味着什么？这是否意味着它接收int变量作为输入并运行函数(Char -> Char)和输出Int变量？

我可能会尝试在这里做一些可能无法做到的事情.是否可以SingleOrDefault在我正在构建的表达式上为可枚举方法注入一些逻辑.

这笔交易是我会得到(2)相同的查询结果,而不是用于拉取结果的参数.

交易是ID和ID2价值并非在所有条件下都存在.我正在尝试创建一个基于条件缩小结果的单个表达式.这是我想要完成的事情:

//'ID' and 'ID2' sre parameters passed into method
var query = Repository.GetQuery<Person>()
                      .Include(x => x.PersonDetail)
                      .SingleOrDefault(
                                       if (String.IsNullOrWhiteSpace(ID))
                                       {
                                         x => x.PersonDetail.ID2 == ID2;
                                       }
                                       else
                                       {
                                         x => x.PersonDetail.ID == ID;
                                       }
                                       );

现在它不会构建并产生以下错误:

无法解析符号PersonDetail

好吧,所以我可能已经完全解释了实现,但基本上我可以像上面尝试的那样做,或者我必须编写(2)单独的查询来拉动相同的数据,并保持"决定逻辑"在外部表达？

任何帮助表示赞赏,谢谢!

我有以下功能;

template<typename T, typename U, typename... Parameters>
void transform(void (*func)(Parameters...))
               {
                  auto lambda_function = [func](T args, U params)
                  {
                     auto combined = std::tuple_cat(args, params);
                     helper(func, combined);
                  };
                  return lambda_function;
               }

我似乎无法找到一个可行的返回类型,或者打电话的方式,我希望能够将其称为相似的;

auto func = transform<std::tuple<char,int>, std::tuple<const char*>>(f);
func(arg, param);

鉴于'f','arg'和'param'为;

void f(char arg1, int arg2, const char* arg3);
std::tuple<char,int> arg = std::tuple<char,int>('C',-3);
std::tuple<const char*> param = std::tuple<const char*>("PO");

任何人都有提示,甚至解决方案？

注意:代码可以在; 连锁

我有以下lamba查询,似乎总是返回所有记录,即使在int？status pamameter不为null且有效.任何人都知道为什么Enum过滤器不被尊重？谢谢阅读!

public ActionResult GetArrivals(int facilityId, int? status)
{
    var registrationList = db.Registrations
            .Where(f => f.Facility.Id == facilityId)
            .Where(a => a.ArrivalDateTime >= DateTime.Today)
            .OrderBy(ln => ln.User.LastName)
            .OrderBy(fn => fn.User.FirstName);


    if (status.HasValue)
    {
        UrgentCareWaitWeb.Models.RegistrationStatus statusValue;

        if (Enum.TryParse(status.Value.ToString(), out statusValue) == true)
        {
            registrationList
                .Where(s => s.Status == statusValue);
        } 
    }



    // Project query to view
    var pview = registrationList.Select(r => new PatientRegistrationsView()
            {
                ArrivalId = r.Id,
                UserId = r.User.UserId,
                UserName = r.User.UserName,
                FirstName = r.User.FirstName,
                LastName = r.User.LastName,
                PrimaryPhone = r.User.PrimaryPhone, …

我有一个任务是创建一个类Student并创建一个方法,只有当他们的名字在使用LINQ查询运算符的字母顺序排在他们的姓氏之前时才从数组中选择Students.我写过这Student堂课:

public class Student
{
     private string firstName;
     private string familyName;
     private int age;

    public Student(string firstName, string familyName, int age)
        : this()
    {
        this.firstName = firstName;
        this.familyName = familyName;
        this.age = age;
    }

    public Student()
    {
        firstName = "Dancho";
        familyName = "Mastikata";
        age = 24;
        this.firstName = firstName;
        this.familyName = familyName;
        this.age = age;
    }

    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }

    public string FamilyName
    { …

这是我想要了解的Haskell程序的片段:

englishToFrench =  [("the", "le"),("savage", "violent"),("work", "travail"),
         ("wild", "sauvage"),("chance", "occasion"),]

data Entry = Entry {word       :: String,
                    definition :: String,
                    length'    :: Int}
             deriving Show

listOfEntries = map (\(x, y) -> Entry x y (length x)) englishToFrench

简而言之,该程序获取一个String元组列表,并生成一个Entry对象列表.

但是,我不喜欢中的lambda函数map,我想创建一个常规函数来替换它.

我尝试了这个,但它给了我一个错误,x和y不在范围内:

entryBuilder x y = Entry x y (length x)

entries = map (entryBuilder x y) englishToFrench

任何人都可以告诉我如何转换lambda函数和一般方法是什么？

任何人都可以解释为什么我没有看到WriteLine的(我的)预期输出？当我在VS中调试它并刷新'结果'以在VS内的本地窗口中查看其内容时,我可以看到它.谢谢

Func<Category, bool> del = (Category cat) => { 
    System.Console.WriteLine(cat.CategoryName);
    return cat.CategoryID > 1; 
};


NorthwindEntities nw = new NorthwindEntities();

var result = nw.Categories.Where<Category>(del);

Console.Read();

我有这个lambda:

echo_word = lambda do |words|
  puts words
  many_words = /\w\s(.+)/
    2.times do
      sleep 1
      match = many_words.match(words)
      puts match[1] if match
    end
  sleep 1
end

我希望将它each作为一个块传递给它,并且将来每个块都会更多.

def is_there_an_echo_in_here *args
  args.each &echo_word # throws a name error
end

is_there_an_echo_in_here 'hello out there', 'fun times'

但是当我用这个lambda方法运行my_funky_lambda.rb时,我得到一个NameError.我不确定这个lambda的范围是什么,但我似乎无法访问它is_there_an_echo_in_here.

echo_word如果我使它成为常量ECHO_WORD并使用它就适当地限定和使用,但必须有一个更直接的解决方案.

在这种情况下,echo_word从内部访问lamba 的最佳方法是什么is_there_an_echo_in_here,例如将其包装在模块中,访问全局范围,还有其他什么？

如何在包含lambda表达式的字符串列表的字典中获取值的实例数？

private Dictionary<string, List<string>> dict = new Dictionary<string, List<string>>();

以下需要改进以消除错误; 基本上无法将字符串与字符串列表进行比较.

int count = dict.Values.Count(v => v == "specific value");