/
ConfigurationLockCollection.cs
340 lines (289 loc) · 13.4 KB
/
ConfigurationLockCollection.cs
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.Collections.Specialized;
using System.Text;
namespace System.Configuration
{
public sealed class ConfigurationLockCollection : ICollection
{
private const string LockAll = "*";
private readonly string _ignoreName;
private readonly ConfigurationElement _thisElement;
private readonly ArrayList _internalArraylist;
private readonly HybridDictionary _internalDictionary;
private string _seedList = string.Empty;
internal ConfigurationLockCollection(ConfigurationElement thisElement)
: this(thisElement, ConfigurationLockCollectionType.LockedAttributes)
{ }
internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType)
: this(thisElement, lockType, string.Empty)
{ }
internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType,
string ignoreName)
: this(thisElement, lockType, ignoreName, null)
{ }
internal ConfigurationLockCollection(ConfigurationElement thisElement, ConfigurationLockCollectionType lockType,
string ignoreName, ConfigurationLockCollection parentCollection)
{
_thisElement = thisElement;
LockType = lockType;
_internalDictionary = new HybridDictionary();
_internalArraylist = new ArrayList();
IsModified = false;
ExceptionList = (LockType == ConfigurationLockCollectionType.LockedExceptionList) ||
(LockType == ConfigurationLockCollectionType.LockedElementsExceptionList);
_ignoreName = ignoreName;
if (parentCollection == null) return;
foreach (string key in parentCollection) // seed the new collection
{
Add(key, ConfigurationValueFlags.Inherited); // add the local copy
if (!ExceptionList) continue;
if (_seedList.Length != 0)
_seedList += ",";
_seedList += key;
}
}
internal ConfigurationLockCollectionType LockType { get; }
public bool IsModified { get; private set; }
internal bool ExceptionList { get; }
public string AttributeList
{
get
{
StringBuilder sb = new StringBuilder();
foreach (DictionaryEntry de in _internalDictionary)
{
if (sb.Length != 0) sb.Append(',');
sb.Append(de.Key);
}
return sb.ToString();
}
}
public bool HasParentElements
{
get
{
// return true if there is at least one element that was defined in the parent
bool result = false;
// Check to see if the exception list is empty as a result of a merge from config
// If so the there were some parent elements because empty string is invalid in config.
// and the only way to get an empty list is for the merged config to have no elements
// in common.
if (ExceptionList && (_internalDictionary.Count == 0) && !string.IsNullOrEmpty(_seedList))
return true;
foreach (DictionaryEntry de in _internalDictionary)
if (((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) != 0)
{
result = true;
break;
}
return result;
}
}
public int Count => _internalDictionary.Count;
public bool IsSynchronized => false;
public object SyncRoot => this;
void ICollection.CopyTo(Array array, int index)
{
_internalArraylist.CopyTo(array, index);
}
public IEnumerator GetEnumerator()
{
return _internalArraylist.GetEnumerator();
}
internal void ClearSeedList()
{
_seedList = string.Empty;
}
public void Add(string name)
{
if (((_thisElement.ItemLocked & ConfigurationValueFlags.Locked) != 0) &&
((_thisElement.ItemLocked & ConfigurationValueFlags.Inherited) != 0))
throw new ConfigurationErrorsException(SR.Format(SR.Config_base_attribute_locked, name));
ConfigurationValueFlags flags = ConfigurationValueFlags.Modified;
string attribToLockTrim = name.Trim();
ConfigurationProperty propToLock = _thisElement.Properties[attribToLockTrim];
if ((propToLock == null) && (attribToLockTrim != LockAll))
{
ConfigurationElementCollection collection = _thisElement as ConfigurationElementCollection;
if ((collection == null) && (_thisElement.Properties.DefaultCollectionProperty != null))
{
// this is not a collection but it may contain a default collection
collection =
_thisElement[_thisElement.Properties.DefaultCollectionProperty] as
ConfigurationElementCollection;
}
if ((collection == null) ||
(LockType == ConfigurationLockCollectionType.LockedAttributes) ||
// If the collection type is not element then the lock is bogus
(LockType == ConfigurationLockCollectionType.LockedExceptionList))
_thisElement.ReportInvalidLock(attribToLockTrim, LockType, null, null);
else
{
if (!collection.IsLockableElement(attribToLockTrim))
_thisElement.ReportInvalidLock(attribToLockTrim, LockType, null, collection.LockableElements);
}
}
else
{
// the lock is in the property bag but is it the correct type?
if ((propToLock != null) && propToLock.IsRequired)
{
throw new ConfigurationErrorsException(SR.Format(SR.Config_base_required_attribute_lock_attempt,
propToLock.Name));
}
if (attribToLockTrim != LockAll)
{
if ((LockType == ConfigurationLockCollectionType.LockedElements) ||
(LockType == ConfigurationLockCollectionType.LockedElementsExceptionList))
{
// If it is an element then it must be derived from ConfigurationElement
if (!typeof(ConfigurationElement).IsAssignableFrom(propToLock?.Type))
_thisElement.ReportInvalidLock(attribToLockTrim, LockType, null, null);
}
else
{
// if it is a property then it cannot be derived from ConfigurationElement
if (typeof(ConfigurationElement).IsAssignableFrom(propToLock?.Type))
_thisElement.ReportInvalidLock(attribToLockTrim, LockType, null, null);
}
}
}
if (_internalDictionary.Contains(name))
{
flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)_internalDictionary[name];
_internalDictionary.Remove(name); // not from parent
_internalArraylist.Remove(name);
}
_internalDictionary.Add(name, flags); // not from parent
_internalArraylist.Add(name);
IsModified = true;
}
internal void Add(string name, ConfigurationValueFlags flags)
{
if ((flags != ConfigurationValueFlags.Inherited) && _internalDictionary.Contains(name))
{
// the user has an item declared as locked below a level where it is already locked
// keep enough info so we can write out the lock if they save in modified mode
flags = ConfigurationValueFlags.Modified | (ConfigurationValueFlags)_internalDictionary[name];
_internalDictionary.Remove(name);
_internalArraylist.Remove(name);
}
_internalDictionary.Add(name, flags); // not from parent
_internalArraylist.Add(name);
}
internal bool DefinedInParent(string name)
{
if (name == null)
return false;
if (!ExceptionList)
{
return _internalDictionary.Contains(name) &&
(((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0);
}
string parentListEnclosed = "," + _seedList + ",";
if (name.Equals(_ignoreName) ||
#if NETCOREAPP
parentListEnclosed.Contains("," + name + ",", StringComparison.Ordinal))
#else
parentListEnclosed.IndexOf("," + name + ",", StringComparison.Ordinal) >= 0)
#endif
return true;
return _internalDictionary.Contains(name) &&
(((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0);
}
internal bool IsValueModified(string name)
{
return _internalDictionary.Contains(name) &&
(((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Modified) != 0);
}
internal void RemoveInheritedLocks()
{
StringCollection removeList = new StringCollection();
foreach (string key in this) if (DefinedInParent(key)) removeList.Add(key);
foreach (string key in removeList)
{
_internalDictionary.Remove(key);
_internalArraylist.Remove(key);
}
}
public void Remove(string name)
{
if (!_internalDictionary.Contains(name))
throw new ConfigurationErrorsException(SR.Format(SR.Config_base_collection_entry_not_found, name));
// in a locked list you cannot remove items that were locked in the parent
// in an exception list this is legal because it makes the list more restrictive
if ((ExceptionList == false) &&
(((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0))
{
if (((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Modified) == 0)
throw new ConfigurationErrorsException(SR.Format(SR.Config_base_attribute_locked, name));
// allow the local one to be "removed" so it won't write out but throw if they try and remove
// one that is only inherited
ConfigurationValueFlags flags = (ConfigurationValueFlags)_internalDictionary[name];
flags &= ~ConfigurationValueFlags.Modified;
_internalDictionary[name] = flags;
IsModified = true;
return;
}
_internalDictionary.Remove(name);
_internalArraylist.Remove(name);
IsModified = true;
}
internal void ClearInternal(bool useSeedIfAvailable)
{
ArrayList removeList = new ArrayList();
foreach (DictionaryEntry de in _internalDictionary)
if ((((ConfigurationValueFlags)de.Value & ConfigurationValueFlags.Inherited) == 0)
|| ExceptionList)
removeList.Add(de.Key);
foreach (object removeKey in removeList)
{
_internalDictionary.Remove(removeKey);
_internalArraylist.Remove(removeKey);
}
// Clearing an Exception list really means revert to parent
if (useSeedIfAvailable && !string.IsNullOrEmpty(_seedList))
{
string[] keys = _seedList.Split(',');
foreach (string key in keys) Add(key, ConfigurationValueFlags.Inherited);
}
IsModified = true;
}
public void Clear()
{
ClearInternal(true);
}
public bool Contains(string name)
{
if (ExceptionList && name.Equals(_ignoreName)) return true;
return _internalDictionary.Contains(name);
}
public void CopyTo(string[] array, int index)
{
((ICollection)this).CopyTo(array, index);
}
internal void ResetModified()
{
IsModified = false;
}
public bool IsReadOnly(string name)
{
if (!_internalDictionary.Contains(name))
throw new ConfigurationErrorsException(SR.Format(SR.Config_base_collection_entry_not_found, name));
return
((ConfigurationValueFlags)_internalDictionary[name] & ConfigurationValueFlags.Inherited) != 0;
}
public void SetFromList(string attributeList)
{
string[] splits = attributeList.Split(',', ';', ':');
Clear();
foreach (string name in splits)
{
string attribTrim = name.Trim();
if (!Contains(attribTrim)) Add(attribTrim);
}
}
}
}