Ответ 1

Как и в случае с ответом Кевина, я бы предпочел использовать ключевое слово dynamic. Я просто упомянул о двух дополнительных подходах.

Теперь вам не нужен доступ к исходному коду, вам просто нужен доступ к самим типам, то есть к сборке. Пока типы public (не private или internal), они должны работать:

Динамический посетитель

Этот подход использует аналогичный подход к обычному шаблону Visitor.

Создайте объект-посетитель с одним методом для каждого подтипа (конечные типы, а не промежуточные или базовые классы, такие как Command), получив внешний объект как параметр.

Затем, чтобы вызвать его, на конкретном объекте, о котором вы не знаете точного типа во время компиляции, просто выполните посетителя следующим образом:

visitor.Visit((dynamic)target);

Вы также можете обрабатывать рекурсию внутри самого посетителя, для типов, у которых есть подвыражения, которые вы хотите посетить.

Словарь обработчиков

Теперь, если вы хотите обрабатывать несколько типов, не все из них, вам может быть проще просто создать Dictionary обработчиков, индексированных с помощью Type. Таким образом, вы можете проверить, есть ли у словаря обработчик точного типа, если он это делает, вызывать его. Либо через стандартный вызов, который может заставлять вас использовать в вашем обработчике, либо через вызов DLR, который не будет, но будет иметь небольшой успех).

Ответ 2

Я не уверен, поддерживается ли оно в Mono, но вы можете выполнить то, что ищете, очень специфичным использованием генериков и ключевым словом dynamic в С# 4.0. То, что вы пытаетесь сделать, это создать новый виртуальный слот, но с немного другой семантикой (виртуальные функции С# не ковариантны). То, что dynamic делает, - это перегрузка нагрузки функции на время выполнения, как виртуальная функция (хотя и гораздо менее эффективно). У методов расширения и статических функций есть разрешение перегрузки во время компиляции, поэтому статический тип переменной используется, и это проблема, с которой вы сражаетесь.

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);
    }
}

Я надеюсь, что это возможно в Mono!

Ответ 3

Здесь версия без динамической, динамической версии слишком медленная (первый вызов):

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, посмотрите подробнее.