Emit, Reflection, кодогенерация

  public class Client
  {
    public void SendMessage(int messageType, object messageContent)
    {
      // .. тут мы должны отправить сообщения, но мы просто сделаем запись в консоль.
      Console.WriteLine("messageSended [Type: {0}, ContentType: {1}]", messageType, messageContent);
    }
  }

  public class FirstMethodContent
  {
    public int SomeFirstParam { get; set; }
    public int SomeSecondParam { get; set; }
  }
 
  public class SecondMethodContent
  {
    public int SomeFirstParam { get; set; }
  }
 
  public class ClientAPI
  {
    Client client;
 
    void FirstMethod(int someFirstParam, int someSecondParam)
    {
      var content = new FirstMethodContent() { SomeFirstParam = someFirstParam, SomeSecondParam = someSecondParam };
      client.SendMessage(1, content);
    }
 
    void SecondMethod(int someFirstParam)
    {
      var content = new SecondMethodContent() { SomeFirstParam = someFirstParam };
      client.SendMessage(2, content);
    }
  }

  // с помощью атрибута ограничиваем его использование
  // только для методов, и только 1 раз
  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)] 
  public class ClientMethodAttribute : Attribute   // Объявляем атрибут
  {
    public int MessageType { get; private set; } // Айдишник сообщения
    public Type ContentType { get; private set; } // Тип класса в который мы будем оборачивать параметры
 
    public ClientMethodAttribute(int messageType, Type contentType)
    {
      MessageType = messageType;
      ContentType = contentType;
    }
  }

  public interface IClientAPI
  {
    [ClientMethod(1, typeof(FirstMethodContent))]
    void FirstMethod(int someFirstParam, int someSecondParam);
 
    [ClientMethod(2, typeof(SecondMethodContent))]
    void SecondMethod(int someFirstParam);
  }

      // создаем динамическую сборку, в текущем домене (AppDomain) с именем "genered_assembly" и с разрешением только на запуск
      var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("genered_assembly"), AssemblyBuilderAccess.Run);
 
      // создаем динамичкский модуль.
      var moduleBuilder = assemblyBuilder.DefineDynamicModule("genered_module");
 
      // объявляем тип с именем Интерейса и постфиксом genered
      var typeBuilder = moduleBuilder.DefineType(typeof(TInterface).Name + "genered");
 
      // унаследуем тип от клиенского апи (что бы не делать лишних действий создавая поле и конструктор)
      typeBuilder.SetParent(typeof(ClientAPI));
 
      // говорим, что тип будет реализовывать наш интерфейс
      typeBuilder.AddInterfaceImplementation(typeof(TInterface));
 
      // достаем из интерфейса все публичные методы
      var methods = typeof(TInterface).GetMethods();

  public class ClientAPI
  {
    protected Client client = new Client();
  }

      foreach (var method in methods)
      {
 
      }

        // достаем наш атрибут
        var clientMethodAttribute = (ClientMethodAttribute) method.GetCustomAttribute(typeof(ClientMethodAttribute));
        if (clientMethodAttribute == null)
          throw new InvalidOperationException("Забыл добавить атрибут! Добавь пожалуйста!");
 
        // достаем тип контекта, объявленого в аттрибуте
        var contentType = clientMethodAttribute.ContentType;
 
        // теперь нам нужно сопоставить свойства с аргементами интерфейса, просто расставим свойства в таком же порядке
        // для этого нужно в начале достать все параметры метода
        var methodParameters = method.GetParameters();
 
        // у свойств будем доставать сразу set методы, по этому объявляем массив MethodInfo
        var contentSetMethods = new MethodInfo[methodParameters.Length];
 
        // достангем все свойства конекта
        var contentProerties = contentType.GetProperties();
 
        for (int i = 0; i < methodParameters.Length; i++)
        {
          // достанем метод установки значения у свойства с таким же именем как и у параметра 
          // (игнорируя загланвые или не загланвые у нас буквы)
          contentSetMethods[i] = contentProerties
            .Single(p => string.Compare(p.Name, methodParameters[i].Name, StringComparison.OrdinalIgnoreCase) == 0)
            .SetMethod;
        }

        // объявим метод, с именем таким же как у интерфейсного
        // он будет публичный, виртуальный (обязательно если хотим переопределить интерфейсный метод)
        // также возвращаемое значение и параметры будут такие же как у интерфейса
        var methodBuilder = typeBuilder.DefineMethod(
          method.Name,
          MethodAttributes.Public | MethodAttributes.Virtual,
          method.ReturnType,
          methodParameters.Select(p => p.ParameterType).ToArray()
        );
 
        // Объявим, что этот метод переопределяет интерфейсный метод.
        typeBuilder.DefineMethodOverride(methodBuilder, method);

        // Дальше достаем геренатор IL кода, и приступаем к генерации тела метода.
        var il = methodBuilder.GetILGenerator();
        // Объявим локальную переменную, с типом контента. Она будет под 0 индексом.
        // Обращение к переменным идет по их индексам.
        il.DeclareLocal(contentType);
 
        // созданим экземпляр объекта
        il.Emit(OpCodes.Newobj, contentType.GetConstructor(new Type[0]));
        // сохраним его в 0 локальную переменную
        il.Emit(OpCodes.Stloc_0);
 
        // теперь необходимо записать в поля объекта аргументы функции
        // начинаем с еденицы, т.к. первый параметр это this
        for(int i = 1; i <= contentSetMethods.Length; i++)
        {
          // загрузим объект, которому будем устанавливать свойства, он у нас в 0 переменной.
          il.Emit(OpCodes.Ldloc_0);
 
          // для оптимизации будем использовать спецефические инструкции
          // для извлечегтя нескольих первых аргументов
          switch (i)
          {
            case 1:
              il.Emit(OpCodes.Ldarg_1); // загружаем первый аргумент
              break;
            case 2:
              il.Emit(OpCodes.Ldarg_2); // загружаем второй аргумент
              break;
            case 3:
              il.Emit(OpCodes.Ldarg_3); // загружаем третий аргумент
              break;
            default:
              // загружаем производьный аргумент, используем короткую форму.
              // Это значит вторым параметром должен быть байт. (в обычной ushort)
              // О короткой форме говорит S в конце,
              il.Emit(OpCodes.Ldarg_S, (byte)i);
              break;
          }
 
          // теперь осталось вызвать метод сет, у объекта, таблицу методов мы уже создали.
          // вызывать мы будем используя Callvirt (виртуальный вызво). Он используется для вызова методов у объектов.
          // для статических функций есть Call.
          il.Emit(OpCodes.Callvirt, contentSetMethods[i - 1]);
        }

        // для вызова метода клиента, нам нужно в начале загрузить в стек объект клиента.
        // используем для этого инструкцию Ldfld (ld - load, fld - field)
        // для вызова этой инструкции нужно в начале загрузить в стек объект, у которого мы будем доставать поле (что очень логично)
        // объект этот это this, тоесть мы можем загрузить его из 0 аргумента.
        il.Emit(OpCodes.Ldarg_0);
        // вторым параметром для инструкции нужно передать FieldInfo
        il.Emit(OpCodes.Ldfld, typeof(ClientAPI).GetField("client", BindingFlags.Instance | BindingFlags.NonPublic));
        // теперь загрузим аргументы для метода клиента
        // загрузим константу
        il.Emit(OpCodes.Ldc_I4, clientMethodAttribute.MessageType);
        // загрузим сохраненную локальную переменную (наш контекнт)
        il.Emit(OpCodes.Ldloc_0);
        // и наконец вызовем функцию
        il.Emit(OpCodes.Callvirt, typeof(Client).GetMethod("SendMessage"));
 
        // самое важное, не забыть завершить метод.
        il.Emit(OpCodes.Ret);

      // создаем тип
      var type = typeBuilder.CreateType();
 
      // создаем инстанс нашего класса
      return (TInterface)Activator.CreateInstance(type);

  public class FirstMethodContent
  {
    public int SomeFirstParam { get; set; }
    public int SomeSecondParam { get; set; }
 
    public override string ToString()
    {
      return string.Format("{0}, {1}, Type: {2}", SomeFirstParam, SomeSecondParam, GetType().Name);
    }
  }
 
  public class SecondMethodContent
  {
    public int SomeFirstParam { get; set; }
 
    public override string ToString()
    {
      return string.Format("{0}, Type: {1}", SomeFirstParam, GetType().Name);
    }
  }
 
    static void Main()
    {
      var autoAPI = TypeGenerator.MakeAPI<IClientAPI>();
      autoAPI.FirstMethod(2, 2);
      autoAPI.SecondMethod(5);
 
      Console.ReadLine();
    }

          // для оптимизации будем использовать спецефические инструкции
          // для извлечегтя нескольих первых аргументов
          switch (i)
          {
            case 1:
              il.Emit(OpCodes.Ldarg_1); // загружаем первый аргумент
              break;
            case 2:
              il.Emit(OpCodes.Ldarg_2); // загружаем второй аргумент
              break;
            case 3:
              il.Emit(OpCodes.Ldarg_3); // загружаем третий аргумент
              break;
            default:
              // загружаем производьный аргумент, используем короткую форму.
              // Это значит вторым параметром должен быть байт. (в обычной ushort)
              // О короткой форме говорит S в конце,
              il.Emit(OpCodes.Ldarg_S, (byte)i);
              break;
          }