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                 [MonoTODO]
 141                 public static IQueryable<TElement> AsQueryable<TElement> (this IEnumerable<TElement> source)
 142                 {
 143                         var queryable = source as IQueryable<TElement>;
 144                         if (queryable != null)
 145                                 return queryable;
 146
 147                         return new QueryableEnumerable<TElement> (new ConstantExpression (source, typeof (IQueryable<TElement>)));
 148                 }
 149
 150                 [MonoTODO]
 151                 public static IQueryable AsQueryable (this IEnumerable source)
 152                 {
 153                         var queryable = source as IQueryable;
 154                         if (queryable != null)
 155                                 return queryable;
 156
 157                         throw new NotImplementedException ();
 158                 }
 159
 160                 #endregion
 161
 162                 #region Average
 163
 164                 public static double Average (this IQueryable<int> source)
 165                 {
 166                         Check.Source (source);
 167
 168                         return source.Provider.Execute<double>(
 169                                 StaticCall (
 170                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 171                                         source.Expression));
 172                 }
 173
 174                 public static double? Average(this IQueryable<int?> source)
 175                 {
 176                         Check.Source (source);
 177
 178                         return source.Provider.Execute<double?>(
 179                                 StaticCall (
 180                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 181                                         source.Expression));
 182                 }
 183
 184                 public static double Average(this IQueryable<long> source)
 185                 {
 186                         Check.Source (source);
 187
 188                         return source.Provider.Execute<double>(
 189                                 StaticCall (
 190                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 191                                         source.Expression));
 192                 }
 193
 194                 public static double? Average(this IQueryable<long?> source)
 195                 {
 196                         Check.Source (source);
 197
 198                         return source.Provider.Execute<double?>(
 199                                 StaticCall (
 200                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 201                                         source.Expression));
 202                 }
 203
 204                 public static float Average(this IQueryable<float> source)
 205                 {
 206                         Check.Source (source);
 207
 208                         return source.Provider.Execute<float>(
 209                                 StaticCall (
 210                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 211                                         source.Expression));
 212                 }
 213
 214                 public static float? Average(this IQueryable<float?> source)
 215                 {
 216                         Check.Source (source);
 217
 218                         return source.Provider.Execute<float?>(
 219                                 StaticCall (
 220                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 221                                         source.Expression));
 222                 }
 223
 224                 public static double Average (this IQueryable<double> source)
 225                 {
 226                         Check.Source (source);
 227
 228                         return source.Provider.Execute<double> (
 229                                 StaticCall (
 230                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 231                                         source.Expression));
 232                 }
 233
 234                 public static double? Average (this IQueryable<double?> source)
 235                 {
 236                         Check.Source (source);
 237
 238                         return source.Provider.Execute<double?> (
 239                                 StaticCall (
 240                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 241                                         source.Expression));
 242                 }
 243
 244                 public static decimal Average(this IQueryable<decimal> source)
 245                 {
 246                         Check.Source (source);
 247
 248                         return source.Provider.Execute<decimal>(
 249                                 StaticCall (
 250                                 (MethodInfo) MethodBase.GetCurrentMethod (),
 251                                         source.Expression));
 252                 }
 253
 254                 public static decimal? Average(this IQueryable<decimal?> source)
 255                 {
 256                         Check.Source (source);
 257
 258                         return source.Provider.Execute<decimal?>(
 259                                 StaticCall (
 260                                         (MethodInfo) MethodBase.GetCurrentMethod (),
 261                                         source.Expression));
 262                 }
 263
 264                 public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
 265                 {
 266                         Check.SourceAndSelector (source, selector);
 267
 268                         return source.Provider.Execute<double>(
 269                                 StaticCall (
 270                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 271                                         source.Expression,
 272                                         Expression.Quote (selector)));
 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, long>> 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 float Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
 309                 {
 310                         Check.SourceAndSelector (source, selector);
 311
 312                         return source.Provider.Execute<float>(
 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 double Average<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
 331                 {
 332                         Check.SourceAndSelector (source, selector);
 333
 334                         return source.Provider.Execute<double> (
 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 decimal Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
 353                 {
 354                         Check.SourceAndSelector (source, selector);
 355
 356                         return source.Provider.Execute<decimal>(
 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                 #endregion
 375
 376                 #region Cast
 377
 378                 public static IQueryable<TResult> Cast<TResult> (this IQueryable source)
 379                 {
 380                         Check.Source (source);
 381
 382                         return (IQueryable<TResult>) source.Provider.CreateQuery (
 383                                 StaticCall (MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TResult)),
 384                                         source.Expression));
 385                 }
 386
 387                 #endregion
 388
 389                 #region Concat
 390
 391                 public static IQueryable<TSource> Concat<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 392                 {
 393                         Check.Source1AndSource2 (source1, source2);
 394
 395                         return source1.Provider.CreateQuery<TSource> (
 396                                 StaticCall (
 397                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 398                                         source1.Expression,
 399                                         Expression.Constant (source2)));
 400                 }
 401
 402                 #endregion
 403
 404                 #region Contains
 405
 406                 public static bool Contains<TSource> (this IQueryable<TSource> source, TSource item)
 407                 {
 408                         Check.Source (source);
 409
 410                         return source.Provider.Execute<bool> (
 411                                 StaticCall (
 412                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 413                                         source.Expression,
 414                                         Expression.Constant (item)));
 415                 }
 416
 417                 public static bool Contains<TSource> (this IQueryable<TSource> source, TSource item, IEqualityComparer<TSource> comparer)
 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                                         Expression.Constant (comparer)));
 427                 }
 428
 429                 #endregion
 430
 431                 #region Count
 432
 433                 public static int Count<TSource> (this IQueryable<TSource> source)
 434                 {
 435                         Check.Source (source);
 436
 437                         return source.Execute<int, TSource> (MethodBase.GetCurrentMethod ());
 438                 }
 439
 440                 public static int Count<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 441                 {
 442                         Check.SourceAndPredicate (source, predicate);
 443
 444                         return source.Provider.Execute<int> (
 445                                 StaticCall (
 446                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 447                                         source.Expression,
 448                                         Expression.Quote (predicate)));
 449                 }
 450
 451                 #endregion
 452
 453                 #region DefaultIfEmpty
 454
 455                 public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source)
 456                 {
 457                         Check.Source (source);
 458
 459                         return source.Provider.CreateQuery<TSource> (
 460                                 StaticCall (
 461                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 462                                         source.Expression));
 463                 }
 464
 465                 public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source, TSource defaultValue)
 466                 {
 467                         Check.Source (source);
 468
 469                         return source.Provider.CreateQuery<TSource> (
 470                                 StaticCall (
 471                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 472                                         source.Expression,
 473                                         Expression.Constant (defaultValue)));
 474                 }
 475
 476                 #endregion
 477
 478                 #region Distinct
 479
 480                 public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source)
 481                 {
 482                         Check.Source (source);
 483
 484                         return source.Provider.CreateQuery<TSource> (
 485                                 StaticCall (
 486                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 487                                         source.Expression));
 488                 }
 489
 490                 public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source, IEqualityComparer<TSource> comparer)
 491                 {
 492                         Check.Source (source);
 493
 494                         return source.Provider.CreateQuery<TSource> (
 495                                 StaticCall (
 496                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 497                                         source.Expression,
 498                                         Expression.Constant (comparer)));
 499                 }
 500
 501                 #endregion
 502
 503                 #region ElementAt
 504
 505                 public static TSource ElementAt<TSource> (this IQueryable<TSource> source, int index)
 506                 {
 507                         Check.Source (source);
 508
 509                         return source.Provider.Execute<TSource> (
 510                                 StaticCall (
 511                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 512                                         source.Expression,
 513                                         Expression.Constant (index)));
 514                 }
 515
 516                 #endregion
 517
 518                 #region ElementAtOrDefault
 519
 520                 public static TSource ElementAtOrDefault<TSource> (this IQueryable<TSource> source, int index)
 521                 {
 522                         Check.Source (source);
 523
 524                         return source.Provider.Execute<TSource> (
 525                                 StaticCall (
 526                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 527                                         source.Expression,
 528                                         Expression.Constant (index)));
 529                 }
 530
 531                 #endregion
 532
 533                 #region Except
 534
 535                 public static IQueryable<TSource> Except<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 536                 {
 537                         Check.Source1AndSource2 (source1, source2);
 538
 539                         return source1.Provider.CreateQuery<TSource> (
 540                                 StaticCall (
 541                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 542                                         source1.Expression,
 543                                         Expression.Constant (source2)));
 544                 }
 545
 546                 public static IQueryable<TSource> Except<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
 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                                         Expression.Constant (comparer)));
 556                 }
 557
 558                 #endregion
 559
 560                 #region First
 561
 562                 public static TSource First<TSource> (this IQueryable<TSource> source)
 563                 {
 564                         Check.Source (source);
 565
 566                         return source.Provider.Execute<TSource> (
 567                                 StaticCall (
 568                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 569                                         source.Expression));
 570                 }
 571
 572                 public static TSource First<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 573                 {
 574                         Check.SourceAndPredicate (source, predicate);
 575
 576                         return source.Provider.Execute<TSource> (
 577                                 StaticCall (
 578                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 579                                         source.Expression,
 580                                         Expression.Quote (predicate)));
 581                 }
 582
 583                 #endregion
 584
 585                 #region FirstOrDefault
 586
 587                 public static TSource FirstOrDefault<TSource> (this IQueryable<TSource> source)
 588                 {
 589                         Check.Source (source);
 590
 591                         return source.Provider.Execute<TSource> (
 592                                 StaticCall (
 593                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 594                                         source.Expression));
 595                 }
 596
 597                 public static TSource FirstOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 598                 {
 599                         Check.SourceAndPredicate (source, predicate);
 600
 601                         return source.Provider.Execute<TSource> (
 602                                 StaticCall (
 603                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 604                                         source.Expression,
 605                                         Expression.Quote (predicate)));
 606                 }
 607
 608                 #endregion
 609
 610                 #region GroupBy
 611
 612                 public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 613                 {
 614                         Check.SourceAndKeySelector (source, keySelector);
 615
 616                         return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
 617                                 StaticCall (
 618                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 619                                         source.Expression,
 620                                         Expression.Quote (keySelector)));
 621                 }
 622                 public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey> comparer)
 623                 {
 624                         Check.SourceAndKeySelector (source, keySelector);
 625
 626                         return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
 627                                 StaticCall (
 628                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 629                                         source.Expression,
 630                                         Expression.Quote (keySelector),
 631                                         Expression.Constant (comparer)));
 632                 }
 633                 public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector)
 634                 {
 635                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 636
 637                         return source.Provider.CreateQuery<IGrouping<TKey, TElement>>(
 638                                 StaticCall (
 639                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
 640                                         source.Expression,
 641                                         Expression.Quote (keySelector),
 642                                         Expression.Quote (elementSelector)));
 643                 }
 644                 public static IQueryable<TResult> GroupBy<TSource, TKey, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector)
 645                 {
 646                         Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
 647
 648                         return source.Provider.CreateQuery<TResult> (
 649                                 StaticCall (
 650                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
 651                                         source.Expression,
 652                                         Expression.Quote (keySelector),
 653                                         Expression.Quote (resultSelector)));
 654                 }
 655                 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)
 656                 {
 657                         Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 658
 659                         return source.Provider.CreateQuery<IGrouping<TKey, TElement>> (
 660                                 StaticCall (
 661                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
 662                                         source.Expression,
 663                                         Expression.Quote (keySelector),
 664                                         Expression.Quote (elementSelector),
 665                                         Expression.Constant (comparer)));
 666                 }
 667                 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)
 668                 {
 669                         Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
 670
 671                         return source.Provider.CreateQuery<TResult> (
 672                                 StaticCall (
 673                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
 674                                         source.Expression,
 675                                         Expression.Quote (keySelector),
 676                                         Expression.Quote (elementSelector),
 677                                         Expression.Quote (resultSelector)));
 678                 }
 679
 680                 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)
 681                 {
 682                         Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
 683
 684                         return source.Provider.CreateQuery<TResult> (
 685                                 StaticCall (
 686                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
 687                                         source.Expression,
 688                                         Expression.Quote (keySelector),
 689                                         Expression.Quote (resultSelector),
 690                                         Expression.Constant (comparer)));
 691                 }
 692                 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)
 693                 {
 694                         Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
 695
 696                         return source.Provider.CreateQuery<TResult> (
 697                                 StaticCall (
 698                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
 699                                         source.Expression,
 700                                         Expression.Quote (keySelector),
 701                                         Expression.Quote (elementSelector),
 702                                         Expression.Quote (resultSelector),
 703                                         Expression.Constant (comparer)));
 704                 }
 705                 #endregion
 706
 707                 #region GroupJoin
 708
 709                 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)
 710                 {
 711                         if (outer == null)
 712                                 throw new ArgumentNullException ("outer");
 713                         if (inner == null)
 714                                 throw new ArgumentNullException ("inner");
 715                         if (outerKeySelector == null)
 716                                 throw new ArgumentNullException ("outerKeySelector");
 717                         if (innerKeySelector == null)
 718                                 throw new ArgumentNullException ("innerKeySelector");
 719                         if (resultSelector == null)
 720                                 throw new ArgumentNullException ("resultSelector");
 721
 722                         return outer.Provider.CreateQuery<TResult> (
 723                                 StaticCall (
 724                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 725                                         outer.Expression,
 726                                         Expression.Constant (inner),
 727                                         Expression.Quote (outerKeySelector),
 728                                         Expression.Quote (innerKeySelector),
 729                                         Expression.Quote (resultSelector)));
 730                 }
 731
 732                 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)
 733                 {
 734                         if (outer == null)
 735                                 throw new ArgumentNullException ("outer");
 736                         if (inner == null)
 737                                 throw new ArgumentNullException ("inner");
 738                         if (outerKeySelector == null)
 739                                 throw new ArgumentNullException ("outerKeySelector");
 740                         if (innerKeySelector == null)
 741                                 throw new ArgumentNullException ("innerKeySelector");
 742                         if (resultSelector == null)
 743                                 throw new ArgumentNullException ("resultSelector");
 744
 745                         return outer.Provider.CreateQuery<TResult> (
 746                                 StaticCall (
 747                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 748                                         outer.Expression,
 749                                         Expression.Constant (inner),
 750                                         Expression.Quote (outerKeySelector),
 751                                         Expression.Quote (innerKeySelector),
 752                                         Expression.Quote (resultSelector),
 753                                         Expression.Constant (comparer)));
 754                 }
 755
 756                 #endregion
 757
 758                 #region Intersect
 759
 760                 public static IQueryable<TSource> Intersect<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
 761                 {
 762                         Check.Source1AndSource2 (source1, source2);
 763
 764                         return source1.Provider.CreateQuery<TSource> (
 765                                 StaticCall (
 766                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 767                                         source1.Expression,
 768                                         Expression.Constant (source2)));
 769                 }
 770
 771                 public static IQueryable<TSource> Intersect<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
 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                                         Expression.Constant (comparer)));
 781                 }
 782
 783                 #endregion
 784
 785                 #region Join
 786
 787                 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)
 788                 {
 789                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 790
 791                         return outer.Provider.CreateQuery<TResult> (
 792                                 StaticCall (
 793                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 794                                         outer.Expression,
 795                                         Expression.Constant (inner),
 796                                         Expression.Quote (outerKeySelector),
 797                                         Expression.Quote (innerKeySelector),
 798                                         Expression.Quote (resultSelector)));
 799                 }
 800
 801                 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)
 802                 {
 803                         Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
 804
 805                         return outer.Provider.CreateQuery<TResult> (
 806                                 StaticCall (
 807                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
 808                                         outer.Expression,
 809                                         Expression.Constant (inner),
 810                                         Expression.Quote (outerKeySelector),
 811                                         Expression.Quote (innerKeySelector),
 812                                         Expression.Quote (resultSelector),
 813                                         Expression.Constant (comparer)));
 814                 }
 815
 816
 817                 #endregion
 818
 819                 #region Last
 820
 821                 public static TSource Last<TSource> (this IQueryable<TSource> source)
 822                 {
 823                         Check.Source (source);
 824
 825                         return source.Provider.Execute<TSource> (
 826                                 StaticCall (
 827                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 828                                         source.Expression));
 829                 }
 830
 831                 public static TSource Last<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 832                 {
 833                         Check.SourceAndPredicate (source, predicate);
 834
 835                         return source.Provider.Execute<TSource> (
 836                                 StaticCall (
 837                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 838                                         source.Expression,
 839                                         Expression.Quote (predicate)));
 840                 }
 841
 842                 #endregion
 843
 844                 #region LastOrDefault
 845
 846                 public static TSource LastOrDefault<TSource> (this IQueryable<TSource> source)
 847                 {
 848                         Check.Source (source);
 849
 850                         return source.Provider.Execute<TSource> (
 851                                 StaticCall (
 852                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 853                                         source.Expression));
 854                 }
 855
 856                 public static TSource LastOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 857                 {
 858                         Check.SourceAndPredicate (source, predicate);
 859
 860                         return source.Provider.Execute<TSource> (
 861                                 StaticCall (
 862                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 863                                         source.Expression,
 864                                         Expression.Quote (predicate)));
 865                 }
 866
 867                 #endregion
 868
 869                 #region LongCount
 870
 871                 public static long LongCount<TSource> (this IQueryable<TSource> source)
 872                 {
 873                         Check.Source (source);
 874
 875                         return source.Execute<long, TSource> (MethodBase.GetCurrentMethod ());
 876                 }
 877
 878                 public static long LongCount<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
 879                 {
 880                         Check.SourceAndPredicate (source, predicate);
 881
 882                         return source.Provider.Execute<long> (
 883                                 StaticCall (
 884                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 885                                         source.Expression,
 886                                         Expression.Quote (predicate)));
 887                 }
 888
 889                 #endregion
 890
 891                 #region Max
 892
 893                 public static TSource Max<TSource> (this IQueryable<TSource> source)
 894                 {
 895                         Check.Source (source);
 896
 897                         return source.Provider.Execute<TSource> (
 898                                 StaticCall (
 899                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 900                                         source.Expression));
 901                 }
 902
 903                 public static TResult Max<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
 904                 {
 905                         Check.Source (source);
 906
 907                         return source.Provider.Execute<TResult> (
 908                                 StaticCall (
 909                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
 910                                         source.Expression,
 911                                         Expression.Quote (selector)));
 912                 }
 913
 914
 915                 #endregion
 916
 917                 #region Min
 918
 919                 public static TSource Min<TSource> (this IQueryable<TSource> source)
 920                 {
 921                         Check.Source (source);
 922
 923                         return source.Provider.Execute<TSource> (
 924                                 StaticCall (
 925                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
 926                                         source.Expression));
 927                 }
 928
 929                 public static TResult Min<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
 930                 {
 931                         Check.SourceAndSelector (source, selector);
 932
 933                         return source.Provider.Execute<TResult> (
 934                                 StaticCall (
 935                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
 936                                         source.Expression,
 937                                         Expression.Quote (selector)));
 938                 }
 939
 940
 941                 #endregion
 942
 943                 #region OfType
 944
 945                 public static IQueryable<TResult> OfType<TResult> (this IQueryable source)
 946                 {
 947                         Check.Source (source);
 948
 949                         return (IQueryable<TResult>) source.Provider.CreateQuery (
 950                         StaticCall (
 951                                 MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TResult)),
 952                                 source.Expression));
 953                 }
 954
 955                 #endregion
 956
 957                 #region OrderBy
 958
 959                 public static IOrderedQueryable<TSource> OrderBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 960                 {
 961                         Check.SourceAndKeySelector (source, keySelector);
 962
 963                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
 964                                 StaticCall (
 965                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 966                                         source.Expression,
 967                                         Expression.Quote (keySelector)));
 968                 }
 969
 970                 public static IOrderedQueryable<TSource> OrderBy<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
 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                                         Expression.Constant (comparer)));
 980                 }
 981
 982                 #endregion
 983
 984                 #region OrderByDescending
 985
 986                 public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
 987                 {
 988                         Check.SourceAndKeySelector (source, keySelector);
 989
 990                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery<TSource> (
 991                                 StaticCall (
 992                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
 993                                         source.Expression,
 994                                         Expression.Quote (keySelector)));
 995                 }
 996
 997                 public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey> (this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
 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                                         Expression.Constant (comparer)));
1007                 }
1008
1009                 #endregion
1010
1011                 #region Reverse
1012
1013                 public static IQueryable<TSource> Reverse<TSource> (this IQueryable<TSource> source)
1014                 {
1015                         Check.Source (source);
1016
1017                         return source.Provider.CreateQuery<TSource> (
1018                                 StaticCall (
1019                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1020                                         source.Expression));
1021                 }
1022
1023                 #endregion
1024
1025                 #region Select
1026
1027                 public static IQueryable<TResult> Select<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector)
1028                 {
1029                         Check.SourceAndSelector (source, selector);
1030
1031                         return source.Provider.CreateQuery<TResult> (
1032                                 StaticCall (
1033                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1034                                         source.Expression,
1035                                         Expression.Quote (selector)));
1036                 }
1037
1038                 public static IQueryable<TResult> Select<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, 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                 #endregion
1050
1051                 #region SelectMany
1052
1053                 public static IQueryable<TResult> SelectMany<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector)
1054                 {
1055                         Check.SourceAndSelector (source, selector);
1056
1057                         return source.Provider.CreateQuery<TResult> (
1058                                 StaticCall (
1059                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
1060                                         source.Expression,
1061                                         Expression.Quote (selector)));
1062                 }
1063
1064                 public static IQueryable<TResult> SelectMany<TSource, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, 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, TCollection, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
1076                 {
1077                         Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
1078
1079                         return source.Provider.CreateQuery<TResult> (
1080                                 StaticCall (
1081                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
1082                                         source.Expression,
1083                                         Expression.Quote (collectionSelector),
1084                                         Expression.Quote (resultSelector)));
1085                 }
1086
1087                 public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult> (this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector)
1088                 {
1089                         Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
1090
1091                         return source.Provider.CreateQuery<TResult> (
1092                                 StaticCall (
1093                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
1094                                         source.Expression,
1095                                         Expression.Quote (collectionSelector),
1096                                         Expression.Quote (resultSelector)));
1097                 }
1098
1099                 #endregion
1100
1101                 #region SequenceEqual
1102
1103                 public static bool SequenceEqual<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
1104                 {
1105                         Check.Source1AndSource2 (source1, source2);
1106
1107                         return source1.Provider.Execute<bool> (
1108                                 StaticCall (
1109                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1110                                         source1.Expression,
1111                                         Expression.Constant (source2)));
1112                 }
1113
1114                 public static bool SequenceEqual<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
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                                         Expression.Constant (comparer)));
1124                 }
1125
1126                 #endregion
1127
1128                 #region Single
1129
1130                 public static TSource Single<TSource> (this IQueryable<TSource> source)
1131                 {
1132                         Check.Source (source);
1133
1134                         return source.Provider.Execute<TSource> (
1135                                 StaticCall (
1136                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1137                                         source.Expression));
1138                 }
1139
1140                 public static TSource Single<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1141                 {
1142                         Check.SourceAndPredicate (source, predicate);
1143
1144                         return source.Provider.Execute<TSource> (
1145                                 StaticCall (
1146                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1147                                         source.Expression,
1148                                         Expression.Quote (predicate)));
1149                 }
1150
1151                 #endregion
1152
1153                 #region SingleOrDefault
1154
1155                 public static TSource SingleOrDefault<TSource> (this IQueryable<TSource> source)
1156                 {
1157                         Check.Source (source);
1158
1159                         return source.Provider.Execute<TSource> (
1160                                 StaticCall (
1161                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1162                                         source.Expression));
1163                 }
1164
1165                 public static TSource SingleOrDefault<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1166                 {
1167                         Check.SourceAndPredicate (source, predicate);
1168
1169                         return source.Provider.Execute<TSource> (
1170                                 StaticCall (
1171                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1172                                         source.Expression,
1173                                         Expression.Quote (predicate)));
1174                 }
1175
1176                 #endregion
1177
1178                 #region Skip
1179
1180                 public static IQueryable<TSource> Skip<TSource> (this IQueryable<TSource> source, int count)
1181                 {
1182                         Check.Source (source);
1183
1184                         return source.Provider.CreateQuery<TSource> (
1185                                 StaticCall (
1186                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1187                                         source.Expression,
1188                                         Expression.Constant (count)));
1189                 }
1190
1191                 #endregion
1192
1193                 #region SkipWhile
1194
1195                 public static IQueryable<TSource> SkipWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1196                 {
1197                         Check.SourceAndPredicate (source, predicate);
1198
1199                         return source.Provider.CreateQuery<TSource> (
1200                                 StaticCall (
1201                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1202                                         source.Expression,
1203                                         Expression.Quote (predicate)));
1204                 }
1205
1206                 public static IQueryable<TSource> SkipWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, 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
1218                 #endregion
1219
1220                 #region Sum
1221
1222
1223                 public static int Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int>> selector)
1224                 {
1225                         Check.SourceAndSelector (source, selector);
1226
1227                         return source.Provider.Execute<int> (
1228                                 StaticCall (
1229                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1230                                         source.Expression,
1231                                         Expression.Quote (selector)));
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 long Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, long>> selector)
1246                 {
1247                         Check.SourceAndSelector (source, selector);
1248
1249                         return source.Provider.Execute<long> (
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 float Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, float>> selector)
1268                 {
1269                         Check.SourceAndSelector (source, selector);
1270
1271                         return source.Provider.Execute<float> (
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 double Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, double>> selector)
1290                 {
1291                         Check.SourceAndSelector (source, selector);
1292
1293                         return source.Provider.Execute<double> (
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 decimal Sum<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
1312                 {
1313                         Check.SourceAndSelector (source, selector);
1314
1315                         return source.Provider.Execute<decimal> (
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 int Sum (this IQueryable<int> source)
1334                 {
1335                         Check.Source (source);
1336
1337                         return source.Provider.Execute<int> (
1338                                 StaticCall (
1339                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1340                                         source.Expression));
1341                 }
1342
1343                 public static int? Sum (this IQueryable<int?> source)
1344                 {
1345                         Check.Source (source);
1346
1347                         return source.Provider.Execute<int?> (
1348                                 StaticCall (
1349                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1350                                         source.Expression));
1351                 }
1352
1353
1354
1355                 public static long Sum (this IQueryable<long> source)
1356                 {
1357                         Check.Source (source);
1358
1359                         return source.Provider.Execute<long> (
1360                                 StaticCall (
1361                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1362                                         source.Expression));
1363                 }
1364
1365
1366
1367                 public static long? Sum (this IQueryable<long?> source)
1368                 {
1369                         Check.Source (source);
1370
1371                         return source.Provider.Execute<long?> (
1372                                 StaticCall (
1373                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1374                                         source.Expression));
1375                 }
1376
1377                 public static float Sum (this IQueryable<float> source)
1378                 {
1379                         Check.Source (source);
1380
1381                         return source.Provider.Execute<float> (
1382                                 StaticCall (
1383                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1384                                         source.Expression));
1385                 }
1386
1387                 public static float? Sum (this IQueryable<float?> source)
1388                 {
1389                         Check.Source (source);
1390
1391                         return source.Provider.Execute<float?> (
1392                                 StaticCall (
1393                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1394                                         source.Expression));
1395                 }
1396
1397
1398                 public static double Sum (this IQueryable<double> source)
1399                 {
1400                         Check.Source (source);
1401
1402                         return source.Provider.Execute<double> (
1403                                 StaticCall (
1404                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1405                                         source.Expression));
1406                 }
1407
1408
1409
1410                 public static double? Sum (this IQueryable<double?> source)
1411                 {
1412                         Check.Source (source);
1413
1414                         return source.Provider.Execute<double?> (
1415                                 StaticCall (
1416                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1417                                         source.Expression));
1418                 }
1419
1420
1421                 public static decimal Sum (this IQueryable<decimal> source)
1422                 {
1423                         Check.Source (source);
1424
1425                         return source.Provider.Execute<decimal> (
1426                                 StaticCall (
1427                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1428                                         source.Expression));
1429                 }
1430
1431
1432
1433                 public static decimal? Sum (this IQueryable<decimal?> source)
1434                 {
1435                         Check.Source (source);
1436
1437                         return source.Provider.Execute<decimal?> (
1438                                 StaticCall (
1439                                         (MethodInfo) MethodBase.GetCurrentMethod (),
1440                                         source.Expression));
1441                 }
1442
1443
1444
1445                 #endregion
1446
1447                 #region Take
1448
1449                 public static IQueryable<TSource> Take<TSource> (this IQueryable<TSource> source, int count)
1450                 {
1451                         Check.Source (source);
1452
1453                         return source.Provider.CreateQuery<TSource> (
1454                                 StaticCall (
1455                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1456                                         source.Expression,
1457                                         Expression.Constant (count)));
1458                 }
1459
1460                 #endregion
1461
1462                 #region TakeWhile
1463
1464                 public static IQueryable<TSource> TakeWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1465                 {
1466                         Check.SourceAndPredicate (source, predicate);
1467
1468                         return source.Provider.CreateQuery<TSource> (
1469                                 StaticCall (
1470                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1471                                         source.Expression,
1472                                         Expression.Quote (predicate)));
1473                 }
1474
1475                 public static IQueryable<TSource> TakeWhile<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, 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                 #endregion
1487
1488                 #region ThenBy
1489
1490                 public static IOrderedQueryable<TSource> ThenBy<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
1491                 {
1492                         Check.SourceAndKeySelector (source, keySelector);
1493
1494                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1495                                 StaticCall (
1496                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1497                                         source.Expression,
1498                                         Expression.Quote (keySelector)));
1499                 }
1500
1501                 public static IOrderedQueryable<TSource> ThenBy<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
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                                         Expression.Constant (comparer)));
1511                 }
1512
1513                 #endregion
1514
1515                 #region ThenByDescending
1516
1517                 public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
1518                 {
1519                         Check.SourceAndKeySelector (source, keySelector);
1520
1521                         return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
1522                                 StaticCall (
1523                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
1524                                         source.Expression,
1525                                         Expression.Quote (keySelector)));
1526                 }
1527
1528                 public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey> (this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey> comparer)
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                                         Expression.Constant (comparer)));
1538                 }
1539
1540                 #endregion
1541
1542                 #region Union
1543
1544                 public static IQueryable<TSource> Union<TSource> (this IQueryable<TSource> source1, IEnumerable<TSource> source2)
1545                 {
1546                         Check.Source1AndSource2 (source1, source2);
1547
1548                         return source1.Provider.CreateQuery<TSource> (
1549                                 StaticCall (
1550                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1551                                         source1.Expression,
1552                                         Expression.Constant (source2)));
1553                 }
1554
1555                 public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource> comparer)
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                                         Expression.Constant (comparer)));
1565                 }
1566
1567
1568                 #endregion
1569
1570                 #region Where
1571
1572                 public static IQueryable<TSource> Where<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
1573                 {
1574                         Check.SourceAndPredicate (source, predicate);
1575
1576                         return source.Provider.CreateQuery<TSource> (
1577                                 StaticCall (
1578                                         MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
1579                                         source.Expression,
1580                                         Expression.Quote (predicate)));
1581                 }
1582
1583                 public static IQueryable<TSource> Where<TSource> (this IQueryable<TSource> source, Expression<Func<TSource, int, 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
1595                 #endregion
1596
1597         }
1598 }