在这种情况下，我可以避免反思吗？

Question

比方说，我有这些类层次结构：

public abstract class Parent { 
} 

public class A : Parent { 
    public void Update() { } 
} 

public class B : Parent { 
    public void Update() { } 
} 

public class C : Parent { 
    public void Update() { } 
    public void Update(bool force) { } 

} 

正如你所看到的，Parent所有后代有一个更新方法，不带参数。

我想创建一个实用程序类，它可以与任何种类的Parent对象一起使用，并在过程结束时调用Update。我相信Update方法将被执行，所以我写了这个代码：

public class ParentUtilities { 
    private static readonly Dictionary<Type, MethodInfo> g_UpdateMethods = new Dictionary<Type, MethodInfo>{ 
     { typeof(A), typeof(A).GetMethod("Update", new Type[] {})}, 
     { typeof(B), typeof(B).GetMethod("Update", new Type[] {})}, 
     { typeof(C), typeof(C).GetMethod("Update", new Type[] {})} 
    }; 

    public static void DoSomething(Parent p) 
    { 
      CalculateTheMeaningOfTheLife(p);    

      g_UpdateMethods[p.GetType()].Invoke(p, null); 
    } 
} 

由于我没有跨类层次（这是一个第三方组件）控制。我只能改变实用程序类。我怎样才能避免这种调整？

由于我坚持使用.Net 3.5 SP1，我无法使用动态。

Answer 1

如果只是一个已知的，（非常）小集合的子类，那么你可以做这样的事情：

public class ParentUtilities 
{ 
    public static void DoSomething(Parent p) 
    { 
     CalculateTheMeaningOfTheLife(p); 

     var a = p as A; 
     if (a != null) 
     { 
      a.Update(); 
      return; 
     } 

     var b = p as B; 
     if (b != null) 
     { 
      b.Update(); 
      return; 
     } 

     var c = p as C; 
     if (c != null) 
     { 
      c.Update(); 
      return; 
     } 
    } 
} 

Answer 2

一两件事你可以不接触这些类做的就是创建自己的接口IUpdateable，然后创建一个属于自己的新的并行层次结构中

interface IUpdateable 
{ 
    void Update(); 
} 

public class A : Original.A, IUpdateable {} 

如果你就可以使用自己的叶类，而不是原始的，您可以将该方法编写为接受IUpdateable参数。但同时消耗自己的类也不是很困难的（usingalias directives可以帮助），生产他们也不是那么容易（你需要每次调用创建的原始类的所有实例的原始库后干预的自定义代码，如果该实例键入为Parent，您已回到原点）。

不要忘记逼迫原始代码的作者看到。

Answer 3

创建一个名为UpdatableParent一个临时类，还带有一个Update（）方法，并从中获得来自它的所有其他类。然后使用UpdateableParent作为DoSomething（）参数的类型。

Answer 4

您可以创建一个定义良好的接口实现的包装类。

使用

class Program 
{ 
    static void Main(string[] args) 
    { 
     A a = new A(); 
     IUpdatable wrapper = new AWrapper(a); 
     wrapper.Update(); // prints A.Update 
    } 
} 

包装类和接口

interface IUpdatable 
{ 
    void Update(); 
} 


public abstract class Parent { } 

public class A : Parent 
{ 
    public void Update() 
    { 
     Console.WriteLine("A.Update"); 
    } 
} 

public class AWrapper : IUpdatable 
{ 
    public A Inner { get; private set; } 
    public AWrapper(A a) 
    { 
     Inner = a; 
    } 

    public void Update() 
    { 
     Inner.Update(); 
    } 
}