Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

307 lines
7.8 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Collections.Generic
{
using System;
using System.Collections;
using System.Diagnostics;
using System.ServiceModel;
[System.Runtime.InteropServices.ComVisible(false)]
public class SynchronizedReadOnlyCollection<T> : IList<T>, IList
{
IList<T> items;
object sync;
public SynchronizedReadOnlyCollection()
{
this.items = new List<T>();
this.sync = new Object();
}
public SynchronizedReadOnlyCollection(object syncRoot)
{
if (syncRoot == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
this.items = new List<T>();
this.sync = syncRoot;
}
public SynchronizedReadOnlyCollection(object syncRoot, IEnumerable<T> list)
{
if (syncRoot == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
if (list == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));
this.items = new List<T>(list);
this.sync = syncRoot;
}
public SynchronizedReadOnlyCollection(object syncRoot, params T[] list)
{
if (syncRoot == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
if (list == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));
this.items = new List<T>(list.Length);
for (int i = 0; i < list.Length; i++)
this.items.Add(list[i]);
this.sync = syncRoot;
}
internal SynchronizedReadOnlyCollection(object syncRoot, List<T> list, bool makeCopy)
{
if (syncRoot == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("syncRoot"));
if (list == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("list"));
if (makeCopy)
this.items = new List<T>(list);
else
this.items = list;
this.sync = syncRoot;
}
public int Count
{
get { lock (this.sync) { return this.items.Count; } }
}
protected IList<T> Items
{
get
{
return this.items;
}
}
public T this[int index]
{
get { lock (this.sync) { return this.items[index]; } }
}
public bool Contains(T value)
{
lock (this.sync)
{
return this.items.Contains(value);
}
}
public void CopyTo(T[] array, int index)
{
lock (this.sync)
{
this.items.CopyTo(array, index);
}
}
public IEnumerator<T> GetEnumerator()
{
lock (this.sync)
{
return this.items.GetEnumerator();
}
}
public int IndexOf(T value)
{
lock (this.sync)
{
return this.items.IndexOf(value);
}
}
void ThrowReadOnly()
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxCollectionReadOnly)));
}
bool ICollection<T>.IsReadOnly
{
get { return true; }
}
T IList<T>.this[int index]
{
get
{
return this[index];
}
set
{
this.ThrowReadOnly();
}
}
void ICollection<T>.Add(T value)
{
this.ThrowReadOnly();
}
void ICollection<T>.Clear()
{
this.ThrowReadOnly();
}
bool ICollection<T>.Remove(T value)
{
this.ThrowReadOnly();
return false;
}
void IList<T>.Insert(int index, T value)
{
this.ThrowReadOnly();
}
void IList<T>.RemoveAt(int index)
{
this.ThrowReadOnly();
}
bool ICollection.IsSynchronized
{
get { return true; }
}
object ICollection.SyncRoot
{
get { return this.sync; }
}
void ICollection.CopyTo(Array array, int index)
{
ICollection asCollection = this.items as ICollection;
if (asCollection == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.SFxCopyToRequiresICollection)));
lock (this.sync)
{
asCollection.CopyTo(array, index);
}
}
IEnumerator IEnumerable.GetEnumerator()
{
lock (this.sync)
{
IEnumerable asEnumerable = this.items as IEnumerable;
if (asEnumerable != null)
return asEnumerable.GetEnumerator();
else
return new EnumeratorAdapter(this.items);
}
}
bool IList.IsFixedSize
{
get { return true; }
}
bool IList.IsReadOnly
{
get { return true; }
}
object IList.this[int index]
{
get
{
return this[index];
}
set
{
this.ThrowReadOnly();
}
}
int IList.Add(object value)
{
this.ThrowReadOnly();
return 0;
}
void IList.Clear()
{
this.ThrowReadOnly();
}
bool IList.Contains(object value)
{
VerifyValueType(value);
return this.Contains((T)value);
}
int IList.IndexOf(object value)
{
VerifyValueType(value);
return this.IndexOf((T)value);
}
void IList.Insert(int index, object value)
{
this.ThrowReadOnly();
}
void IList.Remove(object value)
{
this.ThrowReadOnly();
}
void IList.RemoveAt(int index)
{
this.ThrowReadOnly();
}
static void VerifyValueType(object value)
{
if ((value is T) || (value == null && !typeof(T).IsValueType))
return;
Type type = (value == null) ? typeof(Object) : value.GetType();
string message = SR.GetString(SR.SFxCollectionWrongType2, type.ToString(), typeof(T).ToString());
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(message));
}
sealed class EnumeratorAdapter : IEnumerator, IDisposable
{
IList<T> list;
IEnumerator<T> e;
public EnumeratorAdapter(IList<T> list)
{
this.list = list;
this.e = list.GetEnumerator();
}
public object Current
{
get { return e.Current; }
}
public bool MoveNext()
{
return e.MoveNext();
}
public void Dispose()
{
e.Dispose();
}
public void Reset()
{
e = list.GetEnumerator();
}
}
}
}