mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
307 lines
7.8 KiB
C#
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();
|
|
}
|
|
}
|
|
}
|
|
}
|