标签: lambda

这个函数返回1210而不是385,为什么？

public int CalcSquaresSum() {
    int sumOfSquares = 0;
    List<Func<int>> functions = new List<Func<int>>();
    for (int i = 1; i <= 10; i++) {
        functions.Add(() => i * i);
    }

    foreach (var function in functions) {
        sumOfSquares += function(); // why function() is always 121
    }

    return sumOfSquares;
}

我有一个字符串数组

var controlsToGet = new[] {"lblHome","lblContact"};

我有List<LanguageControl>,LanguageControl类包含控件.我想从列表中获取控件Control.Name == controlsToGet

我正在寻找类似的东西

var all = fooelements.where(l=>l.Control.Name == controlsToGet);

有没有lambda或linq.

注意:我能够用Nhibernate的Disjunction做到这一点,我正在寻找类似的东西

编辑:如果我想将此查询用于实体框架的数据库,我该怎么办？

谢谢

在下面列出的第一个方法中,使用方法,它看起来像:ins是一个实例变量,attr是一个为:ins提供getter和setter的方法.我不确定的是它的@ins << lambda作用.

module Rack
  class Builder
    attr :ins
    def use(middleware, *args, &block)
      middleware.instance_variable_set "@rack_builder", self
      def middleware.rack_builder
        @rack_builder
      end
      @ins << lambda { |app|
        middleware.new(app, *args, &block)
      }
    end

    def run(app)
      klass = app.class
      klass.instance_variable_set "@rack_builder", self
      def klass.rack_builder
        @rack_builder
      end
      @ins << app #lambda { |nothing| app }
    end

    def leaf_app
      ins.last
    end
  end
end

Hello Functional C#Friends,

所以这次我试图压缩我的代码并编写更多功能,lambda样式,以及我想创建不必要的列表和类,让编译器为我做的工作.我确实设法以功能方式转换了一小段代码,但之后我不知道如何去做.

var errorList = new List<DataRow>();

IEnumerable<DataRow> resultRows = GetResultRows();

resultRows      
     .Filter(row => row.Field<string>("status").Equals("FAILURE", StringComparison.InvariantCultureIgnoreCase))
     .ForEach(row => { errorList.Add(row); });

if (errorList.Count > 0)
{
    var excludedBooks = new List<string>();
    foreach (DataRow row in errorList)
    {
        if (ToUseBooksList.Contains((string)row["main_book"]))
        {
            BookCheckResults.AddRow(string.Format("Error for MainBook {0}, RiskType {1}",
                                                  row["main_book"], row["risk_type"]));
            if (!excludedBooks.Contains((string)row["main_book"]))
            {
                excludedBooks.Add((string)row["main_book"]);
            }
        }
    }
}

我的扩展方法:

public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
{
    if (collection == null)
        throw new ArgumentNullException("collection");
    if (action == null)
        throw …

我从Jrista的帖子中回答了以下例子.

找到Twentyone计数

int[] numbers = new[] { 1, 3, 11, 21, 9, 23, 7, 4, 18, 7, 7, 3, 21 };

var twentyoneCount = numbers.Where(n => n == 21).Count();

假设我使用"Func"委托如何获得计数？

我试过(原谅我的语法错误)

var otherway= Func  <int> numbers= x => x==21;

我真的很难理解为什么,当我改变我的代码使用lamdba表达式时,它不起作用.

此代码在控制台上工作和打印:

object dummy = new object();
InterServer.ExecuteDataReader(new InterServerRequest(ServerID.a_01, "dbo.getbooks") 
    { 
        Params = new Dictionary<string, object> { 
            { "Tool", "d1" }, 
            { "Loc", locale == string.Empty ? null : locale } } 
    },
    (_, reader) =>
        {
            reader.AsEnumerable(r => (r.GetString(r.GetOrdinal("book")))).ToList().ForEach(Console.WriteLine);
            return new Response(dummy);
        }
    );

此代码已更改为使用lambda表达式; 它没有打印任何东西,我不明白为什么:

InterServer.ExecuteDataReader(new InterServerRequest(ServerID.a_01, "dbo.getbooks")
    { 
        Params = new Dictionary<string, object> { 
            { "Tool", "d1" }, 
            { "Loc", locale == string.Empty ? null : locale } } 
    },
    (_, reader) =>
        {
            return new Response(new …

我正在学习lambda表达式和委托.虽然我尝试执行以下操作,但我在标记为粗线的行处收到错误.(错误:运算符'+ ='不能应用于'Test.MessageDelegate'和'lambda expression'类型的操作数.)帮我处理lambda表达式.

namespace Test
{
    public delegate void MessageDelegate(string title,object sender,EventArgs e);
    class Program
    {
        static event MessageDelegate logEvent;

        static void Main(string[] args)
        {
            logEvent = new MessageDelegate(OnLog);
            logEvent("title",Program.logEvent,EventArgs.Empty);

            Console.ReadKey(true);

        }

        static void OnLog(string title, object sender, EventArgs e)
        {
            if (logEvent != null)
            {
                Console.WriteLine("title={0}", title);
                Console.WriteLine("sender={0}", sender);
                Console.WriteLine("arguments={0}",e.GetType());
            }
        }
     }

 }

我有一组对象.其中一个属性是"Type",它是一个枚举.我想使用lambda来限制"类型"的集合,并且还没有弄清楚如何做到这一点.

想法？

我正在使用List<T>包含父对象和子对象的a.在此列表中,子对象知道其相关的父对象,反之亦然.使用此列表,我正在尝试实现一个业务规则,当父级属于某种类型时,最多可以从列表中删除4个子对象.换句话说,如果此类型的父级有20个孩子,则应从列表中删除其中的4个孩子.

我在这里概述的代码将RemoveAll符合条件的子对象.这是预期的,但我想做的是限制RemoveAll只删除4个孩子.有没有办法做到这一点,RemoveAll或者我应该使用另一种方法吗？

myList.RemoveaAll(item =>
  item.Child && "Foo".Equals(item.Parent.SpecialType));

X = 5
L = list(map(lambda x: 2**X, range(7)))
print (L)

......我希望这会回来:

[1, 2, 4, 8, 16, 32, 64]

...相反,它返回:

[32, 32, 32, 32, 32, 32, 32]

我究竟做错了什么？