/// <summary>
/// Applies all changes to state.
/// </summary>
public bool ApplyChanges()
{
if (HasChanges)
{
EnsureFetchedKeysIsNotNull();
BackupState();
var currentFetchedKeys = FetchedKeys;
InitializeFetchedKeys();
foreach (var currentFetchedKey in currentFetchedKeys)
{
if (!removedKeys.ContainsKey(currentFetchedKey))
{
FetchedKeys.Add(currentFetchedKey);
}
}
foreach (var addedKey in addedKeys)
{
FetchedKeys.Add(addedKey.Value);
}
InitializeDifferenceCollections();
Rebind();
return(true);
}
return(false);
}
internal void RollbackState()
{
if (previousState != null)
{
TotalItemCount = previousState.TotalItemCount;
IsLoaded = previousState.IsLoaded;
var fetchedKeys = FetchedKeys;
InitializeFetchedKeys();
InitializeDifferenceCollections();
foreach (var fetchedKey in fetchedKeys)
{
FetchedKeys.Add(fetchedKey);
}
foreach (var addedKey in previousState.AddedKeys)
{
if (fetchedKeys.ContainsKey(addedKey))
{
FetchedKeys.Remove(addedKey);
}
addedKeys.Add(addedKey, addedKey);
}
foreach (var removedKey in previousState.RemovedKeys)
{
if (!FetchedKeys.ContainsKey(removedKey))
{
FetchedKeys.Add(removedKey);
}
removedKeys.Add(removedKey, removedKey);
}
}
}
/// <summary>
/// Sets cached keys to <paramref name="keys"/>.
/// </summary>
/// <param name="keys">The keys.</param>
public void Update(IEnumerable <Key> keys, long?count)
{
FetchedKeys.Clear();
TotalItemCount = count;
foreach (var key in keys)
{
FetchedKeys.Add(key);
}
Rebind();
}
/// <summary>
/// Determines whether cached state contains specified item.
/// </summary>
/// <param name="key">The key.</param>
/// <returns>Check result.</returns>
public bool Contains(Key key)
{
if (removedKeys.ContainsKey(key))
{
return(false);
}
if (addedKeys.ContainsKey(key))
{
return(true);
}
if (FetchedKeys.ContainsKey(key))
{
return(true);
}
return(false);
}
private void UpdateStateDisconnected(IEnumerable <Key> syncronizedKeys, long?count)
{
FetchedKeys.Clear();
var countExceptRemoved = 0;
foreach (var key in syncronizedKeys)
{
FetchedKeys.Add(key);
if (!removedKeys.ContainsKey(key))
{
countExceptRemoved++;
}
}
TotalItemCount = count.HasValue
? countExceptRemoved + AddedItemsCount
: count;
Rebind();
}
/// <inheritdoc/>
public IEnumerator <Key> GetEnumerator()
{
var versionSnapshot = version;
using (var fetchedKeysEnumerator = FetchedKeys.GetEnumerator()) {
while (true)
{
if (versionSnapshot != version)
{
throw new InvalidOperationException(Strings.ExCollectionHasBeenChanged);
}
if (!fetchedKeysEnumerator.MoveNext())
{
break;
}
var fetchedKey = fetchedKeysEnumerator.Current;
if (!removedKeys.ContainsKey(fetchedKey))
{
yield return(fetchedKey);
}
}
}
using (var addedKeysEnumerator = addedKeys.GetEnumerator()) {
while (true)
{
if (versionSnapshot != version)
{
throw new InvalidOperationException(Strings.ExCollectionHasBeenChanged);
}
if (!addedKeysEnumerator.MoveNext())
{
break;
}
var addedKey = addedKeysEnumerator.Current;
yield return(addedKey.Value);
}
}
}
/// <summary>
/// Registers the specified fetched key in cached state.
/// </summary>
/// <param name="key">The key to register.</param>
public void Register(Key key)
{
FetchedKeys.Add(key);
}
