public object this[object o, INamedVersionedUniqueId p, string k]
{
get
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k);
SharedDictionaryEntry result;
return(_values.TryGetValue(e, out result) ? result.Value : null);
}
set
{
Set(o, p, k, value);
}
}
public T GetOrSet <T>(object o, INamedVersionedUniqueId p, string k, Func <T> value)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k);
SharedDictionaryEntry result;
if (_values.TryGetValue(e, out result))
{
return((T)result.Value);
}
T val = value == null ? default(T) : value();
e.Value = val;
Add(e);
return(val);
}
public ChangeStatus Set(object o, INamedVersionedUniqueId p, string k, object value)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k);
SharedDictionaryEntry result;
if (_values.TryGetValue(e, out result))
{
if (!Equals(result.Value, value))
{
result.Value = value;
if (Changed != null)
{
Changed(this, new ConfigChangedEventArgs(result, result, ChangeStatus.Update));
}
return(ChangeStatus.Update);
}
return(ChangeStatus.None);
}
e.Value = value;
Add(e);
return(ChangeStatus.Add);
}
internal void ForEach(object o, INamedVersionedUniqueId p, Action <SharedDictionaryEntry> a)
{
PluginConfigByObject co;
if (_byObject.TryGetValue(o, out co) && co.Count > 0)
{
if (co.Count < 10)
{
co.ForEach(p, a);
}
else
{
PluginConfigByPlugin cp;
if (_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p && cp.Count > 0)
{
if (cp.Count < co.Count)
{
cp.ForEach(o, a);
}
else
{
co.ForEach(p, a);
}
}
}
}
}
public bool Remove(object o, INamedVersionedUniqueId p, string k)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k);
SharedDictionaryEntry result;
if (_values.TryGetValue(e, out result))
{
PluginConfigByObject co = _byObject[e.Obj];
co.Remove(result);
PluginConfigByPlugin cp = _byPlugin[e.PluginId.UniqueId];
cp.Remove(result);
_finalDictionary[e].Count--;
_values.Remove(result);
result.Value = null;
if (Changed != null)
{
Changed(this, new ConfigChangedEventArgs(e, e, ChangeStatus.Delete));
}
return(true);
}
return(false);
}
public void CreateSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
string path = TestBase.GetTestFilePath("SharedDic", "SkippedFragments");
SharedDicTestContext.Write("Test", path, dic, this);
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(dic.Fragments.Count, Is.EqualTo(0), "There is no skipped fragments for this dic.");
// Creates a second dictionnary to load previous data (with skippedFragments)
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dic2 = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
dic2.Ensure(uid1);
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(dic2.Fragments.Count, Is.EqualTo(1));
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
}
public SharedDictionaryEntry(object o, INamedVersionedUniqueId p, string k)
{
Debug.Assert(o != null && p != null);
_obj = o;
_pluginId = p;
_key = k;
}
public void ReloadSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
// Creates a second dictionnary to load previous data (with skippedFragments)
string path = TestBase.GetTestFilePath("SharedDic", "ReloadSkippedFragments");
SharedDicTestContext.Write("Test", path, dic, this);
IList <ReadElementObjectInfo> errors;
ISharedDictionary dic2 = SharedDicTestContext.Read("Test", path, this, d => d.Ensure(uid1), out errors);
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(implDic2.Fragments.Count, Is.EqualTo(1));
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
// Now we have skippedFragments. Let's try to reload it.
dic2.Ensure(uid2);
Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1"));
Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2"));
Assert.That(implDic2.Fragments.Count, Is.EqualTo(0));
}
PluginConfigAccessor GetConfigAccessor(INamedVersionedUniqueId idEdited)
{
Debug.Assert(idEdited != null);
Debug.Assert(_contextObject != null);
// Switch from whatever INamedVersionedUniqueId is to IPluginProxy... if it is loaded.
IPluginProxy p = idEdited as IPluginProxy;
if (p == null)
{
p = (IPluginProxy)_host.FindLoadedPlugin(idEdited.UniqueId, true);
if (p == null)
{
_configAccessors.Remove(idEdited);
return(null);
}
}
PluginConfigAccessor result;
if (!_configAccessors.TryGetValue(p, out result))
{
result = new PluginConfigAccessor(p, _config.Extended, _contextObject);
_configAccessors.Add(p, result);
}
return(result);
}
public SharedDictionaryEntry( object o, INamedVersionedUniqueId p, string k )
{
Debug.Assert( o != null && p != null );
_obj = o;
_pluginId = p;
_key = k;
}
public void Destroy(INamedVersionedUniqueId p)
{
if (p == null)
{
throw new ArgumentNullException("p");
}
DoRemove(p, true);
}
public void Clear(INamedVersionedUniqueId p)
{
if (p == null)
{
throw new ArgumentNullException("p");
}
DoRemove(p, false);
}
public bool Contains(INamedVersionedUniqueId p)
{
if (p == null)
{
throw new ArgumentNullException("p");
}
PluginConfigByPlugin cp;
return(_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p);
}
internal void ForEach(INamedVersionedUniqueId p, Action <SharedDictionaryEntry> a)
{
for (int i = 0; i < Count; ++i)
{
SharedDictionaryEntry e = this[i];
if (e.PluginId == p)
{
a(e);
}
}
}
internal PluginConfigAccessor(INamedVersionedUniqueId idEdited, IConfigManagerExtended cfg, object contextObject)
{
Debug.Assert(cfg != null);
_idEdited = idEdited;
_configContainer = cfg.Container;
_system = _configContainer.GetObjectPluginConfig(cfg.ConfigManager.SystemConfiguration, _idEdited);
_user = _configContainer.GetObjectPluginConfig(cfg.ConfigManager.UserConfiguration, _idEdited);
_context = _configContainer.GetObjectPluginConfig(contextObject, _idEdited);
}
internal bool TryRestore(SharedDictionaryImpl dic, MergeMode mergeMode)
{
INamedVersionedUniqueId uid = dic.FindPlugin(PluginId);
if (uid != null)
{
Restore(dic, mergeMode);
return(true);
}
return(false);
}
public bool Contains(object o, INamedVersionedUniqueId p)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
return(_finalDictionary.ContainsKey(new SharedDictionaryEntry(o, p, null)));
}
IObjectPluginConfig IConfigContainer.GetObjectPluginConfig(object o, INamedVersionedUniqueId p, bool ensure)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
return(GetFinalDictionary(new SharedDictionaryEntry(o, p, null), ensure));
}
public PluginUpdateViewModel( INamedVersionedUniqueId pluginId, System.Action<IDownloadResult> InstallAction )
{
PluginId = pluginId;
InstallCommand = new VMCommand( () =>
{
State = PluginUpdateState.Installing;
InstallAction( DownloadResult );
},
( o ) =>
{
return State == PluginUpdateState.WaitingForInstall;
} );
}
public int Count(object o, INamedVersionedUniqueId p)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
FinalDictionary d;
return(_finalDictionary.TryGetValue(new SharedDictionaryEntry(o, p, null), out d) ? d.Count : 0);
}
public INamedVersionedUniqueId Ensure(INamedVersionedUniqueId p)
{
if (p == null)
{
throw new ArgumentNullException("p");
}
PluginConfigByPlugin cp;
if (!_byPlugin.TryGetValue(p.UniqueId, out cp))
{
cp = CreatePluginConfigByPlugin(p);
}
return(cp.PluginId);
}
public SharedDictionaryTester(string testName, string path, object o, INamedVersionedUniqueId uid1, INamedVersionedUniqueId uid2, Action <ISharedDictionary, object, INamedVersionedUniqueId> f)
{
_errors = new List <ReadElementObjectInfo>();
_testName = testName;
_path = path;
_seed = Environment.TickCount;
_o = o;
_uid1 = uid1;
_uid2 = uid2;
_dic = SharedDictionary.Create(null);
_seed2 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed);
f(_dic, _o, _uid1);
_seed3 = GenerateRandomProperties(_dic, _o, _uid1, 10, _seed2);
GenerateRandomProperties(_dic, _o, _uid2, 20, _seed3);
}
public void BugBinarySizeDiffer()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", "BugBinarySizeDiffer");
SharedDictionaryTester checker = new SharedDictionaryTester("BugBinarySizeDiffer", path, this, uid1, uid2, (d, o, id) => d[o, id, "Obj"] = new SerializableObject());
checker.WriteAndReadWithTests(
d => d.SelectSingleNode(@"CK-Structured/BugBinarySizeDiffer/p/data[@key=""Obj""]").Attributes["size"].Value = "1",
dic => { dic.Ensure(uid1); dic.Ensure(uid2); });
Assert.That(checker.Errors.Count, Is.EqualTo(1));
Assert.That(checker.Errors[0].HasError, Is.True);
}
public void Add(object o, INamedVersionedUniqueId p, string k, object value)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
Add(new SharedDictionaryEntry(o, p, k, value));
}
private int GenerateRandomProperties(ISharedDictionary dic, object o, INamedVersionedUniqueId g, int count, int seed)
{
Random r = new Random(seed);
StringBuilder b = new StringBuilder(10);
while (--count > 0)
{
b.Length = 0;
for (int j = 0; j < 10; ++j)
{
b.Append((char)(r.Next(26) + 'A'));
}
dic[o, g, b.ToString()] = count;
}
return(r.Next());
}
private ISharedDictionary BuggyReader <T>(int expectedErrorCount) where T : BuggyObjectBase, new()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", typeof(T).Name);
SharedDictionaryTester checker = new SharedDictionaryTester(typeof(T).Name, path, this, uid1, uid2, (d, o, id) =>
{
Assert.That(id == uid1);
d[o, id, "AnotherValue"] = 13;
d[o, id, "Obj"] = new T()
{
Name = "No Bug for this one!"
};
d[o, id, "Obj2"] = new T()
{
BugWhileReading = BugRead.SkipTag, Name = "This name will not be read back. (But the object exists.)"
};
d[o, id, "Obj3"] = new T()
{
BugWhileReading = BugRead.MoveToEndTag, Name = "This name will not be read back. (But the object exists.)"
};
d[o, id, "Obj4"] = new T()
{
BugWhileReading = BugRead.Throw, Name = "This object should not exist at all..."
};
d[o, id, "YetAnotherValue"] = 87;
});
ISharedDictionary d2 = checker.WriteAndReadWithTests(null, dic => { dic.Ensure(uid1); dic.Ensure(uid2); });
TestBase.DumpFileToConsole(path);
Assert.That(checker.Errors.Count, Is.EqualTo(expectedErrorCount));
Assert.That(checker.Errors.All(e => e.HasError));
Assert.That(d2[this, uid1, "AnotherValue"], Is.EqualTo(13));
Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj"]).Name, Is.EqualTo("No Bug for this one!"));
Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj2"]).Name, Is.EqualTo("Default Name"));
Assert.That(((BuggyObjectBase)d2[this, uid1, "Obj3"]).Name, Is.EqualTo("Default Name"));
Assert.That(d2[this, uid1, "Obj4"], Is.Null);
return(d2);
}
void DoRemove(INamedVersionedUniqueId p, bool definitive)
{
PluginConfigByPlugin cp;
if (_byPlugin.TryGetValue(p.UniqueId, out cp) && cp.PluginId == p)
{
if (cp.Count > 0)
{
HashSet <object> objectsTouched = new HashSet <object>();
foreach (SharedDictionaryEntry e in cp)
{
_values.Remove(e);
PluginConfigByObject co = _byObject[e.Obj];
co.Remove(e);
_finalDictionary.Remove(e);
objectsTouched.Add(e.Obj);
}
cp.Clear();
if (Changed != null)
{
bool allObjectsConcerned = objectsTouched.Count == _byObject.Count;
ChangeStatus changeStatus;
if (definitive)
{
changeStatus = ChangeStatus.ContainerDestroy;
}
else
{
changeStatus = ChangeStatus.ContainerClear;
}
Changed(this, new ConfigChangedEventArgs(new ReadOnlyCollectionOnISet <object>(objectsTouched), allObjectsConcerned, p, changeStatus));
}
}
if (definitive)
{
_byPlugin.Remove(p.UniqueId);
}
}
// Clears fragment in any case (the plugin beeing known or not).
ClearFragments(p);
}
public T GetOrSet <T>(object o, INamedVersionedUniqueId p, string k, Func <T> value, Func <object, T> converter)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
if (p == null)
{
throw new ArgumentNullException("p");
}
if (k == null)
{
throw new ArgumentNullException("k");
}
if (converter == null)
{
throw new ArgumentNullException("converter");
}
SharedDictionaryEntry e = new SharedDictionaryEntry(o, p, k);
SharedDictionaryEntry result;
if (_values.TryGetValue(e, out result))
{
if (result.Value is T)
{
return((T)result.Value);
}
T valT = converter(result.Value);
result.Value = valT;
if (Changed != null)
{
Changed(this, new ConfigChangedEventArgs(result, result, ChangeStatus.Update));
}
return(valT);
}
T val = value == null ? default(T) : value();
e.Value = val;
Add(e);
return(val);
}
public void ImportReloadedSkippedFragments()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", "ImportReloadedSkippedFragments");
#region Creates actual fragments
// Creates a dummy dictionnary and writes it.
SharedDictionaryImpl dic = CreateDummySharedDic(this, uid1, uid2);
SharedDicTestContext.Write("Test", path, dic, this);
// Creates a second dictionnary to load previous data (with skippedFragments).
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.IsTrue(new FileInfo(path).Length > 0, "File must exist and be not empty.");
Assert.That(errors.Count, Is.EqualTo(0));
Assert.That(dicFrag.GetSkippedFragments(this).Count == 2);
Assert.That(dicFrag[this, uid1, "key1"], Is.Null);
Assert.That(dicFrag[this, uid2, "key2"], Is.Null);
#endregion
ISharedDictionary dic2 = SharedDictionary.Create(SharedDicTestContext.ServiceProvider);
dic2[this, uid1, "key1"] = "value1";
dic2[this, uid1, "key2"] = "value2";
Assert.That(dic2[this, uid2, "key1"], Is.Null);
Assert.That(dic2[this, uid2, "key2"], Is.Null);
dic2.Ensure(uid2);
SharedDictionaryImpl implDic2 = (SharedDictionaryImpl)dic2;
implDic2.ImportFragments(dicFrag.Fragments, MergeMode.None);
Assert.That(implDic2.GetSkippedFragments(this) == null);
Assert.That(dic2[this, uid2, "key1"], Is.EqualTo("value1"));
Assert.That(dic2[this, uid2, "key2"], Is.EqualTo("value2"));
}
public void BugBinaryBadContent()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
string path = TestBase.GetTestFilePath("SharedDic", "BugBinaryBadContent");
SharedDictionaryTester checker = new SharedDictionaryTester("BugBinaryBadContent", path, this, uid1, uid2, (d, o, id) => d[o, id, "Obj"] = new SerializableObject());
Assert.Throws <XmlException>(() =>
{
checker.WriteAndReadWithTests
(
d =>
{
XmlNode n = d.SelectSingleNode(@"CK-Structured/BugBinaryBadContent/p/data[@key=""Obj""]");
n.InnerText = n.InnerText.Insert(n.InnerText.Length / 2, "*bug*");
},
dic => { dic.Ensure(uid1); dic.Ensure(uid2); }
);
});
}
/// <summary>
/// Throws an ArgumentException if the Guid is already associated to
/// another IVersionedUniqueId.
/// </summary>
private PluginConfigByPlugin CreatePluginConfigByPlugin(INamedVersionedUniqueId p)
{
PluginConfigByPlugin cp = new PluginConfigByPlugin(p);
_byPlugin.Add(p.UniqueId, cp);
var entriesToRemove = ClearFragments(_fragments.ToReadOnlyCollection(), f =>
{
if (f.PluginId == p.UniqueId)
{
f.Restore(this, MergeMode.ErrorOnDuplicate);
return(true);
}
return(false);
});
foreach (object entry in entriesToRemove)
{
_fragments.Remove(entry);
}
return(cp);
}
public void MergeFragments_PreserveExisting()
{
INamedVersionedUniqueId uid1 = SharedDicTestContext.Plugins[0];
INamedVersionedUniqueId uid2 = SharedDicTestContext.Plugins[1];
INamedVersionedUniqueId uid3 = SharedDicTestContext.Plugins[2];
SharedDictionaryImpl dic = new SharedDictionaryImpl(SharedDicTestContext.ServiceProvider);
dic[this, uid1, "key1"] = "value1";
dic[this, uid1, "key2"] = "value2";
dic[this, uid2, "key1"] = "value1";
dic[this, uid2, "key2"] = "value2";
dic[this, uid3, "key1"] = "value1";
dic[this, uid3, "key2"] = "value2";
string path = TestBase.GetTestFilePath("SharedDic", "MergeFragments");
SharedDicTestContext.Write("Test", path, dic, this);
IList <ReadElementObjectInfo> errors;
SharedDictionaryImpl dicFullFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFullFrag.GetSkippedFragments(this).Count == 3);
SharedDictionaryImpl dicFrag = (SharedDictionaryImpl)SharedDicTestContext.Read("Test", path, this, d => { d.Ensure(uid1); d.Ensure(uid2); }, out errors);
Assert.That(errors.Count == 0);
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
int hashCode = dicFrag.GetSkippedFragments(this)[0].GetHashCode();
dicFrag.ImportFragments(dicFullFrag.Fragments, MergeMode.PreserveExisting);
Assert.That(dicFrag.GetSkippedFragments(this) != null);
Assert.That(dicFrag.GetSkippedFragments(this).Count == 1);
Assert.That(dicFrag.GetSkippedFragments(this)[0].GetHashCode() == hashCode);
}
PluginConfigAccessor GetConfigAccessor( INamedVersionedUniqueId idEdited )
{
Debug.Assert( idEdited != null );
Debug.Assert( _contextObject != null );
// Switch from whatever INamedVersionedUniqueId is to IPluginProxy... if it is loaded.
IPluginProxy p = idEdited as IPluginProxy;
if( p == null )
{
p = (IPluginProxy)_host.FindLoadedPlugin( idEdited.UniqueId, true );
if( p == null )
{
_configAccessors.Remove( idEdited );
return null;
}
}
PluginConfigAccessor result;
if( !_configAccessors.TryGetValue( p, out result ) )
{
result = new PluginConfigAccessor( p, _config.Extended, _contextObject );
_configAccessors.Add( p, result );
}
return result;
}
public ConfigChangedEventArgs( object obj, INamedVersionedUniqueId pluginId, ChangeStatus status )
: this( obj, new ReadOnlyListMono<object>( obj ), new ReadOnlyListMono<INamedVersionedUniqueId>( pluginId ), null, null, status )
{
}
public ConfigChangedEventArgs( IReadOnlyCollection<object> multiObj, bool allObjectsConcerned, INamedVersionedUniqueId pluginId, ChangeStatus status )
: this( null, multiObj, new ReadOnlyListMono<INamedVersionedUniqueId>( pluginId ), null, null, status )
{
IsAllObjectsConcerned = allObjectsConcerned;
}
public HelpUpdateDownloadedEventArgs( INamedVersionedUniqueId plugin, IDownloadResult downloadResult )
: base(plugin)
{
DownloadResult = downloadResult;
}
/// <summary>
/// Gets (creates it if needed) an easy to use <see cref="IObjectPluginConfig"/> that acts as a standard name-value dictionary.
/// </summary>
/// <param name="c">This <see cref="IConfigContainer"/> object.</param>
/// <param name="o">Object that carries the properties.</param>
/// <param name="p">Plugin identifier.</param>
/// <returns>>An easy accessor for the object/plugin couple.</returns>
public static IObjectPluginConfig GetObjectPluginConfig( this IConfigContainer c, object o, INamedVersionedUniqueId p )
{
return c.GetObjectPluginConfig( o, p, true );
}
Action<IDownloadResult> CreateInstallActionFor( INamedVersionedUniqueId pluginId )
{
return d => _manualInstaller( pluginId, d );
}
PluginUpdateViewModel FindOrCreateVm( INamedVersionedUniqueId pluginId )
{
var plugin = PluginUpdates.FirstOrDefault( p => p.PluginId == pluginId );
if( plugin == null )
{
plugin = new PluginUpdateViewModel( pluginId, CreateInstallActionFor( pluginId ) );
PluginUpdates.Add( plugin );
}
return plugin;
}
public HelpUpdateEventArgs( INamedVersionedUniqueId plugin )
{
Plugin = plugin;
}
internal void ClearFragments( INamedVersionedUniqueId id )
{
ClearFragments( f => f.PluginId == id.UniqueId );
}
