1

我正在尝试为基于类层次结构的数据结构实现访问者模式。在 C# 中，你不能打开类型（还）。我正在考虑做这样的事情作为替代：

public MyAlgorithm : Func<IBase, X> {
    // default:
    public X apply(IBase data) {}

    // case param1 is ConcreteSubclass
    public X apply(ConcreteSubclass data) {}

    // case param1 is ConcreteOtherClass
    public X apply(ConcreteOtherClass data) {}
}

然后用后期绑定调度调用它：

public ICanApplyAlgorithmOn {
    public void apply(Func<IBase> alg);
    public TResult apply<TResult>(Func<IBase,TResult> alg);
    public TResult apply<TParam1,TResult>(Func<IBase, TParam1, TResult> alg);
    // etc.
}

public abstract Base : ICanApplyAlgorithmOn {
    // etc.
    public TResult apply(Func<IBase, X> alg) {
        // Hopefully I am correct in deducing that this will call the various apply(...) implementations instead of always method(IBase)
        dynamic me = this;
        return alg(me);
    }
    // etc.
}

但是，这不起作用，因为MyAlgorithm不能从 delegate 继承Func<...>。

我看到的唯一解决方案是定义很多我自己的接口，如下所示。有没有更好的办法？

public interface IAlgorithm { public void apply(IBase data); }
public interface IAlgorithm<TReturn> { public TReturn apply(IBase data); }
public interface IAlgorithm<TP1, TReturn> { public TReturn apply(IBase data, TP1 param1); }
// etc.
4

3 回答 3

4
  • 访问者模式是一种手动实现双重调度的方式。
  • 使用dynamic启用多个分派。

如果您的目标只是根据参数的运行时类型选择一个函数，那么选择这两个选项中的一个就足够了 - 将它们组合起来是没有意义的。

这是一个使用dynamic而不是访问者的解决方案：

class MyAlgorithm
{
    public X Apply(IBase data)
    {
        try
        {
            return ApplyImpl((dynamic) data);
        }
        catch (RuntimeBinderException ex)
        {
            throw new ArgumentException(
                string.Format("{0} is not implemented for type {1}.", typeof (MyAlgorithm).Name, data.GetType().Name),
                ex);
        }
    }

    private X ApplyImpl(ConcreteSubclass sub)
    {
        // Your implementation here.
        return null;
    }

    private X ApplyImpl(ConcreteOtherClass sub)
    {
        // Your implementation here.
        return null;
    }
}

你可以像这样使用它：

var algorithm = new MyAlgorithm();
var data = new ConcreteSubclass();
algorithm.Apply(data);

而且，或者，您可以使用这样的委托：

Func<IBase, X> func = algorithm.Apply;
func(data);
于 2015-09-29T16:59:37.037 回答
1

你需要两个接口。一个用于访问者，一个用于访问类

public interface IAlgorithmVisitor<X>
{
    public X Visit(IBase data);
    public X Visit(ConcreteSubclass data);
    public X Visit(ConcreteOtherClass data);
}

public interface IAlgorithmVisitable<X>
{
    X Accept(IAlgorithmVisitor<X> visitor);
}

一个算法类现在可以实现这样的Accept方法：

public X Accept(IAlgorithmVisitor<X> visitor)
{
    return visitor.Visit(this);
}

注意方法重载机制会Visit根据当前类型自动调用正确的重载。正确的方法重载在编译时解决！（不需要后期绑定动态。）

现在，您可以迭代这样的算法集合

IAlgorithmVisitor<int> visitor = new ConcreteAlgorithmVisitor<int>();
foreach (var algorithm in intAlgorithms) {
    int result = algorithm.Accept(visitor);
    //TODO: do something with result.
}

Accept但是，从or方法返回结果是不常见的Visit，因为访问者的任务是做一些有用的事情。它不是迭代器或接受对象的任务。这使您能够创建执行完全不同的事情的访问者。

也许Strategy Pattern比Visitor Pattern更适合您的需求。

于 2015-09-29T17:01:42.837 回答
0

我有点不清楚您要存档的内容，但对于快速运行时类型绑定，您可以使用以下代码：

您可以使用 aDictionary<Type, Func<object, TReturn>>如下：

public class AlgorithmClass<TReturn>
{
    private Dictionary<Type, Func<object, TReturn>> mMethods;

    public AlgorithmClass<TReturn>(Dictionary<Type, Func<object, TReturn>> methods)
    {
        mMethods = methods
    }

    public TReturn Invoke(object argument)
    {
        Type type = argument.GetType();

        //This line supports inheritance and co/contra-variance.
        //If you want to archive full performance and not support those features you can just use mMethods.TryGetValue(type, out Func<object, TReturn>);
        var kvps = mMethods.Where(x => x.Key.IsAssignableFrom(type));

        if(!kvp.Any())
        {
            throw new MissingMethodException("There is no method which can take " + type.Name + " as an argument");
        }

        if(kvp.Count() > 1)
        {
            throw new ArgumentException("There is more than one method which can take " + type.Name + " as an argument");
        }

        return kvp.First().Value(argument);
    }
}

现在在您的代码中，您可以使用这样的类：

AlgorithmClass<ReturnType> algorithm = new AlgorithmClass(new Dictionary<Type, Func<object, ReturnType>>
    {
        {typeof(int), MethodForIntType},
        {typeof(string), MethodForStringType},
        {typeof(MyClass), MethodForMyClassType}
    });

ReturnType MethodForIntType(object anInt)
{
    code...
}

ReturnType MethodForStringType(object aString)
{
    code...
}

ReturnType MethodForMyClassType(object aMyClass)
{
    code...
}

在运行时使用dynamicorSystem.Reflection的方法Binder会减慢你的程序（尽管object作为参数的使用需要在方法的开头装箱、拆箱和强制转换）。

于 2015-09-29T17:04:25.033 回答