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

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