没有基类问题，在这种特殊情况下如何使用 Castle.DynamicProxy Mixin ？

Question

我有一个设计糟糕的第三方库，我必须使用它。
它可以处理各种类型，我们将它们称为 SomeType1、SomeType2 等。
这些类型都不共享公共基类，但都具有名为 Value 且返回类型不同的属性。
我想要做的就是能够 Mixin 这个类，这样我就能够调用 someType1Instance.Value 和 someType2Instance.Value 而无需关心它的具体类型是什么并且不关心返回类型是什么（我可以使用object）。
所以我的代码目前是：

public interface ISomeType<V>
{
  V Value {get; set;}
}

public interface ISomeTypeWrapper
{
  object Value { get; set; }
}

public class SomeTypeWrapper<T> : ISomeTypeWrapper
    where T : ISomeType<???>
{
  T someType;

  public SomeTypeWrapper(T wrappedSomeType)
  {
    someType = wrappedSomeType
  }

  public object Value
  {
     get { return someType.Value; }
     set { someType.Value = value != null ? value : default(T); }
  }
}

public class SomeType1
{
  public int Value { get; set; }
}

public class SomeType2
{
  public string Value { get; set; }
}

问题是，由于我得到了对象字典，所以直到运行时我才知道 T 可能是什么。

我可以迭代字典并使用反射在运行时创建 SomeWrapperType 但我想避免它。

如何将 SomeType 的具体类型混合到 ISomeType 中？
我怎么知道V类型参数是什么？ （希望我有像 C++ 中那样的 typedef 和 decltype）

我怎样才能以最少的反射使用将这些类与接口/基类混合在一起？

Answer 1

您可以尝试 Windsor 的鸭子打字扩展。这意味着您需要注册每种类型。

container
    .Register(Component.For(typeof(SomeType1)).Duck<ISomeType>())
    .Register(Component.For(typeof(SomeType2)).Duck<ISomeType>());

如果名称相似，您可以使用 linq 和注册 AllTypes 语法来减少代码。

或者在短期内创建一个工厂，它可以返回您需要的对象，为每种类型实现一个具体对象。不，您正在使用该接口，您可以在以后删除该工厂，并将其替换为其他影响最小的东西：

public class SomeTypeWrapperFactory
{
    public ISomeType<int> CreateWrapper(SomeType1 someType1)
    {
        return new SomeType1Wrapper(someType1);
    }

    public ISomeType<string> CreateWrapper(SomeType2 someType2)
    {
        return new SomeType2Wrapper(someType2);
    }
}

public class SomeType1Wrapper : ISomeType<int> { ... }
public class SomeType2Wrapper : ISomeType<int> { ... }

无论您如何实现包装器，是单独的还是使用类似上帝的类，您都可以更改包装完成并保持其余代码干净。

Answer 2

为什么是 SomeTypeWrapper 而不是 SomeObjectWrapper？

public class SomeObjectWrapper : ISomeType
{
    Object _someObject;
    PropertyInfo _valuePropertyInfo;

    public SomeObjectWrapper(Object wrappedSomeObject)
    {
        _someObject = wrappedSomeObject;
        _valuePropertyInfo = _someObject.GetType().GetProperty("Value", System.Reflection.BindingFlags.Public);
    }

    public object Value
    {
        get { return _valuePropertyInfo.GetValue(_someObject, null); }
        set { _valuePropertyInfo.SetValue(_someObject, value, null); }
    }
}

Answer 3

编辑 使用 LinFu 使用 .NET 3.5
您可以使用 LinFu 而不是 Castle。然而，无论如何，您都会使用反射，无论是 Castle 的还是 Linfu 的 DynamicProxy，仅隐藏在库的内部，而不是暴露在代码中。因此，如果您要求避免使用反射是出于性能考虑，那么您实际上不会使用此解决方案来避免它。
在这种情况下，我个人会选择 Orsol 的解决方案。

然而：这里有一个林福鸭式打字的例子。

public interface ISomeType {
    object Value{get; set;}
}

public class SomeType1
{
  public int Value { get; set; }
}

public class SomeType2
{
  public string Value { get; set; }
}

public class SomeTypeWrapperFactory
{

    public static ISomeType CreateSomeTypeWrapper(object aSomeType)
    {
        return aSomeType.CreateDuck<ISomeType>();
    }        
}


class Program
{
    public static void Main(string[] args)
    {
        var someTypes = new object[] {
            new SomeType1() {Value=1},
            new SomeType2() {Value="test"}
        };


        foreach(var o in someTypes)
        {
            Console.WriteLine(SomeTypeWrapperFactory.CreateSomeTypeWrapper(o).Value);
        }
        Console.ReadLine();
    }
}

由于您直到运行时才知道 SomeType 的类型，因此我不会使用 mixins，而是使用访问者模式（我知道这并不能回答有关如何为此使用 mixins 的问题，但我只是想我会抛出在我的 2 美分）。

使用动态的 .NET 4
有关使用 c#4 的动态关键字来实现访客模式。
在您的情况下，从 SomeType 字典中读取所有“Value”属性可以像这样工作：

public class SomeType1
{
  public int Value { get; set; }
}

public class SomeType2
{
  public string Value { get; set; }
}

public class SomeTypeVisitor
{
    public void VisitAll(object[] someTypes)
    {
        foreach(var o in someTypes) {
            // this should be in a try-catch block
            Console.WriteLine(((dynamic) o).Value);
        }

    }
}
class Program
{
    public static void Main(string[] args)
    {
        var someTypes = new object[] {
            new SomeType1() {Value=1},
            new SomeType2() {Value="test"}
        };

        var vis = new SomeTypeVisitor();

        vis.VisitAll(someTypes);            
    }
}