如何在C#中全局访问实例？

所以我有一节课

然后我在某处举了一个例子：

Class1 somesinstance = new Class1;

---

现在我想在任何地方访问此实例，这可能吗？

如果您只需要一个实例，请使用singleton模式：

public class Class1
{
    private Class1()
    {
        ...
    }


    private static readonly Class1 _instance = new Class1();

    public static Class1 Instance { get { return _instance; } }
}

并按如下方式访问该实例：

Class1.Instance

---

否则，只需将其作为类中的静态属性公开。

如果只需要一个实例，请使用singleton模式：

public class Class1
{
    private Class1()
    {
        ...
    }


    private static readonly Class1 _instance = new Class1();

    public static Class1 Instance { get { return _instance; } }
}

并按如下方式访问该实例：

Class1.Instance

---

否则，只需将其作为类中的静态属性公开。

如果只需要一个实例，请使用singleton模式：

public class Class1
{
    private Class1()
    {
        ...
    }


    private static readonly Class1 _instance = new Class1();

    public static Class1 Instance { get { return _instance; } }
}

并按如下方式访问该实例：

Class1.Instance

---

否则，只需将其作为类中的静态属性公开。

如果只需要一个实例，请使用singleton模式：

public class Class1
{
    private Class1()
    {
        ...
    }


    private static readonly Class1 _instance = new Class1();

    public static Class1 Instance { get { return _instance; } }
}

并按如下方式访问该实例：

Class1.Instance

---

否则，只需将其作为类中的静态属性公开。

如果您的anywhere表示您的解决方案，则可以使用具有静态属性的静态类

public static class Shared
{
    private static Class1 _myclass;

    public static Class1 MyClass{
         get
         {
             return _myclass??(_myclass=new Class1());
         }
    }
}

---

如果您的anywhere表示您的解决方案，那么您可以使用具有静态属性的静态类

public static class Shared
{
    private static Class1 _myclass;

    public static Class1 MyClass{
         get
         {
             return _myclass??(_myclass=new Class1());
         }
    }
}

---

如果您的anywhere表示您的解决方案，那么您可以使用具有静态属性的静态类

public static class Shared
{
    private static Class1 _myclass;

    public static Class1 MyClass{
         get
         {
             return _myclass??(_myclass=new Class1());
         }
    }
}

---

如果您的anywhere表示您的解决方案，那么您可以使用具有静态属性的静态类

public static class Shared
{
    private static Class1 _myclass;

    public static Class1 MyClass{
         get
         {
             return _myclass??(_myclass=new Class1());
         }
    }
}

---

啊，难以捉摸的单身模式

如果你有一点空闲时间，我强烈推荐Jon Skeet关于这个主题的文章：

下面是一个简单的例子：

public sealed class YourSingleton
{
    private static readonly YourSingleton instance = new YourSingleton();

    static YourSingleton() {}

    private YourSingleton() { }

    public static YourSingleton Instance
    {
        get { return instance ; }
    }
}

---

啊，难以捉摸的单身模式

如果你有一点空闲时间，我强烈推荐Jon Skeet关于这个主题的文章：

下面是一个简单的例子：

public sealed class YourSingleton
{
    private static readonly YourSingleton instance = new YourSingleton();

    static YourSingleton() {}

    private YourSingleton() { }

    public static YourSingleton Instance
    {
        get { return instance ; }
    }
}

---

啊，难以捉摸的单身模式

如果你有一点空闲时间，我强烈推荐Jon Skeet关于这个主题的文章：

下面是一个简单的例子：

public sealed class YourSingleton
{
    private static readonly YourSingleton instance = new YourSingleton();

    static YourSingleton() {}

    private YourSingleton() { }

    public static YourSingleton Instance
    {
        get { return instance ; }
    }
}

---

啊，难以捉摸的单身模式

如果你有一点空闲时间，我强烈推荐Jon Skeet关于这个主题的文章：

下面是一个简单的例子：

public sealed class YourSingleton
{
    private static readonly YourSingleton instance = new YourSingleton();

    static YourSingleton() {}

    private YourSingleton() { }

    public static YourSingleton Instance
    {
        get { return instance ; }
    }
}

---

您可以按如下方式选择单例模式：

public class MyClass
{
     private static MyClass myClass;

     public static MyClass MyClassInstance
     {
          get { return myClass ?? (myClass = new MyClass()); }
     }

     private MyClass()
     {
          //private constructor makes it where this class can only be created by itself
     }
}

然后可以全局访问该实例，如

MyClass.MyClassInstance

---

您可以按如下方式选择单例模式：

public class MyClass
{
     private static MyClass myClass;

     public static MyClass MyClassInstance
     {
          get { return myClass ?? (myClass = new MyClass()); }
     }

     private MyClass()
     {
          //private constructor makes it where this class can only be created by itself
     }
}

然后可以全局访问该实例，如

MyClass.MyClassInstance

---

您可以按如下方式选择单例模式：

public class MyClass
{
     private static MyClass myClass;

     public static MyClass MyClassInstance
     {
          get { return myClass ?? (myClass = new MyClass()); }
     }

     private MyClass()
     {
          //private constructor makes it where this class can only be created by itself
     }
}

然后可以全局访问该实例，如

MyClass.MyClassInstance

---

您可以按如下方式选择单例模式：

public class MyClass
{
     private static MyClass myClass;

     public static MyClass MyClassInstance
     {
          get { return myClass ?? (myClass = new MyClass()); }
     }

     private MyClass()
     {
          //private constructor makes it where this class can only be created by itself
     }
}

然后可以全局访问该实例，如

MyClass.MyClassInstance

---

您可以创建一个静态类，其中包含可从应用程序中的每个类访问的共享实例

public static class SharedResources
{
    public static Class1 obj1 {get; set;}
    public static Class2 obj2 {get; set;}

    // ...
}

---

您可以创建一个静态类，其中包含可从应用程序中的每个类访问的共享实例

public static class SharedResources
{
    public static Class1 obj1 {get; set;}
    public static Class2 obj2 {get; set;}

    // ...
}

---

您可以创建一个静态类，其中包含可从应用程序中的每个类访问的共享实例

public static class SharedResources
{
    public static Class1 obj1 {get; set;}
    public static Class2 obj2 {get; set;}

    // ...
}

---

您可以创建一个静态类，其中包含可从应用程序中的每个类访问的共享实例

public static class SharedResources
{
    public static Class1 obj1 {get; set;}
    public static Class2 obj2 {get; set;}

    // ...
}

---

要么使类成为静态的，要么遵循单例模式。可以使用，但不赞成，因为这通常（不总是）是糟糕设计的标志。要么使类成为静态的，要么遵循单例模式。可以使用，但不赞成，因为它通常（不总是）设计不好的标志。要么使类

静态

，要么遵循单例模式。可以使用，但不赞成，因为它通常（不总是）是设计不好的标志。要么使类

静态

，要么遵循单例模式。可以使用，但不赞成，因为它通常是（并非总是）设计不好的迹象。