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