Властивість списку <T>

Я хочу реалізувати List<T>як властивість, яку можна безпечно використовувати для потоків без будь-яких сумнівів.

Щось на зразок цього:

private List<T> _list;

private List<T> MyT
{
    get { // return a copy of _list; }
    set { _list = value; }
}

Здається, мені все-таки потрібно повернути копію (клоновану) колекцію, тому якщо десь ми повторюємо колекцію і одночасно колекцію встановлюємо, тоді жодного винятку не виникає.

Як реалізувати безпечну для колекціонування властивість?

Якщо ви орієнтуєтеся .Net 4 Є кілька варіантів в System.Collections.Concurrent просторі імен

Ви можете використовувати ConcurrentBag<T>в цьому випадку замістьList<T>

Навіть тому, що він набрав найбільше голосів, зазвичай його не можна взяти System.Collections.Concurrent.ConcurrentBag<T>за безпечну нитку заміни, System.Collections.Generic.List<T>оскільки його (Радек Стромський уже це вказував) не замовляли.

Але є клас, який називається System.Collections.Generic.SynchronizedCollection<T>вже з .NET 3.0 частиною фреймворку, але він дуже добре прихований у тому місці, де його не очікують, що він маловідомий і, ймовірно, ви ніколи не натрапляли на нього (принаймні Я ніколи цього не робив).

SynchronizedCollection<T> складається у збірку System.ServiceModel.dll (яка є частиною профілю клієнта, але не бібліотеки портативного класу).

Сподіваюся, що це допомагає.

Я думаю, що зробити зразок класу ThreadSafeList буде просто:

public class ThreadSafeList<T> : IList<T>
{
    protected List<T> _interalList = new List<T>();

    // Other Elements of IList implementation

    public IEnumerator<T> GetEnumerator()
    {
        return Clone().GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return Clone().GetEnumerator();
    }

    protected static object _lock = new object();

    public List<T> Clone()
    {
        List<T> newList = new List<T>();

        lock (_lock)
        {
            _interalList.ForEach(x => newList.Add(x));
        }

        return newList;
    }
}

Ви просто клонуєте список перед тим, як подати запит на нумератор, і таким чином будь-яке перерахування опрацьовує копію, яку неможливо змінити під час запуску.

Навіть прийнята відповідь - ConcurrentBag, я не думаю, що це реальна заміна списку у всіх випадках, оскільки коментар Радека до відповіді говорить: "ConcurrentBag - це не упорядкована колекція, тому на відміну від" Список "вона не гарантує замовлення. Також ви не можете отримати доступ до елементів за індексом ".

Отже, якщо ви використовуєте .NET 4.0 або новішої версії, вирішенням може бути використання ConcurrentDictionary з цілим TKey як індекс масиву та TValue як значення масиву. Це рекомендований спосіб заміни списку в курсі одночасних колекцій C # Pluralsight . ConcurrentDictionary вирішує обидві проблеми, згадані вище: доступ до індексу та впорядкування (ми не можемо розраховувати на замовлення, оскільки це хеш-таблиця під кришкою, але поточна реалізація .NET зберігає порядок додавання елементів).

ArrayListКлас C # має Synchronizedметод.

var threadSafeArrayList = ArrayList.Synchronized(new ArrayList());

Це повертає безпечну для обгортання потоку навколо будь-якого примірника IList. Всі операції потрібно виконувати через обгортку, щоб забезпечити безпеку нитки.

Якщо ви подивитеся на вихідний код для списку T ( https://referencesource.microsoft.com/#mscorlib/system/collections/generic/list.cs,c66df6f36c131877 ), ви помітите, що там є клас (що, звичайно, внутрішній - чому, Microsoft, чому?!?!) називається SynchronizedList of T. Я копіюю тут вставлення коду:

   [Serializable()]
    internal class SynchronizedList : IList<T> {
        private List<T> _list;
        private Object _root;

        internal SynchronizedList(List<T> list) {
            _list = list;
            _root = ((System.Collections.ICollection)list).SyncRoot;
        }

        public int Count {
            get {
                lock (_root) { 
                    return _list.Count; 
                }
            }
        }

        public bool IsReadOnly {
            get {
                return ((ICollection<T>)_list).IsReadOnly;
            }
        }

        public void Add(T item) {
            lock (_root) { 
                _list.Add(item); 
            }
        }

        public void Clear() {
            lock (_root) { 
                _list.Clear(); 
            }
        }

        public bool Contains(T item) {
            lock (_root) { 
                return _list.Contains(item);
            }
        }

        public void CopyTo(T[] array, int arrayIndex) {
            lock (_root) { 
                _list.CopyTo(array, arrayIndex);
            }
        }

        public bool Remove(T item) {
            lock (_root) { 
                return _list.Remove(item);
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
            lock (_root) { 
                return _list.GetEnumerator();
            }
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator() {
            lock (_root) { 
                return ((IEnumerable<T>)_list).GetEnumerator();
            }
        }

        public T this[int index] {
            get {
                lock(_root) {
                    return _list[index];
                }
            }
            set {
                lock(_root) {
                    _list[index] = value;
                }
            }
        }

        public int IndexOf(T item) {
            lock (_root) {
                return _list.IndexOf(item);
            }
        }

        public void Insert(int index, T item) {
            lock (_root) {
                _list.Insert(index, item);
            }
        }

        public void RemoveAt(int index) {
            lock (_root) {
                _list.RemoveAt(index);
            }
        }
    }

Особисто я думаю, що вони могли знати кращу реалізацію за допомогою SemaphoreSlim , але не дійшли до неї.

Можна використовувати і більш примітивні

Monitor.Enter(lock);
Monitor.Exit(lock);

який замок використовує (див. цю публікацію C # Блокування об'єкта, який переназначений у блокуванні блокування ).

Якщо ви очікуєте винятків у коді, це не є безпечним, але це дозволяє зробити щось на кшталт наступного:

using System;
using System.Collections.Generic;
using System.Threading;
using System.Linq;

public class Something
{
    private readonly object _lock;
    private readonly List<string> _contents;

    public Something()
    {
        _lock = new object();

        _contents = new List<string>();
    }

    public Modifier StartModifying()
    {
        return new Modifier(this);
    }

    public class Modifier : IDisposable
    {
        private readonly Something _thing;

        public Modifier(Something thing)
        {
            _thing = thing;

            Monitor.Enter(Lock);
        }

        public void OneOfLotsOfDifferentOperations(string input)
        {
            DoSomethingWith(input);
        }

        private void DoSomethingWith(string input)
        {
            Contents.Add(input);
        }

        private List<string> Contents
        {
            get { return _thing._contents; }
        }

        private object Lock
        {
            get { return _thing._lock; }
        }

        public void Dispose()
        {
            Monitor.Exit(Lock);
        }
    }
}

public class Caller
{
    public void Use(Something thing)
    {
        using (var modifier = thing.StartModifying())
        {
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("B");

            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
            modifier.OneOfLotsOfDifferentOperations("A");
        }
    }
}

Одна з приємних речей у цьому - ви отримаєте блокування протягом тривалості серії операцій (а не блокування в кожній операції). Що означає, що вихід повинен виходити в потрібних фрагментах (моє використання цього отримало деякий вихід на екран із зовнішнього процесу)

Мені дуже подобається простота + прозорість ThreadSafeList +, що робить важливий біт у зупинці збоїв

У .NET Core (будь-яка версія) ви можете використовувати ImmutableList , який має всі функціональні можливості List<T>.

Я вірю, що з _list.ToList()вас зроблять копію. Ви також можете запитувати його, якщо вам потрібно:

_list.Select("query here").ToList(); 

У будь-якому випадку, msdn каже, що це дійсно копія, а не просто посилання. О, і так, вам потрібно буде заблокувати встановлений метод, як вказували інші.

Схоже, що багато людей, які виявили це, хочуть колекцію безпечної нитки, індексовану динамічним розміром. Найближчим і найпростішим, що я знаю, було б.

System.Collections.Concurrent.ConcurrentDictionary<int, YourDataType>

Це вимагає, щоб переконатися, що ваш ключ належним чином інкримінується, якщо ви хочете нормальної поведінки щодо індексації. Якщо ви обережні. .Count може бути достатнім як ключ для будь-яких нових пар ключових значень, які ви додали.

Я б запропонував усім, хто має справу зі List<T>сценаріями з багатопотоковою передачею, подивитися на Immutable Collections, зокрема ImmutableArray .

Я вважаю це дуже корисним, коли у вас є:

1. Відносно мало елементів у списку
2. Не так багато операцій читання / запису
3. МНОГО одночасного доступу (тобто багато потоків, які отримують доступ до списку в режимі читання)

Також може бути корисним, коли вам потрібно здійснити якусь поведінку, схожу на транзакцію (тобто відновити операцію вставки / оновлення / видалення у разі невдачі)

Ось клас, про який ви просили:

namespace AI.Collections {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.Serialization;
    using System.Threading.Tasks;
    using System.Threading.Tasks.Dataflow;

    /// <summary>
    ///     Just a simple thread safe collection.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <value>Version 1.5</value>
    /// <remarks>TODO replace locks with AsyncLocks</remarks>
    [DataContract( IsReference = true )]
    public class ThreadSafeList<T> : IList<T> {
        /// <summary>
        ///     TODO replace the locks with a ReaderWriterLockSlim
        /// </summary>
        [DataMember]
        private readonly List<T> _items = new List<T>();

        public ThreadSafeList( IEnumerable<T> items = null ) { this.Add( items ); }

        public long LongCount {
            get {
                lock ( this._items ) {
                    return this._items.LongCount();
                }
            }
        }

        public IEnumerator<T> GetEnumerator() { return this.Clone().GetEnumerator(); }

        IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }

        public void Add( T item ) {
            if ( Equals( default( T ), item ) ) {
                return;
            }
            lock ( this._items ) {
                this._items.Add( item );
            }
        }

        public Boolean TryAdd( T item ) {
            try {
                if ( Equals( default( T ), item ) ) {
                    return false;
                }
                lock ( this._items ) {
                    this._items.Add( item );
                    return true;
                }
            }
            catch ( NullReferenceException ) { }
            catch ( ObjectDisposedException ) { }
            catch ( ArgumentNullException ) { }
            catch ( ArgumentOutOfRangeException ) { }
            catch ( ArgumentException ) { }
            return false;
        }

        public void Clear() {
            lock ( this._items ) {
                this._items.Clear();
            }
        }

        public bool Contains( T item ) {
            lock ( this._items ) {
                return this._items.Contains( item );
            }
        }

        public void CopyTo( T[] array, int arrayIndex ) {
            lock ( this._items ) {
                this._items.CopyTo( array, arrayIndex );
            }
        }

        public bool Remove( T item ) {
            lock ( this._items ) {
                return this._items.Remove( item );
            }
        }

        public int Count {
            get {
                lock ( this._items ) {
                    return this._items.Count;
                }
            }
        }

        public bool IsReadOnly { get { return false; } }

        public int IndexOf( T item ) {
            lock ( this._items ) {
                return this._items.IndexOf( item );
            }
        }

        public void Insert( int index, T item ) {
            lock ( this._items ) {
                this._items.Insert( index, item );
            }
        }

        public void RemoveAt( int index ) {
            lock ( this._items ) {
                this._items.RemoveAt( index );
            }
        }

        public T this[ int index ] {
            get {
                lock ( this._items ) {
                    return this._items[ index ];
                }
            }
            set {
                lock ( this._items ) {
                    this._items[ index ] = value;
                }
            }
        }

        /// <summary>
        ///     Add in an enumerable of items.
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="asParallel"></param>
        public void Add( IEnumerable<T> collection, Boolean asParallel = true ) {
            if ( collection == null ) {
                return;
            }
            lock ( this._items ) {
                this._items.AddRange( asParallel
                                              ? collection.AsParallel().Where( arg => !Equals( default( T ), arg ) )
                                              : collection.Where( arg => !Equals( default( T ), arg ) ) );
            }
        }

        public Task AddAsync( T item ) {
            return Task.Factory.StartNew( () => { this.TryAdd( item ); } );
        }

        /// <summary>
        ///     Add in an enumerable of items.
        /// </summary>
        /// <param name="collection"></param>
        public Task AddAsync( IEnumerable<T> collection ) {
            if ( collection == null ) {
                throw new ArgumentNullException( "collection" );
            }

            var produce = new TransformBlock<T, T>( item => item, new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount } );

            var consume = new ActionBlock<T>( action: async obj => await this.AddAsync( obj ), dataflowBlockOptions: new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = Environment.ProcessorCount } );
            produce.LinkTo( consume );

            return Task.Factory.StartNew( async () => {
                collection.AsParallel().ForAll( item => produce.SendAsync( item ) );
                produce.Complete();
                await consume.Completion;
            } );
        }

        /// <summary>
        ///     Returns a new copy of all items in the <see cref="List{T}" />.
        /// </summary>
        /// <returns></returns>
        public List<T> Clone( Boolean asParallel = true ) {
            lock ( this._items ) {
                return asParallel
                               ? new List<T>( this._items.AsParallel() )
                               : new List<T>( this._items );
            }
        }

        /// <summary>
        ///     Perform the <paramref name="action" /> on each item in the list.
        /// </summary>
        /// <param name="action">
        ///     <paramref name="action" /> to perform on each item.
        /// </param>
        /// <param name="performActionOnClones">
        ///     If true, the <paramref name="action" /> will be performed on a <see cref="Clone" /> of the items.
        /// </param>
        /// <param name="asParallel">
        ///     Use the <see cref="ParallelQuery{TSource}" /> method.
        /// </param>
        /// <param name="inParallel">
        ///     Use the
        ///     <see
        ///         cref="Parallel.ForEach{TSource}(System.Collections.Generic.IEnumerable{TSource},System.Action{TSource})" />
        ///     method.
        /// </param>
        public void ForEach( Action<T> action, Boolean performActionOnClones = true, Boolean asParallel = true, Boolean inParallel = false ) {
            if ( action == null ) {
                throw new ArgumentNullException( "action" );
            }
            var wrapper = new Action<T>( obj => {
                try {
                    action( obj );
                }
                catch ( ArgumentNullException ) {
                    //if a null gets into the list then swallow an ArgumentNullException so we can continue adding
                }
            } );
            if ( performActionOnClones ) {
                var clones = this.Clone( asParallel: asParallel );
                if ( asParallel ) {
                    clones.AsParallel().ForAll( wrapper );
                }
                else if ( inParallel ) {
                    Parallel.ForEach( clones, wrapper );
                }
                else {
                    clones.ForEach( wrapper );
                }
            }
            else {
                lock ( this._items ) {
                    if ( asParallel ) {
                        this._items.AsParallel().ForAll( wrapper );
                    }
                    else if ( inParallel ) {
                        Parallel.ForEach( this._items, wrapper );
                    }
                    else {
                        this._items.ForEach( wrapper );
                    }
                }
            }
        }

        /// <summary>
        ///     Perform the <paramref name="action" /> on each item in the list.
        /// </summary>
        /// <param name="action">
        ///     <paramref name="action" /> to perform on each item.
        /// </param>
        /// <param name="performActionOnClones">
        ///     If true, the <paramref name="action" /> will be performed on a <see cref="Clone" /> of the items.
        /// </param>
        /// <param name="asParallel">
        ///     Use the <see cref="ParallelQuery{TSource}" /> method.
        /// </param>
        /// <param name="inParallel">
        ///     Use the
        ///     <see
        ///         cref="Parallel.ForEach{TSource}(System.Collections.Generic.IEnumerable{TSource},System.Action{TSource})" />
        ///     method.
        /// </param>
        public void ForAll( Action<T> action, Boolean performActionOnClones = true, Boolean asParallel = true, Boolean inParallel = false ) {
            if ( action == null ) {
                throw new ArgumentNullException( "action" );
            }
            var wrapper = new Action<T>( obj => {
                try {
                    action( obj );
                }
                catch ( ArgumentNullException ) {
                    //if a null gets into the list then swallow an ArgumentNullException so we can continue adding
                }
            } );
            if ( performActionOnClones ) {
                var clones = this.Clone( asParallel: asParallel );
                if ( asParallel ) {
                    clones.AsParallel().ForAll( wrapper );
                }
                else if ( inParallel ) {
                    Parallel.ForEach( clones, wrapper );
                }
                else {
                    clones.ForEach( wrapper );
                }
            }
            else {
                lock ( this._items ) {
                    if ( asParallel ) {
                        this._items.AsParallel().ForAll( wrapper );
                    }
                    else if ( inParallel ) {
                        Parallel.ForEach( this._items, wrapper );
                    }
                    else {
                        this._items.ForEach( wrapper );
                    }
                }
            }
        }
    }
}

В основному, якщо ви хочете перерахувати безпечно, вам потрібно застосувати замок.

Про це зверніться до MSDN. http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

Ось частина MSDN, яка може вас зацікавити:

Публічні статичні (Спільно доступні у Visual Basic) члени цього типу є безпечними для потоків. Будь-які члени екземплярів не гарантують безпеку потоку.

Список може одночасно підтримувати декілька читачів, доки колекція не буде змінена. Перерахування через колекцію по суті не є безпечною для потоків процедурою. У рідкісному випадку, коли перерахування суперечить одному або декільком доступам до запису, єдиний спосіб забезпечити безпеку ниток - заблокувати колекцію протягом усього перерахування. Щоб дозволити доступ до колекції декількома потоками для читання та запису, необхідно здійснити власну синхронізацію.

Ось клас для безпечного списку потоків без блокування

 public class ConcurrentList   
    {
        private long _i = 1;
        private ConcurrentDictionary<long, T> dict = new ConcurrentDictionary<long, T>();  
        public int Count()
        {
            return dict.Count;
        }
         public List<T> ToList()
         {
            return dict.Values.ToList();
         }

        public T this[int i]
        {
            get
            {
                long ii = dict.Keys.ToArray()[i];
                return dict[ii];
            }
        }
        public void Remove(T item)
        {
            T ov;
            var dicItem = dict.Where(c => c.Value.Equals(item)).FirstOrDefault();
            if (dicItem.Key > 0)
            {
                dict.TryRemove(dicItem.Key, out ov);
            }
            this.CheckReset();
        }
        public void RemoveAt(int i)
        {
            long v = dict.Keys.ToArray()[i];
            T ov;
            dict.TryRemove(v, out ov);
            this.CheckReset();
        }
        public void Add(T item)
        {
            dict.TryAdd(_i, item);
            _i++;
        }
        public IEnumerable<T> Where(Func<T, bool> p)
        {
            return dict.Values.Where(p);
        }
        public T FirstOrDefault(Func<T, bool> p)
        {
            return dict.Values.Where(p).FirstOrDefault();
        }
        public bool Any(Func<T, bool> p)
        {
            return dict.Values.Where(p).Count() > 0 ? true : false;
        }
        public void Clear()
        {
            dict.Clear();
        }
        private void CheckReset()
        {
            if (dict.Count == 0)
            {
                this.Reset();
            }
        }
        private void Reset()
        {
            _i = 1;
        }
    }

Для цього використовуйте lockоператор. ( Прочитайте тут для отримання додаткової інформації. )

private List<T> _list;

private List<T> MyT
{
    get { return _list; }
    set
    {
        //Lock so only one thread can change the value at any given time.
        lock (_list)
        {
            _list = value;
        }
    }
}

FYI, це, мабуть, не саме те, що ви просите - ви, ймовірно, хочете зафіксувати далі у своєму коді, але я не можу цього припустити. Погляньте наlock ключове слово та пристосуйте його використання до вашої конкретної ситуації.

Якщо вам потрібно, ви можете lockі в блоці, getі в setблоці, використовуючи _listзмінну, яка б зробила так, що читання / запис не може відбуватися одночасно.