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

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