如何使用单例模式保证全局唯一实例（复杂版本）

/// <summary>
/// 登录管理类（单例模式），负责用户登录、注销及用户信息管理
/// </summary>
public class LoginMananger
{
    // 用于线程同步的锁对象
    static object _lockObj = new object();

    // 单例实例（延迟初始化）
    static LoginMananger loginMananger = null;

    // 用户数据库操作帮助类
    ELMeasure.Model.UserSqlHelp userSql;

    /// <summary>
    /// 当前登录用户信息（只读属性）
    /// </summary>
    public UserInfo LoginUser { get; private set; }

    /// <summary>
    /// 私有构造函数（防止外部实例化）
    /// </summary>
    private LoginMananger()
    {
        // 初始化默认用户状态
        LoginUser = new UserInfo() { Name = "未登录", Level = Model.RootLevel.None };
        
        // 创建数据库连接帮助类并建立连接
        userSql = new ELMeasure.Model.UserSqlHelp();
        userSql.Connect();
    }

    /// <summary>
    /// 获取单例实例（线程安全）
    /// </summary>
    /// <returns>LoginMananger的唯一实例</returns>
    public static LoginMananger GetInstance()
    {
        lock (_lockObj)  // 加锁确保线程安全
        {
            if (loginMananger == null)
                loginMananger = new LoginMananger();  // 延迟初始化
        }
        return loginMananger;
    }

    /// <summary>
    /// 用户登录验证
    /// </summary>
    /// <param name="user">用户名</param>
    /// <param name="password">密码</param>
    /// <returns>登录成功返回true，否则返回false</returns>
    public bool Login(string user, string password)
    {
        if (userSql.IsConnected)  // 检查数据库连接状态
        {
            // 查询用户信息
            if (userSql.SelectUser(user, password, out UserInfo info))
            {
                // 更新当前登录用户信息
                LoginUser.Name = info.Name;
                LoginUser.Level = info.Level;
                return true;
            }
            else
                return false;  // 用户验证失败
        }
        else
            return false;  // 数据库未连接
    }

    /// <summary>
    /// 用户注销
    /// </summary>
    public void LoginOut()
    {
        if (LoginUser.Level != Model.RootLevel.None)
        {
            // 重置用户状态为未登录
            LoginUser.Name = "未登录";
            LoginUser.Level = Model.RootLevel.None;
        }
    }

    /// <summary>
    /// 添加新用户
    /// </summary>
    /// <param name="userInfo">用户信息</param>
    /// <returns>操作成功返回true</returns>
    public bool AddUser(UserInfo userInfo)
    {
        return userSql.AddUser(userInfo);
    }

    /// <summary>
    /// 删除用户
    /// </summary>
    /// <param name="userInfo">要删除的用户信息</param>
    /// <returns>操作成功返回true</returns>
    public bool DeleteUser(UserInfo userInfo)
    {
        return userSql.DeleteUser(userInfo);
    }

    /// <summary>
    /// 修改用户信息
    /// </summary>
    /// <param name="userInfo">修改后的用户信息</param>
    /// <returns>操作成功返回true</returns>
    public bool ChangeUser(UserInfo userInfo)
    {
        return userSql.ChangeUser(userInfo);
    }

    /// <summary>
    /// 获取所有用户列表
    /// </summary>
    /// <returns>用户列表</returns>
    public List<UserInfo> SelectUser()
    {
        List<UserInfo> users = null;
        userSql.SelectUsers(out users);
        return users;
    }
}

这样做有什么好处？

1. 单例模式实现

   • 通过私有构造函数 + GetInstance() 方法保证全局唯一实例

   • 使用 lock 确保多线程安全

2. 核心功能

   • Login()：验证用户凭据并更新登录状态

   • LoginOut()：清除当前登录状态

   • 用户管理方法（Add/Delete/Change/Select）

3. 状态管理

   • LoginUser 属性记录当前登录用户

   • 初始状态为"未登录"

4. 数据库依赖

   • 通过 UserSqlHelp 类封装所有数据库操作

   • 在构造函数中初始化数据库连接

5. 线程安全

   • 所有对单例实例的访问都通过加锁保护