Onde praticar função Lambda? [fechadas]

Question

Atualmente, estou tentando aprender todos os novos recursos do C # 3.0. Eu encontrei uma colecção muito agradável de exemplo para prática LINQ, mas eu não consegue encontrar algo semelhante para Lambda.

Você tem um lugar que eu pudesse praticar função Lambda?

Atualização

LINQPad é ótimo para aprender Linq (thx para aquele que sugerem) e usar um pouco Lambda de alguma expressão. Mas seria interessante em mais exercício específico para Lambda.

Answer 1

LINQPad é uma boa ferramenta para aprender LINQ

Answer 2

Lambdas são apenas algo que, uma vez que a sua cabeça ao redor, você "pegar" ela. Se você estiver usando um delegado no momento, você pode substituí-lo com um lambda. Também os System.Action<...>, System.Func<...> e adições System.Predicate<...> são bons atalhos. Alguns exemplos mostram a sintaxe seria embora útil (aviso: são inane mas eu queria para ilustrar como você pode trocar as funções):

public static void Main()
{
    // ToString is shown below for clarification
    Func<int,string,string> intAndString = (x, y) => x.ToString() + y.ToString();
    Func<bool, float, string> boolAndFloat = (x, y) => x.ToString() + y.ToString();

    // with declared
    Combine(13, "dog", intAndString);
    Combine(true, 37.893f, boolAndFloat);

    // inline
    Combine("a string", " with another", (s1, s2) => s1 + s2);
    // and multiline - note inclusion of return
    Combine(new[] { 1, 2, 3 }, new[] { 6, 7, 8 },
        (arr1, arr2) =>
        {
            var ret = "";
            foreach (var i in arr1)
            {
                ret += i.ToString();
            }
            foreach (var n in arr2)
            {
                ret += n.ToString();
            }

            return ret;
        }
    );

    // addition
    PerformOperation(2, 2, (x, y) => 2 + 2);
    // sum, multi-line
    PerformOperation(new[] { 1, 2, 3 }, new[] { 12, 13, 14 },
        (arr1, arr2) =>
        {
            var ret = 0;
            foreach (var i in arr1)
                ret += i;
            foreach (var i in arr2)
                ret += i;
            return ret;
        }
    );

    Console.ReadLine();

}

public static void Combine<TOne, TTwo>(TOne one, TTwo two, Func<TOne, TTwo, string> vd)
{
    Console.WriteLine("Appended: " + vd(one, two));
}

public static void PerformOperation<T,TResult>(T one, T two, Func<T, T, TResult> func)
{
    Console.WriteLine("{0} operation {1} is {2}.", one, two, func(one,two));
}

Principalmente o que me confundiu foi a sintaxe de atalho, por exemplo, quando usando System.Action apenas para executar um delegado sem parâmetros que você pode usar:

var a = new Action(() => Console.WriteLine("Yay!"));

Ou você poderia fazer:

Action a = () => Console.WriteLine("Yay");

Quando você tem um Action, Func, ou Predicate que leva um argumento que você pode omitir o parêntese:

var f = new Func<int, bool>(anInt => anInt > 0);

ou

// note: no var here, explicit declaration
Func<int,bool> f = anInt => anInt > 0;

em vez de:

Func<int,bool> f = (anInt) => anInt > 0;

ou para ir ao extremo:

Func<int,bool> f = (anInt) =>
{
    return anInt > 0;
}

Como mostrado acima, lambdas de linha única não exigem a instrução de retorno, embora lambdas Func várias linhas fazer.

Eu acho que você vai encontrar a melhor maneira de aprender a usar lambdas é trabalhar muito com coleções e incluem System.Linq em seus utilizando namespaces - você verá uma tonelada de métodos de extensão para suas coleções ea maioria destes métodos permitir-lhe exercer o seu conhecimento de lambdas.

Answer 3

O melhor que eu encontrei é este ligação para o momento. É um questionário que deixe conheceu prática, mas eu gostaria de algo mais Lambda e menos LINQ.