public void ContainsKey()
{
sut.Add("a", "c");
sut.ContainsKey("a").Should().BeTrue();
sut.ContainsKey("b").Should().BeFalse();
}
/// <summary>
/// Removes an entry from the list.
/// If after removing this entry, the opcode list is empty,
/// the opcode is then removed from the list as well.
/// </summary>
/// <param name="opCode">The opcode of the packet.</param>
/// <param name="size">The size of the packet, in bytes.</param>
public void Remove(int opCode, int size)
{
m_ignoredPackets.Remove(opCode, size);
if (m_ignoredPackets.ContainsKey(opCode))
{
if (m_ignoredPackets[opCode].Count <= 0)
{
m_ignoredPackets.Remove(opCode);
}
}
}
public void MultiValueDictionaryContainsTest()
{
MultiValueDictionary <Int32, String> dictionary = new MultiValueDictionary <Int32, String>();
foreach (KeyValuePair <Int32, List <String> > value in this.values)
{
dictionary.Add(value.Key, value.Value);
}
dictionary.ContainsKey(1).ShouldBeTrue();
dictionary.ContainsKey(0).ShouldBeFalse();
}
public static void ShouldContainKey()
{
var multiDict = new MultiValueDictionary <string, string>();
multiDict.AddRange("key2", values2);
multiDict.AddRange("key1", values1);
multiDict.Add("key3", "海亀");
Assert.IsTrue(multiDict.ContainsKey("key1"));
Assert.IsTrue(multiDict.ContainsKey("key3"));
Assert.IsTrue(multiDict.ContainsKey("key2"));
Assert.IsTrue(multiDict.Contains("key1"));
Assert.IsTrue(multiDict.Contains("key2"));
Assert.IsTrue(multiDict.Contains("key3"));
}
public override void enterIfAbsent(Symbol c)
{
if (!dict.ContainsKey(c.name))
{
dict.Add(c.name, c);
}
}
public virtual void ManyItems()
{
var items = Enumerable.Range(0, 100).Select(_ =>
{
var key = NextKey();
var values = Enumerable.Range(0, 100).Select(__ => NextValue()).ToArray();
return(new KeyValuePair <TKey, TValue[]>(key, values));
}).ToDictionary(kv => kv.Key, kv => kv.Value);
var data = new MultiValueDictionary <TKey, TValue>();
foreach (var kv in items)
{
data.Add(kv.Key, kv.Value);
}
var count = data.Count;
Assert.Equal(100 * 100, count);
Assert.True(HashSet <TKey> .CreateSetComparer().Equals(new HashSet <TKey>(data.Keys), new HashSet <TKey>(items.Keys)));
foreach (var key in items.Keys)
{
Assert.True(data.ContainsKey(key));
Assert.True(data.TryGetValue(key, out var v));
Assert.Contains(v, items[key]);
Assert.True(data.TryGetValues(key, out var vs));
count = vs.Length;
Assert.Equal(100, count);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue>(items[key])));
var vsx = new List <TValue>();
Assert.True(data.TryGetValues(key, vsx));
count = vsx.Count;
Assert.Equal(100, count);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vsx), new HashSet <TValue>(items[key])));
}
}
public void RemoveTest()
{
var t = new MultiValueDictionary <int, int>();
t.Add(1, 3);
t.Add(1, 4);
t.Add(1, 5);
t.Add(2, 3);
t.Add(2, 4);
t.Remove(1);
Assert.False(t.ContainsKey(1));
t.Remove(2);
Assert.False(t.ContainsKey(1));
Assert.True(!t.Any());
}
private List <string> ReadCardList(string text)
{
List <string> cards = new List <string>();
foreach (string line in Regex.Split(text, "\r\n|\r|\n"))
{
var match = CardRegex.Match(line);
if (match.Success)
{
int amt = int.Parse(match.Groups[1].Value);
string name = match.Groups[3].Value;
if (CardDatabase.ContainsKey(name))
{
for (int i = 0; i < amt; i++)
{
cards.Add(name);
}
}
else
{
lst_notfound.Items.Add(name);
}
}
}
return(cards);
}
public IEnumerable <int> Get(TKey key)
{
if (!_data.ContainsKey(key))
{
return(Enumerable.Empty <int>());
}
return(_data[key]);
}
/// <inheritdoc />
public ICollection <IIndex> GetIndices(IOperationTarget operationTarget)
{
if (!_indicesCoverage.ContainsKey(operationTarget))
{
return(new IIndex[0]);
}
return(_indicesCoverage[operationTarget].ToArray());
}
public IEnumerable <ConnectionId> GetConnections(RoomId roomId, ConnectionId except = null)
{
// An inexistent room can be requested when the first user enters it (because we requests the list of connections before adding the user's connection to the room)
if (!_roomsConnections.ContainsKey(roomId))
{
return(new List <ConnectionId>());
}
return(_roomsConnections [roomId].Where(r => except == null || r != except).ToList()); //without ToList(), result looks like it's null?!
}
public void MultiValueDictionaryContainsTest()
{
MultiValueDictionary <Int32, String> dictionary = new MultiValueDictionary <Int32, String>();
foreach (KeyValuePair <Int32, List <String> > item in _items)
{
dictionary.Add(item.Key, item.Value);
}
Assert.AreEqual(true, dictionary.ContainsKey(1));
Assert.AreEqual(false, dictionary.ContainsKey(0));
Assert.AreEqual(true, dictionary.Contains(new KeyValuePair <Int32, ICollection <String> >(1, new List <String> {
"1", "11"
} as ICollection <String>)));
Assert.AreEqual(false, dictionary.Contains(new KeyValuePair <Int32, ICollection <String> >(1, new List <String> {
"0", "11"
} as ICollection <String>)));
}
protected void RemoveSagaKeys(string name)
{
if (keys.ContainsKey(name))
{
Publish(new SagaKeysChangedEvent(
keys
.Where(x => x.Key != name)
.Select(x => new KeyValuePair <string, ImmutableList <string> >(x.Key, x.Value.ToImmutableList()))
.ToImmutableDictionary()));
}
}
public static IEnumerable <TValue> All <TKey, TValue>(this MultiValueDictionary <TKey, TValue> dictonary, TKey key)
{
if (dictonary.ContainsKey(key))
{
return(dictonary[key]);
}
else
{
return(Enumerable.Empty <TValue>());
}
}
public IEnumerable <int> IdsOf(string name)
{
if (lookup.ContainsKey(name))
{
return(lookup[name]);
}
else
{
return(Enumerable.Empty <int>());
}
}
public IEnumerable <string> NamesOf(int id)
{
if (names.ContainsKey(id))
{
return(names[id]);
}
else
{
return(Enumerable.Empty <string>());
}
}
protected override IEnumerable <Node> GetChildren(Node node)
{
BGoapNode goapNode = (node as AStarDebugNode).content as BGoapNode;
if (childLists.ContainsKey(goapNode))
{
foreach (var BGoapNode in childLists.GetValues(goapNode, true))
{
yield return(new AStarDebugNode(BGoapNode, goal));
}
}
}
private static void AddNestedGuids(GuidWithName child, string parentGuid, RelativePath parentFolder, Dictionary <RelativePath, string> folderProjects, MultiValueDictionary <string, GuidWithName> childrenByParentGuid)
{
// Check whether there is any siblings with the same name.
// If so, put this child to the parent of the current parent folder.
while (childrenByParentGuid.ContainsKey(parentGuid) && childrenByParentGuid[parentGuid].Any(a => a.Name == child.Name))
{
parentFolder = parentFolder.GetParent();
parentGuid = folderProjects[parentFolder];
}
childrenByParentGuid.Add(parentGuid, child);
}
public void Remove_ShouldRemoveTheKeyIfNoMoreValuesExist()
{
_target.Add("A", "B");
_target.Remove("A", "B");
Assert.False(_target.ContainsKey("A"));
}
public void Draw(TagIdent item)
{
if (objectInstances.ContainsKey(item))
{
//IRenderable @object = objects[item] as IRenderable;
//@object.Render( new[] { program, systemProgram } );
}
else
{
var data = Halo2.GetReferenceObject(item);
//objects[item] = new ScenarioObject( (ModelBlock)data );
}
}
private bool ExecutedCore(string name, object value = null) {
value = value ?? typeof(object);
var keyValuePair = new KeyValuePair<string, ApplicationModulesManager>(name, ModuleManager);
if (CallMonitor.ContainsKey(keyValuePair)) {
if (!CallMonitor.GetValues(keyValuePair, true).Contains(value)) {
CallMonitor.Add(keyValuePair, value);
return false;
}
return true;
}
CallMonitor.Add(keyValuePair, value);
return false;
}
public IEnumerable <SignificantAasElemRecord> Retrieve(
AdminShell.AdministrationShellEnv env,
SignificantAasElement kind)
{
if (env == null || true != _records.ContainsKey(kind))
{
yield break;
}
foreach (var r in _records[kind])
{
// look up
var lo = env.FindReferableByReference(r.Reference);
if (lo != null)
{
r.LiveObject = lo;
yield return(r);
}
}
}
public void RemoveTest2()
{
var t = new MultiValueDictionary <int, int>();
t.Add(1, 3);
t.Add(1, 4);
t.Add(1, 5);
t.Add(2, 3);
t.Add(2, 4);
t.Remove(1, 3);
Assert.Equal(new[] { 4, 5 }, t[1].OrderBy(x => x));
t.Remove(1, 5);
Assert.Equal(new[] { 4 }, t[1].OrderBy(x => x));
t.Remove(2, 4);
Assert.Equal(new[] { 3 }, t[2].OrderBy(x => x));
t.Remove(1, 4);
Assert.False(t.ContainsKey(1));
}
public AdminShell.Referable FindReferableByReference(AdminShell.Reference r)
{
var hk = ComputeHashOnReference(r);
if (hk == 0 || !dict.ContainsKey(hk))
{
return(null);
}
foreach (var test in dict[hk])
{
var xx = (test as AdminShell.IGetReference)?.GetReference();
if (xx != null && xx.Matches(r))
{
return(test);
}
}
return(null);
}
public static void Add(SyntaxNode syntaxNode, int identityHash)
{
var filePath = syntaxNode.SyntaxTree?.FilePath;
if (syntaxNode is ICompilationUnitSyntax && filePath != null && _SyntaxNodesFromFilePath.ContainsKey(filePath))
{
// If we've got a new compilation unit syntax then any syntax nodes from the same file won't get used so remove them.
foreach (var node in _SyntaxNodesFromFilePath[filePath])
{
_SyntaxNodeHashes.Remove(node);
}
_SyntaxNodesFromFilePath.Remove(filePath);
}
if (filePath != null)
{
_SyntaxNodesFromFilePath.Add(filePath, syntaxNode);
}
_SyntaxNodeHashes.Add(syntaxNode, identityHash);
}
public virtual void EmptyTests()
{
var key = NextKey();
var empty = new MultiValueDictionary <TKey, TValue>();
var xvs = new List <TValue>();
Assert.False(empty.ContainsKey(key));
Assert.False(empty.TryGetValue(key, out var _));
Assert.False(empty.TryGetValues(key, out var arr));
Assert.Null(arr);
Assert.False(empty.TryGetValues(key, xvs));
Assert.Empty(xvs);
var count = empty.Count;
Assert.Equal(0, count);
count = empty.Count();
Assert.Equal(0, count);
Assert.Empty(empty.Keys);
Assert.Equal(0, empty.Remove(key));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)empty).Remove(new KeyValuePair <TKey, TValue>(key, default(TValue))));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)empty).IsReadOnly);
}
public T FindElementByReference(
AdminShell.Reference r,
AdminShell.Key.MatchMode matchMode = AdminShell.Key.MatchMode.Strict)
{
var hk = ComputeHashOnReference(r);
if (hk == 0 || !dict.ContainsKey(hk))
{
return(default(T));
}
foreach (var test in dict[hk])
{
var xx = (test as AdminShell.IGetReference)?.GetReference();
if (xx != null && xx.Matches(r, matchMode))
{
return(test);
}
}
return(default(T));
}
private static bool MethodCalledFromDispose(MultiValueDictionary<INamedTypeSymbol, IMethodSymbol> disposeMethodsCalledFromDispose, IMethodSymbol dispose)
{
return disposeMethodsCalledFromDispose.ContainsKey(dispose.ContainingType) &&
disposeMethodsCalledFromDispose[dispose.ContainingType].Contains(dispose);
}
public virtual void BasicOperationsTest()
{
var data = new MultiValueDictionary <TKey, TValue>();
var key0 = NextKey();
var key1 = NextKey();
var value00 = NextValue();
var value01 = NextValue();
var value10 = NextValue();
var value11 = NextValue();
TValue v;
TValue[] vs;
var xvs = new List <TValue>();
// single key, single value
data.Add(key0, value00);
Assert.True(data.ContainsKey(key0));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00)));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01)));
Assert.True(data.TryGetValue(key0, out v));
Assert.Equal(value00, v);
Assert.True(data.TryGetValues(key0, out vs));
Assert.NotNull(vs);
Assert.Single(vs, v);
xvs.Clear();
Assert.True(data.TryGetValues(key0, xvs));
Assert.Single(xvs, v);
var count = data.Count;
Assert.Equal(1, count);
count = data.Count();
Assert.Equal(1, count);
Assert.Single(data.Keys, key0);
data.Clear();
Assert.Empty(data);
// single key, two values (added separately)
data.Add(key0, value00);
data.Add(key0, value01);
Assert.True(data.ContainsKey(key0));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00)));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01)));
Assert.True(data.TryGetValue(key0, out v));
Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v));
Assert.True(data.TryGetValues(key0, out vs));
Assert.NotNull(vs);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> {
value00, value01
}));
xvs.Clear();
Assert.True(data.TryGetValues(key0, xvs));
count = xvs.Count;
Assert.Equal(2, count);
Assert.Contains(value00, xvs);
Assert.Contains(value01, xvs);
count = data.Count;
Assert.Equal(2, count);
count = data.Count();
Assert.Equal(2, count);
Assert.Single(data.Keys, key0);
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Remove(new KeyValuePair <TKey, TValue>(key0, value00)));
count = data.Count;
Assert.Equal(1, count);
count = data.Count();
Assert.Equal(1, count);
data.Add(key0, value00);
Assert.Equal(2, data.Remove(key0));
Assert.Empty(data);
// single key, two values (added as enumerable)
data.Add(key0, value00, value01);
Assert.True(data.ContainsKey(key0));
Assert.True(data.TryGetValue(key0, out v));
Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v));
Assert.True(data.TryGetValues(key0, out vs));
Assert.NotNull(vs);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> {
value00, value01
}));
count = data.Count;
Assert.Equal(2, count);
count = data.Count();
Assert.Equal(2, count);
Assert.Single(data.Keys, key0);
data.Set(key0, value01);
count = data.Count;
Assert.Equal(1, count);
count = data.Count();
Assert.Equal(1, count);
data.Set(key0, value00, value01);
Assert.Equal(2, data.Remove(key0));
Assert.Empty(data);
// single key, two values (added as keyvalue pairs)
((ICollection <KeyValuePair <TKey, TValue> >)data).Add(new KeyValuePair <TKey, TValue>(key0, value00));
((ICollection <KeyValuePair <TKey, TValue> >)data).Add(new KeyValuePair <TKey, TValue>(key0, value01));
Assert.True(data.ContainsKey(key0));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00)));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01)));
Assert.True(data.TryGetValue(key0, out v));
Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v));
Assert.True(data.TryGetValues(key0, out vs));
Assert.NotNull(vs);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> {
value00, value01
}));
count = data.Count;
Assert.Equal(2, count);
count = data.Count();
Assert.Equal(2, count);
Assert.Single(data.Keys, key0);
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Remove(new KeyValuePair <TKey, TValue>(key0, value00)));
count = data.Count;
Assert.Equal(1, count);
count = data.Count();
Assert.Equal(1, count);
data.Add(key0, value00);
Assert.Equal(2, data.Remove(key0));
Assert.Empty(data);
// two keys, two values (added separately)
data.Add(key0, value00);
data.Add(key0, value01);
data.Add(key1, value10);
data.Add(key1, value11);
Assert.True(data.ContainsKey(key0));
Assert.True(data.ContainsKey(key1));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00)));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01)));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value10)));
Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value11)));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value00)));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value01)));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value10)));
Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value11)));
Assert.True(data.TryGetValue(key0, out v));
Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v));
Assert.True(data.TryGetValues(key0, out vs));
Assert.NotNull(vs);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> {
value00, value01
}));
xvs.Clear();
Assert.True(data.TryGetValues(key0, xvs));
count = xvs.Count;
Assert.Equal(2, count);
Assert.Contains(value00, xvs);
Assert.Contains(value01, xvs);
Assert.True(data.TryGetValue(key1, out v));
Assert.True(EqualityComparer <TValue> .Default.Equals(value10, v) || EqualityComparer <TValue> .Default.Equals(value11, v));
Assert.True(data.TryGetValues(key1, out vs));
Assert.NotNull(vs);
Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> {
value10, value11
}));
xvs.Clear();
Assert.True(data.TryGetValues(key1, xvs));
count = xvs.Count;
Assert.Equal(2, count);
Assert.Contains(value10, xvs);
Assert.Contains(value11, xvs);
count = data.Count;
Assert.Equal(4, count);
count = data.Count();
Assert.Equal(4, count);
Assert.True(HashSet <TKey> .CreateSetComparer().Equals(new HashSet <TKey>(data.Keys), new HashSet <TKey> {
key0, key1
}));
count = data.Keys.Count();
Assert.Equal(2, count);
Assert.Equal(2, data.Remove(key0));
count = data.Count;
Assert.Equal(2, count);
count = data.Count();
Assert.Equal(2, count);
data.Clear();
Assert.Empty(data);
}
public static void ShouldContainKey()
{
var multiDict = new MultiValueDictionary<string, string>();
multiDict.AddRange("key2", values2);
multiDict.AddRange("key1", values1);
multiDict.Add("key3", "海亀");
Assert.IsTrue(multiDict.ContainsKey("key1"));
Assert.IsTrue(multiDict.ContainsKey("key3"));
Assert.IsTrue(multiDict.ContainsKey("key2"));
Assert.IsTrue(multiDict.Contains("key1"));
Assert.IsTrue(multiDict.Contains("key2"));
Assert.IsTrue(multiDict.Contains("key3"));
}
private void ParseManagedSemantics()
{
var stringTable = m_context.PathTable.StringTable;
var magicNugetMarker = PathAtom.Create(stringTable, "_._");
var dllExtension = PathAtom.Create(stringTable, ".dll");
var refs = new MultiValueDictionary <NugetTargetFramework, RelativePath>();
var libs = new MultiValueDictionary <NugetTargetFramework, RelativePath>();
var assemblyToTargetFramework = new MultiValueDictionary <PathAtom, NugetTargetFramework>();
foreach (var relativePath in PackageOnDisk.Contents)
{
// This is a dll. Check if it is in a lib folder or ref folder.
var atoms = relativePath.GetAtoms();
if (atoms.Length == 3)
{
var libOrRef = atoms[0];
var targetFrameworkFolder = atoms[1];
var fileName = atoms[2];
var isLib = NugetFrameworkMonikers.LibFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
var isRef = NugetFrameworkMonikers.RefFolderName.CaseInsensitiveEquals(stringTable, libOrRef);
if (isLib || isRef)
{
if (!TryGetKnownTargetFramework(targetFrameworkFolder, out NugetTargetFramework targetFramework))
{
// We skip unknown frameworks, packages are not necessarily well constructed. We log this
// as a verbose message (i.e., this is not an error).
Logger.Log.NugetUnknownFramework(m_context.LoggingContext, PackageOnDisk.Package.Id,
targetFrameworkFolder.ToString(stringTable), relativePath.ToString(stringTable));
continue;
}
var isManagedEntry = false;
var ext = fileName.GetExtension(stringTable);
if (dllExtension.CaseInsensitiveEquals(stringTable, ext))
{
isManagedEntry = true;
if (isRef)
{
refs.Add(targetFramework, relativePath);
}
if (isLib)
{
libs.Add(targetFramework, relativePath);
}
}
else if (fileName == magicNugetMarker)
{
isManagedEntry = true;
}
if (isManagedEntry)
{
IsManagedPackage = true;
if (!TargetFrameworkWithFallbacks.ContainsKey(targetFramework.Moniker))
{
bool comaptibleMonikerAlreadyPresent = false;
if (NugetFrameworkMonikers.CompatibilityMatrix.ContainsKey(targetFramework.Moniker))
{
foreach (var compatibleMoniker in NugetFrameworkMonikers.CompatibilityMatrix[targetFramework.Moniker])
{
if (TargetFrameworkWithFallbacks.ContainsKey(compatibleMoniker))
{
comaptibleMonikerAlreadyPresent = true;
break;
}
}
}
if (!comaptibleMonikerAlreadyPresent)
{
// If nuspec does not specify target frameworks, we need to infer from the layout
TargetFrameworkWithFallbacks.Add(targetFramework.Moniker);
}
}
// The magic marker is there so the framework is declared as supported, but no actual files are listed
// So we don't want to add a magic marker as a real artifact that can be referenced.
if (fileName != magicNugetMarker)
{
assemblyToTargetFramework.Add(fileName, targetFramework);
}
}
}
}
}
// For the refs without lib, copy them to refs.
foreach (var kv in libs)
{
if (!refs.ContainsKey(kv.Key))
{
refs.Add(kv.Key, kv.Value.ToArray());
}
}
References = refs;
Libraries = libs;
AssemblyToTargetFramework = assemblyToTargetFramework;
}
/// <nodoc/>
public bool ContainsModule(ModuleDescriptor module)
{
return(m_backingDictionary.ContainsKey(module));
}