Como converter resultados linq em HashSet ou HashedSet

Eu tenho uma propriedade em uma classe que é um ISet. Estou tentando obter os resultados de uma consulta linq nessa propriedade, mas não consigo descobrir como fazer isso.

Basicamente, procurando a última parte disso:

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

Também poderia fazer isso:

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

Eu não acho que exista algo embutido que faça isso ... mas é realmente fácil escrever um método de extensão:

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

Observe que você realmente deseja um método de extensão (ou pelo menos um método genérico de alguma forma) aqui, porque talvez não seja possível expressar Texplicitamente o tipo de :

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

Você não pode fazer isso com uma chamada explícita ao HashSet<T>construtor. Estamos confiando na inferência de tipo para métodos genéricos para fazer isso por nós.

Agora você pode escolher nomeá-lo ToSete retornar ISet<T>- mas eu continuaria com ToHashSeto tipo de concreto. Isso é consistente com os operadores LINQ padrão ( ToDictionary, ToList) e permite expansão futura (por exemplo ToSortedSet). Você também pode fornecer uma sobrecarga especificando a comparação a ser usada.

Basta passar seu IEnumerable para o construtor do HashSet.

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

Essa funcionalidade foi adicionada como um método de extensão IEnumerable<TSource>ao .NET Framework 4.7.2 :

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

Como o @Joel afirmou, você pode simplesmente passar o seu enumerável. Se você deseja fazer um método de extensão, pode:

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

Se você precisa apenas acessar somente leitura ao conjunto e a fonte é um parâmetro para o seu método, então eu usaria

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

O motivo é que os usuários podem chamar seu método com o ISetjá, para que você não precise criar a cópia.

Há um método de extensão criado na estrutura .NET e no núcleo .NET para converter um IEnumerableem 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 ainda não posso usá-lo nas bibliotecas padrão do .NET (no momento da redação). Então, eu uso este método de extensão:

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

Isso é bem simples :)

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

e sim T é o tipo especificado por OP :)

A resposta de Jon é perfeita. A única ressalva é que, usando o HashedSet do NHibernate, preciso converter os resultados em uma coleção. Existe uma maneira ideal de fazer isso?

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

ou

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

Ou estou faltando outra coisa?

Edit: Isto é o que acabei fazendo:

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

Em vez da simples conversão de IEnumerable em um HashSet, geralmente é conveniente converter uma propriedade de outro objeto em um HashSet. Você pode escrever isso como:

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

mas, minha preferência seria usar seletores:

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

Eles fazem a mesma coisa, e o segundo é obviamente mais curto, mas acho que o idioma se encaixa melhor no meu cérebro (acho que é como o ToDictionary).

Aqui está o método de extensão a ser usado, com suporte para comparadores personalizados como um bônus.

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