public bool TryAdd(string filepath, out SessionDefinition definition)
{
FileInfo file = new FileInfo(filepath);
string key = file.FullName;
if (file.Exists && TryLoadDefinition(file, out definition))
{
if (_definitions.ContainsKey(key) == false)
{
_definitions.Add(key, definition);
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedItem(definition));
return(true);
}
else if (_definitions[key].CreatedAt != definition.CreatedAt)
{
var removed = _definitions[key];
_definitions.Remove(key);
_definitions.Add(key, definition);
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .Create(definition, removed));
return(true);
}
}
// TODO add message file does not exist
definition = null;
return(false);
}
private void UpdateDefinitions(Dictionary <string, SessionDefinition> currentDefinitions)
{
var previousDefinitions = ObjectEx.GetAndReplace(ref _definitions, currentDefinitions);
if (previousDefinitions != null && previousDefinitions.Any())
{
var addedDefinitions = currentDefinitions.Where(kvp => previousDefinitions.ContainsKey(kvp.Key) == false ||
previousDefinitions[kvp.Key].CreatedAt != kvp.Value.CreatedAt)
.Select(kvp => kvp.Value)
.OrderBy(definition => definition.CreatedAt)
.ToList();
var removedDefinitions = previousDefinitions.Where(kvp => currentDefinitions.ContainsKey(kvp.Key) == false ||
currentDefinitions[kvp.Key].CreatedAt != kvp.Value.CreatedAt)
.Select(kvp => kvp.Value)
.ToList();
if (addedDefinitions.Any() || removedDefinitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .Create(addedDefinitions, removedDefinitions));
}
}
else if (currentDefinitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedCollection(currentDefinitions.Values.OrderBy(d => d.CreatedAt)));
}
}
public void Add(SessionDefinition definition)
{
definition.ThrowIfNull(nameof(definition));
_definitions.Add(definition);
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedItem(definition));
}
public void Unlink(ISessionDefinitionsSource collection)
{
if (collection != null && _linkedCollections.Contains(collection))
{
_linkedCollections.Remove(collection);
collection.DefinitionsChanged -= LinkedCollection_DefinitionsChanged;
if (collection.Definitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForRemovedCollection(collection.Definitions));
}
}
}
//public void AddRange(IEnumerable<SessionDefinition> definitions)
//{
// var newDefinitions = definitions.Where(d => _definitions.Contains(d) == false).ToList();
// if (newDefinitions.Any())
// {
// _definitions.AddRange(newDefinitions);
// DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs<SessionDefinition>.CreateForAddedCollection(definitions));
// }
//}
//public void Add(SessionDefinition definition)
//{
// if (_definitions.Contains(definition) == false)
// {
// _definitions.Add(definition);
// DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs<SessionDefinition>.CreateForAddedItem(definition));
// }
//}
//public void Delete(SessionDefinition session)
//{
// if (_definitions.Remove(session))
// {
// DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs<SessionDefinition>.CreateForRemovedItem(session));
// }
//}
public void Link(ISessionDefinitionsSource collection)
{
collection.ThrowIfNull(nameof(collection));
if (_linkedCollections.Contains(collection) == false)
{
_linkedCollections.Add(collection);
collection.DefinitionsChanged += LinkedCollection_DefinitionsChanged;
if (collection.Definitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedCollection(collection.Definitions));
}
}
}
private void UpdateDefinitions(Dictionary <int, SessionDefinition> definitions)
{
var newDefinitions = definitions.Where(kvp => _definitions.ContainsKey(kvp.Key) == false ||
_definitions[kvp.Key].CreatedAt != kvp.Value.CreatedAt)
.ToList();
if (newDefinitions.Any())
{
List <SessionDefinition> addedDefinitions = new List <SessionDefinition>();
List <SessionDefinition> removedDefinitions = newDefinitions.Where(d => _definitions.ContainsKey(d.Key))
.Select(d => _definitions[d.Key]).ToList();
foreach (var kvp in newDefinitions)
{
if (_definitions.AddOrUpdate(kvp.Key, kvp.Value, (id, value) => value.CreatedAt < kvp.Value.CreatedAt ? kvp.Value : value) == kvp.Value)
{
addedDefinitions.Add(kvp.Value);
}
}
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .Create(addedDefinitions.OrderBy(d => d.CreatedAt), removedDefinitions));
}
}
protected virtual void OnDefinitionsChanged()
{
DefinitionsChanged?.Invoke(this, EventArgs.Empty);
}
private void LinkedCollection_DefinitionsChanged(object sender, CollectionChangedEventArgs <SessionDefinition> e)
{
DefinitionsChanged?.Invoke(this, e);
}
