namespace ConnectingImpl {

 public interface Int1 {
  string MethodA(string par1);
 }

 public class Impl1 : Int1 {
  public string MethodA(string par1) {
   return "Implementation 1 "+par1;
  }
 }

 public interface Int2 {
  string MethodB();
  void MethodC();
 }

 public class Impl2 : Int2 {
  public string MethodB() {
   return "Implementation 2";
  }
  public void MethodC() {
   System.Console.WriteLine("MethodC");
  }
 }

 public class Test {

  [Implements(typeof(Int1))]
  public Impl1 impl1 = new Impl1();

  [Implements(typeof(Int2))]
  public Impl2 impl2 = new Impl2();

  static void Main() {
   ImplBuilder ib = new ImplBuilder(typeof(Test));

   object conimpl = ib.CreateInstance(new Test());

   System.Console.WriteLine(((Int1) conimpl).MethodA("X"));
   System.Console.WriteLine(((Int2) conimpl).MethodB());
   ((Int2) conimpl).MethodC();
  }

 }

}

public interface IActive
{
  public bool IsActive
  {
    get;
    set;
  }
}

public interface INaming
{
  public string Name
  {
    get;
    set;
  }
}

public interface IActiveImpl
{
  bool _isActive;
  public bool IsActive
  {
    get {return _isActive;}
    set {_isActive = value;}
  }
}

public interface INamingImpl
{
  string _name;
  public string Name
  {
    get {return _name;}
    set {_name = value;}
  }
}

DG>public interface IActive
DG>{
DG>  public bool IsActive
DG>  {
DG>    get;
DG>    set;
DG>  }
DG>}

DG>public interface INaming
DG>{
DG>  public string Name
DG>  {
DG>    get;
DG>    set;
DG>  }
DG>}

DG>

DG>public interface IActiveImpl
DG>{
DG>  bool _isActive;
DG>  public bool IsActive
DG>  {
DG>    get {return _isActive;}
DG>    set {_isActive = value;}
DG>  }
DG>}

DG>public interface INamingImpl
DG>{
DG>  string _name;
DG>  public string Name
DG>  {
DG>    get {return _name;}
DG>    set {_name = value;}
DG>  }
DG>}
DG>

public class NamingImpl : INaming, IActive
{
   bool _isActive;
   string _name;
   public bool IsActive
   {
     get
     {
       return _isActive & _name != null;
     }
   }
   public string Name
   {
     get
     {
       if( _isActive )
         return _name;
       return null;
     }
   }
}

public interface IActive
{
  public bool IsActive
  {
    get;
    set;
  }
}

public class ActiveImpl : IActive
{
  bool _isActive;
  public bool IsActive
  {
    get {return _isActive;}
    set {_isActive = value;}
  }

}

public interface INaming
{
  public string Name
  {
    get;
    set;
  }
}

public class NamingImpl : INaming
{
  string _name;
  public string Name
  {
    get {return _name;}
    set {_name = value;}
  }
}

public class GenericClass : IActive, INaming
{
  // all IActive calls are delegated to this object
  private implements IActive active = new ActiveImpl();  

  // all INaming calls are delegated to this instance
  private implements INaming naming = new ActiveImpl();
}

A>Хм... оценку я тебе уже поставил, а пример не компилируется признавайся, откуда нужно брать этот таинственный Implements ?

using System;
using System.Reflection;
using System.Collections;
using System.Text;
using System.CodeDom.Compiler;

namespace ConnectingImpl {

 [AttributeUsage(AttributeTargets.Field)]
 public class ImplementsAttribute : Attribute {

  private Type intf;
  public Type Interface {
   get {
    return intf;
   }
  }

  public ImplementsAttribute(Type i) {
   intf = i;
  }
 }

 public class BaseImplementor {
  public object ImplClass;
 }

 public class ImplBuilder {
  
  private class Implementation {
   public Type Interface;
   public FieldInfo Field;
   public Implementation(Type i, FieldInfo f) {
    Interface = i;
    Field = f;
   }
  }

  private Assembly CompiledAssembly;

  public ImplBuilder(Type ic) {
   ArrayList il = new ArrayList();

   //retreiving list of implementation fields
   foreach(FieldInfo fi in ic.GetFields()) {
    ImplementsAttribute ia = (ImplementsAttribute) Attribute.
      GetCustomAttribute(fi,typeof(ImplementsAttribute));
    if(ia == null)
     throw new ArgumentException("No any fields marked [Implements] found");
    else {
     il.Add(new Implementation(ia.Interface,fi));
    }
   }

   //Building implementor class
   StringBuilder csrc = new StringBuilder();
   csrc.Append("namespace ConnectingImpl.DynamicAssembly {\n");
   csrc.Append(" public class "+ic.Name+"Implementor : ConnectingImpl.BaseImplementor");
   foreach(Implementation impl in il)
    csrc.Append(","+impl.Interface.FullName);
   csrc.Append(" {\n");
   foreach(Implementation impl in il)
    foreach(MethodInfo mi in impl.Interface.GetMethods()) {
     ParameterInfo[] pia = mi.GetParameters();
     StringBuilder dl = new StringBuilder(), cl = new StringBuilder();
     foreach(ParameterInfo pi in pia) {
      if(dl.Length > 0) {
       dl.Append(", ");
       cl.Append(", ");
      }
      dl.Append(pi.ParameterType.FullName+" "+pi.Name);
      cl.Append(pi.Name);
     }
     csrc.Append("  public ");
     if(mi.ReturnType.FullName != "System.Void")
      csrc.Append(mi.ReturnType.FullName);
     else
      csrc.Append("void");
     csrc.Append(" "+mi.Name+"(");
     csrc.Append(dl);
     csrc.Append(") {\n");
     if(mi.ReturnType.FullName != "System.Void")
      csrc.Append("   return ");
     else
      csrc.Append("   ");
     csrc.Append("(("+ic.FullName+") ImplClass)."+impl.Field.Name+"."+mi.Name+"(");
     csrc.Append(cl);
     csrc.Append(");\n");
     csrc.Append("  }\n");
    }
   csrc.Append(" }\n");
   csrc.Append("}");

   //Compile class
   ICodeCompiler cc = new Microsoft.CSharp.CSharpCodeProvider().CreateCompiler();
   CompilerParameters cp = new CompilerParameters();
   cp.ReferencedAssemblies.Add(ic.Assembly.Location);
   cp.GenerateInMemory = true;
   CompilerResults cr = cc.CompileAssemblyFromSource(cp,csrc.ToString());

   Console.WriteLine(cr.NativeCompilerReturnValue);
   CompiledAssembly = cr.CompiledAssembly;
  }

  public object CreateInstance(object ic) {
   BaseImplementor i = (BaseImplementor) CompiledAssembly.CreateInstance(
     "ConnectingImpl.DynamicAssembly."+ic.GetType().Name+"Implementor");
   i.ImplClass = ic;
   return i;
  }

 }

}