没有访客模式的动态调度

时间:2012-12-27 22:33:45

标签: c# mono polymorphism overloading dynamic-dispatch

问题

我正在使用已经存在的库,以及我无法访问的源代码。该库代表AST。

我想复制此AST的部分内容,但重命名过程中对变量的引用。由于可以有一个包含Expression对象的AssignCommand-Object,我希望能够使用自己的函数复制每个对象,因此我可以递归地调用它们。但是,由于我无法访问库的代码,因此无法添加CopyAndRename(string prefix)等方法。

因此,我的方法是创建一个具有多个重载的单个函数Rename。因此,我的家庭功能如下:

public static Command Rename(Command cmd, string prefix)
public static AssignCommand Rename(AssignCommand cmd, string prefix)
public static AdditionExpressionRename(AdditionExpression expr, string prefix)
....

现在,函数包含List<Command>,其中AssignCommandCommand的子类。我假设我可以将Command传递给Rename - 函数,运行时会找到最具体的函数。但是,情况并非如此,所有命令都传递给Command Rename(Command cmd, string prefix)。为什么会这样?有没有办法将调用委托给正确的函数而不使用丑陋的is - 操作?

最小示例

我已将此问题分解为以下NUnit-Testcode

using NUnit.Framework;

public class TopClass{
    public int retVal;
}

public class SubClassA : TopClass{ }

[TestFixture]
public class ThrowawayTest {


    private TopClass Foo (TopClass x) {
        x.retVal = 1;
        return x;
    }

    private SubClassA Foo (SubClassA x) {
        x.retVal = 2;
        return x;
    }

    [Test]
    public void OverloadTest(){
        TopClass t = new TopClass();
        TopClass t1 = new SubClassA();
        SubClassA s1 = new SubClassA();

    t = Foo (t);
        t1 = Foo (t1);
        s1 = Foo (s1);

        Assert.AreEqual(1, t.retVal);
        Assert.AreEqual(2, s1.retVal);
        Assert.AreEqual(2, t1.retVal);
    }
}

所以我的问题归结为:“如何在不诉诸is的情况下,以优雅,多态,面向对象的方式修复上述测试 - 检查?”

扩展方法

我也尝试过如下使用扩展方法。这并没有解决问题,因为它们只是上述方法的语法糖:

using NUnit.Framework;
using ExtensionMethods;

public class TopClass{
    public int retVal;
}

public class SubClassA : TopClass{ }

[TestFixture]
public class ThrowawayTest {


    private TopClass Foo (TopClass x) {
        x.retVal = 1;
        return x;
    }

    private SubClassA Foo (SubClassA x) {
        x.retVal = 2;
        return x;
    }

    [Test]
    public void OverloadTest(){
        TopClass t = new TopClass();
        TopClass t1 = new SubClassA();
        SubClassA s1 = new SubClassA();

        t.Foo(); s1.Foo(); t1.Foo();

        Assert.AreEqual(1, t.retVal);
        Assert.AreEqual(2, s1.retVal);
        Assert.AreEqual(2, t1.retVal);
    }
}

namespace ExtensionMethods{
    public static class Extensions {
        public static void Foo (this TopClass x) {
            x.retVal = 1;
        }

        public static void Foo (this SubClassA x) {
            x.retVal = 2;
        }
    }
}

3 个答案:

答案 0 :(得分:7)

与Kevin的答案相似,我会考虑利用dynamic关键字。我只想提到另外两种方法。

现在,您并不需要访问源代码,只需要访问类型本身,即组件。只要类型为public(不是privateinternal),这些就应该有效:

动态访客

这个方法使用与传统Visitor模式类似的方法。

创建一个访问者对象,每个子类型有一个方法(结束类型,不是中间类或基类,如Command),接收外部对象作为参数。

然后要调用它,在编译时你不知道确切类型的特定对象上,只需像这样执行访问者:

visitor.Visit((dynamic)target);

对于包含您要访问的子表达式的类型,您还可以在访问者本身内处理递归。

处理程序字典

现在,如果您只想处理一些类型,而不是所有类型,那么只需创建一个由Dictionary索引的Type处理程序就可能更简单了。这样你可以检查字典是否有精确类型的处理程序,如果有,则调用它。通过标准调用可能会强制您在您的处理程序中进行强制转换,或者通过DLR调用,这将不会产生一点性能损失。

答案 1 :(得分:4)

我不确定Mono是否支持它,但你可以通过非常具体地使用泛型来完成你正在寻找的东西。 C#4.0中的dynamic关键字。你要做的是创建一个新的虚拟插槽,但语义略有不同(C#虚函数不协变)。 dynamic所做的是将函数重载决策推送到运行时,就像虚函数一样(尽管效率低得多)。扩展方法&amp;静态函数都具有编译时重载解析,因此变量的静态类型就是使用的,这就是你要解决的问题。

public class FooBase
{
    public int RetVal { get; set; }
}

public class Bar : FooBase {}

设置动态访问者。

public class RetValDynamicVisitor
{
    public const int FooVal = 1;
    public const int BarVal = 2;

    public T Visit<T>(T inputObj) where T : class
    {            
        // Force dynamic type of inputObj
        dynamic @dynamic = inputObj; 

        // SetRetVal is now bound at runtime, not at compile time
        return SetRetVal(@dynamic);
    }

    private FooBase SetRetVal(FooBase fooBase)
    {
        fooBase.RetVal = FooVal;
        return fooBase;
    }

    private Bar SetRetVal(Bar bar)
    {
        bar.RetVal = BarVal;
        return bar;
    }
}

特别感兴趣的是inputObj, @dynamic Visit<T>Visit(new Bar())的类型。

public class RetValDynamicVisitorTests
{
    private readonly RetValDynamicVisitor _sut = new RetValDynamicVisitor();

    [Fact]
    public void VisitTest()
    {
        FooBase fooBase = _sut.Visit(new FooBase());
        FooBase barAsFooBase = _sut.Visit(new Bar() as FooBase);
        Bar bar = _sut.Visit(new Bar());

        Assert.Equal(RetValDynamicVisitor.FooVal, fooBase.RetVal);
        Assert.Equal(RetValDynamicVisitor.BarVal, barAsFooBase.RetVal);
        Assert.Equal(RetValDynamicVisitor.BarVal, bar.RetVal);
    }
}

我希望单声道是可行的!

答案 2 :(得分:1)

这是没有动态的版本,动态版本太慢(第一次调用):

public static class Visitor
{
    /// <summary>
    /// Create <see cref="IActionVisitor{TBase}"/>.
    /// </summary>
    /// <typeparam name="TBase">Base type.</typeparam>
    /// <returns>New instance of <see cref="IActionVisitor{TBase}"/>.</returns>
    public static IActionVisitor<TBase> For<TBase>()
        where TBase : class
    {
        return new ActionVisitor<TBase>();
    }

    private sealed class ActionVisitor<TBase> : IActionVisitor<TBase>
        where TBase : class
    {
        private readonly Dictionary<Type, Action<TBase>> _repository =
            new Dictionary<Type, Action<TBase>>();

        public void Register<T>(Action<T> action)
            where T : TBase
        {
            _repository[typeof(T)] = x => action((T)x);
        }

        public void Visit<T>(T value)
            where T : TBase

        {
            Action<TBase> action = _repository[value.GetType()];
            action(value);
        }
    }
}

接口声明:

public interface IActionVisitor<in TBase>
    where TBase : class
{

    void Register<T>(Action<T> action)
        where T : TBase;    

    void Visit<T>(T value)
        where T : TBase;
}

用法:

IActionVisitor<Letter> visitor = Visitor.For<Letter>();
visitor.Register<A>(x => Console.WriteLine(x.GetType().Name));
visitor.Register<B>(x => Console.WriteLine(x.GetType().Name));

Letter a = new A();
Letter b = new B();
visitor.Visit(a);
visitor.Visit(b);

控制台输出: A,B ,请查看more details