Question

我试图弄清楚这是否可能：

public abstract class A<T>
{
    public void MyFunc() { ... }
}

public MyClass : A<string>
{
}

MyFunc 是否有办法知道它已在 MyClass 类型的clas中实例化？

我想我需要更多地澄清这个问题：我有一个通用的抽象类，它包含一些通过单例访问的核心功能。

用户正在构建一个派生类来扩展功能，但该类不是通过一个新的实例化，而是通过一个包含在A类中的单例来实例化。

所以，你可以看到这样的流程：

In the beginning, there is the abstract A<T>
The user creates MyClass : A<string>
The user now accesses: MyClass.MyFunc()
The singleton in MyFunc is then creating the instance

单例代码如下：

public abstract class Singleton<T> where T : class
{
    private static readonly Lazy<T> _Instance = new Lazy<T>(CreateInstanceOfT);
    protected static T Instance => _Instance.Value;
    private static T CreateInstanceOfT()
    {
        return Activator.CreateInstance(typeof(T), true) as T;
    }
}

这样：

class A<T>

真的是：

class A<T> : Singleton<A>

但我真正需要的是，以某种方式，使它像

Singleton<MyClass>

或任何来自

的类

A<T>

我希望这能澄清这个问题。

Answer 1

是的，你可以这样做：

public abstract class A<T>
{
    public void MyFunc() 
    {
        if(this.GetType() == typeof(MyClass))
        {
            // do your magic
        }
    }
}

public class MyClass : A<string>
{
}

但是为什么？

Answer 2

对我而言，如果我正确地读出你的问题，如果A的实例需要MyFunc在MyClass时采取不同的行为，那么MyFunc应该是虚拟的，并在MyClass中重写。

import more_itertools as mit

list(mit.pairwise([1, 5, 2, 4, 7, 9]))
# [(1, 5), (5, 2), (2, 4), (4, 7), (7, 9)]

可以在通用抽象基类中使用方法＆＃34;知道＆＃34;它实例的派生程度最高的类？

2 个答案: