private static void FillStringBuilderCommon(StringBuilder stringBuilder, String stringArgument)
        {
            if (stringBuilder == null)
            {
                throw new ArgumentNullException("stringBuilder");            }
            if (stringArgument == null)
            {
                throw new ArgumentNullException("stringArgument");
            }

            stringBuilder.Append(stringArgument);
        }

    static class Extensions
    {
        public static string GetName<TResult>(this Expression<Func<TResult>> expression)
        {
            return ((MemberExpression)expression.Body).Member.Name;
        }
    }

        public static void NullValidate1<TResult>(Expression<Func<TResult>> argumentExpresion)
            where TResult : class
        {
            if (argumentExpresion.Compile()() == null)
            {
                throw new ArgumentNullException(argumentExpresion.GetName());
            }
        }

            Tools.NullValidate1(() => stringBuilder);

        [DebuggerStepThrough]
        public static void NullValidate2<TResult>(Expression<Func<TResult>> argumentExpresion, TResult argument)
            where TResult : class
        {
            if (argument == null)
            {
                throw new ArgumentNullException(argumentExpresion.GetName());
            }
        }

            Tools.NullValidate1(() => stringBuilder, stringBuilder);

        [DebuggerStepThrough]
        public static void NullValidate<TResult>(TResult argument, Func<Expression<Func<TResult>>> nameRetreiver)
            where TResult : class
        {
            if (argument == null)
            {
                throw new ArgumentNullException(nameRetreiver().GetName());
            }
        }

            Tools.NullValidate(stringBuilder, () => (() => stringBuilder));

        private static void FillStringBuilderExpression(StringBuilder stringBuilder, String stringArgument)
        {
            Tools.NullValidate(stringArgument, () => (() => stringArgument));
            Tools.NullValidate(stringBuilder, () => (() => stringBuilder));

            stringBuilder.Append(stringArgument);
        }

[FillStringBuilderCommon] StringBuilder length: 3000000
[FillStringBuilderCommon]: 00:00:00.0532751
[FillStringBuilderExpression2] StringBuilder length: 3000000
[FillStringBuilderExpression2]: 00:00:07.2346404
[FillStringBuilderExpression] StringBuilder length: 3000000
[FillStringBuilderExpression]: 00:00:00.1308366
Press any key to exit...

      static void Main(string[] args)
        {
            MeasureFunc((sb, arg) => FillStringBuilderCommon(sb, arg));

            MeasureFunc((sb, arg) => FillStringBuilderExpression2(sb, arg));
            MeasureFunc((sb, arg) => FillStringBuilderExpression(sb, arg));

            Console.WriteLine("Press any key to exit...");
            Console.Read();
        }

        private static void MeasureFunc(Expression<Action<StringBuilder, string>> functionExpression)
        {
            const uint limit = 1000000;
            string title = string.Format("[{0}]", ((MethodCallExpression)functionExpression.Body).Method.Name);

            Action<StringBuilder, string> function = functionExpression.Compile();

            StringBuilder stringBuilder = new StringBuilder();
            String stringArgument = "saa";
            
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            uint index = 0;
            while (index++ < limit)
            {
                function(stringBuilder, stringArgument);
            }

            stopwatch.Stop();

            Console.WriteLine(title + " StringBuilder length: " + stringBuilder.Length);
            Console.WriteLine(title + ": " + stopwatch.Elapsed);
        }

U>        public static void NullValidate1<TResult>(Expression<Func<TResult>> argumentExpresion)
U>            where TResult : class
U>        {
U>            if (argumentExpresion.Compile()() == null)
U>            {
U>                throw new ArgumentNullException(argumentExpresion.GetName());
U>            }
U>        }
U>

public class A
{
  public static Method1([NotNull] parameter : string) : void
  {
    WriteLine(parameter)
  }
}

  static class Arg
  {
    #region Public Methods

    // Не инлайнится, сука такая >:o
    public static void NotNullRef<T>(T value) where T : class
    {
      if (value == null)
      {
        throw new ArgumentNullException(GetArgumentName());
      }
    }

    // А это инлайнится, но меньше контроля в compile-time:
    // можно valuetype передать случайно
    // или ref-аргумент (они не поддерживаются) :(
    public static void NotNull(object value)
    {
      if (value == null)
      {
        throw new ArgumentNullException(GetArgumentName());
      }
    }

    #endregion
    #region Crazy Implementation

    static readonly MethodBase NotNullInfo1 = typeof(Arg).GetMethod("NotNull");
    static readonly MethodBase NotNullInfo2 = typeof(Arg).GetMethod("NotNullRef");

    const byte Ldarg0 = 0x02;
    const byte Ldarg3 = 0x05;
    const byte LdargS = 0x0E;

    // выглядит как шутка, но всё же...
    [MethodImpl(MethodImplOptions.NoInlining)]

    private static string GetArgumentName()
    {
      var stackTrace = new StackTrace(false);

      // смотрим кто нас вызвал
      var frame = stackTrace.GetFrame(1);
      if (frame == null) return null;

      var method = frame.GetMethod();

      // проверяем, заинлайнило ли вызов NotNullRef
      if (method == NotNullInfo1 // а вот вдруг?
       || method == NotNullInfo2)
      {
        frame = stackTrace.GetFrame(2); // ниже
        if (frame == null) return null;

        method = frame.GetMethod();
      }

      // метод получили, теперь берём его внутренности :)
      byte[] il;
      try // может упасть из-за reflection permission?
      {
        var methodBody = method.GetMethodBody();
        if (methodBody == null) return null;
        il = methodBody.GetILAsByteArray();
      }
      catch (System.Security.SecurityException) { return null; }

      var offset = frame.GetILOffset();
      var parameters = method.GetParameters();

      // теперь исследуем MSIL перед вызовом NotNullRef()
      // сдвиг на 4 байта токена метода и 1 байт опкода call
      offset -= 5;

      Debug.Assert(il[offset] == 0x28); // это точно call

      offset--;
      if (offset < 0) return null; // на всякий пожарный

      string nameShort = null,
             nameLong  = null;

      // ищем короткие опкоды ldarg.x
      if (il[offset] >= Ldarg0 &&
          il[offset] <= Ldarg3)
      {
        int id = il[offset] - 2; // порядковый номер аргумента
        if (!method.IsStatic) id--; // учитываем instance-методы

        nameShort = TryGetParameterName(id, parameters);
      }

      offset--; // ещё левее
      // ищем "длинный" вариант - ldarg.S <index>
      if (offset >= 0 && il[offset] == LdargS)
      {
        int id = il[offset + 1];
        if (!method.IsStatic) id--;

        nameLong = TryGetParameterName(id, parameters);
      }

      // а теперь оцениваем что узнали
      if (nameShort != null)
      {
        if (nameLong != null)
        {
          if (nameLong == nameShort) return nameShort;

          // будем уж честными,
          // скажем что не знаем какой именно аргумент :)
          return nameLong + " or " + nameLong;
        }

        return nameShort;
      }
      
      return nameLong;
    }

    static string TryGetParameterName(int id, ParameterInfo[] parameters)
    {
      Debug.Assert(parameters != null);

      if (id < 0 || id >= parameters.Length) return null;

      var type = parameters[id].ParameterType;
      
      // оставляем только ref-типы
      if (type.IsValueType) return null;
      
      return parameters[id].Name;
    }

    #endregion
  }

[какой-нить опкод][и его аргумент 0x0E][ldarg.2][вызов]

[что-то там][ldarg.s][0x04][вызов]

П>Короче занятный костыль

      var method = frame.GetMethod();
      bool isInlined = true;

      // проверяем, заинлайнило ли вызов NotNullRef
      if (method == NotNullInfo1
       || method == NotNullInfo2)
      {
        frame = stackTrace.GetFrame(2); // ниже
        if (frame == null) return null;

        method = frame.GetMethod();
        isInlined = false;
      }

      ...

      if (isInlined) offset++;
      else offset -= 5;

      Debug.Assert(il[offset] == 0x28); // это точно call

        private static void FillStringBuilderCommon(StringBuilder stringBuilder, String stringArgument)
        {
            if (stringBuilder == null)
                Tools.ThrowNullArgumentException(() => stringBuilder);
            if (stringArgument == null)
                Tools.ThrowNullArgumentException(() => stringArgument);

            stringBuilder.Append(stringArgument);
        }

  m.Body = <[
    Assert($(p.ParsedName : name) : object != null, $(msg : string));
    $(m.Body)
  ]>;

П>  m.Body = <[
П>    Assert($(p.ParsedName : name) : object != null, $(msg : string));
П>    $(m.Body)
П>  ]>;
П>

  [Nemerle.MacroUsage (MacroPhase.WithTypedMembers, MacroTargets.Parameter,
                       Inherited = true, AllowMultiple = false)]
  macro NotNull(_ : TypeBuilder, m : MethodBuilder, p : ParameterBuilder)
  {
    if (p.ty.CanBeNull)
    {
      def name      = <[ $(p.AsParsed().PName : name) ]>;
      def nameLoc   = p.NameLocation;
      def loc       = m.Body.Location;
      def paramName = p.Name.ToString();
      def msg       = $<#The ``NotNull'' contract of parameter ``$paramName'' has been violated. See $nameLoc.#>;
      def condition = if (p.ty.Fix().IsValueType) name
                      else                        <[ $name : object ]>;

      m.Body = <[
        when ($condition == null)
        {
          //System.Diagnostics.Debug.Fail($(msg : string));
          throw System.ArgumentNullException($(paramName : string), $(msg : string))
        }
          
        $(m.Body)
      ]>;
      
      m.Body.Location = loc;
    }
    else
      Message.Warning(p.Location, 
        $"The ``NotNull'' contract for parameter ``$(p.Name)'' has no effect. Instance of type ``$(p.ty)'' can't be null reference.");
  }

static class NullValidator<T>
{
    private static readonly T Default = (T) FormatterServices.GetSafeUninitializedObject(typeof (T));
    public static void Validate(T argument)
    {
        if (argument.Equals(Default))
        {
            throw new ArgumentNullException(typeof(T).GetProperties()[0].Name);
        }
    }
}

    public static void NullValidate<TResult>(TResult argument)
        where TResult : class
    {
        NullValidator<TResult>.Validate(argument);

    }
        // исходный вариант
        Tools.NullValidate(stringArgument, () => (() => stringArgument));
        Tools.NullValidate(stringBuilder, () => (() => stringBuilder));
        // вариант с анонимными типами
        Tools.NullValidate(new {stringArgument});
        Tools.NullValidate(new {stringBuilder});

A member declarator can be abbreviated to a simple name (§7.5.2) or a member access (§7.5.4). This is called a projection initializer and is shorthand for a declaration of and assignment to a property with the same name. Specifically, member declarators of the forms
identifier expr . identifier
are precisely equivalent to the following, respectively:
identifer = identifier identifier = expr . identifier