xml.Div(new { @class = "editor-area" }, () => {
                if (!HideBackButton()) {
                    xml.PTag(() => {
                        xml.ImageActionRef(Page.Content.ImgUrl(IMG_PREVIOUS_BUTTON), "To the List", ActionNameForBackButton(), "Back to the List", ParentListRoutes());
                    });
                }

                xml.FieldSet((fieldset) => {
                    fieldset.Legend(LegendText());

                    if (!string.IsNullOrEmpty(model.ErrorMessage)) {
                        xml.Div(new { @class = "error-message" }, () => {
                            xml.WriteString(model.ErrorMessage);
                        });
                    }
                    if (model.Exception != null) {
                        xml.Div(new { @class = "error-exception" }, () => {
                            xml.PrintException(model.Exception);
                        });
                    }

                    xml.ComplexFieldHidden(GetLambdaFroSerializedObject(m => m.SerializedOriginalModel), model.SerializedOriginalModel);

                    if (fields != null) {
                        foreach (var one_field in fields) {
                            one_field.Render(xml);
                        }
                    } else if (customFields != null) {
                        customFields(xml);
                    } else {
                        throw new InvalidOperationException("Do not have any field for render!");
                    }

                    if (! this.HideSubmitButton())
                    {
                        xml.SubmitButton("Submit");
                    }
                });
            });

N>            xml.Div(new { @class = "editor-area" }, () => {
N>                if (!HideBackButton()) {
N>                    xml.PTag(() => {
                          // сделать разве что "поуже", не так широко,
                          // перенеся длинные строки на несколько строк.
N>                        xml.ImageActionRef(Page.Content.ImgUrl(IMG_PREVIOUS_BUTTON), 
                              "To the List", ActionNameForBackButton(), 
                              "Back to the List", ParentListRoutes());
N>                    });
N>                }

                  // убрал бы скобки вокруг одного параметра лямбды
N>                //xml.FieldSet((fieldset) => {
                  xml.FieldSet(fieldset => {
N>                    fieldset.Legend(LegendText());

N>                    if (!string.IsNullOrEmpty(model.ErrorMessage)) {
N>                        xml.Div(new { @class = "error-message" }, 
                              // А тут убрал бы не обязательные скобки.
                              () => xml.WriteString(model.ErrorMessage););
N>                    }
N>                    if (model.Exception != null) {
N>                        xml.Div(new { @class = "error-exception" },
                              // И тут.
                              () => xml.PrintException(model.Exception););
N>                    }

N>                    xml.ComplexFieldHidden(
                          GetLambdaFroSerializedObject(m => m.SerializedOriginalModel),
                          model.SerializedOriginalModel);

N>                    if (fields != null) {
N>                        foreach (var one_field in fields) {
N>                            one_field.Render(xml);
N>                        }
N>                    } else if (customFields != null) {
N>                        customFields(xml);
N>                    } else {
N>                        throw new InvalidOperationException("Do not have any field for render!");
N>                    }

                      // Этот абзац сильвы выбивается из общего стиля:
                      // скобки не так расставлены, "this." …
N>                    if (!HideSubmitButton()) {
N>                        xml.SubmitButton("Submit");
N>                    }
N>                });
N>            });

…(учитывая подводные и широко неизвестные факты в EE про создания лямбд над методом класса с дженериками)

   .Select(person => person.Name)

         Direct:       82,0 ms
           Data:    1 301,0 ms
    Cached Data:       81,0 ms
          IData:    1 692,0 ms
   Cached IData:      704,0 ms
         Lambda:      865,0 ms
  Cached lambda:      651,0 ms
       Delegate:    2 906,0 ms
Cached delegate:      627,0 ms

  class Program
  {
    interface IData
    {
      int Foo();
    }

    class Data: IData
    {
      public int val;

      public int Foo()
      {
        return val;
      }
    }

    const int Count = 200 * 1000 * 1000;

    static int Foo()
    {
      return 0;
    }

    static void Main(string[] args)
    {
      Measure("Direct", () =>
      {
        for (int i = 0; i < Count; i++)
        {
          Foo();
        }
      });
      Measure("Data", () =>
      {
        for (int i = 0; i < Count; i++)
        {
          new Data()
          {
            val = i
          }.Foo();
        }
      });
      Measure("Cached Data", () =>
      {
        Data data = new Data()
        {
          val = 0
        };
        for (int i = 0; i < Count; i++)
        {
          data.Foo();
        }
      });
      Measure("IData", () =>
      {
        for (int i = 0; i < Count; i++)
        {
          ((IData)new Data()
          {
            val = i
          }).Foo();
        }
      });
      Measure("Cached IData", () =>
      {
        IData data = new Data()
        {
          val = 0
        };
        for (int i = 0; i < Count; i++)
        {
          data.Foo();
        }
      });
      Measure("Lambda", () =>
      {
        for (int i = 0; i < Count; i++)
        {
          Func<int> a = () => i;
          a();
        }
      });
      Measure("Cached lambda", () =>
      {
        int c = 5;
        Func<int> a = () => c;
        for (int i = 0; i < Count; i++)
        {
          a();
        }
      });
      Measure("Delegate", () =>
      {
        for (int i = 0; i < Count; i++)
        {
          Func<int> a = Foo;
          a();
        }
      });
      Measure("Cached delegate", () =>
      {
        Func<int> a = Foo;
        for (int i = 0; i < Count; i++)
        {
          a();
        }
      });
      Console.ReadKey();
    }

    static void Measure(string name, Action callback)
    {
      Stopwatch sw = Stopwatch.StartNew();
      callback();
      sw.Stop();
      Console.WriteLine("{0,15}: {1,10:#,##0.0###} ms", name, sw.ElapsedMilliseconds);
    }
  }

S>      Measure("Data", () =>
S>      {
S>        for (int i = 0; i < Count; i++)
S>        {
S>          new Data()
S>          {
S>            val = i
S>          }.Foo();
S>        }
S>      });

S>      Measure("Lambda", () =>
S>      {
S>        for (int i = 0; i < Count; i++)
S>        {
S>          Func<int> a = () => i;
S>          a();
S>        }
S>      });

for (int i = 0; i < Count; i++)
{
    int j = i;
    Func<int> a = () => j;
    a();
}

1. Вызов virtual-метода = косвенный вызов, самый быстрый из косвенных в CLR;
   
2. Вызов метода через интерфейс = дважды косвенный вызов, чуть медленнее;
   
3. Вызов делегата = косвенный вызов + некоторый оверхед [ + ещё оверхед из-за подстановки Target'а ]

    class Data2: Data
    {
      public override int Foo() // Data.Foo - virtual
      {
        return 42;
      }
    }

П>Что значит "JITтится оно аналогично call"?

1. Вызов virtual-метода = косвенный вызов, самый быстрый из косвенных в CLR;
   
2. Вызов метода через интерфейс = дважды косвенный вызов, чуть медленнее;
   
3. Вызов делегата = косвенный вызов + некоторый оверхед [ + ещё оверхед из-за подстановки Target'а ]

Fun(x =>
    {
        Fun2(y =>
            {

            });
    });

именованные функции рулят.

Virtual call took: 661
Delegate call took: 782
Functional type call took: 642

Virtual call took: 642
Delegate call took: 787
Functional type call took: 640

651
852
638
852

public DoSomething[T](predicator : Predicate[T], word : T) : int

Virtual call took: 1065
Delegate call took: 781
Functional type call took: 640

Virtual call took: 1065
Delegate call took: 781
Functional type call took: 640

using System;
using System.Console;
using System.Diagnostics;

class Foo
{
  public virtual IsTokenChar(word : string) : bool 
  {
    String.IsNullOrEmpty(word);
  }

  // this is a template method
  public DoSomething(word : string) : int
  {
    unchecked
    {
      mutable trueCount = 0;
      
      for (mutable i = 0; i < Repeat; ++i)
        when (IsTokenChar(word))
          ++trueCount;
      
      trueCount;
    }
  }

  public DoSomething(predicator : Predicate[string], word : string) : int
  {
    unchecked
    {
      mutable trueCount = 0;
      
      for (mutable i = 0; i < Repeat; ++i)
        when (predicator(word))
          ++trueCount;
          
      trueCount;
    }
  }

  public DoSomethingHof(predicator : string -> bool, word : string) : int
  {
    unchecked
    {
      mutable trueCount = 0;
      
      for (mutable i = 0; i < Repeat; ++i)
        when (predicator(word))
          ++trueCount;
          
      trueCount;
    }
  }

  private Repeat = 200000000;
}

module Program
{
  Main() : void
  {
    def f = Foo();

    repeat (2)
    {
      def sw = Stopwatch.StartNew();
      _ = f.DoSomething(null);
      sw.Stop();
      WriteLine($"Virtual call took: $(sw.ElapsedMilliseconds)");


      def sw = Stopwatch.StartNew();
      _ = f.DoSomething(str => String.IsNullOrEmpty(str), null);
      sw.Stop();
      WriteLine($"Delegate call took: $(sw.ElapsedMilliseconds)");

      def sw = Stopwatch.StartNew();
      _ = f.DoSomethingHof(str => String.IsNullOrEmpty(str), null);
      sw.Stop();
      WriteLine($"Functional type call took: $(sw.ElapsedMilliseconds)");

      WriteLine();
    }
  }
}

VD>Virtual call took: 1065
VD>Delegate call took: 781
VD>Functional type call took: 640

VD>Virtual call took: 1065
VD>Delegate call took: 781
VD>Functional type call took: 640
VD>

640
925

                   Direct:       84,0 ms
                Direct<T>:       84,0 ms
------
                     Data:    1 304,0 ms
              Cached Data:       80,0 ms
          Data-GenericFoo:    1 273,0 ms
   Cached Data-GenericFoo:       79,0 ms
           GenericData<T>:    1 290,0 ms
    Cached GenericData<T>:       78,0 ms
------
                    IData:    1 864,0 ms
             Cached IData:      717,0 ms
         IData-GenericFoo:    3 855,0 ms
  Cached IData-GenericFoo:    2 780,0 ms
                 IData<T>:    1 415,0 ms
          Cached IData<T>:      637,0 ms
------
                   Lambda:      884,0 ms
            Cached lambda:      635,0 ms
                 Delegate:    2 812,0 ms
          Cached delegate:      722,0 ms
              Delegate<T>:    2 808,0 ms
       Cached delegate<T>:    1 115,0 ms
Done...

using System;
using System.Diagnostics;

class Program
{
  interface IData
  {
    int Foo();
    T GenericFoo<T>() where T: class;
  }
  interface IData<T>
  {
    T Foo();
  }

  class Data: IData
  {
    public int val;

    public int Foo()
    {
      return val;
    }

    public T GenericFoo<T>() where T: class
    {
      return null;
    }
  }

  class GenericData<T>: IData<T>
  {
    public T val;

    public T Foo()
    {
      return val;
    }
  }

  const int Count = 200 * 1000 * 1000;

  static int Foo()
  {
    return 0;
  }
  static T Foo<T>() where T: class
  {
    return null;
  }

  static void Main(string[] args)
  {
    Measure("Direct", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        Foo();
      }
    });
    Measure("Direct<T>", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        Foo<object>();
      }
    });

    Console.WriteLine("------");
    Measure("Data", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        new Data()
        {
          val = i
        }.Foo();
      }
    });
    Measure("Cached Data", () =>
    {
      Data data = new Data()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.Foo();
      }
    });
    Measure("Data-GenericFoo", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        new Data()
        {
          val = i
        }.GenericFoo<object>();
      }
    });
    Measure("Cached Data-GenericFoo", () =>
    {
      Data data = new Data()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.GenericFoo<object>();
      }
    });
    Measure("GenericData<T>", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        new GenericData<int>()
        {
          val = i
        }.Foo();
      }
    });
    Measure("Cached GenericData<T>", () =>
    {
      GenericData<int> data = new GenericData<int>()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.Foo();
      }
    });

    Console.WriteLine("------");
    Measure("IData", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        ((IData)new Data()
        {
          val = i
        }).Foo();
      }
    });
    Measure("Cached IData", () =>
    {
      IData data = new Data()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.Foo();
      }
    });
    Measure("IData-GenericFoo", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        ((IData)new Data()
        {
          val = i
        }).GenericFoo<object>();
      }
    });
    Measure("Cached IData-GenericFoo", () =>
    {
      IData data = new Data()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.GenericFoo<object>();
      }
    });
    Measure("IData<T>", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        ((IData<int>)new GenericData<int>()
        {
          val = i
        }).Foo();
      }
    });
    Measure("Cached IData<T>", () =>
    {
      IData<int> data = new GenericData<int>()
      {
        val = 0
      };
      for (int i = 0; i < Count; i++)
      {
        data.Foo();
      }
    });

    Console.WriteLine("------");
    Measure("Lambda", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        Func<int> a = () => i;
        a();
      }
    });
    Measure("Cached lambda", () =>
    {
      int c = 5;
      Func<int> a = () => c;
      for (int i = 0; i < Count; i++)
      {
        a();
      }
    });
    Measure("Delegate", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        Func<int> a = Foo;
        a();
      }
    });
    Measure("Cached delegate", () =>
    {
      Func<int> a = Foo;
      for (int i = 0; i < Count; i++)
      {
        a();
      }
    });
    Measure("Delegate<T>", () =>
    {
      for (int i = 0; i < Count; i++)
      {
        Func<object> a = Foo<object>;
        a();
      }
    });
    Measure("Cached delegate<T>", () =>
    {
      Func<object> a = Foo<object>;
      for (int i = 0; i < Count; i++)
      {
        a();
      }
    });
    Console.Write("Done...");
    Console.ReadKey();
  }

  static void Measure(string name, Action callback)
  {
    Stopwatch sw = Stopwatch.StartNew();
    callback();
    sw.Stop();
    Console.WriteLine("{0,25}: {1,10:#,##0.0###} ms", name, sw.ElapsedMilliseconds);
  }
}