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