Come convertire i risultati di linq in HashSet o HashedSet

Ho una proprietà su una classe che è un ISet. Sto cercando di ottenere i risultati di una query linq in quella proprietà, ma non riesco a capire come farlo.

Fondamentalmente, cercando l'ultima parte di questo:

ISet<T> foo = new HashedSet<T>();
foo = (from x in bar.Items select x).SOMETHING;

Potrebbe anche fare questo:

HashSet<T> foo = new HashSet<T>();
foo = (from x in bar.Items select x).SOMETHING;

Non penso che ci sia qualcosa di incorporato in questo che fa ... ma è davvero facile scrivere un metodo di estensione:

public static class Extensions
{
    public static HashSet<T> ToHashSet<T>(
        this IEnumerable<T> source,
        IEqualityComparer<T> comparer = null)
    {
        return new HashSet<T>(source, comparer);
    }
}

Nota che vuoi davvero un metodo di estensione (o almeno un metodo generico in qualche forma) qui, perché potresti non essere in grado di esprimere esplicitamente il tipo di T:

var query = from i in Enumerable.Range(0, 10)
            select new { i, j = i + 1 };
var resultSet = query.ToHashSet();

Non puoi farlo con una chiamata esplicita al HashSet<T>costruttore. Facciamo affidamento sull'inferenza del tipo per metodi generici per farlo per noi.

Ora si potrebbe scegliere di chiamarlo ToSete di ritorno ISet<T>- ma mi piacerebbe restare con ToHashSete il tipo concreto. Ciò è coerente con gli operatori LINQ standard ( ToDictionary, ToList) e consente espansioni future (ad es ToSortedSet.). È inoltre possibile fornire un sovraccarico specificando il confronto da utilizzare.

Basta passare IEnumerable nel costruttore per HashSet.

HashSet<T> foo = new HashSet<T>(from x in bar.Items select x);

Questa funzionalità è stata aggiunta come metodo di estensione IEnumerable<TSource>a .NET Framework 4.7.2 :

• ToHashSet<TSource>(IEnumerable<TSource>)
• ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Come affermato da @Joel, puoi semplicemente passare il tuo enumerabile. Se vuoi fare un metodo di estensione, puoi fare:

public static HashSet<T> ToHashSet<T>(this IEnumerable<T> items)
{
    return new HashSet<T>(items);
}

Se hai bisogno solo dell'accesso in sola lettura al set e la fonte è un parametro per il tuo metodo, allora vorrei andare con

public static ISet<T> EnsureSet<T>(this IEnumerable<T> source)
{
    ISet<T> result = source as ISet<T>;
    if (result != null)
        return result;
    return new HashSet<T>(source);
}

Il motivo è che gli utenti possono chiamare il tuo metodo con il ISetgià, quindi non è necessario creare la copia.

Esiste un metodo di estensione creato nel framework .NET e nel core .NET per la conversione IEnumerablein HashSet: https://docs.microsoft.com/en-us/dotnet/api/?term=ToHashSet

public static System.Collections.Generic.HashSet<TSource> ToHashSet<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);

Sembra che non riesca ancora a usarlo nelle librerie standard .NET (al momento della stesura). Quindi uso questo metodo di estensione:

    [Obsolete("In the .NET framework and in NET core this method is available, " +
              "however can't use it in .NET standard yet. When it's added, please remove this method")]
public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer = null) => new HashSet<T>(source, comparer);

È abbastanza semplice :)

var foo = new HashSet<T>(from x in bar.Items select x);

e sì T è il tipo specificato da OP :)

La risposta di Jon è perfetta. L'unica avvertenza è che, utilizzando HashedSet di NHibernate, devo convertire i risultati in una raccolta. C'è un modo ottimale per farlo?

ISet<string> bla = new HashedSet<string>((from b in strings select b).ToArray()); 

o

ISet<string> bla = new HashedSet<string>((from b in strings select b).ToList()); 

O mi manca qualcos'altro?

Modifica: questo è quello che ho finito per fare:

public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source)
{
    return new HashSet<T>(source);
}

public static HashedSet<T> ToHashedSet<T>(this IEnumerable<T> source)
{
    return new HashedSet<T>(source.ToHashSet());
}

Anziché la semplice conversione di IEnumerable in un HashSet, è spesso conveniente convertire una proprietà di un altro oggetto in un HashSet. Puoi scrivere questo come:

var set = myObject.Select(o => o.Name).ToHashSet();

ma la mia preferenza sarebbe quella di utilizzare i selettori:

var set = myObject.ToHashSet(o => o.Name);

Fanno la stessa cosa, e il secondo è ovviamente più breve, ma trovo che il linguaggio si adatti meglio al mio cervello (penso che sia come ToDictionary).

Ecco il metodo di estensione da utilizzare, con supporto per comparatori personalizzati come bonus.

public static HashSet<TKey> ToHashSet<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> selector,
    IEqualityComparer<TKey> comparer = null)
{
    return new HashSet<TKey>(source.Select(selector), comparer);
}