通过多个派生类传递类型参数以在通用静态构造函数中使用

Question

我有一些用于multiton或对象池的通用模板。

public class A<TC> where TC : class, new()
{
    protected static ConcurrentDictionary<object, TC> _instances = new ConcurrentDictionary<object, TC>();

    public static TC Instance(object key)
    {
        return _instances.GetOrAdd(key, k => new TC());
    }
}

// One level inheritance works as expected    

public class B : A<B> 
{
    public virtual int Demo() { return 1; }
}

// Class C is example of what I want    
// How to override method from B, pass C to A and use it in GetInstance?

public class C : B<C>
{
    public override int Demo() { return 2; }
}

问题 ：我想让类C覆盖B的方法，如何通过子类链传递类型参数“ C”，以将其与A的Instance（）方法一起使用，这有可能吗？

我试图修改B，但似乎使它通用，并且不允许实例化B：

public class B<TC> : A<TC> where TC : class, new()
{
    public virtual int Demo() { return 1; }
}

更新 ：这个想法是要有一个通用的静态构造函数，然后我从中派生可与内存映射文件一起使用的Memory类，但是此类只能读写字节序列，因此，我创建了从Memory派生的类MemoryStructs类可以读取和写入整个结构，当然， 我可以将所有这些方法放入Memory中，但是我认为逻辑上拆分它们可能会有用，因此，我有这样的继承链：BaseClass> Memory> MemoryStructs

Memory和MemoryStructs类具有方法OpenMemory和CloseMemory，并且我不愿意为每个方法复制这些方法，因此我需要：

• 我现在尝试从内存继承MemoryStructs或
• 将所有方法放入Memory类，将它们命名为ReadBytes（Memory）和ReadStructs（MemoryStructs）

Answer 1

Instance是A<TC>的静态方法，因此B甚至不存在您可以覆盖的Instance方法（即使您可以， TC类型参数到那时也会绑定到B ，因此返回C的方法将是一种不同的方法）。

因此，调用Instance的方式是使用A<TC>.Instance(key) ，其中TC是实际类型。 因此，例如：

B objectB = A<B>.Instance(key)
C objectC = A<C>.Instance(key)

注意，并发字典对于每个类型参数TC是分开的 ，因此A<B>和A<C> 不共享同一字典； 它们是具有不同静态成员的不同类型。

Answer 2

也许您需要连锁课程中的另一个课程？

public class B1<T> : A<B1<T>> 
{
    public virtual int Demo() { return 1; }
}
public class B2 : B1<B2>
{
    // Something that C does not do
}
public class C : B1<C>
{
   public override int Demo() { return 2; }
}

编辑：

似乎您想继承B的某些功能并在C中将类型参数传递给它，同时又想将B定义为一个非泛型类，这是不可能的，因为B必须是您没有的非泛型类C：B <C>了：

public class B : A<B>
{
    public virtual int Demo() { return 1; }
}
public class C : B
{
   public override int Demo() { return 2; }
}

否则它必须是通用的，因此您不能将B作为类型参数传递给A：

public class B<T> : A<T>
{
    public virtual int Demo() { return 1; }
}
public class C : B<T>
{
   public override int Demo() { return 2; }
}

或者您可以选择使用合成模式并在C中创建B的实例，以便可以在C中使用其功能：

public class B : A<B>
{
    public virtual int Demo() { return 1; }
}
public class C : A<C>
{
   private B b = new B();
   public override int Demo() {
      // Maybe use b here
      return 2;
   }
}

Answer 3

@David Amo绝对正确。 也许这就是你所追求的？

public abstract class A<TC> where TC : class, new()
{
    protected static ConcurrentDictionary<object, TC> _instances = 
        new ConcurrentDictionary<object, TC>();

    public static TC Instance(object key)
    {
        return _instances.GetOrAdd(key, k => new TC());
    }

    public abstract int Demo();
}

public class B : A<B>
{
    public override int Demo() { return 1; }
}

public class C : A<C>
{
    public override int Demo() { return 2; }
}