Пример #1
0
        /// <summary>
        /// 该方法用于保存数据后,更新基表的信息
        /// </summary>
        /// <param name="root"></param>
        /// <param name="obj"></param>
        private void OnDataInsert(DomainObject root, DomainObject obj, DynamicData objData)
        {
            SetDataProxy(obj, objData);//对于保存的对象,我们依然要同步数据代理
            obj.MarkClean();

            if (this.Type == DataTableType.AggregateRoot)
            {
                var ar = (IAggregateRoot)obj;
                DomainBuffer.Add(this.ObjectTip.ObjectType, ar.GetIdentity(), ar);
            }

            if (this.IsDerived || this.IsDynamic)
            {
                //如果是派生对象或者动态对象,那么我们需要更新基表信息
                var inheritedRoot = this.InheritedRoot;
                using (var temp = SqlHelper.BorrowData())
                {
                    var data = temp.Item;
                    if (this.Type != DataTableType.AggregateRoot)
                    {
                        data.Add(this.Root.TableIdName, GetObjectId(root));
                    }

                    data.Add(EntityObject.IdPropertyName, GetObjectId(obj));

                    //修改类型码
                    var typeKey = this.IsDerived ? this.DerivedClass.TypeKey : this.DynamicType.Define.TypeName;
                    data.Add(GeneratedField.TypeKeyName, typeKey);

                    //更改基表的信息
                    var sql = inheritedRoot.GetUpdateSql(data);
                    SqlHelper.Execute(inheritedRoot.Name, sql, data);
                }
            }
        }
Пример #2
0
        /// <summary>
        /// 从条目数据中获取对象
        /// <para>如果加载的对象是聚合根,那么如果存在缓冲区中,那么使用缓冲区的对象,如果不存在,则在数据库中查询并更新缓冲区</para>
        /// <para>如果加载的是成员对象,那么始终从数据库中查询</para>
        /// <para>不论是什么类型的对象都可以识别继承类型</para>
        /// </summary>
        /// <returns></returns>
        private object GetObjectFromEntry(DynamicData entry, QueryLevel level)
        {
            if (this.Type == DataTableType.AggregateRoot)
            {
                object id          = entry.Get(EntityObject.IdPropertyName);
                int    dataVersion = (int)entry.Get(GeneratedField.DataVersionName);
                string typeKey     = (string)entry.Get(GeneratedField.TypeKeyName);
                var    table       = string.IsNullOrEmpty(typeKey) ? this : GetDataTable(typeKey);

                if (level.Code == QueryLevel.MirroringCode)
                {
                    //镜像查询会绕过缓冲区
                    return(table.LoadObject(id, QueryLevel.None));
                }

                return(DomainBuffer.GetOrCreate(table.ObjectTip.ObjectType, id, dataVersion, () =>
                {
                    return (IAggregateRoot)table.LoadObject(id, QueryLevel.None); //由于查询条目的时候已经锁了数据,所以此处不用再锁定
                }));
            }
            else
            {
                object rootId      = entry.Get(this.Root.TableIdName);
                object id          = entry.Get(EntityObject.IdPropertyName);
                int    dataVersion = (int)entry.Get(GeneratedField.DataVersionName);
                string typeKey     = (string)entry.Get(GeneratedField.TypeKeyName);
                var    table       = string.IsNullOrEmpty(typeKey) ? this : GetDataTable(typeKey);

                //非聚合根是不能被加入到缓冲区的
                return(table.LoadObject(rootId, id));
            }
        }
Пример #3
0
 /// <summary>
 /// 该方法用于删除数据后的补充操作
 /// </summary>
 /// <param name="obj"></param>
 private void OnDataDelete(object rootId, object id, DomainObject obj)
 {
     //从缓冲区中删除对象
     if (this.Type == DataTableType.AggregateRoot)
     {
         DomainBuffer.Remove(this.ObjectTip.ObjectType, rootId);
     }
 }