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