コード例 #1
0
        /// <summary>
        /// Returns null if:
        /// 1. Could not take a lock on the item
        /// 2. Item was not available locally
        ///
        /// When you are done editing, call CommitAsync() on the RecordItemEditOperation
        /// To abort, call RecordItemEditOperation::Cancel()
        ///
        /// </summary>
        public IAsyncOperation <RecordItemEditOperation> OpenForEditAsync(ItemKey key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }
            return(AsyncInfo.Run <RecordItemEditOperation>(async cancelToken =>
            {
                RecordItemLock rLock = this.AcquireItemLock(key);
                if (rLock == null)
                {
                    return null;
                }

                RecordItemEditOperation editOp = null;
                try
                {
                    editOp = await this.OpenForEditAsync(key, rLock);
                    return editOp;
                }
                finally
                {
                    if (editOp == null)
                    {
                        rLock.Release();
                    }
                }
            }));
        }
コード例 #2
0
 void ReleaseLock()
 {
     if (m_rLock != null)
     {
         m_rLock.Release();
         m_rLock = null;
     }
 }
コード例 #3
0
 /// <summary>
 /// Updates an existing item. To update, you must first acquire a lock on it, and prove that you own the lock.
 /// Note: if you use higher level objects like SynchronizedStore, you won't have to acquire locks yourself.
 /// </summary>
 public IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock)
 {
     if (item == null)
     {
         throw new ArgumentNullException("item");
     }
     return(this.PutItemAsync(item.Item, itemLock));
 }
コード例 #4
0
        internal IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock)
        {
            this.ValidateItem(item);

            return(AsyncInfo.Run(async cancelToken => {
                await this.Data.PutAsync(item, itemLock);
                await this.UpdateKeyAsync(item.Item);
            }));
        }
コード例 #5
0
        internal IAsyncAction RemoveAsync(ItemKey key, RecordItemLock itemLock)
        {
            key.ValidateRequired("key");

            return(AsyncInfo.Run(async cancelToken =>
            {
                await this.Data.RemoveItemAsync(m_typeID, key, itemLock);
                await this.RemoveKeyAsync(key);
            }));
        }
コード例 #6
0
        void Dispose(bool fromDispose)
        {
            if (fromDispose)
            {
                this.ReleaseLock();
                GC.SuppressFinalize(this);
            }

            m_rLock = null;
        }
コード例 #7
0
        internal async Task <RecordItemEditOperation> OpenForEditAsync(ItemKey key, RecordItemLock itemLock)
        {
            IItemDataTyped data = await this.EnsureItemAvailableAndGetByKeyAsync(key);

            if (data == null)
            {
                return(null);
            }

            return(new RecordItemEditOperation(this, data, itemLock));
        }
コード例 #8
0
        /// <summary>
        /// Remove an item. To remove, you must first acquire a lock on the item, and prove that you own the lock.
        /// If you use the higher level SychronizedType object, you won't have to acquire the lock yourself
        /// </summary>
        public IAsyncAction RemoveItemAsync(string typeID, ItemKey itemKey, RecordItemLock itemLock)
        {
            itemKey.ValidateRequired("key");
            if (itemLock == null)
            {
                throw new ArgumentNullException("itemLock");
            }

            m_itemLocks.ValidateLock(itemKey.ID, itemLock.LockID);

            return(AsyncInfo.Run(async cancelToken => {
                await m_localStore.RemoveItemAsync(itemKey);
                await m_changeManager.TrackRemoveAsync(typeID, itemKey);
            }));
        }
コード例 #9
0
        public IAsyncAction NewItemAsync(RecordItem item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            SynchronizedStore.PrepareForNew(item);

            return(AsyncInfo.Run(async cancelToken =>
            {
                RecordItemLock rlock = m_itemLocks.AcquireItemLock(item.ID);
                if (rlock != null)
                {
                    using (rlock)
                    {
                        await this.PutItemAsync(item, rlock);
                    }
                }
            }));
        }
コード例 #10
0
        public IAsyncAction PutItemAsync(RecordItem item, RecordItemLock itemLock)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            if (itemLock == null)
            {
                throw new ArgumentNullException("itemLock");
            }

            m_itemLocks.ValidateLock(item.ID, itemLock.LockID);

            item.UpdateEffectiveDate();

            return(AsyncInfo.Run(async cancelToken => {
                await m_localStore.PutItemAsync(item);
                await m_changeManager.TrackPutAsync(item);
            }));
        }
コード例 #11
0
        /// <summary>
        /// Before removing the item, will try to take a lock on the item in question.
        /// If it can't, it will return FALSE
        /// </summary>
        public IAsyncOperation <bool> RemoveAsync(ItemKey key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }
            return(AsyncInfo.Run(async cancelToken =>
            {
                RecordItemLock rLock = this.AcquireItemLock(key);
                if (rLock == null)
                {
                    return false;
                }
                using (rLock)
                {
                    await this.RemoveAsync(key, rLock);
                }

                this.StartCommitChanges();
                return true;
            }));
        }
コード例 #12
0
        internal RecordItemLock AcquireItemLock(string itemID)
        {
            long lockID = 0;

            try
            {
                lockID = this.AcquireLock(itemID);
                if (!IsValidLockID(lockID))
                {
                    return(null);
                }

                RecordItemLock itemLock = new RecordItemLock(this, itemID, lockID);
                lockID = 0;
                return(itemLock);
            }
            finally
            {
                if (IsValidLockID(lockID))
                {
                    this.ReleaseLock(itemID, lockID);
                }
            }
        }
コード例 #13
0
        /// <summary>
        /// Add a new item. The item is saved in the local store immediately, and a pending commit to the remote store is put in
        /// the synchronized store's change queue
        /// </summary>
        public IAsyncAction AddNewAsync(IItemDataTyped item)
        {
            this.ValidateItem(item);

            RecordItem recordItem = item.Item;

            SynchronizedStore.PrepareForNew(recordItem);

            return(AsyncInfo.Run(async cancelToken => {
                RecordItemLock rlock = this.AcquireItemLock(recordItem.Key);
                if (rlock == null)
                {
                    return;
                }

                using (rlock)
                {
                    await this.Data.PutItemAsync(recordItem, rlock);
                    await this.AddKeyAsync(recordItem);
                }

                this.StartCommitChanges();
            }));
        }
コード例 #14
0
 internal RecordItemEditOperation(SynchronizedType sType, IItemDataTyped data, RecordItemLock rLock)
 {
     m_sType = sType;
     m_rLock = rLock;
     m_data  = data.Item.DeepClone().TypedData;
 }
 void ReleaseLock()
 {
     if (m_rLock != null)
     {
         m_rLock.Release();
         m_rLock = null;
     }
 }
        void Dispose(bool fromDispose)
        {
            if (fromDispose)
            {
                this.ReleaseLock();
                GC.SuppressFinalize(this);
            }

            m_rLock = null;
        }
 internal RecordItemEditOperation(SynchronizedType sType, IItemDataTyped data, RecordItemLock rLock)
 {
     m_sType = sType;
     m_rLock = rLock;
     m_data = data.Item.DeepClone().TypedData;
 }
        /// <summary>
        /// Remove an item. To remove, you must first acquire a lock on the item, and prove that you own the lock.
        /// If you use the higher level SychronizedType object, you won't have to acquire the lock yourself
        /// </summary>
        public IAsyncAction RemoveItemAsync(string typeID, ItemKey itemKey, RecordItemLock itemLock)
        {
            itemKey.ValidateRequired("key");
            if (itemLock == null)
            {
                throw new ArgumentNullException("itemLock");
            }

            m_itemLocks.ValidateLock(itemKey.ID, itemLock.LockID);

            return AsyncInfo.Run(async cancelToken => {                
                await m_localStore.RemoveItemAsync(itemKey);
                await m_changeManager.TrackRemoveAsync(typeID, itemKey);                
            });
        }        
        internal IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock)
        {
            this.ValidateItem(item);

            return AsyncInfo.Run(async cancelToken => {            
                await this.Data.PutAsync(item, itemLock);
                await this.UpdateKeyAsync(item.Item);
            });
        }
        internal RecordItemLock AcquireItemLock(string itemID)
        {
            long lockID = 0;
            try
            {
                lockID = this.AcquireLock(itemID);
                if (!IsValidLockID(lockID))
                {
                    return null;
                }

                RecordItemLock itemLock = new RecordItemLock(this, itemID, lockID);
                lockID = 0;
                return itemLock;
            }
            finally
            {
                if (IsValidLockID(lockID))
                {
                    this.ReleaseLock(itemID, lockID);
                }
            }
        }
        internal async Task<RecordItemEditOperation> OpenForEditAsync(ItemKey key, RecordItemLock itemLock)
        {
            IItemDataTyped data = await this.EnsureItemAvailableAndGetByKeyAsync(key);
            if (data == null)
            {
                return null;
            }

            return new RecordItemEditOperation(this, data, itemLock);
        }
 /// <summary>
 /// Updates an existing item. To update, you must first acquire a lock on it, and prove that you own the lock. 
 /// Note: if you use higher level objects like SynchronizedStore, you won't have to acquire locks yourself. 
 /// </summary>
 public IAsyncAction PutAsync(IItemDataTyped item, RecordItemLock itemLock)
 {
     if (item == null)
     {
         throw new ArgumentNullException("item");
     }
     return this.PutItemAsync(item.Item, itemLock);
 }
        internal IAsyncAction RemoveAsync(ItemKey key, RecordItemLock itemLock)
        {
            key.ValidateRequired("key");

            return AsyncInfo.Run(async cancelToken =>
            {
                await this.Data.RemoveItemAsync(m_typeID, key, itemLock);
                await this.RemoveKeyAsync(key);
            });
        }
        public IAsyncAction PutItemAsync(RecordItem item, RecordItemLock itemLock)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            if (itemLock == null)
            {
                throw new ArgumentNullException("itemLock");
            }

            m_itemLocks.ValidateLock(item.ID, itemLock.LockID);
            
            item.UpdateEffectiveDate();

            return AsyncInfo.Run(async cancelToken => {
                await m_localStore.PutItemAsync(item);
                await m_changeManager.TrackPutAsync(item);
            });
        }