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