interface IListControl

{

      object SelectedItem{ get; set;}

      int SelectedIndex { get; set; }

      IList Items{ get;}

      string Text {get; set;}

      bool Sorted { get; set; }

      void BeginUpdate();

      void EndUpdate();

      void Refresh();

      event EventHandler SelectedValueChanged;

      event EventHandler SelectedIndexChanged;

}

static object castTo(object target, Type interfaceType)

 {

   Type proxyType =

   TypeBuilder proxyTypeBuilder =

     modBuilder.DefineType

      (

       interfaceType.Name

       + “ProxyFor_" + target.GetType().Name,

       TypeAttributes.Class | TypeAttributes.Public,

       typeof (object), //Base type

       new Type[] {interfaceType} //Implemented interface types

      );

    FieldInfo realTarget =

      proxyTypeBuilder.DefineField("realTarget", target.GetType(),

                                   FieldAttributes.Private);

    ConstructorInfo ctor = EmitCtor(proxyTypeBuilder, realTarget);

    EmitMethods(interfaceType, proxyTypeBuilder, realTarget);

    proxyType = proxyTypeBuilder.CreateType();

    return Activator.CreateInstance(proxyType, new object[] {target});

  }

class IATwinOf_B : IA

{

//... The same variables as in B

      //... A constructor to do the copy from b

      //The methods:

      public T1 f1()

      {

            // ... The same IL code as the IL code for f1 in B

      }

      ...

      public T2 fn()

      {

            // ... The same IL code as the IL code for fn in B

      }

}

static void EmitMethods(Type interf, TypeBuilder proxyTypeBuilder,

                        FieldInfo realTarget)

 {

   MethodInfo[] methods = interf.GetMethods();

   foreach (MethodInfo mi in methods)

    {

    Type[] argsTypes = getTypesOf(mi.GetParameters());

    MethodBuilder methodBuilder =

       proxyTypeBuilder.DefineMethod(mi.Name,

           MethodAttributes.Public | MethodAttributes.Virtual,

           mi.ReturnType,

           argsTypes);

    MethodInfo realMethod = realTarget.FieldType.GetMethod(mi.Name,

                            argsTypes);

      ILGenerator generator = methodBuilder.GetILGenerator();

    generator.Emit(OpCodes.Ldarg_0);

    generator.Emit(OpCodes.Ldfld, realTarget);

    for (int i = 0; i < argsTypes.Length; i++)

            generator.Emit(OpCodes.Ldarg, i+1);

    OpCode callCode = OpCodes.Call;

    if (realMethod.IsVirtual) callCode = OpCodes.Callvirt;

      generator.EmitCall(callCode, realMethod, null);

      generator.Emit(OpCodes.Ret);

    }

  }

Fuente 1. Generación de cada uno de los métodos del tipo proxy creado por el conversor

static bool CheckConformance(Type implementingType, Type interfaceType)

{

      if (!interfaceType.IsInterface)

            throw new ArgumentException("Type parameter must be an

                                         interface type");

      foreach (MethodInfo method in interfaceType.GetMethods())

      {

        bool present = false;

        foreach (MethodInfo implMethod in implementingType.GetMethods())

        {

              if (method.ToString().Equals(implMethod.ToString()))

              {

                    present = true;  break;

              }

        }

        if (!present) return false;

   }

   return true;

}

Fuente 2. Verificación de que un tipo implementa todos los métodos existentes en un tipo interface