Unity中C#单例模式使用总结

最新推荐文章于 2024-05-11 14:02:47 发布
最新推荐文章于 2024-05-11 14:02:47 发布
阅读量1.2k 收藏 10
点赞数
分类专栏： C# 文章标签： 单例

一、单例模式优点

  1. 单例模式核心在于对于某个单例类，在系统中同时只存在唯一一个实例，并且该实例容易被外界所访问；
  2. 意味着在内存中，只存在一个实例，减少了内存开销；

 

二、单例模式特点

  1. 只存在唯一一个实例；
  2. 提供统一对外访问接口，使得全局可对该单例的唯一实例进行访问；
  3. 自行实例化（私有构造函数，不允许外界对其进行实例化）。

 

三、单例模式使用

  1. 资源管理器，资源对象数据的加载和卸载（无状态不需要实例化的对象）；
  2. 单一客户端连接服务器等；
  3. 生命周期在游戏中永不消毁的对象。

 

四、单例模式注意点

  1. 注意线程安全问题，在多线程、高并发的情况下，可能同时产生多个实例,违背了单例模式。
  2. Unity中如果过度使用单例模式，将会导致代码耦合度非常高，脚本与脚本之间的耦合，代码的后续拓展变得非常麻烦。一个过分依赖单例模式的开发者不能成为一个好的开发者，也不会去接触到更多优秀的设计模式。个人推荐ECS 实体 - 组件式编程。
  3. Unity中暂时不需要考虑多线程问题，Unity就只有一个主线程和开启多个辅助协程，不会出现多线程并发问题。
  4. 控制游戏对象的生成和销毁并不建议使用单例模式，可通过主游戏逻辑InGame进行事件下发，自行管理Update，使用工厂来进行对象的创建和销毁。

 

五、单例模式常见模式

  1. 懒汉模式(最常用)

    1.1 提供私有构造函数;

    1.2 自行实例化;

    1.3 提供唯一实例，并且对外提供全局静态访问接口对该实例进行访问；

    • 代码如下： 
      /// <summary>
/// 普通模式
/// </summary>
public class Singleton
{
    private static Singleton _instance = null;

    private Singleton()
    {
    }

    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            _instance = new Singleton();
        }
        return _instance;
    }
}

       

  2. 饿汉模式

    2.1 本类内部预先自行实例化出唯一实例；

    2.2 对外提供唯一访问接口（静态方法），对预先实例化的唯一实例进行访问；

    2.3 私有构造函数；

    • 代码如下：
         /// <summary>
    /// 饿汉单例模式
    /// </summary>
    public class Singleton
    {
        // 自行预先实例化,内部定义自己唯一实例，只供内部使用 //
        private readonly static  Singleton Instance = new Singleton();

        private Singleton() 
        {
            // Do Something
        }

        // 提供外部访问的静态方法，来对内部唯一实例进行访问 //
        public static Singleton GetInstance()
        {
            return Instance;
        }
    }

     

  3. 双重锁模式（解决线程安全问题）

    3.1 保证多线程中只存在唯一实例

    • 代码如下： 
      /// <summary>
/// 双重锁单例模式
/// </summary>
public class Singleton
{
    private static Singleton _instance = null;
    private static readonly object _syslock = new object();  
    private Singleton()
    {
    }

    public static Singleton GetInstance()
    {
        // 最开始判断不存在的时候，该类从来未被实例化过 //
        if (_instance == null)
        {
            // 锁定状态，继续搜索是否存在该类的实例 //
            lock (_syslock)
            {
                // 如果不存在，在锁定状态下实例化出一个实例 //
                if (_instance == null)
                {
                    _instance = new Singleton();
                    return _instance;
                }
                else  // 锁定状态下，存在该类实例，直接返回 //
                {
                    return _instance;
                }
            }
        }
        // 该实例本身就已经存在了，直接返回 //
        return _instance;
    }
}

       

  5. 泛型单例模式

     

    4.1 在一个案例中,我们可能需要使用到不止一个单例模式类,甚至更多。那么此时,使用泛型单例模式模板来实现单例模式,我们可以有两种不同的方法来实现它:

    4.2首先我们来看下泛型模板，我们对泛型类进行约束，T只能是一个Class，并且有一个公共无参构造函数，代码如下：

    using System;
using UnityEngine;

public class SingletonProvider<T> where T : class ,new()
{
    private SingletonProvider()
    {
    }

    private static T _instance;
    // 用于lock块的对象
    private static readonly object _synclock = new object();

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_synclock)
                {
                    if (_instance == null)
                    {
                        // 若T class具有私有构造函数,那么则无法使用SingletonProvider<T>来实例化new T();
                        _instance = new T();
                        //测试用，如果T类型创建了实例，则输出它的类型名称
                        Debug.Log("{0}：创建了单例对象" + typeof(T).Name);
                    }
                }
            }
            return _instance;
        }
        set { _instance = value; }
    }
}
    • 4.2.1 然后我们定义了一个网络连接类 NetIO,使用单例提供类中的泛型T替代为具体的网络连接类进行使用：
    • 4.2.2 使用具体类替代泛型，用泛型单例提供类对该具体类达到提供唯一实例的单例实现效果：
    • 4.2.3 具体类中定义了字段NetIoCreateTime来存储该类实例化的时间，进行下一步分析该类实例是否是唯一实例，具体类代码如下：

      复制代码

      public class NetIO 
{

    public static NetIO GetInstance()
    {
        return SingletonProvider<NetIO>.Instance;
    }

    public NetIO()
    {
        this.NetIoCreateTime = DateTime.Now;
    }

    public DateTime NetIoCreateTime
    {
        get { return _ct; }
        set { _ct = value; }
    }

    private DateTime _ct;
}

      复制代码

    • 4.2.4 在Unity中Update参数中调用该类，对该类创建时间进行输出 
      public void Update()
    {
        Debug.Log(NetIO.GetInstance().NetIoCreateTime);
    }
    • 4.2.5 测试结果如下：
    • image
    • 4.2.6 所有创建时间都一致，证明该类提供单例提供类中的泛型替代，达到了单例模式的效果，提供了该类的唯一实例访问

     

    4.3 在一个案例中,我们可能需要使用到不止一个单例模式类,甚至更多。那么此时,使用泛型单例模式模板来实现单例模式,我们可以有两种不同的方法来实现它:

    • 4.3.1 首先我们来看下泛型模板，我们对泛型类进行约束，T只能是一个Class，并且有一个公共无参构造函数，代码如下： 
      using System;
using UnityEngine;

public class SingletonProvider<T> where T : class ,new()
{
    private SingletonProvider()
    {
    }

    private static T _instance;
    // 用于lock块的对象
    private static readonly object _synclock = new object();

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                lock (_synclock)
                {
                    if (_instance == null)
                    {
                        // 若T class具有私有构造函数,那么则无法使用SingletonProvider<T>来实例化new T();
                        _instance = new T();
                        //测试用，如果T类型创建了实例，则输出它的类型名称
                        Debug.Log("{0}：创建了单例对象" + typeof(T).Name);
                    }
                }
            }
            return _instance;
        }
        set { _instance = value; }
    }
}

       

    • 4.3.2 然后我们定义了一个网络连接类 NetIO,使用单例提供类中的泛型T替代为具体的网络连接类进行使用：
      1. 使用具体类替代泛型，用泛型单例提供类对该具体类达到提供唯一实例的单例实现效果：
      2. 具体类中定义了字段NetIoCreateTime来存储该类实例化的时间，进行下一步分析该类实例是否是唯一实例，具体类代码如下： 
        public class NetIO 
{

    public static NetIO GetInstance()
    {
        return SingletonProvider<NetIO>.Instance;
    }

    public NetIO()
    {
        this.NetIoCreateTime = DateTime.Now;
    }

    public DateTime NetIoCreateTime
    {
        get { return _ct; }
        set { _ct = value; }
    }

    private DateTime _ct;
}

        复制代码

      3. 在Unity中Update参数中调用该类，对该类创建时间进行输出 
        public void Update()
    {
        Debug.Log(NetIO.GetInstance().NetIoCreateTime);
    }
      4. 测试结果如下：QQ截图20160114152652
      5. 所有创建时间都一致，证明该类提供单例提供类中的泛型替代，达到了单例模式的效果，提供了该类的唯一实例访问
One_Piece_Fu
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity中涉及的三种单例模式
12-26
下面将详细介绍在Unity中涉及的三种单例模式：C#经典单例、Unity内置单例以及一种线程安全的改进版单例。 1. C#经典单例： 这是最常见的单例实现方式，通常通过私有构造函数和一个静态方法来保证只有一个实例。在...
单例模式（Singleton Pattern）
jiangxt211的专栏
08-26 218
单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 1、经典实现 1）利用一个静态变量来记录Singleton类的唯一实例； 2）将构造器声明为私有的； 3）使用GetInstance()方法实例化对象，并返回该实例（全局访问点）。 class Singleton { private s
Unity 单例模式
最新发布
Liam's blog
05-11 651
在Unity中常见的单例模式的几种写法
C#学习笔记：private / readonly / const 关键字各自作用
JIA的博客
03-24 1962
readonly常量是字段，只能在定义类的构造函数内修改（或者变量初始化器），派生类的构造函数不可以！ 参考博客：PunCha
C# private static readonly是什么样的含 new和override的区别
IT技术猿猴的博客
04-03 2184
private static readonly是什么样的含义，private static const对不对？ private - 这个成员只能在本类内使用 static - 这个成员不需要实例化即可使用 readonly - 这个成员只能在“类初始化”时赋值 所谓的“类初始化”，是下面两者之一 直接在定义后面写值，例如 private static readon...
Unity3D C# 单例属性和单例模板及优缺点
yueh0607
01-10 1011
总有人告诉我们不用单例，可是我们渐渐发现他们自己也在用，真的哭死！！
UnitySingleton：在Unity中实现单例模式的最佳方法
02-05
在Unity中实现单例模式的最佳方法。 通过使用这种模式，您将能够定义Global变量和类，并在Global中使用它们的方法和属性。 对于使用Unity引擎制作的大多数游戏来说，这种模式都是必须的。 :open_book: 产品特点 ...
Unity3D通用单例基类
04-01
在Unity中，网络编程是游戏开发的重要部分，单例模式可以帮助我们更好地组织网络管理代码，确保网络资源在整个游戏运行期间的正确使用和释放。 综上所述，"Unity3D通用单例基类"是一个强大的工具，它可以适应多种...
举例讲解C#编程中对设计模式中的单例模式的运用
09-02
下面是一个简单的C#单例模式实现示例： ```csharp public sealed class Singleton { private static readonly Singleton instance = new Singleton(); private Singleton() { } // 私有构造函数 public static ...
unity新手抛物线大炮单例.zip
04-13
本教程"unity新手抛物线大炮单例.zip"专为初学者设计，旨在教授如何利用Unity创建一个简单的抛物线大炮游戏，并且融入了单例模式的设计思想。 首先，我们来详细探讨Unity中的抛物线投射。在物理模拟中，大炮发射...
C# 单例模式
weixin_30765505的博客
08-08 180
一、多线程不安全方式实现 public sealed class SingleInstance { private static SingleInstance instance; private SingleInstance() { } public static SingleInstance Instanc...
单例模式及为何构造函数/析构函数私有化
初心不改
03-16 6959
单例类的构造函数是私有的 单例模式（单例类）： 即该类只有一个实例化对象，不管外部声明调用多少次，其本质也都是访问同一块内存。 比如生活中的实例： 只有一个的windows任务管理器； 只有一个的windows回收站。。。 单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用。 几种单例模式实现 待定… 了解其本质就好。 以C++11为例 C++11提供的call_once和once_flag解决了单例类线程安全问题。 CData
C#入门学习——单例模式和委托
HYHDYK的博客
04-04 671
单例模式，委托
c#中 get {return 字段;} set{字段=value;}
ghevinn欢迎您光临
02-21 6965
其实就是属性。属性可以使外部程序能够访问你的私有字段（前提是你的属性是公有的）。 但是属性最大的作用是，可以在get和set里面对字段进行一些处理，包括判断范围，求值等处理。这样一来是保证了数据的正确性，而来是保证你在外面读取的时候字段的值都是正确，而且是及时的数据。 或者可以说 属性最重要的作用是，做只读属性，或只写属性。这个是最有用的。控制了字段的读和写，保证了程序的正确性。 比如说：pri
java 泛型接口 实现类_java内部类、接口、集合框架、泛型、工具类、实现类
weixin_42137022的博客
02-13 1103
1.成员内部类。(1)成员内部类的实例化：外部类名.内部类名 变量名=外部类对象.new 内部类名();classPerson{classTest{}}Person p=newPerson();Person.Test t=p.new Test();(2)在内部类中访问外部类属性或方法。外部类名.this.属性名Person.this.name(3)成员内部类声明的注意事项①内部类不能与外部类重...
[Unity]C#中的泛型单例(Singleton)
m0_56738500的博客
08-21 1600
[Unity]C#中的泛型单例
unity中脚本互相调用 使用instance的方法
qq_42522380的博客
08-06 8233
这样子就可以在其他脚本中通过声明instance变量的这个类的名称来访问Instance对象，而不需要实例化该类。比如你在MyClass类中声明了public static EnemyHP Instance；并对instance初始化。 那么你在其他脚本中就可以直接用MyClass.instance来操作使用EnemyHP中的公共属性或方法。 ...
unity中使用C#实现一个单例
06-15
下面是一个在 Unity 中使用 C# 实现单例的示例代码： ```csharp public class MySingleton : MonoBehaviour { private static MySingleton instance; public static MySingleton Instance { get { if ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值