Po co używać.AsEnumerable() zamiast rzucać do IEnumerable?

Wymyśliłem powód oprócz czytelności, choć związany z implementacją zapytań: używanie Linq do obiektów na anonimowych typach zwracanych przez innego dostawcę Linq. Nie możesz obsadzić anonimowego typu (lub zbioru anonimowych typów), ale możesz użyć .AsEnumerable(), Aby wykonać obsadę za Ciebie.

Przykład:

// Get an IQueryable of anonymous types.
var query = from p in db.PeopleTable /* Assume Linq to SQL */
            select new { Name = p.Name, Age = p.Age };

// Execute the query and pull the results into an IEnumerable of anonymous types
var enum = query.AsEnumerable();

// Use Linq to Objects methods to further refine.
var refined = from p in enum
              select new
              {
                  Name = GetPrettyName(p.Name),
                  DOB = CalculateDOB(p.Age, DateTime.Now)
              };

Najwyraźniej powodem jest to, że chcemy użyć czegoś takiego jak Linq do SQL, aby ściągnąć niektóre rekordy do anonimowego typu, a następnie wykonać niestandardową logikę (która nie byłoby możliwe poprzez Linq do SQL) używając Linq do obiektów po stronie klienta.

Casting do IEnumerable<_anon> nie jest możliwy, więc .AsEnumerable() to jedyna droga.

Jak czytam książkę C# 6.0 in a Nutshell. Poniżej znajduje się przykład AsEnumerable w książce.

Celem jest dodanie sekwencji IQueryable<T> do IEnumerable<T>, zmuszając kolejne operatory zapytań do wiązania się z operatorami Wyliczeniowymi zamiast z operatorami zapytań. Powoduje to, że reszta zapytania wykonuje lokalnie .

Aby zilustrować, Załóżmy, że mieliśmy MedicalArticles tabelę w SQL Server i chcieliśmy użyć LINQ do SQL lub EF, aby pobrać wszystkie artykuły na temat grypy, których streszczenie zawierało mniej niż 100 słów. Dla tego ostatniego predykatu potrzebujemy wyrażenia regularnego:

Regex wordCounter = new Regex (@"\b(\w|[-'])+\b");

var query = dataContext.MedicalArticles
            .Where (article => article.Topic == "influenza" &&
            wordCounter.Matches (article.Abstract).Count < 100);

Problem polega na tym, że SQL Server nie obsługuje wyrażeń regularnych, więc dostawcy LINQ-to-db rzucą wyjątek, narzekając, że zapytanie nie może być przetłumaczone na SQL. Możemy to rozwiązać poprzez odpytywanie w dwóch krokach: najpierw pobierając wszystkie artykuły na temat grypy za pomocą zapytania LINQ do SQL, a następnie filtrując lokalnie dla abstraktów mniej niż 100 słów:

Regex wordCounter = new Regex (@"\b(\w|[-'])+\b");

IEnumerable<MedicalArticle> sqlQuery = dataContext.MedicalArticles
    .Where (article => article.Topic == "influenza");

IEnumerable<MedicalArticle> localQuery = sqlQuery
    .Where (article => wordCounter.Matches (article.Abstract).Count < 100);

Zliczalnie, możemy zrobić to samo w jednym zapytaniu:

var query = dataContext.MedicalArticles
      .Where (article => article.Topic == "influenza")
      .AsEnumerable()
      .Where (article => wordCounter.Matches (article.Abstract).Count < 100);

Alternatywą dla wywołania liczby jest wywołanie Doarray lub ToList. zaletą AsEnumerable jest to, że nie wymusza natychmiastowego wykonywania zapytań , ani nie tworzy żadnej struktury pamięci masowej.

To po prostu najmilszy i najkrótszy sposób na rzucanie do liczby mnogiej. Jeśli spojrzysz na to w reflektorze, zobaczysz, że nie robi nic poza zwróceniem obiektu jako liczby mnogiej.

Z MSDN:

AsEnumerable(Of TSource) (IEnumerable(Of TSource)) metoda nie ma innego wpływu niż na zmiana typu źródła w czasie kompilacji od typu, który realizuje IEnumerable (of T) to IEnumerable (of T) siebie.

Typy anonimowe są głównym powodem dostarczania tego rodzaju metod rozszerzeń. (nie można używać anonimowych typów w parametrach generycznych) Ale wywołanie metody może używać wnioskowania typu, pozwalając na pominięcie określania typu w parametrach ogólnych.

Jeśli na obiekcie znajduje się Metoda o tej samej nazwie co metoda rozszerzenia Linq, ukrywa ona metodę rozszerzenia. Korzystanie Zliczalne pozwala uzyskać na rozszerzenie.

To wydaje się być nowe w SP1.

Wczoraj miałem wiersz kodu, który wyodrębnił identyfikatory członków z tabeli danych:-

var lMmIds = new List<int>(
    lDmMember.DataTable.Select(R => R.MmId)
);

Który działał dobrze, dopóki nie zainstalowałem SP1. Teraz nie będzie działać, jeśli nie będzie czytać

var lMmIds = new List<int>(
    lDmMember.DataTable.AsEnumerable().Select(R => (int)((dsMtables.tbMMemberRow)R).MmId)
);

Edit: znalazłem prawdziwy powód

Jest tak, że można używać zarówno metod zdalnych (np. WHERE w instrukcji SQL), jak i metod lokalnych w tej samej instrukcji linq. Bez użycia liczby (np. tylko odlewania) spowoduje, że generator zapytań spróbuje utworzyć drzewo wyrażeń do zdalnego wykonania, które zawiera lokalną metodę. Umieszczenie liczby w zapytaniu spowoduje, że reszta tego zapytania zostanie wykonana lokalnie na wynikach zapytania zdalnego.

Od https://msdn.microsoft.com/en-us/library/bb335435 (v=vs.110). aspx

Typ tabeli reprezentujący tabelę bazy danych może mieć metodę Where, która przyjmuje argument predykatu jako drzewo wyrażeń i konwertuje drzewo do SQL w celu zdalnego wykonania. Jeśli zdalne wykonanie nie jest pożądane, na przykład dlatego, że predykat wywołuje metodę lokalną, można użyć metody numerycznej do ukrycia niestandardowych metod i zamiast tego utworzyć standardowe operatory zapytań dostępny.

Jak mówisz, jeśli typ implementuje już IEnumerable<T>, to nie ma żadnej funkcjonalnej różnicy między uruchamianiem interfejsu a wywołaniem metody AsEnumerable.

Moim zdaniem, i to tylko przypuszczenie, jest to, że wywołanie AsEnumerable poprawia czytelność i zachowuje płynną sygnaturę innych metod rozszerzenia LINQ:

var query = ((IEnumerable<YourType>)yourCollection).Select(x => x.YourProperty);

// vs

var query = yourCollection.AsEnumerable().Select(x => x.YourProperty);

Pozwala również na typy, które nie implementują IEnumerable<T> - na przykład, DataTable - mieć własną wersję rozszerzenia AsEnumerable. Pozwala to na kontynuuj używanie tego samego wzorca w zapytaniach przeciwko tym typom - nawet jeśli jest to inna metoda AsEnumerable, którą wywołujesz - bez martwienia się o to, czy typ rzeczywiście implementuje IEnumerable<T>.