mcs/class/System.Core/System.Linq/Queryable.cs

   1 //
   2 // Queryable.cs
   3 //
   4 // Authors:
   5 //  Marek Safar (marek.safar@gmail.com)
   6 //  Alejandro Serrano "Serras" (trupill@yahoo.es)
   7 //  Jb Evain (jbevain@novell.com)
   8 //  Andreas Noever (andreas.noever@gmail.com)
   9 //
  10 // Copyright (C) 2008 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.Collections;
  34 using System.Collections.Generic;
  35 using System.Linq.Expressions;
  36 using System.Reflection;
  37 using System.Linq;
  38
  39 namespace System.Linq {
  40
  41         public static class Queryable {
  42
  43                 static MethodInfo MakeGeneric (MethodBase method, params Type [] parameters)
  44                 {
  45                         return ((MethodInfo) method).MakeGenericMethod (parameters);
  46                 }
  47
  48                 static Expression StaticCall (MethodInfo method, params Expression [] expressions)
  49                 {
  50                         return Expression.Call (null, method, expressions);
  51                 }
  52
  53                 static TRet Execute<TRet, TSource> (this IQueryable<TSource> source, MethodBase current)
  54                 {
  55                         return source.Provider.Execute<TRet> (
  56                                 StaticCall (
  57                                         MakeGeneric (current, typeof (TSource)),
  58                                         source.Expression));
  59                 }
  60
  61                 #region Aggregate
  62
  63                 public static TSource Aggregate<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, TSource, TSource>> func)
  64                 {
  65                         Check.SourceAndFunc (source, func);
  66                         return source.Provider.Execute<TSource> (
  67                         StaticCall (
  68                                 MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
  69                                 source.Expression,
  70                                 Expression.Quote (func)));
  71                 }
  72
  73                 public static TAccumulate Aggregate<TSource, TAccumulate> (this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func)
  74                 {
  75                         Check.SourceAndFunc (source, func);
  76                         return source.Provider.Execute<TAccumulate> (
  77                                 StaticCall (
  78                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TAccumulate)),
  79                                         source.Expression,
  80                                         Expression.Constant (seed, typeof (TAccumulate)),
  81                                         Expression.Quote (func)));
  82                 }
  83
  84                 public static TResult Aggregate<TSource, TAccumulate, TResult> (this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func, Expression<Func<TAccumulate, TResult>> selector)
  85                 {
  86                         Check.SourceAndFuncAndSelector (source, func, selector);
  87                         return source.Provider.Execute<TResult> (
  88                                 StaticCall (
  89                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TAccumulate), typeof (TResult)),
  90                                         source.Expression,
  91                                         Expression.Constant (seed, typeof (TAccumulate)),
  92                                         Expression.Quote (func),
  93                                         Expression.Quote (selector)));
  94                 }
  95
  96                 #endregion
  97
  98                 #region All
  99
 100                 public static bool All<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 101                 {
 102                         Check.SourceAndPredicate (source, predicate);
 103
 104                         return source.Provider.Execute<bool> (
 105                                 StaticCall (
 106                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 107                                         source.Expression,
 108                                         Expression.Quote (predicate)));
 109                 }
 110
 111                 #endregion
 112
 113                 #region Any
 114
 115                 public static bool Any<TSource> (this IQueryable<TSource> source)
 116                 {
 117                         Check.Source (source);
 118
 119                         return source.Provider.Execute<bool> (
 120                                 StaticCall (
 121                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 122                                         source.Expression));
 123                 }
 124
 125                 public static bool Any<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 126                 {
 127                         Check.SourceAndPredicate (source, predicate);
 128
 129                         return source.Provider.Execute<bool> (
 130                                 StaticCall (
 131                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 132                                         source.Expression,
 133                                         Expression.Quote (predicate)));
 134                 }
 135
 136                 #endregion
 137
 138                 #region AsQueryable
 139
 140                 public static IQueryable<TElement> AsQueryable<TElement> (this IEnumerable<TElement> source)
 141                 {
 142                         if (source == null)
 143                                 throw new ArgumentNullException ("source");
 144
 145                         var queryable = source as IQueryable<TElement>;
 146                         if (queryable != null)
 147                                 return queryable;
 148
 149                         return new QueryableEnumerable<TElement> (source);
 150                 }
 151
 152                 public static IQueryable AsQueryable (this IEnumerable source)
 153                 {
 154                         if (source == null)
 155                                 throw new ArgumentNullException ("source");
 156
 157                         var queryable = source as IQueryable;
 158                         if (queryable != null)
 159                                 return queryable;
 160
 161                         Type ienumerable;
 162                         if (!source.GetType ().IsGenericImplementationOf (typeof (IEnumerable<>), out ienumerable))
 163                                 throw new ArgumentException ("source is not IEnumerable<>");
 164
 165                         return (IQueryable) Activator.CreateInstance (
 166                                 typeof (QueryableEnumerable<>).MakeGenericType (ienumerable.GetFirstGenericArgument ()), source);
 167                 }
 168
 169                 #endregion
 170
 171                 #region Average
 172
 173                 public static double Average (this IQueryable<int> source)
 174                 {
 175                         Check.Source (source);
 176
 177                         return source.Provider.Execute<double>(
 178                                 StaticCall (
 179                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 180                                         source.Expression));
 181                 }
 182
 183                 public static double? Average(this IQueryable<int?> source)
 184                 {
 185                         Check.Source (source);
 186
 187                         return source.Provider.Execute<double?>(
 188                                 StaticCall (
 189                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 190                                         source.Expression));
 191                 }
 192
 193                 public static double Average(this IQueryable<long> source)
 194                 {
 195                         Check.Source (source);
 196
 197                         return source.Provider.Execute<double>(
 198                                 StaticCall (
 199                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 200                                         source.Expression));
 201                 }
 202
 203                 public static double? Average(this IQueryable<long?> source)
 204                 {
 205                         Check.Source (source);
 206
 207                         return source.Provider.Execute<double?>(
 208                                 StaticCall (
 209                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 210                                         source.Expression));
 211                 }
 212
 213                 public static float Average(this IQueryable<float> source)
 214                 {
 215                         Check.Source (source);
 216
 217                         return source.Provider.Execute<float>(
 218                                 StaticCall (
 219                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 220                                         source.Expression));
 221                 }
 222
 223                 public static float? Average(this IQueryable<float?> source)
 224                 {
 225                         Check.Source (source);
 226
 227                         return source.Provider.Execute<float?>(
 228                                 StaticCall (
 229                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 230                                         source.Expression));
 231                 }
 232
 233                 public static double Average (this IQueryable<double> source)
 234                 {
 235                         Check.Source (source);
 236
 237                         return source.Provider.Execute<double> (
 238                                 StaticCall (
 239                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 240                                         source.Expression));
 241                 }
 242
 243                 public static double? Average (this IQueryable<double?> source)
 244                 {
 245                         Check.Source (source);
 246
 247                         return source.Provider.Execute<double?> (
 248                                 StaticCall (
 249                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 250                                         source.Expression));
 251                 }
 252
 253                 public static decimal Average(this IQueryable<decimal> source)
 254                 {
 255                         Check.Source (source);
 256
 257                         return source.Provider.Execute<decimal>(
 258                                 StaticCall (
 259                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 260                                         source.Expression));
 261                 }
 262
 263                 public static decimal? Average(this IQueryable<decimal?> source)
 264                 {
 265                         Check.Source (source);
 266
 267                         return source.Provider.Execute<decimal?>(
 268                                 StaticCall (
 269                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 270                                         source.Expression));
 271                 }
 272
 273                 public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
 274                 {
 275                         Check.SourceAndSelector (source, selector);
 276
 277                         return source.Provider.Execute<double>(
 278                                 StaticCall (
 279                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 280                                         source.Expression,
 281                                         Expression.Quote (selector)));
 282                 }
 283
 284                 public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector)
 285                 {
 286                         Check.SourceAndSelector (source, selector);
 287
 288                         return source.Provider.Execute<double?>(
 289                                 StaticCall (
 290                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 291                                         source.Expression,
 292                                         Expression.Quote (selector)));
 293                 }
 294
 295                 public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector)
 296                 {
 297                         Check.SourceAndSelector (source, selector);
 298
 299                         return source.Provider.Execute<double>(
 300                                 StaticCall (
 301                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 302                                         source.Expression,
 303                                         Expression.Quote (selector)));
 304                 }
 305
 306                 public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector)
 307                 {
 308                         Check.SourceAndSelector (source, selector);
 309
 310                         return source.Provider.Execute<double?>(
 311                                 StaticCall (
 312                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 313                                         source.Expression,
 314                                         Expression.Quote (selector)));
 315                 }
 316
 317                 public static float Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
 318                 {
 319                         Check.SourceAndSelector (source, selector);
 320
 321                         return source.Provider.Execute<float>(
 322                                 StaticCall (
 323                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 324                                         source.Expression,
 325                                         Expression.Quote (selector)));
 326                 }
 327
 328                 public static float? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector)
 329                 {
 330                         Check.SourceAndSelector (source, selector);
 331
 332                         return source.Provider.Execute<float?>(
 333                                 StaticCall (
 334                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 335                                         source.Expression,
 336                                         Expression.Quote (selector)));
 337                 }
 338
 339                 public static double Average<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
 340                 {
 341                         Check.SourceAndSelector (source, selector);
 342
 343                         return source.Provider.Execute<double> (
 344                                 StaticCall (
 345                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 346                                         source.Expression,
 347                                         Expression.Quote (selector)));
 348                 }
 349
 350                 public static double? Average<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector)
 351                 {
 352                         Check.SourceAndSelector (source, selector);
 353
 354                         return source.Provider.Execute<double?> (
 355                                 StaticCall (
 356                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 357                                         source.Expression,
 358                                         Expression.Quote (selector)));
 359                 }
 360
 361                 public static decimal Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
 362                 {
 363                         Check.SourceAndSelector (source, selector);
 364
 365                         return source.Provider.Execute<decimal>(
 366                                 StaticCall (
 367                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 368                                         source.Expression,
 369                                         Expression.Quote (selector)));
 370                 }
 371
 372                 public static decimal? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector)
 373                 {
 374                         Check.SourceAndSelector (source, selector);
 375
 376                         return source.Provider.Execute<decimal?>(
 377                                 StaticCall (
 378                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 379                                         source.Expression,
 380                                         Expression.Quote (selector)));
 381                 }
 382
 383                 #endregion
 384
 385                 #region Cast
 386
 387                 public static IQueryable<TResult> Cast<TResult> (this IQueryable source)
 388                 {
 389                         Check.Source (source);
 390
 391                         return (IQueryable<TResult>) source.Provider.CreateQuery (
 392                                 StaticCall (MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TResult)),
 393                                         source.Expression));
 394                 }
 395
 396                 #endregion
 397
 398                 #region Concat
 399
 400                 public static IQueryable<TSource> Concat<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 401                 {
 402                         Check.Source1AndSource2 (source1, source2);
 403
 404                         return source1.Provider.CreateQuery<TSource> (
 405                                 StaticCall (
 406                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 407                                         source1.Expression,
 408                                         Expression.Constant (source2, typeof (IEnumerable<TSource>))));
 409                 }
 410
 411                 #endregion
 412
 413                 #region Contains
 414
 415                 public static bool Contains<TSource> (this IQueryable<TSource> source, TSource item)
 416                 {
 417                         Check.Source (source);
 418
 419                         return source.Provider.Execute<bool> (
 420                                 StaticCall (
 421                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 422                                         source.Expression,
 423                                         Expression.Constant (item, typeof (TSource))));
 424                 }
 425
 426                 public static bool Contains<TSource> (this IQueryable<TSource> source, TSource item, IEqualityComparer<TSource> comparer)
 427                 {
 428                         Check.Source (source);
 429
 430                         return source.Provider.Execute<bool> (
 431                                 StaticCall (
 432                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 433                                         source.Expression,
 434                                         Expression.Constant (item, typeof (TSource)),
 435                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
 436                 }
 437
 438                 #endregion
 439
 440                 #region Count
 441
 442                 public static int Count<TSource> (this IQueryable<TSource> source)
 443                 {
 444                         Check.Source (source);
 445
 446                         return source.Execute<int, TSource> (MethodBase.GetCurrentMethod ());
 447                 }
 448
 449                 public static int Count<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 450                 {
 451                         Check.SourceAndPredicate (source, predicate);
 452
 453                         return source.Provider.Execute<int> (
 454                                 StaticCall (
 455                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 456                                         source.Expression,
 457                                         Expression.Quote (predicate)));
 458                 }
 459
 460                 #endregion
 461
 462                 #region DefaultIfEmpty
 463
 464                 public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source)
 465                 {
 466                         Check.Source (source);
 467
 468                         return source.Provider.CreateQuery<TSource> (
 469                                 StaticCall (
 470                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 471                                         source.Expression));
 472                 }
 473
 474                 public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source, TSource defaultValue)
 475                 {
 476                         Check.Source (source);
 477
 478                         return source.Provider.CreateQuery<TSource> (
 479                                 StaticCall (
 480                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 481                                         source.Expression,
 482                                         Expression.Constant (defaultValue, typeof (TSource))));
 483                 }
 484
 485                 #endregion
 486
 487                 #region Distinct
 488
 489                 public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source)
 490                 {
 491                         Check.Source (source);
 492
 493                         return source.Provider.CreateQuery<TSource> (
 494                                 StaticCall (
 495                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 496                                         source.Expression));
 497                 }
 498
 499                 public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source, IEqualityComparer<TSource> comparer)
 500                 {
 501                         Check.Source (source);
 502
 503                         return source.Provider.CreateQuery<TSource> (
 504                                 StaticCall (
 505                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 506                                         source.Expression,
 507                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
 508                 }
 509
 510                 #endregion
 511
 512                 #region ElementAt
 513
 514                 public static TSource ElementAt<TSource> (this IQueryable<TSource> source, int index)
 515                 {
 516                         Check.Source (source);
 517
 518                         return source.Provider.Execute<TSource> (
 519                                 StaticCall (
 520                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 521                                         source.Expression,
 522                                         Expression.Constant (index)));
 523                 }
 524
 525                 #endregion
 526
 527                 #region ElementAtOrDefault
 528
 529                 public static TSource ElementAtOrDefault<TSource> (this IQueryable<TSource> source, int index)
 530                 {
 531                         Check.Source (source);
 532
 533                         return source.Provider.Execute<TSource> (
 534                                 StaticCall (
 535                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 536                                         source.Expression,
 537                                         Expression.Constant (index)));
 538                 }
 539
 540                 #endregion
 541
 542                 #region Except
 543
 544                 public static IQueryable<TSource> Except<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 545                 {
 546                         Check.Source1AndSource2 (source1, source2);
 547
 548                         return source1.Provider.CreateQuery<TSource> (
 549                                 StaticCall (
 550                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 551                                         source1.Expression,
 552                                         Expression.Constant (source2, typeof (IEnumerable<TSource>))));
 553                 }
 554
 555                 public static IQueryable<TSource> Except<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
 556                 {
 557                         Check.Source1AndSource2 (source1, source2);
 558
 559                         return source1.Provider.CreateQuery<TSource> (
 560                                 StaticCall (
 561                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 562                                         source1.Expression,
 563                                         Expression.Constant (source2, typeof (IEnumerable<TSource>)),
 564                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
 565                 }
 566
 567                 #endregion
 568
 569                 #region First
 570
 571                 public static TSource First<TSource> (this IQueryable<TSource> source)
 572                 {
 573                         Check.Source (source);
 574
 575                         return source.Provider.Execute<TSource> (
 576                                 StaticCall (
 577                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 578                                         source.Expression));
 579                 }
 580
 581                 public static TSource First<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 582                 {
 583                         Check.SourceAndPredicate (source, predicate);
 584
 585                         return source.Provider.Execute<TSource> (
 586                                 StaticCall (
 587                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 588                                         source.Expression,
 589                                         Expression.Quote (predicate)));
 590                 }
 591
 592                 #endregion
 593
 594                 #region FirstOrDefault
 595
 596                 public static TSource FirstOrDefault<TSource> (this IQueryable<TSource> source)
 597                 {
 598                         Check.Source (source);
 599
 600                         return source.Provider.Execute<TSource> (
 601                                 StaticCall (
 602                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 603                                         source.Expression));
 604                 }
 605
 606                 public static TSource FirstOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 607                 {
 608                         Check.SourceAndPredicate (source, predicate);
 609
 610                         return source.Provider.Execute<TSource> (
 611                                 StaticCall (
 612                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 613                                         source.Expression,
 614                                         Expression.Quote (predicate)));
 615                 }
 616
 617                 #endregion
 618
 619                 #region GroupBy
 620
 621                 public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 622                 {
 623                         Check.SourceAndKeySelector (source, keySelector);
 624
 625                         return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
 626                                 StaticCall (
 627                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 628                                         source.Expression,
 629                                         Expression.Quote (keySelector)));
 630                 }
 631                 public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer)
 632                 {
 633                         Check.SourceAndKeySelector (source, keySelector);
 634
 635                         return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
 636                                 StaticCall (
 637                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 638                                         source.Expression,
 639                                         Expression.Quote (keySelector),
 640                                         Expression.Constant (comparer, typeof (IEqualityComparer<TKey>))));
 641                 }
 642                 public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector)
 643                 {
 644                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 645
 646                         return source.Provider.CreateQuery<IGrouping<TKey, TElement>>(
 647                                 StaticCall (
 648                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
 649                                         source.Expression,
 650                                         Expression.Quote (keySelector),
 651                                         Expression.Quote (elementSelector)));
 652                 }
 653                 public static IQueryable<TResult> GroupBy<TSource, TKey, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector)
 654                 {
 655                         Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
 656
 657                         return source.Provider.CreateQuery<TResult> (
 658                                 StaticCall (
 659                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
 660                                         source.Expression,
 661                                         Expression.Quote (keySelector),
 662                                         Expression.Quote (resultSelector)));
 663                 }
 664                 public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, IEqualityComparer<TKey> comparer)
 665                 {
 666                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 667
 668                         return source.Provider.CreateQuery<IGrouping<TKey, TElement>> (
 669                                 StaticCall (
 670                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
 671                                         source.Expression,
 672                                         Expression.Quote (keySelector),
 673                                         Expression.Quote (elementSelector),
 674                                         Expression.Constant (comparer, typeof (IEqualityComparer<TKey>))));
 675                 }
 676                 public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector)
 677                 {
 678                         Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
 679
 680                         return source.Provider.CreateQuery<TResult> (
 681                                 StaticCall (
 682                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
 683                                         source.Expression,
 684                                         Expression.Quote (keySelector),
 685                                         Expression.Quote (elementSelector),
 686                                         Expression.Quote (resultSelector)));
 687                 }
 688
 689                 public static IQueryable<TResult> GroupBy<TSource, TKey, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector, IEqualityComparer<TKey> comparer)
 690                 {
 691                         Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
 692
 693                         return source.Provider.CreateQuery<TResult> (
 694                                 StaticCall (
 695                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
 696                                         source.Expression,
 697                                         Expression.Quote (keySelector),
 698                                         Expression.Quote (resultSelector),
 699                                         Expression.Constant (comparer, typeof (IEqualityComparer<TKey>))));
 700                 }
 701                 public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector, IEqualityComparer<TKey> comparer)
 702                 {
 703                         Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
 704
 705                         return source.Provider.CreateQuery<TResult> (
 706                                 StaticCall (
 707                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
 708                                         source.Expression,
 709                                         Expression.Quote (keySelector),
 710                                         Expression.Quote (elementSelector),
 711                                         Expression.Quote (resultSelector),
 712                                         Expression.Constant (comparer, typeof (IEqualityComparer<TKey>))));
 713                 }
 714                 #endregion
 715
 716                 #region GroupJoin
 717
 718                 public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector)
 719                 {
 720                         if (outer == null)
 721                                 throw new ArgumentNullException ("outer");
 722                         if (inner == null)
 723                                 throw new ArgumentNullException ("inner");
 724                         if (outerKeySelector == null)
 725                                 throw new ArgumentNullException ("outerKeySelector");
 726                         if (innerKeySelector == null)
 727                                 throw new ArgumentNullException ("innerKeySelector");
 728                         if (resultSelector == null)
 729                                 throw new ArgumentNullException ("resultSelector");
 730
 731                         return outer.Provider.CreateQuery<TResult> (
 732                                 StaticCall (
 733                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 734                                         outer.Expression,
 735                                         Expression.Constant (inner, typeof (IEnumerable<TInner>)),
 736                                         Expression.Quote (outerKeySelector),
 737                                         Expression.Quote (innerKeySelector),
 738                                         Expression.Quote (resultSelector)));
 739                 }
 740
 741                 public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult> (this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector, IEqualityComparer<TKey> comparer)
 742                 {
 743                         if (outer == null)
 744                                 throw new ArgumentNullException ("outer");
 745                         if (inner == null)
 746                                 throw new ArgumentNullException ("inner");
 747                         if (outerKeySelector == null)
 748                                 throw new ArgumentNullException ("outerKeySelector");
 749                         if (innerKeySelector == null)
 750                                 throw new ArgumentNullException ("innerKeySelector");
 751                         if (resultSelector == null)
 752                                 throw new ArgumentNullException ("resultSelector");
 753
 754                         return outer.Provider.CreateQuery<TResult> (
 755                                 StaticCall (
 756                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 757                                         outer.Expression,
 758                                         Expression.Constant (inner, typeof (IEnumerable<TInner>)),
 759                                         Expression.Quote (outerKeySelector),
 760                                         Expression.Quote (innerKeySelector),
 761                                         Expression.Quote (resultSelector),
 762                                         Expression.Constant (comparer)));
 763                 }
 764
 765                 #endregion
 766
 767                 #region Intersect
 768
 769                 public static IQueryable<TSource> Intersect<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 770                 {
 771                         Check.Source1AndSource2 (source1, source2);
 772
 773                         return source1.Provider.CreateQuery<TSource> (
 774                                 StaticCall (
 775                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 776                                         source1.Expression,
 777                                         Expression.Constant (source2, typeof (IEnumerable<TSource>))));
 778                 }
 779
 780                 public static IQueryable<TSource> Intersect<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
 781                 {
 782                         Check.Source1AndSource2 (source1, source2);
 783
 784                         return source1.Provider.CreateQuery<TSource> (
 785                                 StaticCall (
 786                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 787                                         source1.Expression,
 788                                         Expression.Constant (source2, typeof (IEnumerable<TSource>)),
 789                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
 790                 }
 791
 792                 #endregion
 793
 794                 #region Join
 795
 796                 public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult> (this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector)
 797                 {
 798                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 799
 800                         return outer.Provider.CreateQuery<TResult> (
 801                                 StaticCall (
 802                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 803                                         outer.Expression,
 804                                         Expression.Constant (inner, typeof (IEnumerable<TInner>)),
 805                                         Expression.Quote (outerKeySelector),
 806                                         Expression.Quote (innerKeySelector),
 807                                         Expression.Quote (resultSelector)));
 808                 }
 809
 810                 public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult> (this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector, IEqualityComparer<TKey> comparer)
 811                 {
 812                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 813
 814                         return outer.Provider.CreateQuery<TResult> (
 815                                 StaticCall (
 816                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 817                                         outer.Expression,
 818                                         Expression.Constant (inner, typeof (IEnumerable<TInner>)),
 819                                         Expression.Quote (outerKeySelector),
 820                                         Expression.Quote (innerKeySelector),
 821                                         Expression.Quote (resultSelector),
 822                                         Expression.Constant (comparer, typeof (IEqualityComparer<TKey>))));
 823                 }
 824
 825
 826                 #endregion
 827
 828                 #region Last
 829
 830                 public static TSource Last<TSource> (this IQueryable<TSource> source)
 831                 {
 832                         Check.Source (source);
 833
 834                         return source.Provider.Execute<TSource> (
 835                                 StaticCall (
 836                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 837                                         source.Expression));
 838                 }
 839
 840                 public static TSource Last<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 841                 {
 842                         Check.SourceAndPredicate (source, predicate);
 843
 844                         return source.Provider.Execute<TSource> (
 845                                 StaticCall (
 846                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 847                                         source.Expression,
 848                                         Expression.Quote (predicate)));
 849                 }
 850
 851                 #endregion
 852
 853                 #region LastOrDefault
 854
 855                 public static TSource LastOrDefault<TSource> (this IQueryable<TSource> source)
 856                 {
 857                         Check.Source (source);
 858
 859                         return source.Provider.Execute<TSource> (
 860                                 StaticCall (
 861                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 862                                         source.Expression));
 863                 }
 864
 865                 public static TSource LastOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 866                 {
 867                         Check.SourceAndPredicate (source, predicate);
 868
 869                         return source.Provider.Execute<TSource> (
 870                                 StaticCall (
 871                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 872                                         source.Expression,
 873                                         Expression.Quote (predicate)));
 874                 }
 875
 876                 #endregion
 877
 878                 #region LongCount
 879
 880                 public static long LongCount<TSource> (this IQueryable<TSource> source)
 881                 {
 882                         Check.Source (source);
 883
 884                         return source.Execute<long, TSource> (MethodBase.GetCurrentMethod ());
 885                 }
 886
 887                 public static long LongCount<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 888                 {
 889                         Check.SourceAndPredicate (source, predicate);
 890
 891                         return source.Provider.Execute<long> (
 892                                 StaticCall (
 893                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 894                                         source.Expression,
 895                                         Expression.Quote (predicate)));
 896                 }
 897
 898                 #endregion
 899
 900                 #region Max
 901
 902                 public static TSource Max<TSource> (this IQueryable<TSource> source)
 903                 {
 904                         Check.Source (source);
 905
 906                         return source.Provider.Execute<TSource> (
 907                                 StaticCall (
 908                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 909                                         source.Expression));
 910                 }
 911
 912                 public static TResult Max<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
 913                 {
 914                         Check.Source (source);
 915
 916                         return source.Provider.Execute<TResult> (
 917                                 StaticCall (
 918                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
 919                                         source.Expression,
 920                                         Expression.Quote (selector)));
 921                 }
 922
 923
 924                 #endregion
 925
 926                 #region Min
 927
 928                 public static TSource Min<TSource> (this IQueryable<TSource> source)
 929                 {
 930                         Check.Source (source);
 931
 932                         return source.Provider.Execute<TSource> (
 933                                 StaticCall (
 934                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 935                                         source.Expression));
 936                 }
 937
 938                 public static TResult Min<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
 939                 {
 940                         Check.SourceAndSelector (source, selector);
 941
 942                         return source.Provider.Execute<TResult> (
 943                                 StaticCall (
 944                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
 945                                         source.Expression,
 946                                         Expression.Quote (selector)));
 947                 }
 948
 949
 950                 #endregion
 951
 952                 #region OfType
 953
 954                 public static IQueryable<TResult> OfType<TResult> (this IQueryable source)
 955                 {
 956                         Check.Source (source);
 957
 958                         return (IQueryable<TResult>) source.Provider.CreateQuery (
 959                         StaticCall (
 960                                 MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TResult)),
 961                                 source.Expression));
 962                 }
 963
 964                 #endregion
 965
 966                 #region OrderBy
 967
 968                 public static IOrderedQueryable<TSource> OrderBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 969                 {
 970                         Check.SourceAndKeySelector (source, keySelector);
 971
 972                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
 973                                 StaticCall (
 974                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 975                                         source.Expression,
 976                                         Expression.Quote (keySelector)));
 977                 }
 978
 979                 public static IOrderedQueryable<TSource> OrderBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
 980                 {
 981                         Check.SourceAndKeySelector (source, keySelector);
 982
 983                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
 984                                 StaticCall (
 985                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 986                                         source.Expression,
 987                                         Expression.Quote (keySelector),
 988                                         Expression.Constant (comparer, typeof (IComparer<TKey>))));
 989                 }
 990
 991                 #endregion
 992
 993                 #region OrderByDescending
 994
 995                 public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 996                 {
 997                         Check.SourceAndKeySelector (source, keySelector);
 998
 999                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
1000                                 StaticCall (
1001                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1002                                         source.Expression,
1003                                         Expression.Quote (keySelector)));
1004                 }
1005
1006                 public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
1007                 {
1008                         Check.SourceAndKeySelector (source, keySelector);
1009
1010                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
1011                                 StaticCall (
1012                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1013                                         source.Expression,
1014                                         Expression.Quote (keySelector),
1015                                         Expression.Constant (comparer, typeof (IComparer<TKey>))));
1016                 }
1017
1018                 #endregion
1019
1020                 #region Reverse
1021
1022                 public static IQueryable<TSource> Reverse<TSource> (this IQueryable<TSource> source)
1023                 {
1024                         Check.Source (source);
1025
1026                         return source.Provider.CreateQuery<TSource> (
1027                                 StaticCall (
1028                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1029                                         source.Expression));
1030                 }
1031
1032                 #endregion
1033
1034                 #region Select
1035
1036                 public static IQueryable<TResult> Select<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
1037                 {
1038                         Check.SourceAndSelector (source, selector);
1039
1040                         return source.Provider.CreateQuery<TResult> (
1041                                 StaticCall (
1042                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1043                                         source.Expression,
1044                                         Expression.Quote (selector)));
1045                 }
1046
1047                 public static IQueryable<TResult> Select<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, TResult>> selector)
1048                 {
1049                         Check.SourceAndSelector (source, selector);
1050
1051                         return source.Provider.CreateQuery<TResult> (
1052                                 StaticCall (
1053                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1054                                         source.Expression,
1055                                         Expression.Quote (selector)));
1056                 }
1057
1058                 #endregion
1059
1060                 #region SelectMany
1061
1062                 public static IQueryable<TResult> SelectMany<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector)
1063                 {
1064                         Check.SourceAndSelector (source, selector);
1065
1066                         return source.Provider.CreateQuery<TResult> (
1067                                 StaticCall (
1068                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1069                                         source.Expression,
1070                                         Expression.Quote (selector)));
1071                 }
1072
1073                 public static IQueryable<TResult> SelectMany<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector)
1074                 {
1075                         Check.SourceAndSelector (source, selector);
1076
1077                         return source.Provider.CreateQuery<TResult> (
1078                                 StaticCall (
1079                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1080                                         source.Expression,
1081                                         Expression.Quote (selector)));
1082                 }
1083
1084                 public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
1085                 {
1086                         Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
1087
1088                         return source.Provider.CreateQuery<TResult> (
1089                                 StaticCall (
1090                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
1091                                         source.Expression,
1092                                         Expression.Quote (collectionSelector),
1093                                         Expression.Quote (resultSelector)));
1094                 }
1095
1096                 public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
1097                 {
1098                         Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
1099
1100                         return source.Provider.CreateQuery<TResult> (
1101                                 StaticCall (
1102                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
1103                                         source.Expression,
1104                                         Expression.Quote (collectionSelector),
1105                                         Expression.Quote (resultSelector)));
1106                 }
1107
1108                 #endregion
1109
1110                 #region SequenceEqual
1111
1112                 public static bool SequenceEqual<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
1113                 {
1114                         Check.Source1AndSource2 (source1, source2);
1115
1116                         return source1.Provider.Execute<bool> (
1117                                 StaticCall (
1118                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1119                                         source1.Expression,
1120                                         Expression.Constant (source2, typeof (IEnumerable<TSource>))));
1121                 }
1122
1123                 public static bool SequenceEqual<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
1124                 {
1125                         Check.Source1AndSource2 (source1, source2);
1126
1127                         return source1.Provider.Execute<bool> (
1128                                 StaticCall (
1129                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1130                                         source1.Expression,
1131                                         Expression.Constant (source2, typeof (IEnumerable<TSource>)),
1132                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
1133                 }
1134
1135                 #endregion
1136
1137                 #region Single
1138
1139                 public static TSource Single<TSource> (this IQueryable<TSource> source)
1140                 {
1141                         Check.Source (source);
1142
1143                         return source.Provider.Execute<TSource> (
1144                                 StaticCall (
1145                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1146                                         source.Expression));
1147                 }
1148
1149                 public static TSource Single<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1150                 {
1151                         Check.SourceAndPredicate (source, predicate);
1152
1153                         return source.Provider.Execute<TSource> (
1154                                 StaticCall (
1155                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1156                                         source.Expression,
1157                                         Expression.Quote (predicate)));
1158                 }
1159
1160                 #endregion
1161
1162                 #region SingleOrDefault
1163
1164                 public static TSource SingleOrDefault<TSource> (this IQueryable<TSource> source)
1165                 {
1166                         Check.Source (source);
1167
1168                         return source.Provider.Execute<TSource> (
1169                                 StaticCall (
1170                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1171                                         source.Expression));
1172                 }
1173
1174                 public static TSource SingleOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1175                 {
1176                         Check.SourceAndPredicate (source, predicate);
1177
1178                         return source.Provider.Execute<TSource> (
1179                                 StaticCall (
1180                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1181                                         source.Expression,
1182                                         Expression.Quote (predicate)));
1183                 }
1184
1185                 #endregion
1186
1187                 #region Skip
1188
1189                 public static IQueryable<TSource> Skip<TSource> (this IQueryable<TSource> source, int count)
1190                 {
1191                         Check.Source (source);
1192
1193                         return source.Provider.CreateQuery<TSource> (
1194                                 StaticCall (
1195                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1196                                         source.Expression,
1197                                         Expression.Constant (count)));
1198                 }
1199
1200                 #endregion
1201
1202                 #region SkipWhile
1203
1204                 public static IQueryable<TSource> SkipWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1205                 {
1206                         Check.SourceAndPredicate (source, predicate);
1207
1208                         return source.Provider.CreateQuery<TSource> (
1209                                 StaticCall (
1210                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1211                                         source.Expression,
1212                                         Expression.Quote (predicate)));
1213                 }
1214
1215                 public static IQueryable<TSource> SkipWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
1216                 {
1217                         Check.SourceAndPredicate (source, predicate);
1218
1219                         return source.Provider.CreateQuery<TSource> (
1220                                 StaticCall (
1221                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1222                                         source.Expression,
1223                                         Expression.Quote (predicate)));
1224                 }
1225
1226
1227                 #endregion
1228
1229                 #region Sum
1230
1231
1232                 public static int Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
1233                 {
1234                         Check.SourceAndSelector (source, selector);
1235
1236                         return source.Provider.Execute<int> (
1237                                 StaticCall (
1238                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1239                                         source.Expression,
1240                                         Expression.Quote (selector)));
1241                 }
1242
1243                 public static int? Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector)
1244                 {
1245                         Check.SourceAndSelector (source, selector);
1246
1247                         return source.Provider.Execute<int?> (
1248                                 StaticCall (
1249                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1250                                         source.Expression,
1251                                         Expression.Quote (selector)));
1252                 }
1253
1254                 public static long Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, long>> selector)
1255                 {
1256                         Check.SourceAndSelector (source, selector);
1257
1258                         return source.Provider.Execute<long> (
1259                                 StaticCall (
1260                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1261                                         source.Expression,
1262                                         Expression.Quote (selector)));
1263                 }
1264
1265                 public static long? Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector)
1266                 {
1267                         Check.SourceAndSelector (source, selector);
1268
1269                         return source.Provider.Execute<long?> (
1270                                 StaticCall (
1271                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1272                                         source.Expression,
1273                                         Expression.Quote (selector)));
1274                 }
1275
1276                 public static float Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
1277                 {
1278                         Check.SourceAndSelector (source, selector);
1279
1280                         return source.Provider.Execute<float> (
1281                                 StaticCall (
1282                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1283                                         source.Expression,
1284                                         Expression.Quote (selector)));
1285                 }
1286
1287                 public static float? Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector)
1288                 {
1289                         Check.SourceAndSelector (source, selector);
1290
1291                         return source.Provider.Execute<float?> (
1292                                 StaticCall (
1293                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1294                                         source.Expression,
1295                                         Expression.Quote (selector)));
1296                 }
1297
1298                 public static double Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
1299                 {
1300                         Check.SourceAndSelector (source, selector);
1301
1302                         return source.Provider.Execute<double> (
1303                                 StaticCall (
1304                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1305                                         source.Expression,
1306                                         Expression.Quote (selector)));
1307                 }
1308
1309                 public static double? Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector)
1310                 {
1311                         Check.SourceAndSelector (source, selector);
1312
1313                         return source.Provider.Execute<double?> (
1314                                 StaticCall (
1315                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1316                                         source.Expression,
1317                                         Expression.Quote (selector)));
1318                 }
1319
1320                 public static decimal Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
1321                 {
1322                         Check.SourceAndSelector (source, selector);
1323
1324                         return source.Provider.Execute<decimal> (
1325                                 StaticCall (
1326                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1327                                         source.Expression,
1328                                         Expression.Quote (selector)));
1329                 }
1330
1331                 public static decimal? Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector)
1332                 {
1333                         Check.SourceAndSelector (source, selector);
1334
1335                         return source.Provider.Execute<decimal?> (
1336                                 StaticCall (
1337                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1338                                         source.Expression,
1339                                         Expression.Quote (selector)));
1340                 }
1341
1342                 public static int Sum (this IQueryable<int> source)
1343                 {
1344                         Check.Source (source);
1345
1346                         return source.Provider.Execute<int> (
1347                                 StaticCall (
1348                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1349                                         source.Expression));
1350                 }
1351
1352                 public static int? Sum (this IQueryable<int?> source)
1353                 {
1354                         Check.Source (source);
1355
1356                         return source.Provider.Execute<int?> (
1357                                 StaticCall (
1358                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1359                                         source.Expression));
1360                 }
1361
1362
1363
1364                 public static long Sum (this IQueryable<long> source)
1365                 {
1366                         Check.Source (source);
1367
1368                         return source.Provider.Execute<long> (
1369                                 StaticCall (
1370                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1371                                         source.Expression));
1372                 }
1373
1374
1375
1376                 public static long? Sum (this IQueryable<long?> source)
1377                 {
1378                         Check.Source (source);
1379
1380                         return source.Provider.Execute<long?> (
1381                                 StaticCall (
1382                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1383                                         source.Expression));
1384                 }
1385
1386                 public static float Sum (this IQueryable<float> source)
1387                 {
1388                         Check.Source (source);
1389
1390                         return source.Provider.Execute<float> (
1391                                 StaticCall (
1392                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1393                                         source.Expression));
1394                 }
1395
1396                 public static float? Sum (this IQueryable<float?> source)
1397                 {
1398                         Check.Source (source);
1399
1400                         return source.Provider.Execute<float?> (
1401                                 StaticCall (
1402                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1403                                         source.Expression));
1404                 }
1405
1406
1407                 public static double Sum (this IQueryable<double> source)
1408                 {
1409                         Check.Source (source);
1410
1411                         return source.Provider.Execute<double> (
1412                                 StaticCall (
1413                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1414                                         source.Expression));
1415                 }
1416
1417
1418
1419                 public static double? Sum (this IQueryable<double?> source)
1420                 {
1421                         Check.Source (source);
1422
1423                         return source.Provider.Execute<double?> (
1424                                 StaticCall (
1425                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1426                                         source.Expression));
1427                 }
1428
1429
1430                 public static decimal Sum (this IQueryable<decimal> source)
1431                 {
1432                         Check.Source (source);
1433
1434                         return source.Provider.Execute<decimal> (
1435                                 StaticCall (
1436                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1437                                         source.Expression));
1438                 }
1439
1440
1441
1442                 public static decimal? Sum (this IQueryable<decimal?> source)
1443                 {
1444                         Check.Source (source);
1445
1446                         return source.Provider.Execute<decimal?> (
1447                                 StaticCall (
1448                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1449                                         source.Expression));
1450                 }
1451
1452
1453
1454                 #endregion
1455
1456                 #region Take
1457
1458                 public static IQueryable<TSource> Take<TSource> (this IQueryable<TSource> source, int count)
1459                 {
1460                         Check.Source (source);
1461
1462                         return source.Provider.CreateQuery<TSource> (
1463                                 StaticCall (
1464                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1465                                         source.Expression,
1466                                         Expression.Constant (count)));
1467                 }
1468
1469                 #endregion
1470
1471                 #region TakeWhile
1472
1473                 public static IQueryable<TSource> TakeWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1474                 {
1475                         Check.SourceAndPredicate (source, predicate);
1476
1477                         return source.Provider.CreateQuery<TSource> (
1478                                 StaticCall (
1479                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1480                                         source.Expression,
1481                                         Expression.Quote (predicate)));
1482                 }
1483
1484                 public static IQueryable<TSource> TakeWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
1485                 {
1486                         Check.SourceAndPredicate (source, predicate);
1487
1488                         return source.Provider.CreateQuery<TSource> (
1489                                 StaticCall (
1490                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1491                                         source.Expression,
1492                                         Expression.Quote (predicate)));
1493                 }
1494
1495                 #endregion
1496
1497                 #region ThenBy
1498
1499                 public static IOrderedQueryable<TSource> ThenBy<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
1500                 {
1501                         Check.SourceAndKeySelector (source, keySelector);
1502
1503                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1504                                 StaticCall (
1505                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1506                                         source.Expression,
1507                                         Expression.Quote (keySelector)));
1508                 }
1509
1510                 public static IOrderedQueryable<TSource> ThenBy<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
1511                 {
1512                         Check.SourceAndKeySelector (source, keySelector);
1513
1514                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1515                                 StaticCall (
1516                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1517                                         source.Expression,
1518                                         Expression.Quote (keySelector),
1519                                         Expression.Constant (comparer, typeof (IComparer<TKey>))));
1520                 }
1521
1522                 #endregion
1523
1524                 #region ThenByDescending
1525
1526                 public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
1527                 {
1528                         Check.SourceAndKeySelector (source, keySelector);
1529
1530                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1531                                 StaticCall (
1532                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1533                                         source.Expression,
1534                                         Expression.Quote (keySelector)));
1535                 }
1536
1537                 public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
1538                 {
1539                         Check.SourceAndKeySelector (source, keySelector);
1540
1541                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1542                                 StaticCall (
1543                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1544                                         source.Expression,
1545                                         Expression.Quote (keySelector),
1546                                         Expression.Constant (comparer, typeof (IComparer<TKey>))));
1547                 }
1548
1549                 #endregion
1550
1551                 #region Union
1552
1553                 public static IQueryable<TSource> Union<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
1554                 {
1555                         Check.Source1AndSource2 (source1, source2);
1556
1557                         return source1.Provider.CreateQuery<TSource> (
1558                                 StaticCall (
1559                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1560                                         source1.Expression,
1561                                         Expression.Constant (source2, typeof (IEnumerable<TSource>))));
1562                 }
1563
1564                 public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
1565                 {
1566                         Check.Source1AndSource2 (source1, source2);
1567
1568                         return source1.Provider.CreateQuery<TSource> (
1569                                 StaticCall (
1570                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1571                                         source1.Expression,
1572                                         Expression.Constant (source2, typeof (IEnumerable<TSource>)),
1573                                         Expression.Constant (comparer, typeof (IEqualityComparer<TSource>))));
1574                 }
1575
1576
1577                 #endregion
1578
1579                 #region Where
1580
1581                 public static IQueryable<TSource> Where<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1582                 {
1583                         Check.SourceAndPredicate (source, predicate);
1584
1585                         return source.Provider.CreateQuery<TSource> (
1586                                 StaticCall (
1587                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1588                                         source.Expression,
1589                                         Expression.Quote (predicate)));
1590                 }
1591
1592                 public static IQueryable<TSource> Where<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
1593                 {
1594                         Check.SourceAndPredicate (source, predicate);
1595
1596                         return source.Provider.CreateQuery<TSource> (
1597                                 StaticCall (
1598                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1599                                         source.Expression,
1600                                         Expression.Quote (predicate)));
1601                 }
1602
1603
1604                 #endregion
1605
1606 #if NET_4_0 || MOBILE
1607                 #region Zip
1608
1609                 public static IQueryable<TResult> Zip<TFirst, TSecond, TResult> (this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, Expression<Func<TFirst, TSecond, TResult>> resultSelector)
1610                 {
1611                         Check.Source1AndSource2 (source1, source2);
1612                         if (resultSelector == null)
1613                                 throw new ArgumentNullException ("resultSelector");
1614
1615                         return source1.Provider.CreateQuery<TResult> (
1616                                 StaticCall (
1617                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TFirst), typeof (TSecond), typeof (TResult)),
1618                                         source1.Expression,
1619                                         Expression.Quote (resultSelector)));
1620                 }
1621
1622                 #endregion
1623 #endif
1624         }
1625 }