从通用中垂下来，但不失表现力

Question

我有这样的想法：

public class Something
{
    private IDictionary<object,Activity> fCases;

    public IDictionary<object,Activity> Cases
    {
        get { return fCases; }
        set { fCases = value; }
    }
}

public sealed class Something<T> : Something 
{
    private IDictionary<T,Activity> fCases;

    public override IDictionary<T,Activity> Cases
    {
        get { return fCases; }
        set { fCases = value; }
    }
}

注意：在这种情况下不接受覆盖

由于大量使用反射，在某些情况下我必须从Something向下转换到 Something 但是，我猜因为 Cases 属性被隐藏，我丢失了 Cases 数据。

我怎样才能避免这种情况呢？我尝试使用 where T:object 但这也不被接受。

编辑： 这是为什么我需要继承的一个例子：

if (someVar is Something) {

    if (someVar.GetType().IsGenericType) 
    {
        // Construct AnotherObject<T> depending on the Something<T>'s generic argument
        Type typeArg = someVar.GetType().GetGenericArguments()[0],
            genericDefinition = typeof(AnotherObject<>),
            typeToConstruct = genericDefinition.makeGenericType(typeArgs);

        object newAnotherObject = Activator.CreateInstance(typeToConstruct);

        // Pass Something 'Cases' property to AnotherObject<T>
        constructedType.InvokeMember(
            "Cases",
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty,
            null,
            newActivity,
            new Object[] { someVar.Cases });
    }
}

但是，因为“Cases”是隐藏的，所以它将始终为空。如果没有继承，我将不得不编写一个包含所有可能的通用参数的大 if-then-else 。而且，相信我，我确实必须使用 someVar is Something 和 Reflection 来构造所有这些对象。这是一个大型通用 API 正在转换为其他大型通用 API，因此它们不应该互相了解，并且转换应该尽可能透明。

Answer 1

你将无法像这样覆盖它，并且有充分的理由。

想象一下：

Something x = new Something<string>();
Button key = new Button();
x.Cases[key] = new Activity();

如果您的覆盖有效，那么将尝试将 Button 引用存储为 Dictionary 中的键。那将是一件坏事。

也许继承在这种情况下实际上并不合适？如果您能更多地解释您想要实现的目标，那将会有所帮助。也许您真的不需要字典作为属性？也许只是一种通过键获取的方法？

Answer 2

这根本行不通，因为 IDictionary接口是不变的。 IDictionary 不能被视为 IDictionary。

您可以做的，不是在派生类中公开整个IDictionary，而是简单地委托您想要公开的调用，如下所示

public class Something
{
    protected IDictionary<object, Activity> Cases { get; set; }
}

public sealed class Something<T> : Something 
{
    public Activity GetCase(T key)
    {
        return Cases[key];
    }

    public void AddCase(T key, Activity case)
    {
        Cases.Add(key, case);
    }

    // etc. etc.
}

：您还可以定义自己的逆变接口，例如：

interface IKeyedCollection<in TKey, TValue>
{
    TValue this[TKey key] { get; set; }
    void Add(TKey key, TValue value);
}

对于上述接口，IKeyedCollection可以充当IKeyedCollection; 因为每个 T 都是一个对象。

Answer 3

如果您尝试在不同级别公开不兼容的类型，您将不断遇到问题，因为最终您将不得不维护 2 个单独的对象（或 1 个具有 2 个接口的自定义对象）完全满足）。

这些类型不兼容，因为有些值可以添加到 IDictionary 中，但不能添加到 IDictionary 的每个实例中。想象一下，例如，T 被实例化为 string，并且开发人员通过 Something 在其他地方使用 int 键。这给 Something 实现带来了真正的问题。

我处理此问题的方法是更改​​基本类型 Something ，使其不公开具体类型，而是公开相关的 API。

public abstract class Something {
  public abstract IEnumerable<KeyValuePair> GetElements(); 
  public abstract bool TryGetValue(object key, out Activity value);
}

这为 Something 提供了正确子类 Something 所需的灵活性，并非常表达它想要公开的类型

public sealed class Something<T> : Something {
  private IDictionary<T,Activity> fCases;

  public override IDictionary<T,Activity> Cases
  {
    get { return fCases; }
    set { fCases = value; }
  }

  public override IEnumerable<KeyValuPair<object, Activity>> GetElements() {
    foreach (var cur in fCases) {
      yield return new KeyValuePair<object, Activity>(cur.Key, cur.Value);
    }
  }

  public override bool TryGetValue(object key, out Activity activity) {
    try {
      T typedKey = (T)key;
      return fCases.TryGetValue(typedKey, out activity);
    } catch (InvalidCastException) {
      activity = null;
      return false;
    }
  }
}

}

Answer 4

在大量使用反射期间，我还需要从泛型类型进行“向上转换”。我知道某些调用是兼容的，但我不知道编译时的类型。如果您这样看，它并不是真正“向上转换”泛型类型，而是通过生成正确的向下转换来允许在反射期间使用泛型。

为此，我创建了一个辅助方法来按照 Delegate.CreateDelegate< 的方式创建委托/a>，但允许创建不太通用的委托。必要时会产生沮丧。我在我的博客上详细解释了 。

MethodInfo methodToCall = typeof( string ).GetMethod( "Compare" );
Func<object, object, int> unknownArgument
    = DelegateHelper.CreateDowncastingDelegate<Func<object, object, int>>(
          null, methodToCall );
unknownArgument( "test", "test" ); // Will return 0.
unknownArgument( "test", 1 ); // Will compile, but throw InvalidCastException.

稍后，我需要为泛型类创建完整的不太通用的包装类，以便所有方法调用在反射期间立即变得可用作为不太通用的调用。这在您的场景中可能有用也可能没用。为此，我创建了一个（未经过彻底测试）方法，该方法允许在运行时使用emit生成此包装器类。它可以在 我的开源库。我还没有写过这个，所以如果有兴趣，你就必须尝试一下（并且可能会看到它失败，因为它仍然很新）。