繼承已經實例化的基本對象

Question

是否有可能做一些這樣的：

public class ChildClass : BaseClass 
{ 
    public ChildClass(BaseClass o) 
    { 
     base = o; 
    } 
} 

基本上，我希望有一個透明的方式來包裝的其他功能裏面的基類。我想到的一個例子是自定義設置提供程序，它透明地審查通過它的設置。

public class SettingsAuditor : SettingsProvider 
{ 
    public SettingsAuditor(SettingsProvider o) 
    { 
     base = o; 
    } 

    public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) 
    { 
     // Log the property change to a file 
     base.SetPropertyValues(context, propvals); 
    } 
} 

然後，我可以做到以下幾點：

mySettingsProvider = new SettingsAuditor(mySettingsProvider); 

所有更改會去通過重寫SetPropertyValues傳遞給原來的對象之前。

我可以用一個私人SettingsProvider成員，但後來我要麼無法從SettingsProvider繼承，或有一個完整的SettingsProvider（base）不被使用的。

我正在使用C＃4.0和.Net 4.0。

Answer 1

1. 你不能這樣做base = o;
2. 你在找什麼是Decorator Pattern），這是一種組合方式在運行時添加功能（vs.遺產）。

而不是試圖設置base，你只是包含內部成員。只要包裝器實現與內部對象相同的接口或基類，就可以傳回新的包裝器。您可以根據需要包裝儘可能多的裝飾器。

考慮：

public interface ICar 
{ 
    void Drive(); 
} 

public class Car : ICar 
{ 
    public void Drive() 
    { 
     Console.WriteLine("vroom"); 
    } 
} 

public class BuckleUp : ICar 
{ 
    ICar car; 

    public BuckleUp(ICar car) { this.car = car; } 

    public void Drive() 
    { 
     Console.WriteLine("click!"); 
     car.Drive(); 
    } 
} 

public class CheckMirrors : ICar 
{ 
    ICar car; 
    public CheckMirrors(ICar car) { this.car = car; } 

    public void Drive() 
    { 
     Console.WriteLine("mirrors adjusted"); 
     car.Drive(); 
    } 
} 

現在考慮你有接受一個ICar並告訴它來驅動的方法。你可以給它一個Car，它可以工作，但你也可以將這輛車換成BuckleUp和CheckMirrors，你根本不需要改變那個方法。您已通過使用Decorator Pattern進行合成來修改功能。

Answer 2

不，這看起來應該是一個組合vs繼承問題。你需要評估你是「一個」還是「有一個」。

A little help for your journey

Answer 3

沒有，但你可以假的吧：在這裏

public class SettingsAuditor 
{ 
    SettingsProvider @base; 

    public SettingsAuditor(SettingsProvider o) 
    { 
     @base = o; 
    } 

    public void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) 
    { 
     // Log the property change to a file 
     @base.SetPropertyValues(context, propvals); 
    } 
} 

注意，@base是不實際的基礎，只是命名爲varaible base

Answer 4

這不是一個完整的暗示，它可能可以用表達式樹做得更乾淨......但這是使用DynamicObject和.Net 4.0來僞造AOP的一個快速動作。

public class MyDynamicWrapper<T> : DynamicObject 
{ 
    public T Wrapped { get; private set; } 
    public Action<T> Pre { get; private set; } 
    public Action<T> Post { get; private set; } 


    public MyDynamicWrapper(T wrapped, Action<T> pre, Action<T> post) 
    { 
     this.Wrapped = wrapped; 
     this.Pre = pre; 
     this.Post = post; 
    } 

    public override bool TryGetMember(
     GetMemberBinder binder, 
     out object result) 
    { 
     var type = typeof(T); 
     var method = type.GetMethod(binder.Name); 
     if (method != null) 
     { 
      Func<object> func =() => 
      { 
       if (Pre != null) 
        Pre(Wrapped); 

       // support for input parameters could be added here 
       var ret = method.Invoke(Wrapped, null); 

       if (Post != null) 
        Post(Wrapped); 
       return ret; 
      }; 
      result = func; 
      return true; 
     } 

     return base.TryGetMember(binder, out result); 
    } 
} 
public class MyDynamicWrapper 
{ 
    public static MyDynamicWrapper<T> Create<T>(
     T toWrap, 
     Action<T> pre = null, 
     Action<T> post = null) 
    { 
     return new MyDynamicWrapper<T>(toWrap, pre, post); 
    } 
} 

public class MyObject 
{ 
    public void MyMethod() 
    { 
     Console.WriteLine("Do Something"); 
    } 
} 

class Program 
{ 
    static void Main() 
    { 
     var myobject = new MyObject(); 
     dynamic mydyn = MyDynamicWrapper.Create(
           myobject, 
           p => Console.WriteLine("before"), 
           p => Console.WriteLine("after")); 
     // Note that you have no intellisence... 
     // but you could use the old implmentation before you 
     // changed to this wrapped version. 
     mydyn.MyMethod(); 

     /* output below 
     before 
     Do Something 
     after 
     */ 
    } 
}