Cómo convertir resultados de linq a HashSet o HashedSet

Tengo una propiedad en una clase que es un ISet. Estoy tratando de obtener los resultados de una consulta linq en esa propiedad, pero no puedo entender cómo hacerlo.

Básicamente, buscando la última parte de esto:

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

También podría hacer esto:

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

No creo que haya nada incorporado que haga esto ... pero es realmente fácil escribir un método de extensión:

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

Tenga en cuenta que realmente desea un método de extensión (o al menos un método genérico de alguna forma) aquí, porque es posible que no pueda expresar el tipo Texplícitamente:

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

No puede hacer eso con una llamada explícita al HashSet<T> constructor. Confiamos en la inferencia de tipos para métodos genéricos que lo hagan por nosotros.

Ahora podría elegir nombrarlo ToSety regresar ISet<T>, pero me quedaría con ToHashSetel tipo concreto. Esto es consistente con los operadores estándar de LINQ ( ToDictionary, ToList) y permite una expansión futura (por ejemplo ToSortedSet). También puede proporcionar una sobrecarga que especifique la comparación a utilizar.

Simplemente pase su IEnumerable al constructor de HashSet.

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

Esta funcionalidad se ha agregado como método de extensión IEnumerable<TSource>a .NET Framework 4.7.2 :

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

Como dijo @Joel, puede pasar su enumerable. Si desea hacer un método de extensión, puede hacer:

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

Si solo necesita acceso de solo lectura al conjunto y la fuente es un parámetro para su método, entonces iría 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);
}

La razón es que los usuarios pueden llamar a su método con el ISetya no necesita crear la copia.

Hay una compilación de método de extensión en .NET Framework y en .NET core para convertir una IEnumerablea 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);

Parece que todavía no puedo usarlo en las bibliotecas estándar de .NET (en el momento de la escritura). Entonces uso este método de extensión:

    [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);

Eso es bastante simple :)

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

y sí T es el tipo especificado por OP :)

La respuesta de Jon es perfecta. La única advertencia es que, usando HashedSet de NHibernate, necesito convertir los resultados en una colección. ¿Hay una manera óptima de hacer esto?

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 me estoy perdiendo algo más?

Editar: Esto es lo que terminé haciendo:

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());
}

En lugar de la simple conversión de IEnumerable a un HashSet, a menudo es conveniente convertir una propiedad de otro objeto en un HashSet. Podrías escribir esto como:

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

pero, mi preferencia sería usar selectores:

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

Hacen lo mismo, y el segundo es obviamente más corto, pero creo que el idioma se adapta mejor a mi cerebro (lo considero como ToDictionary).

Este es el método de extensión para usar, con soporte para comparadores personalizados como un bono.

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);
}