C# 从基类创建继承的类_C#_.net_Winforms

C# 从基类创建继承的类

c# .net winforms

C# 从基类创建继承的类,c#,.net,winforms,C#,.net,Winforms,我试图从基类实例化继承的类我已尝试使用此代码： public class BasicClass { private static BasicClass instance; private BasicClass() { } public static BasicClass Instance { get { if (instance == null) {

我试图从基类实例化继承的类

我已尝试使用此代码：

public class BasicClass
{
    private static BasicClass instance;
    private BasicClass() { }

    public static BasicClass Instance
    {
        get
        {
            if (instance == null)
            {
                var dataType = MethodBase.GetCurrentMethod().DeclaringType;
                instance = (BasicClass)Activator.CreateInstance(dataType);
            }

            return instance;
        }
    }
}



public class MyClass1 : BasicClass
{

}

public class MyClass2 : BasicClass
{

}

然后称之为：

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        var o = MyClass2.Instance;

        Text = o.GetType().Name;
    }
}

我在我的小演示中使用了WinForm应用程序，但这只是为了测试

我的问题是，我得到了一个

BasicClass

的实例，而不是

MyClass2

我可以如何得到

MyClass2

简单的回答是：模式不能被继承。这是因为静态字段（例如，ex.）是在特殊的所谓的

类型对象中声明的？在你的例子中是BaseType，所以他们对自己的孩子一无所知
你想要实现什么
您可以实现如下包装器：
public class Singleton<T>
        where T:class, new()
    {
        private static readonly Lazy<T> _instance = new Lazy<T>(()=>new T()); 

        public static T Instance
        {
            get { return _instance.Value; }
        }
    }

private static IDictionary<Type,BasicClass> instances = new Dictionary<Type,BasicClass>();
...
public static T GetInstance<T>() where T : BasicClass {
    BasicClass res;
    if (!instances.TryGetValue(typeof(T), out res)) {
        res = (BasicClass)Activator.CreateInstance(typeof(T));
        instances.Add(typeof(T), res);
    }
    return (T)res;
}
...
var o = MyClass2.GetInstance<MyClass2>();

公共类单例
其中T:class，new（）
{
private static readonly Lazy _instance=new Lazy（（）=>new T（））；
公共静态T实例
{
获取{return}instance.Value；}
}
}

请参阅下面的答案，它提供了单例包装器的酷实现
简短的答案是：模式不能被继承。这是因为静态字段（例如，ex.）是在特殊的所谓的类型对象中声明的？在你的例子中是BaseType，所以他们对自己的孩子一无所知
你想要实现什么
您可以实现如下包装器：
public class Singleton<T>
        where T:class, new()
    {
        private static readonly Lazy<T> _instance = new Lazy<T>(()=>new T()); 

        public static T Instance
        {
            get { return _instance.Value; }
        }
    }

private static IDictionary<Type,BasicClass> instances = new Dictionary<Type,BasicClass>();
...
public static T GetInstance<T>() where T : BasicClass {
    BasicClass res;
    if (!instances.TryGetValue(typeof(T), out res)) {
        res = (BasicClass)Activator.CreateInstance(typeof(T));
        instances.Add(typeof(T), res);
    }
    return (T)res;
}
...
var o = MyClass2.GetInstance<MyClass2>();

公共类单例
其中T:class，new（）
{
private static readonly Lazy _instance=new Lazy（（）=>new T（））；
公共静态T实例
{
获取{return}instance.Value；}
}
}

请参阅下面的答案，它提供了单例包装器的酷实现
我可以知道如何获得MyClass2吗
不，至少不是你采取的方法GetCurrentMethod（）
不会在调用者中获取方法，它将为您提供实现getter属性的方法
此外，考虑这个声明：
private static BasicClass instance;

无论创建多少子类，程序中只有一个实例。问题是，如果MyClass2
创建一个实例并将其存储在BasicClass.instance
中，那么MyClass1
的实例就没有地方可去了
您可以采取的一种方法是使用将子类型映射到实例的字典，以及访问它们的通用方法，如下所示：
public class Singleton<T>
        where T:class, new()
    {
        private static readonly Lazy<T> _instance = new Lazy<T>(()=>new T()); 

        public static T Instance
        {
            get { return _instance.Value; }
        }
    }

private static IDictionary<Type,BasicClass> instances = new Dictionary<Type,BasicClass>();
...
public static T GetInstance<T>() where T : BasicClass {
    BasicClass res;
    if (!instances.TryGetValue(typeof(T), out res)) {
        res = (BasicClass)Activator.CreateInstance(typeof(T));
        instances.Add(typeof(T), res);
    }
    return (T)res;
}
...
var o = MyClass2.GetInstance<MyClass2>();

private static IDictionary instances=new Dictionary（）；
...
公共静态T GetInstance（），其中T:BasicClass{
基本类res；
if（！instances.TryGetValue（typeof（T），out res））{
res=（BasicClass）Activator.CreateInstance（typeof（T））；
实例。添加（类型（T），res）；
}
返回（T）res；
}
...
var o=MyClass2.GetInstance（）；

我可以知道如何获得MyClass2吗
不，至少不是你采取的方法GetCurrentMethod（）
不会在调用者中获取方法，它将为您提供实现getter属性的方法
此外，考虑这个声明：
private static BasicClass instance;

无论创建多少子类，程序中只有一个实例。问题是，如果MyClass2
创建一个实例并将其存储在BasicClass.instance
中，那么MyClass1
的实例就没有地方可去了
您可以采取的一种方法是使用将子类型映射到实例的字典，以及访问它们的通用方法，如下所示：
public class Singleton<T>
        where T:class, new()
    {
        private static readonly Lazy<T> _instance = new Lazy<T>(()=>new T()); 

        public static T Instance
        {
            get { return _instance.Value; }
        }
    }

private static IDictionary<Type,BasicClass> instances = new Dictionary<Type,BasicClass>();
...
public static T GetInstance<T>() where T : BasicClass {
    BasicClass res;
    if (!instances.TryGetValue(typeof(T), out res)) {
        res = (BasicClass)Activator.CreateInstance(typeof(T));
        instances.Add(typeof(T), res);
    }
    return (T)res;
}
...
var o = MyClass2.GetInstance<MyClass2>();

private static IDictionary instances=new Dictionary（）；
...
公共静态T GetInstance（），其中T:BasicClass{
基本类res；
if（！instances.TryGetValue（typeof（T），out res））{
res=（BasicClass）Activator.CreateInstance（typeof（T））；
实例。添加（类型（T），res）；
}
返回（T）res；
}
...
var o=MyClass2.GetInstance（）；
您可以创建模板化基类：
public abstract class Singleton<T> where T : class
{      
  private static readonly Lazy<T> instance = new Lazy<T>(() => CreateInstance());   

  public static T Instance { get { return instance.Value; } }

  private static T CreateInstance()
  {
    return Activator.CreateInstance(typeof(T), true) as T;
  }

公共抽象类单例，其中T:class
{      
私有静态只读惰性实例=新惰性（（）=>CreateInstance（））；
公共静态T实例{get{return Instance.Value；}}
私有静态T CreateInstance（）
{
将Activator.CreateInstance（typeof（T），true）返回为T；
}

然后继承它：
public class MyClass1 : Singleton<MyClass1>
{
}

公共类MyClass1:Singleton
{
}
您可以创建模板化基类：
public abstract class Singleton<T> where T : class
{      
  private static readonly Lazy<T> instance = new Lazy<T>(() => CreateInstance());   

  public static T Instance { get { return instance.Value; } }

  private static T CreateInstance()
  {
    return Activator.CreateInstance(typeof(T), true) as T;
  }

公共抽象类单例，其中T:class
{      
私有静态只读惰性实例=新惰性（（）=>CreateInstance（））；
公共静态T实例{get{return Instance.Value；}}
私有静态T CreateInstance（）
{
将Activator.CreateInstance（typeof（T），true）返回为T；
}

然后继承它：
public class MyClass1 : Singleton<MyClass1>
{
}

公共类MyClass1:Singleton
{
}
不幸的是，在.NET中，静态成员不被视为“属于”除声明它们的类之外的任何其他类。因此，实例
属性的获取者不可能知道您实际用于调用它的类。您还有其他建议吗？不幸的是，在.NET中，静态成员不被视为“属于”除声明它们的类之外的任何其他类。因此，实例
属性的获取者不可能对您实际用于调用它的类有任何了解。您有其他建议吗？好吧……那么假设它不是一个单例。然后可以完成吗？@JensBorrisholt查看编辑，这应该是至少修复您看到的即时问题。好吧……那么让我们假设它不是一个单例。然后可以完成吗？@JensBorrisholt查看编辑，这应该至少修复您看到的即时问题。