/// <summary>
        /// Persist object list into *.xml file
        /// </summary>
        public void Save(bool reload = false)
        {
            if (OnSaving != null)
            {
                OnSaving.Invoke();
            }

            lock (List)
            {
                using (var writer = new StreamWriter(FilePath, false, System.Text.Encoding.GetEncoding("utf-8")))
                {
                    new XmlSerializer(List.GetType()).Serialize(writer, List);
                }
            }

            if (OnSaved != null)
            {
                OnSaved.Invoke();
            }

            if (reload)
            {
                Load();
            }
        }
        /// <summary>
        /// Persist object list into *.xml file
        /// </summary>
        public void Save(bool reload = false)
        {
            if (OnSaving != null)
            {
                OnSaving.Invoke();
            }

            lock (List)
            {
                using (var writer = File.Create(FilePath))
                {
                    new XmlSerializer(List.GetType()).Serialize(writer, List);
                }
            }

            if (OnSaved != null)
            {
                OnSaved.Invoke();
            }

            if (reload)
            {
                Load();
            }
        }
 public void Save()
 {
     foreach (int checkpoint in checkpoints)
     {
         if (checkpoint == waveSpawnerScript.GetActualWaveIndex())
         {
             OnSaving.Invoke();
             SaveLoad.Save();
         }
     }
 }
        /// <summary>
        /// 更新一个对象信息
        /// </summary>
        /// <param name="info">更新对象</param>
        /// <param name="logonInfo">登录人信息</param>
        /// <returns></returns>
        public virtual ResultView Update(T info, TokenLogonInfo logonInfo)
        {
            if (info == null)
            {
                ApiException.ThrowBadRequest("更新对象不能为空");
            }
            _logger.LogTrace($"更新一个对象信息 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n更新对象:[{info.ToJson()}]");

            try
            {
                // 根据ID获取原数据信息
                var old = _SearchById(info.Id);
                // 更新数据前的预制数据
                info.CreateDate  = old.CreateDate;
                info.CreaterId   = old.CreaterId;
                info.CreaterName = old.CreaterName;
                info.UpdateDate  = DateTime.Now;
                info.UpdaterId   = logonInfo.Id;
                info.UpdaterName = logonInfo.Name;
                info.IsDelete    = false;
                if (info.ProcessState == ProcessState.None)
                {
                    info.ProcessState = ProcessState.Edit;
                }

                #region 保存验证
                // 保存的数据校验,可以被重写
                SavingCheck(info, logonInfo);
                // 判断是否可以执行新增操作,可以被重写
                if (!IsExecuteUpdate(info, old, logonInfo))
                {
                    return(ResultView.Success());
                }
                OnUpdateCheck?.Invoke(info, old, logonInfo);
                OnSaveCheck?.Invoke(info, logonInfo);
                #endregion

                #region 保存的前置处理
                // 更新的前置操作,可以被重写
                Updating(info, old, logonInfo);
                // 新增/保存的通用前置操作,可以被重写
                Saving(info, logonInfo);
                // 事件处理
                OnUpdating?.Invoke(info, old, logonInfo);
                OnSaving?.Invoke(info, logonInfo);
                #endregion

                // 持久化数据
                _Dal.UpdateObject(info);

                #region 保存后置处理
                // 更新的后置操作,可以被重写
                Updated(info, old, logonInfo);
                // 新增/保存的通用后置操作,可以被重写
                Saved(info, logonInfo);
                // 新增后的后置事件处理
                OnUpdated?.Invoke(info, old, logonInfo);
                OnSaved?.Invoke(info, logonInfo);
                #endregion

                // 返回保存结果
                return(ResultView.Success(info.IdString));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"更新一个对象信息异常 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n更新对象:[{info.ToJson()}]");
                throw;
            }
        }
        /// <summary>
        /// 创建一个对象信息
        /// </summary>
        /// <param name="info">新增对象</param>
        /// <param name="logonInfo">登录人信息</param>
        /// <returns></returns>
        public virtual ResultView Create(T info, TokenLogonInfo logonInfo)
        {
            if (info == null)
            {
                ApiException.ThrowBadRequest("新增对象不能为空");
            }
            _logger.LogTrace($"新增一个对象信息 ==> 类型为:[{typeof(T).FullName}]\r\n新增对象:[{info.ToJson()}]");

            try
            {
                // 新增数据前的预制数据
                info.CreateDate   = DateTime.Now;
                info.UpdateDate   = DateTime.Now;
                info.UpdaterId    = logonInfo.Id;
                info.UpdaterName  = logonInfo.Name;
                info.CreaterId    = logonInfo.Id;
                info.CreaterName  = logonInfo.Name;
                info.IsDelete     = false;
                info.ProcessState = ProcessState.Edit;

                #region 保存验证
                // 保存的数据校验
                SavingCheck(info, logonInfo);
                // 判断是否可以执行新增操作
                if (!IsExecuteCreate(info, logonInfo))
                {
                    return(ResultView.Success());
                }
                // 保存数据验证的事件处理
                OnCreateCheck?.Invoke(info, logonInfo);
                OnSaveCheck?.Invoke(info, logonInfo);
                #endregion

                #region 保存的前置处理
                // 新增的前置操作,可以被重写
                Creating(info, logonInfo);
                // 新增/保存的通用前置操作,可以被重写
                Saving(info, logonInfo);
                // 新增时的前置事件处理
                OnCreating?.Invoke(info, logonInfo);
                OnSaving?.Invoke(info, logonInfo);
                #endregion

                // 持久化数据
                _Dal.InsertObject(info);

                #region 保存后置处理
                // 新增的通用后置操作,可以被重写
                Created(info, logonInfo);
                // 新增/保存的通用后置操作,可以被重写
                Saved(info, logonInfo);
                // 新增后的后置事件处理
                OnCreated?.Invoke(info, logonInfo);
                OnSaved?.Invoke(info, logonInfo);
                #endregion

                // 返回保存结果
                return(ResultView.Success(info.IdString));
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"新增一个对象信息异常 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n新增对象:[{info.ToJson()}]");
                throw;
            }
        }
Exemple #6
0
 public void Save() => OnSaving?.Invoke();