Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/SynchronizedReadOnlyCollection.cs

@@ -0,0 +1,306 @@
+//-----------------------------------------------------------------------------
+// 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();
+            }
+        }
+    }
+}