1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.WindowsRuntime;
namespace System.Runtime.InteropServices.WindowsRuntime {
[Serializable]
[DebuggerDisplay("Count = {Count}")]
internal sealed class DictionaryValueCollection<TKey, TValue> : ICollection<TValue>
{
private readonly IDictionary<TKey, TValue> dictionary;
public DictionaryValueCollection(IDictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
throw new ArgumentNullException(nameof(dictionary));
this.dictionary = dictionary;
}
public void CopyTo(TValue[] array, int index)
{
if (array == null)
throw new ArgumentNullException(nameof(array));
if (index < 0)
throw new ArgumentOutOfRangeException(nameof(index));
if (array.Length <= index && this.Count > 0)
throw new ArgumentException(Environment.GetResourceString("Arg_IndexOutOfRangeException"));
if (array.Length - index < dictionary.Count)
throw new ArgumentException(Environment.GetResourceString("Argument_InsufficientSpaceToCopyCollection"));
int i = index;
foreach (KeyValuePair<TKey, TValue> mapping in dictionary)
{
array[i++] = mapping.Value;
}
}
public int Count {
get { return dictionary.Count; }
}
bool ICollection<TValue>.IsReadOnly {
get { return true; }
}
void ICollection<TValue>.Add(TValue item)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_ValueCollectionSet"));
}
void ICollection<TValue>.Clear()
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_ValueCollectionSet"));
}
public bool Contains(TValue item)
{
EqualityComparer<TValue> comparer = EqualityComparer<TValue>.Default;
foreach (TValue value in this)
if (comparer.Equals(item, value))
return true;
return false;
}
bool ICollection<TValue>.Remove(TValue item)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_ValueCollectionSet"));
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<TValue>)this).GetEnumerator();
}
public IEnumerator<TValue> GetEnumerator()
{
return new DictionaryValueEnumerator<TKey, TValue>(dictionary);
}
} // public class DictionaryValueCollection<TKey, TValue>
[Serializable]
internal sealed class DictionaryValueEnumerator<TKey, TValue> : IEnumerator<TValue>
{
private readonly IDictionary<TKey, TValue> dictionary;
private IEnumerator<KeyValuePair<TKey, TValue>> enumeration;
public DictionaryValueEnumerator(IDictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
throw new ArgumentNullException(nameof(dictionary));
this.dictionary = dictionary;
this.enumeration = dictionary.GetEnumerator();
}
void IDisposable.Dispose()
{
enumeration.Dispose();
}
public bool MoveNext()
{
return enumeration.MoveNext();
}
Object IEnumerator.Current {
get { return ((IEnumerator<TValue>)this).Current; }
}
public TValue Current {
get { return enumeration.Current.Value; }
}
public void Reset()
{
enumeration = dictionary.GetEnumerator();
}
} // class DictionaryValueEnumerator<TKey, TValue>
}
// DictionaryValueCollection.cs
|
