public void AddUnactualResource(UnactualResourceContent resource, ICachierStorage <Guid> resourceStorage) { if (Transaction.Current == null) { SendUpdate(resource); } else { bool newTransaction = false; var transactedResourceStorage = _transactionUpdates.GetOrAdd(Transaction.Current.TransactionInformation.DistributedIdentifier, id => { newTransaction = true; Transaction.Current.TransactionCompleted += Current_TransactionCompleted; return(new TransactedUpdatesStorage(_subscriptor, Transaction.Current.IsolationLevel)); }); if (newTransaction) { Transaction.Current.EnlistVolatile(transactedResourceStorage, EnlistmentOptions.None); } transactedResourceStorage.AddResource(resource, resourceStorage); } }
public DataRecord GetResource(UnactualResourceContent description) { Contract.Requires(Transaction.Current != null); var transactedResourceStorage = _centralStore.GetResourceStorage(() => new TransactionPacketStorage(_poster, _dependentTransactionRepository)); return(transactedResourceStorage.GetResource(description)); }
public void AddResourceToLocalTransaction(UnactualResourceContent description, object resource) { try { _resourceWriterQueueLock.EnterUpgradeableReadLock(); var existingResource = _resourcesInLocalTransaction.FirstOrDefault(k => k.Content.Equals(description)); try { _resourceWriterQueueLock.EnterWriteLock(); if (existingResource != null) //если найден уже записанный в данной транзакции ресурс { existingResource.Resource = resource; } else { _resourcesInLocalTransaction.Add(new DataRecord(description, resource)); } } finally { _resourceWriterQueueLock.ExitWriteLock(); } } finally { _resourceWriterQueueLock.ExitUpgradeableReadLock(); } }
public void AddResourceToCurrentTransaction(UnactualResourceContent description, object resource) { Contract.Requires(Transaction.Current != null); if (Transaction.Current != null && !_dependentTransactionRepository.IsOurTransaction(Transaction.Current)) { var transactedResourceStorage = _centralStore.GetResourceStorage(() => new TransactionPacketStorage(_poster, _dependentTransactionRepository)); transactedResourceStorage.AddResourceToLocalTransaction(description, resource); } }
public void MarkForUpdate(UnactualResourceContent res) { var resToken = _registrationStorage[res.ResourceName]; if (resToken == null) { throw new ArgumentException(string.Format("Resource {0} is unregistered", res.ResourceName)); } var type = resToken.ResourceType; _stores[type].MarkAsUnactual(res.ResourceKey); }
private void AddDependency(Guid id, UnactualResourceContent unactualResource) { _dependentUpdates.AddOrUpdate(id, new ConcurrentBag <UnactualResourceContent> { unactualResource }, (i, b) => { b.Add(unactualResource); return(b); }); }
public DataRecord GetResource(UnactualResourceContent resource) { try { _resourceWriterQueueLock.EnterReadLock(); return(_resourcesToWrite.FirstOrDefault(k => k.Content.Equals(resource))); } finally { _resourceWriterQueueLock.ExitReadLock(); } }
#pragma warning restore 0649 public void AddResourceToSend(UnactualResourceContent description, object resource, Action <Guid, object> poster, Action updateSender) { Contract.Requires(Transaction.Current != null); if (Transaction.Current == null || _dependentTransactionRepository.IsOurTransaction(Transaction.Current)) { poster(description.ResourceKey, resource); } else { var transactedResourceStorage = _centralStore.GetResourceStorage( () => new TransactionPacketStorage(_poster, _dependentTransactionRepository)); transactedResourceStorage.AddResourceToPost(new DataRecord(updateSender, poster, resource, description)); } }
private void SendUpdate(Guid key) { var update = new UnactualResourceContent { ResourceName = Name, ResourceKey = key }; if (_unactualityAnnounce != null && _services._settingsHolder.Settings.AsyncronousUpdates) { LockForReadingThisAndDependent(); _unactualityAnnounce(update); } else { try { LockForReadingThisAndDependent(); _services._intCachier.MarkForUpdate(update); } finally { UnlockForReadingThisAndDependent(); } } }
public DataRecord(Action updateSender, Action <Guid, object> poster, object resource, UnactualResourceContent content) : this(poster, resource, content) { UpdateSender = updateSender; }
public DataRecord(Action <Guid, object> poster, object resource, UnactualResourceContent content) : this(content, resource) { Poster = poster; }
public DataRecord(UnactualResourceContent content, object resource) { Content = content; Resource = resource; }
internal void SendUpdate(UnactualResourceContent resource) { _subscriptor.AnnonunceUnactuality(resource.ResourceName, resource.ResourceKey); }
internal void MarkAsUnactual(Guid id) { UnactualResourceContent[] allUpdates; ConcurrentBag <UnactualResourceContent> bagUpdates; if (_storage.IsMarkedObject(Name, id)) { return; } _storage.PutMarkedObject(Name, id); if (!_dependentUpdates.TryGetValue(id, out bagUpdates)) { allUpdates = new UnactualResourceContent[0]; } else { var list = new List <UnactualResourceContent>(); while (!bagUpdates.IsEmpty) { UnactualResourceContent t; if (bagUpdates.TryTake(out t)) { list.Add(t); } } allUpdates = list.ToArray(); } // ReSharper disable ImplicitlyCapturedClosure var queryUpdates = _updatesByQueries.SelectMany(k => k(id)); // ReSharper restore ImplicitlyCapturedClosure allUpdates = queryUpdates .Concat(allUpdates) .Concat(_dependentTypes.Select(k => new UnactualResourceContent { ResourceKey = id, ResourceName = k })) .Distinct(_comp) .ToArray(); _dataCache.SetUpdateNecessity(id); _getter.StatChannel.SendMessageAboutOneResource(id, Actions.BecameUnactual); if (allUpdates.Any(k => k.ResourceName == Name && k.ResourceKey == id)) { if (Debugger.IsAttached) { Debugger.Break(); } } for (int i = 0; i < allUpdates.Count(); i++) { _services._intCachier.MarkForUpdate(allUpdates[i]); } _services._subscriptor.AnnonunceUnactuality(Name, id); _storage.ClearLastMarked(); }