Самый крутой C# LINQ/лямбда-трюк, который вы когда-либо вытягивали?

LINQ Raytracer определенно возглавляет мой список =)

Я не совсем уверен, если квалифицируется как элегантный, но это, безусловно, самое крутое linq-выражение, которое я когда-либо видел!

О, и просто чтобы быть предельно ясным; я не писал этого ( Люк Хобан сделал это)

Некоторые основные функционалы:

public static class Functionals
{
    // One-argument Y-Combinator.
    public static Func<T, TResult> Y<T, TResult>(Func<Func<T, TResult>, Func<T, TResult>> F)
    {
        return t => F(Y(F))(t);
    }

    // Two-argument Y-Combinator.
    public static Func<T1, T2, TResult> Y<T1, T2, TResult>(Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>> F)
    {
        return (t1, t2) => F(Y(F))(t1, t2);
    }

    // Three-arugument Y-Combinator.
    public static Func<T1, T2, T3, TResult> Y<T1, T2, T3, TResult>(Func<Func<T1, T2, T3, TResult>, Func<T1, T2, T3, TResult>> F)
    {
        return (t1, t2, t3) => F(Y(F))(t1, t2, t3);
    }

    // Four-arugument Y-Combinator.
    public static Func<T1, T2, T3, T4, TResult> Y<T1, T2, T3, T4, TResult>(Func<Func<T1, T2, T3, T4, TResult>, Func<T1, T2, T3, T4, TResult>> F)
    {
        return (t1, t2, t3, t4) => F(Y(F))(t1, t2, t3, t4);
    }

    // Curry first argument
    public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(Func<T1, T2, TResult> F)
    {
        return t1 => t2 => F(t1, t2);
    }

    // Curry second argument.
    public static Func<T2, Func<T1, TResult>> Curry2nd<T1, T2, TResult>(Func<T1, T2, TResult> F)
    {
        return t2 => t1 => F(t1, t2);
    }

    // Uncurry first argument.
    public static Func<T1, T2, TResult> Uncurry<T1, T2, TResult>(Func<T1, Func<T2, TResult>> F)
    {
        return (t1, t2) => F(t1)(t2);
    }

    // Uncurry second argument.
    public static Func<T1, T2, TResult> Uncurry2nd<T1, T2, TResult>(Func<T2, Func<T1, TResult>> F)
    {
        return (t1, t2) => F(t2)(t1);
    }
}

Не очень-то хорошо, если вы не знаете, как их использовать. Чтобы узнать это, вам нужно знать, для чего они предназначены:

• Что такое Карри?
• Что такое y-комбинатор?

Безусловно, самая впечатляющая реализация Linq, с которой я когда-либо сталкивался, - это структура Brahma.

Он может быть использован для разгрузки параллельных вычислений в GPU, используя 'от Linq до GPU'. Вы пишете 'query' на linq, а затем Брахма переводит его на HLSL (язык высокого уровня Shader), чтобы DirectX мог обработать его на GPU.

Этот сайт позволит мне вставить только одну ссылку, так что попробуйте эту веб-трансляцию с dotnetrocks:

http://www.dotnetrocks.com/default.aspx?showNum=466

В противном случае google для проекта Brahma, вы получите правильные страницы.

Очень крутая штука.

GJ

Отчеты о ходе выполнения для длительно выполняющихся запросов LINQ. В записи блога можно найти метод расширения WithProgressReporting(), который позволяет обнаруживать и сообщать о ходе выполнения запроса linq по мере его выполнения.

Для меня двойственность между делегатами (Func<T,R> , Action<T> ) и выражениями ( Expression<Func<T,R>> Expression<Action<T>>) - это то, что порождает наиболее умное использование лямбд.

Например:

public static class PropertyChangedExtensions
{
    public static void Raise(this PropertyChangedEventHandler handler, Expression<Func<object>> propertyExpression)
    {
        if (handler != null)
        {
            // Retrieve lambda body
            var body = propertyExpression.Body as MemberExpression;
            if (body == null)
                throw new ArgumentException("'propertyExpression' should be a member expression");

            // Extract the right part (after "=>")
            var vmExpression = body.Expression as ConstantExpression;
            if (vmExpression == null)
                throw new ArgumentException("'propertyExpression' body should be a constant expression");

            // Create a reference to the calling object to pass it as the sender
            LambdaExpression vmlambda = Expression.Lambda(vmExpression);
            Delegate vmFunc = vmlambda.Compile();
            object vm = vmFunc.DynamicInvoke();

            // Extract the name of the property to raise a change on
            string propertyName = body.Member.Name;
            var e = new PropertyChangedEventArgs(propertyName);
            handler(vm, e);
        }
    }
}

Затем вы можете "safely" реализовать INotifyPropertyChanged , вызвав

if (PropertyChanged != null)
    PropertyChanged.Raise( () => MyProperty );

Примечание: я увидел это в интернете сначала несколько недель назад, а затем потерял ссылку, и с тех пор здесь и там появилось множество вариаций, поэтому я боюсь, что не могу дать правильную атрибуцию.

http://igoro.com/archive/extended-linq-additional-operators-for-linq-to-objects/

http://igoro.com/archive/7-tricks-to-simplify-your-programs-with-linq/

Не мой дизайн, но я использовал его несколько раз, оператор типизированного переключателя: http://community.bartdesmet.net/blogs/bart/archive/2008/03/30/a-functional-c-type-switch.aspx

Это спасло мне так много жизней... иначе если..... иначе если..... еще IF! заявления

На самом деле, я очень горжусь этим для генерации Excel docments: http://www.aaron-powell.com/linq-to-xml-to-excel

Я сделал одну (немного сумасшедшую, но интересную) вещь, как это совсем недавно:

• http://tomasp.net/blog/reactive-iv-reactivegame.aspx

Возможно, не самый крутой, но в последнее время я использую их всякий раз, когда у меня есть блок кода, который получает C+Pd снова и снова, только чтобы изменить несколько строк. Например, выполнение простых команд SQL для извлечения данных может быть выполнено следующим образом:

SqlDevice device = GetDevice();

return device.GetMultiple<Post>(
    "GetPosts",
    (s) => {
        s.Parameters.AddWithValue("@CreatedOn", DateTime.Today);

        return true;
    },
    (r, p) => {
        p.Title = r.Get<string>("Title");

        // Fill out post object

        return true;
    }
);

Который может вернуть список записей, созданных сегодня. Таким образом, мне не придется копировать и вставлять блок try-catch-finally пятнадцать миллионов раз для каждой команды, объекта и т. д.

Я пытался придумать классный способ создания навигационного элемента управления для веб-сайта, который я создавал. Я хотел использовать обычные элементы HTML неупорядоченного списка (используя стандартный вид CSS "Sucker Fish") с эффектом наведения курсора мыши сверху, который показывает выпадающие элементы. У меня был sql зависимый кэшированный DataSet с двумя таблицами (NavigationTopLevels & NavigationBottomLevels). Затем мне нужно было всего лишь создать два объекта класса (TopNav & SubNav) с несколькими необходимыми свойствами (класс TopNav должен был иметь общий список элементов bottomnav -> List<SubNav> SubItems).

var TopNavs = from n in ds.NavigationTopLevels
                          select new TopNav
                          {
                              NavigateUrl = String.Format("{0}/{1}", tmpURL, n.id),
                              Text = n.Text,
                              id = n.id,
                              SubItems = new List<SubNav>(
                                  from si in ds.NavigationBottomLevels
                                  where si.parentID == n.id
                                  select new SubNav
                                  {
                                      id = si.id,
                                      level = si.NavLevel,
                                      NavigateUrl = String.Format("{0}/{1}/{2}", tmpURL, n.id, si.id),
                                      parentID = si.parentID,
                                      Text = si.Text
                                  }
                                )

                          };

 List<TopNav> TopNavigation = TopNavs.ToList(); 

Это может быть и не "coolest", но для многих людей, которые хотят иметь динамическую навигацию, это очень мило, что им не приходится путаться в обычной логике циклирования, которая приходит с этим. LINQ-это, если угодно, экономия времени в этом случае.

Я думаю, что LINQ-это серьезное изменение к .NET, и это очень мощный инструмент.

Я использую LINQ - XML в производстве для анализа и фильтрации записей из файла 6MB XML (с 20 + уровнями узлов) в набор данных в двух строках кода.

До LINQ это заняло бы сотни строк кода и дней для отладки.

Вот что я называю элегантным!

Работа с атрибутами:

private void WriteMemberDescriptions(Type type)
{
    var descriptions =
        from member in type.GetMembers()
        let attributes = member.GetAttributes<DescriptionAttribute>(true)
        let attribute = attributes.FirstOrDefault()
        where attribute != null
        select new
        {
            Member = member.Name,
            Text = attribute.Description
        };

        foreach(var description in descriptions)
        {
            Console.WriteLine("{0}: {1}", description.Member, description.Text);
        }
}

Метод расширения GetAttributes :

public static class AttributeSelection
{
    public static IEnumerable<T> GetAttributes<T>(this ICustomAttributeProvider provider, bool inherit) where T : Attribute
    {
        if(provider == null)
        {
            throw new ArgumentNullException("provider");
        }

        return provider.GetCustomAttributes(typeof(T), inherit).Cast<T>();
    }
}

AttributeSelection -это производственный код, а также определяет GetAttribute и HasAttribute . В этом примере я решил использовать предложения let и where .

OLINQ reactive LINQ queries over INotifyingCollection-они позволяют выполнять (помимо прочего) агрегацию в реальном времени для больших наборов данных.

https://github.com/wasabii/OLinq