Ho bisogno di una raccolta thread-safe per contenere elementi senza duplicati. ConcurrentBag<T>
consente articoli non univoci e HashSet<T>
non è thread-safe. Esiste una raccolta come questa in .NET Framework 4.5?Raccolta thread-safe senza ordine e senza duplicati
risposta
Ti suggerisco di utilizzare ConcurrentDictionary
e utilizzare solo un valore fittizio per ciascuna voce. È fastidioso in termini di efficienza (avendo tutti quei valori fittizi) ma ho il sospetto che nella maggior parte delle applicazioni sarebbe insignificante.
Si consiglia di avvolgere questo nella propria implementazione ConcurrentSet
, che fa appena abbastanza per i vostri scopi, in modo che non è necessario vedere la perdita di astrazione in gran parte del codice.
Il tipo di "valore fittizio" fa la differenza? Usare 'ConcurrentDictionary
@ ŞafakGür: Potresti farlo, o forse usare un 'int' con un valore di 0. Usare qualcosa di più piccolo di' int' è probabilmente inutile a causa dell'allineamento della memoria. –
@ ŞafakGür le due cose più comuni che vedo sono l'utilizzo di null per tutti i valori o (per i tipi di riferimento) sempre rendendo sia la chiave che il valore per ogni coppia della stessa istanza. – Servy
Ecco un po 'di codice che ho appena scritto che fa questo ConcurrentSet costrutto:
public class ConcurrentSet<T> : IEnumerable<T>, ISet<T>, ICollection<T>
{
private readonly ConcurrentDictionary<T, byte> _dictionary = new ConcurrentDictionary<T, byte>();
/// <summary>
/// Returns an enumerator that iterates through the collection.
/// </summary>
/// <returns>
/// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
/// </returns>
public IEnumerator<T> GetEnumerator()
{
return _dictionary.Keys.GetEnumerator();
}
/// <summary>
/// Returns an enumerator that iterates through a collection.
/// </summary>
/// <returns>
/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
/// </returns>
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
/// <summary>
/// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
/// </summary>
/// <returns>
/// true if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>.
/// </returns>
/// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.</exception>
public bool Remove(T item)
{
return TryRemove(item);
}
/// <summary>
/// Gets the number of elements in the set.
/// </summary>
public int Count
{
get { return _dictionary.Count; }
}
/// <summary>
/// Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.
/// </summary>
/// <returns>
/// true if the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only; otherwise, false.
/// </returns>
public bool IsReadOnly { get { return false; } }
/// <summary>
/// Gets a value that indicates if the set is empty.
/// </summary>
public bool IsEmpty
{
get { return _dictionary.IsEmpty; }
}
public ICollection<T> Values
{
get { return _dictionary.Keys; }
}
/// <summary>
/// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1"/>.
/// </summary>
/// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.</exception>
void ICollection<T>.Add(T item)
{
if(!Add(item))
throw new ArgumentException("Item already exists in set.");
}
/// <summary>
/// Modifies the current set so that it contains all elements that are present in both the current set and in the specified collection.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public void UnionWith(IEnumerable<T> other)
{
foreach (var item in other)
TryAdd(item);
}
/// <summary>
/// Modifies the current set so that it contains only elements that are also in a specified collection.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public void IntersectWith(IEnumerable<T> other)
{
var enumerable = other as IList<T> ?? other.ToArray();
foreach (var item in this)
{
if (!enumerable.Contains(item))
TryRemove(item);
}
}
/// <summary>
/// Removes all elements in the specified collection from the current set.
/// </summary>
/// <param name="other">The collection of items to remove from the set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public void ExceptWith(IEnumerable<T> other)
{
foreach (var item in other)
TryRemove(item);
}
/// <summary>
/// Modifies the current set so that it contains only elements that are present either in the current set or in the specified collection, but not both.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public void SymmetricExceptWith(IEnumerable<T> other)
{
throw new NotImplementedException();
}
/// <summary>
/// Determines whether a set is a subset of a specified collection.
/// </summary>
/// <returns>
/// true if the current set is a subset of <paramref name="other"/>; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool IsSubsetOf(IEnumerable<T> other)
{
var enumerable = other as IList<T> ?? other.ToArray();
return this.AsParallel().All(enumerable.Contains);
}
/// <summary>
/// Determines whether the current set is a superset of a specified collection.
/// </summary>
/// <returns>
/// true if the current set is a superset of <paramref name="other"/>; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool IsSupersetOf(IEnumerable<T> other)
{
return other.AsParallel().All(Contains);
}
/// <summary>
/// Determines whether the current set is a correct superset of a specified collection.
/// </summary>
/// <returns>
/// true if the <see cref="T:System.Collections.Generic.ISet`1"/> object is a correct superset of <paramref name="other"/>; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set. </param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool IsProperSupersetOf(IEnumerable<T> other)
{
var enumerable = other as IList<T> ?? other.ToArray();
return this.Count != enumerable.Count && IsSupersetOf(enumerable);
}
/// <summary>
/// Determines whether the current set is a property (strict) subset of a specified collection.
/// </summary>
/// <returns>
/// true if the current set is a correct subset of <paramref name="other"/>; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool IsProperSubsetOf(IEnumerable<T> other)
{
var enumerable = other as IList<T> ?? other.ToArray();
return Count != enumerable.Count && IsSubsetOf(enumerable);
}
/// <summary>
/// Determines whether the current set overlaps with the specified collection.
/// </summary>
/// <returns>
/// true if the current set and <paramref name="other"/> share at least one common element; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool Overlaps(IEnumerable<T> other)
{
return other.AsParallel().Any(Contains);
}
/// <summary>
/// Determines whether the current set and the specified collection contain the same elements.
/// </summary>
/// <returns>
/// true if the current set is equal to <paramref name="other"/>; otherwise, false.
/// </returns>
/// <param name="other">The collection to compare to the current set.</param><exception cref="T:System.ArgumentNullException"><paramref name="other"/> is null.</exception>
public bool SetEquals(IEnumerable<T> other)
{
var enumerable = other as IList<T> ?? other.ToArray();
return Count == enumerable.Count && enumerable.AsParallel().All(Contains);
}
/// <summary>
/// Adds an element to the current set and returns a value to indicate if the element was successfully added.
/// </summary>
/// <returns>
/// true if the element is added to the set; false if the element is already in the set.
/// </returns>
/// <param name="item">The element to add to the set.</param>
public bool Add(T item)
{
return TryAdd(item);
}
public void Clear()
{
_dictionary.Clear();
}
public bool Contains(T item)
{
return _dictionary.ContainsKey(item);
}
/// <summary>
/// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.
/// </summary>
/// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param><param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param><exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="arrayIndex"/> is less than 0.</exception><exception cref="T:System.ArgumentException"><paramref name="array"/> is multidimensional.-or-The number of elements in the source <see cref="T:System.Collections.Generic.ICollection`1"/> is greater than the available space from <paramref name="arrayIndex"/> to the end of the destination <paramref name="array"/>.-or-Type <paramref name="T"/> cannot be cast automatically to the type of the destination <paramref name="array"/>.</exception>
public void CopyTo(T[] array, int arrayIndex)
{
Values.CopyTo(array, arrayIndex);
}
public T[] ToArray()
{
return _dictionary.Keys.ToArray();
}
public bool TryAdd(T item)
{
return _dictionary.TryAdd(item, default(byte));
}
public bool TryRemove(T item)
{
byte donotcare;
return _dictionary.TryRemove(item, out donotcare);
}
}
+1 per il codice vero ma non posso annullare la risposta di Jon poiché tutto quello che chiedevo era se .net avesse un'alternativa o meno e lui mi ha indicato come fare esattamente questo. La tua implementazione è migliore della mia, però. Grazie, userò questo. Vorrei solo poter dare più voti. –
Va bene. Ad essere onesti, non ho guardato la data della tua domanda dato che stavo cercando la mia soluzione. Pensavo di rispondere a una domanda secolare, non qualcosa di qualche giorno fa. :-) –
Di recente ho dato un'altra occhiata a questo e penso che 'SymmetricExceptWith' possa essere implementato in questo modo:' foreach (var item in other) if (!Rimuovi (elemento)) Aggiungi (elemento): "Non ho idea di quando lo userò mai. –
- 1. conteggio senza duplicati
- 2. cross join senza combinazioni duplicati
- 3. Elimina duplicati senza chiave primaria
- 4. MySQL - Unire due tabelle senza duplicati?
- 5. Inserire elemento da ArrayList con ordine crescente e senza elementi duplicati
- 6. ListField senza duplicati in Python mongoengine
- 7. Visualizzazione ordine di una query SQL senza ordine dalla clausola
- 8. Raccolta immagini C# senza libreria .net
- 9. Ordina i DIV in ordine alfabetico senza distruggerli e ricrearli?
- 10. TSQL: ordine per asc senza nome colonna
- 11. Unione di due elenchi di array in una nuova lista di array, senza duplicati e in ordine, in Java
- 12. java.util.concurrent.Future threadsafe?
- 13. Ricerca di duplicati in una raccolta
- 14. Come unire due liste di array senza duplicati?
- 15. Hibernate/JPA: duplicati nella raccolta figli
- 16. Salvataggio/ripristino di ricevute di rinnovo automatico senza duplicati
- 17. R: genera tutte le permutazioni del vettore senza elementi duplicati
- 18. Un elenco senza duplicati o un set ordinato
- 19. Intersezione di due elenchi senza elementi duplicati in Prolog
- 20. Leggi file di testo nel dizionario senza duplicati
- 21. Oracle: identificazione dei duplicati in una tabella senza indice
- 22. Unisci più righe in una colonna senza duplicati
- 23. Passare un argomento di raccolta senza decomprimere il suo contenuto
- 24. Aggiornamento di una raccolta Backbone.js senza cancellare i vecchi modelli
- 25. Aggiornamento raccolta meteorologica senza rimozione o sovrascrittura dei campi esistenti
- 26. Oggetto non raccolta dati inutili, ma senza gcroots
- 27. Come confrontare due JSON hanno le stesse proprietà senza ordine?
- 28. ordinamento dei risultati senza uso di ordine per clausola
- 29. sottrarre due std :: vector degli oggetti senza ordine
- 30. Può NHibernate salvare una raccolta senza un iteratore?
ConcurrentDictionary? –