var allIds = result.SelectMany(x => x).Distinct().ToList();

var allIds = result.SelectMany.Distinct.ToList

allIds = result.SelectMany.Distinct.ToList

public class Some
{
   private int val1;
   private int val2;
   public Some(int val1, int val2)
   {
    this.val1 = val1;
    this.val2 = val2;
   }
}

public class Some
{
   public Some(int val1, int val2)
   {
   }
}

List<T> ys = xs.ToList();
Func<List<T>> f = xs.ToList;

Just don't break the line between the "return" keyword and what you're returning, or <...> will end the line before you intend to.

public Some(int val1, int val2)
{
    this.val1 = val1;
    this.val2 = val2;
}

var some = Call() hara krishna
some.DoWork() krishna hari

S>С шарпом при этом никаких проблем, если конечно автор понимал, что пишет. Если не понимал — никакая IDE не спасает, увы

G>>Ну да, а пока будете горбиатится и делать мартышкин труд по копированию кода...

G>>Стоп, вы контекст не теряйте, пожалуйста. Когда вы читаете код на гитхабе вы только читаете. Вы не можете опечататься когда читаете.

someVar = 1729
... A lot of lines of code ...
sameVar = 19937
...

public static void F(MyNestedType t)
{
  GC.Collect(); // Что мы делаем с тем объектом, на который ссылается t?
  return;
}

F((new MyParentType().child)?

auto it = min_element(source, [](auto &i){ return i->value; });

S>auto it = min_element(source, [](auto &i){ return i->value; });
S>

template<typename Range, typename Selector, typename Compare = std::less<>>
auto min_element(Range &&x, Selector selector, Compare compare = Compare{})
{
    using std::begin; using std::end;
    return min_element(begin(x), end(x), selector, compare);
}

S>>auto it = min_element(source, [](auto &i){ return i->value; });
S>>

EP>template<typename Range, typename Selector, typename Compare = std::less<>>
EP>auto min_element(Range &&x, Selector selector, Compare compare = Compare{})
EP>{
EP>    using std::begin; using std::end;
EP>    return min_element(begin(x), end(x), selector, compare);
EP>}
EP>

EP>

[](auto &i){ return i->value; }

        Method |      Median |     StdDev | Scaled |         Min | Lnml(min) | Lnml(max) |         Max |
-------------- |------------ |----------- |------- |------------ |---------- |---------- |------------ |
    MinCodeJam |  13.5474 us |  4.2560 us |   1.00 |   9.8527 us |      1.00 |      1.00 |  57.8845 us |
      MinNaive | 133.8322 us | 37.9869 us |   9.88 | 109.2005 us |      9.78 |      9.78 | 584.1817 us |
         MinOk |  17.6527 us |  1.5569 us |   1.30 |  13.9580 us |      1.28 |      1.28 |  25.8633 us |
 MinOkComparer |  16.4211 us |  1.2513 us |   1.21 |  13.5474 us |      1.18 |      1.18 |  27.0949 us |
  MinDoneRight |   1.6421 us |  0.5551 us |   0.12 |   1.2316 us |      0.12 |      0.12 |  10.2632 us |

        Method |        Median |      StdDev | Scaled |           Min | Lnml(min) | Lnml(max) |           Max |
-------------- |-------------- |------------ |------- |-------------- |---------- |---------- |-------------- |
    MinCodeJam |   331.7068 us |  19.2213 us |   1.00 |   289.4224 us |      1.00 |      1.00 |   419.9704 us |
      MinNaive | 4,391.0101 us | 622.1757 us |  13.24 | 2,497.2433 us |     12.18 |     12.18 | 5,005.5709 us |
         MinOk |    25.0422 us |   5.5940 us |   0.08 |    16.4211 us |      0.07 |      0.07 |    79.2320 us |
 MinOkComparer |   313.6436 us |  38.8401 us |   0.95 |   170.3692 us |      0.94 |      0.94 |   474.9812 us |
  MinDoneRight |   252.4749 us |  61.4753 us |   0.76 |   155.5902 us |      0.66 |      0.66 |   359.6227 us |

        private static T MyMinByComparer<T, TValue>(IEnumerable<T> source, Func<T, TValue> selector)
        {
            var comparer = Comparer<TValue>.Default;
            T result = default(T);
            TValue resultValue = default(TValue);
            bool hasData = false;
            foreach (var item in source)
            {
                if (!hasData || comparer.Compare(resultValue, selector(item)) > 0)
                {
                    result = item;
                    resultValue = selector(item);
                    hasData = true;
                }
            }
            if (!hasData)
                throw new Exception("Bla-bla-bla");
            return result;
        }

using System;
using System.Collections.Generic;
using System.Linq;

using CodeJam.Arithmetic;
using CodeJam.Collections;
using CodeJam.PerfTests;

using JetBrains.Annotations;

using NUnit.Framework;

using static CodeJam.AssemblyWideConfig;
using static CodeJam.PerfTests.CompetitionHelpers;

// ReSharper disable once CheckNamespace

namespace CodeJam
{
    [PublicAPI]
    [TestFixture(Category = PerfTestCategory + ": EnumHelper")]
    public class TempPerfTests
    {
        public class Data
        {
            public Data(int structField)
            {
                StructField = structField;
                StringField = structField.ToString();
            }

            public int StructField { get; }
            public string StringField { get; }
        }

        private static readonly Data[] _data = Enumerable
            .Range(1, 1000)
            .Select(i => new Data(i))
            .ToArray();

        private static T MyMinBy<T, TValue>(IEnumerable<T> source, Func<T, TValue> selector)
        {
            var greater = Operators<TValue>.GreaterThan;
            T result = default(T);
            TValue resultValue = default(TValue);
            bool hasData = false;
            foreach (var item in source)
            {
                if (!hasData || greater(resultValue, selector(item)))
                {
                    result = item;
                    resultValue = selector(item);
                    hasData = true;
                }
            }
            if (!hasData)
                throw new Exception("Bla-bla-bla");
            return result;
        }

        private static T MyMinByComparer<T, TValue>(IEnumerable<T> source, Func<T, TValue> selector)
        {
            var comparer = Comparer<TValue>.Default;
            T result = default(T);
            TValue resultValue = default(TValue);
            bool hasData = false;
            foreach (var item in source)
            {
                if (!hasData || comparer.Compare(resultValue, selector(item)) > 0)
                {
                    result = item;
                    resultValue = selector(item);
                    hasData = true;
                }
            }
            if (!hasData)
                throw new Exception("Bla-bla-bla");
            return result;
        }

        [Test]
        public void RunMinByIntCase() => Competition.Run<MinByIntCase>(RunConfig);

        public class MinByIntCase
        {
            [CompetitionBaseline]
            public Data MinCodeJam() => _data.MinBy(x => x.StructField);

            [CompetitionBenchmark(6.98, 15.66)]
            public Data MinNaive() => _data.OrderBy(x => x.StructField).FirstOrDefault();

            [CompetitionBenchmark(0.81, 1.67)]
            public Data MinOk() => MyMinBy(_data, x => x.StructField);

            [CompetitionBenchmark(0.83, 1.64)]
            public Data MinOkComparer() => MyMinByComparer(_data, x => x.StructField);

            [CompetitionBenchmark(0.07, 0.18)]
            public Data MinDoneRight()
            {
                Data result = null;
                int resultValue = 0;
                var local = _data;
                foreach (var other in local)
                {
                    if (result == null || resultValue > other.StructField)
                    {
                        result = other;
                        resultValue = other.StructField;
                    }
                }
                return result;
            }
        }

        [Test]
        public void RunMinByStringCase() => Competition.Run<MinByStringCase>(RunConfig);

        public class MinByStringCase
        {
            [CompetitionBaseline]
            public Data MinCodeJam() => _data.MinBy(x => x.StringField);

            [CompetitionBenchmark(8.46, 21.14)]
            public Data MinNaive() => _data.OrderBy(x => x.StringField).FirstOrDefault();

            [CompetitionBenchmark(0.05, 0.11)]
            public Data MinOk() => MyMinBy(_data, x => x.StringField);

            [CompetitionBenchmark(0.53, 1.33)]
            public Data MinOkComparer() => MyMinByComparer(_data, x => x.StringField);

            [CompetitionBenchmark(0.53, 0.86)]
            public Data MinDoneRight()
            {
                Data result = null;
                string resultValue = null;
                var local = _data;
                foreach (var other in local)
                {
                    if (result == null || string.Compare(resultValue, other.StringField) > 0)
                    {
                        result = other;
                        resultValue = other.StringField;
                    }
                }
                return result;
            }
        }
    }
}

S>>Специально засёк время — 10 минут на код ушло. Блин, но оформление ответа больше потрачу, наверно

//if (value == null)
 //    source=source.Where(x=>x!=null); // Уберем фильтр на Linq из-за тормоза делегата

                bool isFirst=true;
                bool fl=0;
                foreach(var item in source)
                {
                   // Поставим фильтр сюда
                  if (isNullable && item == null) continue;

                   var x = selector(item ); 
                   if (isFirst) 
                      {                  
                      isFirst=false;
                       fl=-1;
                     }
                    else
                      fl=comparer.Compare(x,value);
                                 
                        if (fl< 0)
                        {
                            value = x;
                            result= item;
                        }
                    }
                
                                  if (isFirst)
                  
                                  { 
                                    // по их алгоритму при пустом списке вызвать исключение для Nullable
                                      if (isNullable)
                                        throw NoElementsException();
                                          else
                                       return default(TSource); // вернуть default при пустом списке 
                                    }
            return result;

EP>Мне лень разворачивать именно тебе, именно в этой теме, ибо приходится постоянно повторяться, ты теряешь контекст, возвращаешься опять с многократно отвеченными вопросами, приписываешь мне слова которые я не говорил и т.д. и т.п. — это всё утомляет

Тут речь не про перегрузки и кодогенерацию, а про то что там разное поведение для reference/value type.

if (isNullable && item == null) continue;

EP>>>Мне лень разворачивать именно тебе, именно в этой теме, ибо приходится постоянно повторяться, ты теряешь контекст, возвращаешься опять с многократно отвеченными вопросами, приписываешь мне слова которые я не говорил и т.д. и т.п. — это всё утомляет

По алгоритмической выразительности среди мэйнстрима C++ сейчас впереди всех.
Для сравнения C#, свежий пример — на C++ десять строк (+ может несколько wrapper'ов, это максимум десятки строк), на C# — несколько сотен строк кода (è1 + è2) причём включая кодогенетратор, который генерирует èнесколько тысяч строк, а алгоритм-то совсем пустяковый.

По алгоритмической выразительности среди мэйнстрима C++ сейчас впереди всех.

public static TSource MinItem<TSource, TValue>( 
             [NotNull, InstantHandle] this IEnumerable<TSource> source, 
             [NotNull, InstantHandle] Func<TSource, TValue> selector) => MinItem(source, selector, Comparer<TValue>.Default);

S>>if (isNullable && item == null) continue;
S>>

EP>Строки короткие, а это лишнее сравнение, пусть даже и предсказуемое. Там-то и разница всего 5%~6%

S>>>сравниваем, если что, с вот этим. 5000 строк неэффективной кодогенерации

http://rsdn.ru/forum/flame.comp/6481518.1

Автор: IT
Дата: 24.06.16

IT>>>т.е. требует минимальной поддержки.
EP>>Генерируемый код через склейку текста требует большей поддержки нежели аналогичный обычный код выраженный средствами языка — его труднее писать, труднее отлаживать, труднее править и т.д. и т.п.
IT>Генерируемый код вообще не требует никакой поддержки. Поддержки требует код генератора. В данном случае код генератора прост как угол дома. Вообще-то, precompile time генерация кода самый простой и на сегодняшний день доступный вид метапрограммирования. Так что твои жалобы на сложность поддержки такого решения я не разделяю.

EP>>Так их кодогенерация в итоге быстрее же чем твой вариант

S>Она там не требуется, если честно. У кода нет ни одного теста, который наглядно оправдывает потерю нескольких человекочасов на такую мелочь. Но в проекте для души можно и не так упороться (в хорошем смысле ).

S>>>Блин, но оформление ответа больше потрачу, наверно

S>Время уходит на подумать, текст, вычитку, проверку на грубые ляпы и тыды. Автоматизируй это(с)

public static Nullable<double> Max<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, Nullable<double>> selector
)

var МаксимальноеЗначение=Список.Where(значение =>значение!=null).Max(значение =>значение.СравниваемоеПоле);
//var МаксимальноеЗначение=Список.DefaultIfEmpty().Max(p => p == null ? 0 : p.X)

if (МаксимальноеЗначение!=null)
   Result=Список.Where(значение =>значение .СравниваемоеПоле==МаксимальноеЗначение).First();

IT>>Генерируемый код вообще не требует никакой поддержки. Поддержки требует код генератора. В данном случае код генератора прост как угол дома. Вообще-то, precompile time генерация кода самый простой и на сегодняшний день доступный вид метапрограммирования. Так что твои жалобы на сложность поддержки такого решения я не разделяю.

          Method |      Median |     StdDev | Scaled |         Min | Lnml(min) | Lnml(max) |         Max |
---------------- |------------ |----------- |------- |------------ |---------- |---------- |------------ |
      MinCodeJam |   7.8484 us |  0.7074 us |   1.00 |   7.5465 us |      1.00 |      1.00 |  15.3949 us |
        MinNaive | 146.5534 us | 16.9635 us |  18.67 | 138.2523 us |     18.63 |     18.63 | 416.2661 us |
         MyMinBy |   9.3577 us |  1.4898 us |   1.19 |   9.0558 us |      1.22 |      1.22 |  20.8284 us |
 MyMinByComparer |  10.8670 us |  0.5786 us |   1.38 |  10.5651 us |      1.36 |      1.36 |  20.2247 us |
    MinDoneRight |   0.9056 us |  0.8442 us |   0.12 |   0.9056 us |      0.13 |      0.13 |  15.3949 us |

          Method |        Median |     StdDev | Scaled |           Min | Lnml(min) | Lnml(max) |           Max |
---------------- |-------------- |----------- |------- |-------------- |---------- |---------- |-------------- |
      MinCodeJam |   143.9876 us |  6.2432 us |   1.00 |   136.1392 us |      1.00 |      1.00 |   192.2853 us |
        MinNaive | 1,998.1677 us | 47.3561 us |  13.88 | 1,892.6674 us |     13.87 |     13.87 | 2,263.6543 us |
         MyMinBy |    15.0930 us |  0.9107 us |   0.10 |    14.7912 us |      0.10 |      0.10 |    27.7712 us |
 MyMinByComparer |   136.7430 us | 14.7119 us |   0.95 |   135.2337 us |      0.97 |      0.97 |   283.1455 us |
    MinDoneRight |   123.4611 us |  1.0342 us |   0.86 |   122.5555 us |      0.86 |      0.86 |   133.4225 us |

public static T MyMinByComparer<T, TValue>(
            this IEnumerable<T> source,
            Func<T, TValue> selector,
            IComparer<TValue> comparer = null)
{
    comparer = comparer ?? Comparer<TValue>.Default;

S>Ну и разумеется в реальном коде эти 8 раз выигрыша превращаются в 3-5% разницы, остальной код тоже делом занят

EP>public static T MyMinByComparer<T, TValue>(
EP>            this IEnumerable<T> source,
EP>            Func<T, TValue> selector,
EP>            IComparer<TValue> comparer = null)
EP>{
EP>    comparer = comparer ?? Comparer<TValue>.Default;
EP>

 if (comparer==null) comparer = Comparer<TValue>.Default;

S>> Боюсь за тебя, ты же сейчас на смех изойдешь

EP>Ты в очередной раз не понял о чём речь "Буквы не читай, сообщения пиши"

EP>Вопрос не про значение конструкции. А про мотивацию использования именно её, вместо той которая была в CodeJam — это например вполне может влиять на оптимизатор

public static T MyMinByComparer<T, TValue>(
            this IEnumerable<T> source,
            Func<T, TValue> selector,
            IComparer<TValue> comparer = null)
{
    comparer = comparer ?? Comparer<TValue>.Default;

    [CompetitionBaseline] 
    public Data MinCodeJam() => _data.MinBy(x => x.StructField); 

    [CompetitionBenchmark(18.45, 19.60)] // <=
    public Data MinNaive() => _data.OrderBy(x => x.StructField).FirstOrDefault(); 

    [CompetitionBenchmark(1.18, 1.33)]   // <=
    public Data MyMinBy() => _data.MyMinBy(x => x.StructField);

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

S>>Ну и разумеется в реальном коде эти 8 раз выигрыша превращаются в 3-5% разницы, остальной код тоже делом занят

EP>Остальной код пишется теми же средствами, в нём те же самые "разы проигрыша"

give me delegate of Action<Int> foo.Bar

int f(int arg){ //функция
...
}


float f(float arg){ //разве нельзя иметь еще одну f, но с другим типом аргумента?
...
}

void p(){
(int (int )) *f_ptr; //указатель на функцию (здесь и далее я могу ошибиться в синтаксисе, но суть остается)

int b = f(8); //вызов функции, имя со скобочками
f_ptr = f; //взятие указателя на функцию, имя без скобочек
int c = f_ptr(8); //вызов функции через указатель
}