Jak przekonwertować wyniki linq na HashSet lub HashedSet

Mam właściwość klasy, która jest ISet. Próbuję uzyskać wyniki zapytania linq w tej właściwości, ale nie mogę wymyślić, jak to zrobić.

Zasadniczo, szukając ostatniej części tego:

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

Mógłby to również zrobić:

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

Nie sądzę, żeby było w tym coś wbudowanego ... ale bardzo łatwo jest napisać metodę rozszerzenia:

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

Zauważ, że naprawdę potrzebujesz tutaj metody rozszerzenia (lub przynajmniej ogólnej metody jakiejś formy), ponieważ możesz nie być w stanie wyrazić typu Tjawnie:

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

Nie możesz tego zrobić za pomocą jawnego wywołania HashSet<T>konstruktora. W tym celu opieramy się na wnioskowaniu o typ dla metod ogólnych.

Teraz już mógł wybrać, aby go wymienić ToSeti powrót ISet<T>- ale będę trzymać ToHashSeti rodzaju betonu. Jest to zgodne ze standardowymi operatorami LINQ ( ToDictionary, ToList) i umożliwia przyszłą rozbudowę (np ToSortedSet.). Możesz także podać przeciążenie określające porównanie do użycia.

Po prostu przekaż swój IEnumerable do konstruktora dla HashSet.

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

Ta funkcjonalność została dodana jako metoda rozszerzenia IEnumerable<TSource>do .NET Framework 4.7.2 :

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

Jak stwierdził @Joel, możesz po prostu przekazać swoje wyliczenie. Jeśli chcesz zastosować metodę rozszerzenia, możesz:

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

Jeśli potrzebujesz tylko dostępu do zestawu tylko do odczytu, a źródło jest parametrem twojej metody, to wybrałbym

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

Powodem jest to, że użytkownicy mogą wywołać twoją metodę z ISetjuż, więc nie musisz tworzyć kopii.

Istnieje metoda rozszerzenia wbudowana w środowisko .NET i .NET core do konwersji IEnumerablena 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);

Wygląda na to, że nie mogę go jeszcze używać w standardowych bibliotekach .NET (w momencie pisania). Więc używam tej metody rozszerzenia:

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

To całkiem proste :)

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

i tak T jest typem określonym przez OP :)

Odpowiedź Jona jest idealna. Jedynym zastrzeżeniem jest to, że używając HashedSet NHibernate'a muszę przekonwertować wyniki na kolekcję. Czy istnieje optymalny sposób to zrobić?

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

lub

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

A może brakuje mi czegoś innego?

Edycja: Właśnie to skończyłem:

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

Zamiast zwykłej konwersji IEnumerable na HashSet, często wygodnie jest przekonwertować właściwość innego obiektu na HashSet. Możesz to napisać jako:

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

ale wolę używać selektorów:

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

Robią to samo, a druga jest oczywiście krótsza, ale uważam, że ten idiom lepiej pasuje do moich mózgów (myślę, że to jak ToDictionary).

Oto metoda rozszerzenia, której należy użyć, ze wsparciem dla niestandardowych programów porównujących jako bonusu.

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