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();
}
