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

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 //
  19 // Authors:
  20 //      Alejandro Serrano "Serras" (trupill@yahoo.es)
  21 //      Marek Safar (marek.safar@gmail.com)
  22 //
  23
  24 using System;
  25 using System.Collections.Generic;
  26 using System.Linq.Expressions;
  27
  28 namespace System.Linq
  29 {
  30         public static class Queryable
  31         {
  32                 #region Count
  33
  34                 public static int Count<TSource> (this IQueryable<TSource> source)
  35                 {
  36                         if (source == null)
  37                                 throw new ArgumentNullException ();
  38
  39                         if (source is ICollection<TSource>)
  40                                 return ((ICollection<TSource>)source).Count;
  41
  42                         int counter = 0;
  43                         foreach (TSource element in source)
  44                                 counter++;
  45                         return counter;
  46                 }
  47
  48                 public static int Count<TSource> (
  49                         this IQueryable<TSource> source,
  50                         Func<TSource, bool> selector)
  51                 {
  52                         if (source == null || selector == null)
  53                                 throw new ArgumentNullException ();
  54
  55                         int counter = 0;
  56                         foreach (TSource element in source)
  57                                 if (selector(element))
  58                                         counter++;
  59
  60                         return counter;
  61                 }
  62
  63                 #endregion
  64
  65                 #region LongCount
  66
  67                 public static long LongCount<TSource> (this IQueryable<TSource> source)
  68                 {
  69                         if (source == null)
  70                                 throw new ArgumentNullException ();
  71
  72                         long counter = 0;
  73                         foreach (TSource element in source)
  74                                 counter++;
  75                         return counter;
  76                 }
  77
  78                 public static long LongCount<TSource> (
  79                         this IQueryable<TSource> source,
  80                         Func<TSource, bool> selector)
  81                 {
  82                         if (source == null || selector == null)
  83                                 throw new ArgumentNullException ();
  84
  85                         long counter = 0;
  86                         foreach (TSource element in source)
  87                                 if (selector(element))
  88                                         counter++;
  89
  90                         return counter;
  91                 }
  92
  93                 #endregion
  94
  95                 #region Sum
  96
  97                 public static int Sum (this IQueryable<int> source)
  98                 {
  99                         if (source == null)
 100                                 throw new ArgumentNullException ();
 101
 102                         int sum = 0;
 103                         foreach (int element in source)
 104                                 sum += element;
 105
 106                         return sum;
 107                 }
 108
 109                 public static int Sum<TSource> (
 110                         this IQueryable<TSource> source,
 111                         Func<TSource, int> selector)
 112                 {
 113                         if (source == null || selector == null)
 114                                 throw new ArgumentNullException ();
 115
 116                         int sum = 0;
 117                         foreach (TSource element in source)
 118                                 sum += selector (element);
 119
 120                         return sum;
 121                 }
 122
 123                 public static int? Sum (this IQueryable<int?> source)
 124                 {
 125                         if (source == null)
 126                                 throw new ArgumentNullException ();
 127
 128                         int? sum = 0;
 129                         foreach (int? element in source)
 130                                 if (element.HasValue)
 131                                         sum += element.Value;
 132
 133                         return sum;
 134                 }
 135
 136                 public static int? Sum<TSource> (
 137                         this IQueryable<TSource> source,
 138                         Func<TSource, int?> selector)
 139                 {
 140                         if (source == null || selector == null)
 141                                 throw new ArgumentNullException ();
 142
 143                         int? sum = 0;
 144                         foreach (TSource element in source) {
 145                                 int? item = selector (element);
 146                                 if (item.HasValue)
 147                                         sum += item.Value;
 148                         }
 149
 150                         return sum;
 151                 }
 152
 153                 public static long Sum (this IQueryable<long> source)
 154                 {
 155                         if (source == null)
 156                                 throw new ArgumentNullException ();
 157
 158                         long sum = 0;
 159                         foreach (long element in source)
 160                                 sum += element;
 161
 162                         return sum;
 163                 }
 164
 165                 public static long Sum<TSource> (
 166                         this IQueryable<TSource> source,
 167                         Func<TSource, long> selector)
 168                 {
 169                         if (source == null || selector == null)
 170                                 throw new ArgumentNullException ();
 171
 172                         long sum = 0;
 173                         foreach (TSource element in source)
 174                                 sum += selector (element);
 175
 176                         return sum;
 177                 }
 178
 179                 public static long? Sum (this IQueryable<long?> source)
 180                 {
 181                         if (source == null)
 182                                 throw new ArgumentNullException ();
 183
 184                         long? sum = 0;
 185                         foreach (long? element in source)
 186                                 if (element.HasValue)
 187                                         sum += element.Value;
 188
 189                         return sum;
 190                 }
 191
 192                 public static long? Sum<TSource> (
 193                         this IQueryable<TSource> source,
 194                         Func<TSource, long?> selector)
 195                 {
 196                         if (source == null || selector == null)
 197                                 throw new ArgumentNullException ();
 198
 199                         long? sum = 0;
 200                         foreach (TSource element in source) {
 201                                 long? item = selector (element);
 202                                 if (item.HasValue)
 203                                         sum += item.Value;
 204                         }
 205
 206                         return sum;
 207                 }
 208
 209                 public static double Sum (this IQueryable<double> source)
 210                 {
 211                         if (source == null)
 212                                 throw new ArgumentNullException ();
 213
 214                         double sum = 0;
 215                         foreach (double element in source)
 216                                 sum += element;
 217
 218                         return sum;
 219                 }
 220
 221                 public static double Sum<TSource> (
 222                         this IQueryable<TSource> source,
 223                         Func<TSource, double> selector)
 224                 {
 225                         if (source == null || selector == null)
 226                                 throw new ArgumentNullException ();
 227
 228                         double sum = 0;
 229                         foreach (TSource element in source)
 230                                 sum += selector (element);
 231
 232                         return sum;
 233                 }
 234
 235                 public static double? Sum (this IQueryable<double?> source)
 236                 {
 237                         if (source == null)
 238                                 throw new ArgumentNullException ();
 239
 240                         double? sum = 0;
 241                         foreach (double? element in source)
 242                                 if (element.HasValue)
 243                                         sum += element.Value;
 244
 245                         return sum;
 246                 }
 247
 248                 public static double? Sum<TSource> (
 249                         this IQueryable<TSource> source,
 250                         Func<TSource, double?> selector)
 251                 {
 252                         if (source == null || selector == null)
 253                                 throw new ArgumentNullException ();
 254
 255                         double? sum = 0;
 256                         foreach (TSource element in source) {
 257                                 double? item = selector (element);
 258                                 if (item.HasValue)
 259                                         sum += item.Value;
 260                         }
 261
 262                         return sum;
 263                 }
 264
 265                 public static decimal Sum (this IQueryable<decimal> source)
 266                 {
 267                         if (source == null)
 268                                 throw new ArgumentNullException ();
 269
 270                         decimal sum = 0;
 271                         foreach (decimal element in source)
 272                                 sum += element;
 273
 274                         return sum;
 275                 }
 276
 277                 public static decimal Sum<TSource> (
 278                         this IQueryable<TSource> source,
 279                         Func<TSource, decimal> selector)
 280                 {
 281                         if (source == null || selector == null)
 282                                 throw new ArgumentNullException ();
 283
 284                         decimal sum = 0;
 285                         foreach (TSource element in source)
 286                                 sum += selector (element);
 287
 288                         return sum;
 289                 }
 290
 291                 public static decimal? Sum (this IQueryable<decimal?> source)
 292                 {
 293                         if (source == null)
 294                                 throw new ArgumentNullException ();
 295
 296                         decimal? sum = 0;
 297                         foreach (decimal? element in source)
 298                                 if (element.HasValue)
 299                                         sum += element.Value;
 300
 301                         return sum;
 302                 }
 303
 304                 public static decimal? Sum<TSource> (
 305                         this IQueryable<TSource> source,
 306                         Func<TSource, decimal?> selector)
 307                 {
 308                         if (source == null || selector == null)
 309                                 throw new ArgumentNullException ();
 310
 311                         decimal? sum = 0;
 312                         foreach (TSource element in source) {
 313                                 decimal? item = selector (element);
 314                                 if (item.HasValue)
 315                                         sum += item.Value;
 316                         }
 317
 318                         return sum;
 319                 }
 320
 321                 #endregion
 322
 323                 #region Min
 324
 325                 public static int Min (this IQueryable<int> source)
 326                 {
 327                         if (source == null)
 328                                 throw new ArgumentNullException ();
 329
 330                         int minimum = int.MaxValue;
 331                         int counter = 0;
 332                         foreach (int element in source) {
 333                                 if (element < minimum)
 334                                         minimum = element;
 335                                 counter++;
 336                         }
 337
 338                         if (counter == 0)
 339                                 throw new InvalidOperationException ();
 340                         else
 341                                 return minimum;
 342                 }
 343
 344                 public static int? Min (this IQueryable<int?> source)
 345                 {
 346                         if (source == null)
 347                                 throw new ArgumentNullException ();
 348
 349                         bool onlyNull = true;
 350                         int? minimum = int.MaxValue;
 351                         foreach (int? element in source) {
 352                                 if (element.HasValue) {
 353                                         onlyNull = false;
 354                                         if (element < minimum)
 355                                                 minimum = element;
 356                                 }
 357                         }
 358                         return (onlyNull ? null : minimum);
 359                 }
 360
 361                 public static long Min (this IQueryable<long> source)
 362                 {
 363                         if (source == null)
 364                                 throw new ArgumentNullException ();
 365
 366                         long minimum = long.MaxValue;
 367                         int counter = 0;
 368                         foreach (long element in source) {
 369                                 if (element < minimum)
 370                                         minimum = element;
 371                                 counter++;
 372                         }
 373
 374                         if (counter == 0)
 375                                 throw new InvalidOperationException ();
 376                         else
 377                                 return minimum;
 378                 }
 379
 380                 public static long? Min (this IQueryable<long?> source)
 381                 {
 382                         if (source == null)
 383                                 throw new ArgumentNullException ();
 384
 385                         bool onlyNull = true;
 386                         long? minimum = long.MaxValue;
 387                         foreach (long? element in source) {
 388                                 if (element.HasValue) {
 389                                         onlyNull = false;
 390                                         if (element < minimum)
 391                                                 minimum = element;
 392                                 }
 393                         }
 394                         return (onlyNull ? null : minimum);
 395                 }
 396
 397                 public static double Min (this IQueryable<double> source)
 398                 {
 399                         if (source == null)
 400                                 throw new ArgumentNullException ();
 401
 402                         double minimum = double.MaxValue;
 403                         int counter = 0;
 404                         foreach (double element in source) {
 405                                 if (element < minimum)
 406                                         minimum = element;
 407                                 counter++;
 408                         }
 409
 410                         if (counter == 0)
 411                                 throw new InvalidOperationException ();
 412                         else
 413                                 return minimum;
 414                 }
 415
 416                 public static double? Min (this IQueryable<double?> source)
 417                 {
 418                         if (source == null)
 419                                 throw new ArgumentNullException ();
 420
 421                         bool onlyNull = true;
 422                         double? minimum = double.MaxValue;
 423                         foreach (double? element in source) {
 424                                 if (element.HasValue) {
 425                                         onlyNull = false;
 426                                         if (element < minimum)
 427                                                 minimum = element;
 428                                 }
 429                         }
 430                         return (onlyNull ? null : minimum);
 431                 }
 432
 433                 public static decimal Min (this IQueryable<decimal> source)
 434                 {
 435                         if (source == null)
 436                                 throw new ArgumentNullException ();
 437
 438                         decimal minimum = decimal.MaxValue;
 439                         int counter = 0;
 440                         foreach (decimal element in source) {
 441                                 if (element < minimum)
 442                                         minimum = element;
 443                                 counter++;
 444                         }
 445
 446                         if (counter == 0)
 447                                 throw new InvalidOperationException ();
 448                         else
 449                                 return minimum;
 450                 }
 451
 452                 public static decimal? Min (this IQueryable<decimal?> source)
 453                 {
 454                         if (source == null)
 455                                 throw new ArgumentNullException ();
 456
 457                         bool onlyNull = true;
 458                         decimal? minimum = decimal.MaxValue;
 459                         foreach (decimal? element in source) {
 460                                 if (element.HasValue) {
 461                                         onlyNull = false;
 462                                         if (element < minimum)
 463                                                 minimum = element;
 464                                 }
 465                         }
 466                         return (onlyNull ? null : minimum);
 467                 }
 468
 469                 public static TSource Min<TSource> (this IQueryable<TSource> source)
 470                 {
 471                         if (source == null)
 472                                 throw new ArgumentNullException ();
 473
 474                         bool notAssigned = true;
 475                         TSource minimum = default (TSource);
 476                         int counter = 0;
 477                         foreach (TSource element in source) {
 478                                 if (notAssigned) {
 479                                         minimum = element;
 480                                         notAssigned = false;
 481                                 }
 482                                 else {
 483                                         int comparison;
 484                                         if (element is IComparable<TSource>)
 485                                                 comparison = ((IComparable<TSource>)element).CompareTo (minimum);
 486                                         else if (element is System.IComparable)
 487                                                 comparison = ((System.IComparable)element).CompareTo (minimum);
 488                                         else
 489                                                 throw new ArgumentNullException();
 490
 491                                         if (comparison < 0)
 492                                                 minimum = element;
 493                                 }
 494                                 counter++;
 495                         }
 496
 497                         if (counter == 0)
 498                                 throw new InvalidOperationException ();
 499                         else
 500                                 return minimum;
 501                 }
 502
 503                 public static int Min<TSource> (
 504                         this IQueryable<TSource> source,
 505                         Func<TSource, int> selector)
 506                 {
 507                         if (source == null || selector == null)
 508                                 throw new ArgumentNullException ();
 509
 510                         int minimum = int.MaxValue;
 511                         int counter = 0;
 512                         foreach (TSource item in source) {
 513                                 int element = selector (item);
 514                                 if (element < minimum)
 515                                         minimum = element;
 516                                 counter++;
 517                         }
 518
 519                         if (counter == 0)
 520                                 throw new InvalidOperationException ();
 521                         else
 522                                 return minimum;
 523                 }
 524
 525                 public static int? Min<TSource> (
 526                         this IQueryable<TSource> source,
 527                         Func<TSource, int?> selector)
 528                 {
 529                         if (source == null || selector == null)
 530                                 throw new ArgumentNullException ();
 531
 532                         bool onlyNull = true;
 533                         int? minimum = int.MaxValue;
 534                         foreach (TSource item in source) {
 535                                 int? element = selector (item);
 536                                 if (element.HasValue) {
 537                                         onlyNull = false;
 538                                         if (element < minimum)
 539                                                 minimum = element;
 540                                 }
 541                         }
 542                         return (onlyNull ? null : minimum);
 543                 }
 544
 545                 public static long Min<TSource> (
 546                         this IQueryable<TSource> source,
 547                         Func<TSource, long> selector)
 548                 {
 549                         if (source == null || selector == null)
 550                                 throw new ArgumentNullException ();
 551
 552                         long minimum = long.MaxValue;
 553                         int counter = 0;
 554                         foreach (TSource item in source) {
 555                                 long element = selector (item);
 556                                 if (element < minimum)
 557                                         minimum = element;
 558                                 counter++;
 559                         }
 560
 561                         if (counter == 0)
 562                                 throw new InvalidOperationException ();
 563                         else
 564                                 return minimum;
 565                 }
 566
 567                 public static long? Min<TSource> (
 568                         this IQueryable<TSource> source,
 569                         Func<TSource, long?> selector)
 570                 {
 571                         if (source == null || selector == null)
 572                                 throw new ArgumentNullException ();
 573
 574                         bool onlyNull = true;
 575                         long? minimum = long.MaxValue;
 576                         foreach (TSource item in source) {
 577                                 long? element = selector (item);
 578                                 if (element.HasValue) {
 579                                         onlyNull = false;
 580                                         if (element < minimum)
 581                                                 minimum = element;
 582                                 }
 583                         }
 584                         return (onlyNull ? null : minimum);
 585                 }
 586
 587                 public static double Min<TSource> (
 588                         this IQueryable<TSource> source,
 589                         Func<TSource, double> selector)
 590                 {
 591                         if (source == null || selector == null)
 592                                 throw new ArgumentNullException ();
 593
 594                         double minimum = double.MaxValue;
 595                         int counter = 0;
 596                         foreach (TSource item in source)
 597                         {
 598                                 double element = selector (item);
 599                                 if (element < minimum)
 600                                         minimum = element;
 601                                 counter++;
 602                         }
 603
 604                         if (counter == 0)
 605                                 throw new InvalidOperationException ();
 606                         else
 607                                 return minimum;
 608                 }
 609
 610                 public static double? Min<TSource> (
 611                         this IQueryable<TSource> source,
 612                         Func<TSource, double?> selector)
 613                 {
 614                         if (source == null || selector == null)
 615                                 throw new ArgumentNullException ();
 616
 617                         bool onlyNull = true;
 618                         double? minimum = double.MaxValue;
 619                         foreach (TSource item in source) {
 620                                 double? element = selector (item);
 621                                 if (element.HasValue) {
 622                                         onlyNull = false;
 623                                         if (element < minimum)
 624                                                 minimum = element;
 625                                 }
 626                         }
 627                         return (onlyNull ? null : minimum);
 628                 }
 629
 630                 public static decimal Min<TSource> (
 631                         this IQueryable<TSource> source,
 632                         Func<TSource, decimal> selector)
 633                 {
 634                         if (source == null || selector == null)
 635                                 throw new ArgumentNullException ();
 636
 637                         decimal minimum = decimal.MaxValue;
 638                         int counter = 0;
 639                         foreach (TSource item in source) {
 640                                 decimal element = selector (item);
 641                                 if (element < minimum)
 642                                         minimum = element;
 643                                 counter++;
 644                         }
 645
 646                         if (counter == 0)
 647                                 throw new InvalidOperationException ();
 648                         else
 649                                 return minimum;
 650                 }
 651
 652                 public static decimal? Min<TSource> (
 653                         this IQueryable<TSource> source,
 654                         Func<TSource, decimal?> selector)
 655                 {
 656                         if (source == null || selector == null)
 657                                 throw new ArgumentNullException ();
 658
 659                         bool onlyNull = true;
 660                         decimal? minimum = decimal.MaxValue;
 661                         foreach (TSource item in source) {
 662                                 decimal? element = selector (item);
 663                                 if (element.HasValue) {
 664                                         onlyNull = false;
 665                                         if (element < minimum)
 666                                                 minimum = element;
 667                                 }
 668                         }
 669                         return (onlyNull ? null : minimum);
 670                 }
 671
 672                 public static TResult Min<TSource, TResult> (
 673                         this IQueryable<TSource> source,
 674                         Func<TSource, TResult> selector)
 675                 {
 676                         if (source == null || selector == null)
 677                                 throw new ArgumentNullException ();
 678
 679                         bool notAssigned = true;
 680                         TResult minimum = default (TResult);
 681                         int counter = 0;
 682                         foreach (TSource item in source) {
 683                                 TResult element = selector (item);
 684                                 if (notAssigned) {
 685                                         minimum = element;
 686                                         notAssigned = false;
 687                                 }
 688                                 else {
 689                                         int comparison;
 690                                         if (element is IComparable<TResult>)
 691                                                 comparison = ((IComparable<TResult>)element).CompareTo (minimum);
 692                                         else if (element is System.IComparable)
 693                                                 comparison = ((System.IComparable)element).CompareTo (minimum);
 694                                         else
 695                                                 throw new ArgumentNullException ();
 696
 697                                         if (comparison < 0)
 698                                                 minimum = element;
 699                                 }
 700                                 counter++;
 701                         }
 702
 703                         if (counter == 0)
 704                                 throw new InvalidOperationException ();
 705                         else
 706                                 return minimum;
 707                 }
 708
 709                 #endregion
 710
 711                 #region Max
 712
 713                 public static int Max (this IQueryable<int> source)
 714                 {
 715                         if (source == null)
 716                                 throw new ArgumentNullException ();
 717
 718                         int maximum = int.MinValue;
 719                         int counter = 0;
 720                         foreach (int element in source) {
 721                                 if (element > maximum)
 722                                         maximum = element;
 723                                 counter++;
 724                         }
 725
 726                         if (counter == 0)
 727                                 throw new InvalidOperationException ();
 728                         else
 729                                 return maximum;
 730                 }
 731
 732                 public static int? Max (this IQueryable<int?> source)
 733                 {
 734                         if (source == null)
 735                                 throw new ArgumentNullException ();
 736
 737                         bool onlyNull = true;
 738                         int? maximum = int.MinValue;
 739                         foreach (int? element in source) {
 740                                 if (element.HasValue) {
 741                                         onlyNull = false;
 742                                         if (element > maximum)
 743                                                 maximum = element;
 744                                 }
 745                         }
 746                         return (onlyNull ? null : maximum);
 747                 }
 748
 749                 public static long Max (this IQueryable<long> source)
 750                 {
 751                         if (source == null)
 752                                 throw new ArgumentNullException ();
 753
 754                         long maximum = long.MinValue;
 755                         int counter = 0;
 756                         foreach (long element in source) {
 757                                 if (element > maximum)
 758                                         maximum = element;
 759                                 counter++;
 760                         }
 761
 762                         if (counter == 0)
 763                                 throw new InvalidOperationException ();
 764                         else
 765                                 return maximum;
 766                 }
 767
 768                 public static long? Max (this IQueryable<long?> source)
 769                 {
 770                         if (source == null)
 771                                 throw new ArgumentNullException ();
 772
 773                         bool onlyNull = true;
 774                         long? maximum = long.MinValue;
 775                         foreach (long? element in source) {
 776                                 if (element.HasValue) {
 777                                         onlyNull = false;
 778                                         if (element > maximum)
 779                                                 maximum = element;
 780                                 }
 781                         }
 782                         return (onlyNull ? null : maximum);
 783                 }
 784
 785                 public static double Max (
 786                         this IQueryable<double> source)
 787                 {
 788                         if (source == null)
 789                                 throw new ArgumentNullException ();
 790
 791                         double maximum = double.MinValue;
 792                         int counter = 0;
 793                         foreach (double element in source) {
 794                                 if (element > maximum)
 795                                         maximum = element;
 796                                 counter++;
 797                         }
 798
 799                         if (counter == 0)
 800                                 throw new InvalidOperationException ();
 801                         else
 802                                 return maximum;
 803                 }
 804
 805                 public static double? Max (
 806                         this IQueryable<double?> source)
 807                 {
 808                         if (source == null)
 809                                 throw new ArgumentNullException ();
 810
 811                         bool onlyNull = true;
 812                         double? maximum = double.MinValue;
 813                         foreach (double? element in source) {
 814                                 if (element.HasValue) {
 815                                         onlyNull = false;
 816                                         if (element > maximum)
 817                                                 maximum = element;
 818                                 }
 819                         }
 820                         return (onlyNull ? null : maximum);
 821                 }
 822
 823                 public static decimal Max (
 824                         this IQueryable<decimal> source)
 825                 {
 826                         if (source == null)
 827                                 throw new ArgumentNullException ();
 828
 829                         decimal maximum = decimal.MinValue;
 830                         int counter = 0;
 831                         foreach (decimal element in source) {
 832                                 if (element > maximum)
 833                                         maximum = element;
 834                                 counter++;
 835                         }
 836
 837                         if (counter == 0)
 838                                 throw new InvalidOperationException ();
 839                         else
 840                                 return maximum;
 841                 }
 842
 843                 public static decimal? Max (
 844                         this IQueryable<decimal?> source)
 845                 {
 846                         if (source == null)
 847                                 throw new ArgumentNullException ();
 848
 849                         bool onlyNull = true;
 850                         decimal? maximum = decimal.MinValue;
 851                         foreach (decimal? element in source) {
 852                                 if (element.HasValue) {
 853                                         onlyNull = false;
 854                                         if (element > maximum)
 855                                                 maximum = element;
 856                                 }
 857                         }
 858                         return (onlyNull ? null : maximum);
 859                 }
 860
 861                 public static TSource Max<TSource> (
 862                         this IQueryable<TSource> source)
 863                 {
 864                         if (source == null)
 865                                 throw new ArgumentNullException ();
 866
 867                         bool notAssigned = true;
 868                         TSource maximum = default (TSource);
 869                         int counter = 0;
 870                         foreach (TSource element in source) {
 871                                 if (notAssigned) {
 872                                         maximum = element;
 873                                         notAssigned = false;
 874                                 }
 875                                 else {
 876                                         int comparison;
 877                                         if (element is IComparable<TSource>)
 878                                                 comparison = ((IComparable<TSource>)element).CompareTo (maximum);
 879                                         else if (element is System.IComparable)
 880                                                 comparison = ((System.IComparable)element).CompareTo (maximum);
 881                                         else
 882                                                 throw new ArgumentNullException();
 883
 884                                         if (comparison > 0)
 885                                                 maximum = element;
 886                                 }
 887                                 counter++;
 888                         }
 889
 890                         if (counter == 0)
 891                                 throw new InvalidOperationException ();
 892                         else
 893                                 return maximum;
 894                 }
 895
 896                 public static int Max<TSource> (
 897                         this IQueryable<TSource> source,
 898                         Func<TSource, int> selector)
 899                 {
 900                         if (source == null || selector == null)
 901                                 throw new ArgumentNullException ();
 902
 903                         int maximum = int.MinValue;
 904                         int counter = 0;
 905                         foreach (TSource item in source)
 906                         {
 907                                 int element = selector (item);
 908                                 if (element > maximum)
 909                                         maximum = element;
 910                                 counter++;
 911                         }
 912
 913                         if (counter == 0)
 914                                 throw new InvalidOperationException ();
 915                         else
 916                                 return maximum;
 917                 }
 918
 919                 public static int? Max<TSource> (
 920                         this IQueryable<TSource> source,
 921                         Func<TSource, int?> selector)
 922                 {
 923                         if (source == null || selector == null)
 924                                 throw new ArgumentNullException ();
 925
 926                         bool onlyNull = true;
 927                         int? maximum = int.MinValue;
 928                         foreach (TSource item in source) {
 929                                 int? element = selector (item);
 930                                 if (element.HasValue) {
 931                                         onlyNull = false;
 932                                         if (element > maximum)
 933                                                 maximum = element;
 934                                 }
 935                         }
 936                         return (onlyNull ? null : maximum);
 937                 }
 938
 939                 public static long Max<TSource> (
 940                         this IQueryable<TSource> source,
 941                         Func<TSource, long> selector)
 942                 {
 943                         if (source == null || selector == null)
 944                                 throw new ArgumentNullException ();
 945
 946                         long maximum = long.MinValue;
 947                         int counter = 0;
 948                         foreach (TSource item in source) {
 949                                 long element = selector (item);
 950                                 if (element > maximum)
 951                                         maximum = element;
 952                                 counter++;
 953                         }
 954
 955                         if (counter == 0)
 956                                 throw new InvalidOperationException ();
 957                         else
 958                                 return maximum;
 959                 }
 960
 961                 public static long? Max<TSource> (
 962                         this IQueryable<TSource> source,
 963                         Func<TSource, long?> selector)
 964                 {
 965                         if (source == null || selector == null)
 966                                 throw new ArgumentNullException ();
 967
 968                         bool onlyNull = true;
 969                         long? maximum = long.MinValue;
 970                         foreach (TSource item in source) {
 971                                 long? element = selector (item);
 972                                 if (element.HasValue) {
 973                                         onlyNull = false;
 974                                         if (element > maximum)
 975                                                 maximum = element;
 976                                 }
 977                         }
 978                         return (onlyNull ? null : maximum);
 979                 }
 980
 981                 public static double Max<TSource> (
 982                         this IQueryable<TSource> source,
 983                         Func<TSource, double> selector)
 984                 {
 985                         if (source == null || selector == null)
 986                                 throw new ArgumentNullException ();
 987
 988                         double maximum = double.MinValue;
 989                         int counter = 0;
 990                         foreach (TSource item in source) {
 991                                 double element = selector (item);
 992                                 if (element > maximum)
 993                                         maximum = element;
 994                                 counter++;
 995                         }
 996
 997                         if (counter == 0)
 998                                 throw new InvalidOperationException ();
 999                         else
1000                                 return maximum;
1001                 }
1002
1003                 public static double? Max<TSource> (
1004                         this IQueryable<TSource> source,
1005                         Func<TSource, double?> selector)
1006                 {
1007                         if (source == null || selector == null)
1008                                 throw new ArgumentNullException ();
1009
1010                         bool onlyNull = true;
1011                         double? maximum = double.MinValue;
1012                         foreach (TSource item in source) {
1013                                 double? element = selector(item);
1014                                 if (element.HasValue) {
1015                                         onlyNull = false;
1016                                         if (element > maximum)
1017                                                 maximum = element;
1018                                 }
1019                         }
1020                         return (onlyNull ? null : maximum);
1021                 }
1022
1023                 public static decimal Max<TSource> (
1024                         this IQueryable<TSource> source,
1025                         Func<TSource, decimal> selector)
1026                 {
1027                         if (source == null || selector == null)
1028                                 throw new ArgumentNullException ();
1029
1030                         decimal maximum = decimal.MinValue;
1031                         int counter = 0;
1032                         foreach (TSource item in source) {
1033                                 decimal element = selector(item);
1034                                 if (element > maximum)
1035                                         maximum = element;
1036                                 counter++;
1037                         }
1038
1039                         if (counter == 0)
1040                                 throw new InvalidOperationException ();
1041                         else
1042                                 return maximum;
1043                 }
1044
1045                 public static decimal? Max<TSource> (
1046                         this IQueryable<TSource> source,
1047                         Func<TSource, decimal?> selector)
1048                 {
1049                         if (source == null || selector == null)
1050                                 throw new ArgumentNullException ();
1051
1052                         bool onlyNull = true;
1053                         decimal? maximum = decimal.MinValue;
1054                         foreach (TSource item in source) {
1055                                 decimal? element = selector(item);
1056                                 if (element.HasValue) {
1057                                         onlyNull = false;
1058                                         if (element > maximum)
1059                                                 maximum = element;
1060                                 }
1061                         }
1062                         return (onlyNull ? null : maximum);
1063                 }
1064
1065                 public static TResult Max<TSource, TResult> (
1066                         this IQueryable<TSource> source,
1067                         Func<TSource, TResult> selector)
1068                 {
1069                         if (source == null || selector == null)
1070                                 throw new ArgumentNullException ();
1071
1072                         bool notAssigned = true;
1073                         TResult maximum = default (TResult);
1074                         int counter = 0;
1075                         foreach (TSource item in source)
1076                         {
1077                                 TResult element = selector (item);
1078                                 if (notAssigned)  {
1079                                         maximum = element;
1080                                         notAssigned = false;
1081                                 }
1082                                 else  {
1083                                         int comparison;
1084                                         if (element is IComparable<TResult>)
1085                                                 comparison = ((IComparable<TResult>)element).CompareTo (maximum);
1086                                         else if (element is System.IComparable)
1087                                                 comparison = ((System.IComparable)element).CompareTo (maximum);
1088                                         else
1089                                                 throw new ArgumentNullException();
1090
1091                                         if (comparison > 0)
1092                                                 maximum = element;
1093                                 }
1094                                        counter++;
1095                         }
1096
1097                         if (counter == 0)
1098                                 throw new InvalidOperationException ();
1099                         else
1100                                 return maximum;
1101                 }
1102
1103                 #endregion
1104
1105                 #region Average
1106
1107                 public static double Average (this IQueryable<int> source)
1108                 {
1109                         if (source == null)
1110                                 throw new ArgumentNullException ();
1111
1112                         long sum = 0;
1113                         long counter = 0;
1114                         foreach (int element in source) {
1115                                 sum += element;
1116                                 counter++;
1117                         }
1118
1119                         if (counter == 0)
1120                                 throw new InvalidOperationException ();
1121                         else
1122                                 return (double)sum / (double)counter;
1123                 }
1124
1125                 public static double? Average (this IQueryable<int?> source)
1126                 {
1127                         if (source == null)
1128                                 throw new ArgumentNullException ();
1129
1130                         bool onlyNull = true;
1131                         long sum = 0;
1132                         long counter = 0;
1133                         foreach (int? element in source) {
1134                                 if (element.HasValue) {
1135                                         onlyNull = false;
1136                                         sum += element.Value;
1137                                         counter++;
1138                                 }
1139                         }
1140                         return (onlyNull ? null : (double?)sum / (double?)counter);
1141                 }
1142
1143                 public static double Average (this IQueryable<long> source)
1144                 {
1145                         if (source == null)
1146                                 throw new ArgumentNullException ();
1147
1148                         long sum = 0;
1149                         long counter = 0;
1150                         foreach (long element in source) {
1151                                 sum += element;
1152                                 counter++;
1153                         }
1154
1155                         if (counter == 0)
1156                                 throw new InvalidOperationException ();
1157                         else
1158                                 return (double)sum / (double)counter;
1159                 }
1160
1161                 public static double? Average (this IQueryable<long?> source)
1162                 {
1163                         if (source == null)
1164                                 throw new ArgumentNullException ();
1165
1166                         bool onlyNull = true;
1167                         long sum = 0;
1168                         long counter = 0;
1169                         foreach (long? element in source) {
1170                                 if (element.HasValue) {
1171                                         onlyNull = false;
1172                                         sum += element.Value;
1173                                         counter++;
1174                                 }
1175                         }
1176                         return (onlyNull ? null : (double?)sum / (double?)counter);
1177                 }
1178
1179                 public static double Average (this IQueryable<double> source)
1180                 {
1181                         if (source == null)
1182                                 throw new ArgumentNullException ();
1183
1184                         double sum = 0;
1185                         double counter = 0;
1186                         foreach (double element in source) {
1187                                 sum += element;
1188                                 counter++;
1189                         }
1190
1191                         if (counter == 0)
1192                                 throw new InvalidOperationException ();
1193                         else
1194                                 return sum / counter;
1195                 }
1196
1197                 public static double? Average (this IQueryable<double?> source)
1198                 {
1199                         if (source == null)
1200                                 throw new ArgumentNullException ();
1201
1202                         bool onlyNull = true;
1203                         double sum = 0;
1204                         double counter = 0;
1205                         foreach (double? element in source) {
1206                                 if (element.HasValue) {
1207                                         onlyNull = false;
1208                                         sum += element.Value;
1209                                         counter++;
1210                                 }
1211                         }
1212                         return (onlyNull ? null : (double?)(sum / counter));
1213                 }
1214
1215                 public static decimal Average (this IQueryable<decimal> source)
1216                 {
1217                         if (source == null)
1218                                 throw new ArgumentNullException ();
1219
1220                         decimal sum = 0;
1221                         decimal counter = 0;
1222                         foreach (decimal element in source) {
1223                                 sum += element;
1224                                 counter++;
1225                         }
1226
1227                         if (counter == 0)
1228                                 throw new InvalidOperationException ();
1229                         else
1230                                 return sum / counter;
1231                 }
1232
1233                 public static decimal? Average (this IQueryable<decimal?> source)
1234                 {
1235                         if (source == null)
1236                                 throw new ArgumentNullException ();
1237
1238                         bool onlyNull = true;
1239                         decimal sum = 0;
1240                         decimal counter = 0;
1241                         foreach (decimal? element in source) {
1242                                 if (element.HasValue) {
1243                                         onlyNull = false;
1244                                         sum += element.Value;
1245                                         counter++;
1246                                 }
1247                         }
1248                         return (onlyNull ? null : (decimal?)(sum / counter));
1249                 }
1250
1251                 public static double Average<TSource> (this IQueryable<TSource> source,
1252                         Func<TSource, int> selector)
1253                 {
1254                         if (source == null || selector == null)
1255                                 throw new ArgumentNullException ();
1256
1257                         long sum = 0;
1258                         long counter = 0;
1259                         foreach (TSource item in source) {
1260                                 sum += selector (item);
1261                                 counter++;
1262                         }
1263
1264                         if (counter == 0)
1265                                 throw new InvalidOperationException ();
1266                         else
1267                                 return (double)sum / (double)counter;
1268                 }
1269
1270                 public static double? Average<TSource> (this IQueryable<TSource> source,
1271                         Func<TSource, int?> selector)
1272                 {
1273                         if (source == null || selector == null)
1274                                 throw new ArgumentNullException ();
1275
1276                         bool onlyNull = true;
1277                         long sum = 0;
1278                         long counter = 0;
1279                         foreach (TSource item in source) {
1280                                 int? element = selector (item);
1281                                 if (element.HasValue) {
1282                                         onlyNull = false;
1283                                         sum += element.Value;
1284                                         counter++;
1285                                 }
1286                         }
1287                         return (onlyNull ? null : (double?)sum / (double?)counter);
1288                 }
1289
1290                 public static double Average<TSource> (this IQueryable<TSource> source,
1291                         Func<TSource, long> selector)
1292                 {
1293                         if (source == null || selector == null)
1294                                 throw new ArgumentNullException ();
1295
1296                         long sum = 0;
1297                         long counter = 0;
1298                         foreach (TSource item in source) {
1299                                 sum += selector (item);
1300                                 counter++;
1301                         }
1302
1303                         if (counter == 0)
1304                                 throw new InvalidOperationException();
1305                         else
1306                                 return (double)sum / (double)counter;
1307                 }
1308
1309                 public static double? Average<TSource> (this IQueryable<TSource> source,
1310                         Func<TSource, long?> selector)
1311                 {
1312                         if (source == null || selector == null)
1313                                 throw new ArgumentNullException ();
1314
1315                         bool onlyNull = true;
1316                         long sum = 0;
1317                         long counter = 0;
1318                         foreach (TSource item in source) {
1319                                 long? element = selector (item);
1320                                 if (element.HasValue) {
1321                                         onlyNull = false;
1322                                         sum += element.Value;
1323                                         counter++;
1324                                 }
1325                         }
1326                         return (onlyNull ? null : (double?)sum/(double?)counter);
1327                 }
1328
1329                 public static double Average<TSource> (this IQueryable<TSource> source,
1330                         Func<TSource, double> selector)
1331                 {
1332                         if (source == null || selector == null)
1333                                 throw new ArgumentNullException ();
1334
1335                         double sum = 0;
1336                         double counter = 0;
1337                         foreach (TSource item in source) {
1338                                 sum += selector (item);
1339                                 counter++;
1340                         }
1341
1342                         if (counter == 0)
1343                                 throw new InvalidOperationException ();
1344                         else
1345                                 return sum / counter;
1346                 }
1347
1348                 public static double? Average<TSource> (this IQueryable<TSource> source,
1349                         Func<TSource, double?> selector)
1350                 {
1351                         if (source == null || selector == null)
1352                                 throw new ArgumentNullException ();
1353
1354                         bool onlyNull = true;
1355                         double sum = 0;
1356                         double counter = 0;
1357                         foreach (TSource item in source) {
1358                                 double? element = selector (item);
1359                                 if (element.HasValue) {
1360                                         onlyNull = false;
1361                                         sum += element.Value;
1362                                         counter++;
1363                                 }
1364                         }
1365                         return (onlyNull ? null : (double?)(sum/counter));
1366                 }
1367
1368                 public static decimal Average<TSource> (this IQueryable<TSource> source,
1369                         Func<TSource, decimal> selector)
1370                 {
1371                         if (source == null || selector == null)
1372                                 throw new ArgumentNullException ();
1373
1374                         decimal sum = 0;
1375                         decimal counter = 0;
1376                         foreach (TSource item in source) {
1377                                 sum += selector(item);
1378                                 counter++;
1379                         }
1380
1381                         if (counter == 0)
1382                                 throw new InvalidOperationException ();
1383                         else
1384                                 return sum / counter;
1385                 }
1386
1387                 public static decimal? Average<TSource> (this IQueryable<TSource> source,
1388                         Func<TSource, decimal?> selector)
1389                 {
1390                         if (source == null || selector == null)
1391                                 throw new ArgumentNullException ();
1392
1393                         bool onlyNull = true;
1394                         decimal sum = 0;
1395                         decimal counter = 0;
1396                         foreach (TSource item in source) {
1397                                 decimal? element = selector (item);
1398                                 if (element.HasValue) {
1399                                         onlyNull = false;
1400                                         sum += element.Value;
1401                                         counter++;
1402                                 }
1403                         }
1404                         return (onlyNull ? null : (decimal?)(sum/counter));
1405                 }
1406
1407                 #endregion
1408
1409                 #region Fold
1410 /*
1411                 [Obsolete ("Use Aggregate instead")]
1412                 [System.Runtime.CompilerServices.Extension]
1413                 public static TSource Fold<TSource> (
1414                         IQueryable<TSource> source,
1415                         Func<TSource, TSource, TSource> func)
1416                 {
1417                         return Fold<TSource> (source, func);
1418                 }
1419
1420                 [Obsolete ("Use Aggregate instead")]
1421                 [System.Runtime.CompilerServices.Extension]
1422                 public static U Fold<TSource, U> (
1423                         IQueryable<TSource> source,
1424                         U seed,
1425                         Func<U, TSource, U> func)
1426                 {
1427                         return Fold<TSource, U> (source, seed, func);
1428                 }
1429 */
1430                 #endregion
1431
1432                 #region Aggregate
1433
1434                 public static TSource Aggregate<TSource> (
1435                         this IQueryable<TSource> source,
1436                         Func<TSource, TSource, TSource> func)
1437                 {
1438                         if (source == null || func == null)
1439                                 throw new ArgumentNullException ();
1440
1441                         int counter = 0;
1442                         TSource folded = default (TSource);
1443
1444                         foreach (TSource element in source) {
1445                                 if (counter == 0)
1446                                         folded = element;
1447                                 else
1448                                         folded = func (folded, element);
1449                         }
1450
1451                         if (counter == 0)
1452                                 throw new InvalidOperationException ();
1453                         else
1454                                 return folded;
1455                 }
1456
1457                 public static U Aggregate<TSource, U> (
1458                         this IQueryable<TSource> source,
1459                         U seed,
1460                         Func<U, TSource, U> func)
1461                 {
1462                         if (source == null || func == null)
1463                                 throw new ArgumentNullException ();
1464
1465                         U folded = seed;
1466                         foreach (TSource element in source)
1467                                 folded = func (folded, element);
1468                         return folded;
1469                 }
1470
1471                 #endregion
1472
1473                 #region Concat
1474
1475                 public static IEnumerable<TSource> Concat<TSource> (
1476                         this IQueryable<TSource> first,
1477                         IEnumerable<TSource> second)
1478                 {
1479                         if (first == null || second == null)
1480                                 throw new ArgumentNullException ();
1481
1482                         foreach (TSource element in first)
1483                                 yield return element;
1484                         foreach (TSource element in second)
1485                                 yield return element;
1486                 }
1487
1488                 #endregion
1489 /*
1490                 #region ToSequence
1491
1492                 [System.Runtime.CompilerServices.Extension]
1493                 public static IQueryable<TSource> ToSequence<TSource> (
1494                         IQueryable<TSource> source)
1495                 {
1496                         return (IQueryable<TSource>)source;
1497                 }
1498
1499                 #endregion
1500
1501                 #region ToArray
1502
1503                 [System.Runtime.CompilerServices.Extension]
1504                 public static TSource[] ToArray<TSource> (
1505                         IQueryable<TSource> source)
1506                 {
1507                         if (source == null)
1508                                 throw new ArgumentNullException ();
1509
1510                         List<TSource> list = new List<TSource> (source);
1511                         return list.ToArray ();
1512                 }
1513
1514                 #endregion
1515
1516                 #region ToList
1517
1518                 [System.Runtime.CompilerServices.Extension]
1519                 public static List<TSource> ToList<TSource> (
1520                         IQueryable<TSource> source)
1521                 {
1522                         if (source == null)
1523                                 throw new ArgumentNullException ();
1524
1525                         return new List<TSource> (source);
1526                 }
1527
1528                 #endregion
1529
1530                 #region ToDictionary
1531
1532                 [System.Runtime.CompilerServices.Extension]
1533                 public static Dictionary<K, TSource> ToDictionary<TSource, K> (
1534                         IQueryable<TSource> source,
1535                         Func<TSource, K> keySelector)
1536                 {
1537                         return ToDictionary<TSource, K> (source, keySelector, null);
1538                 }
1539
1540                 [System.Runtime.CompilerServices.Extension]
1541                 public static Dictionary<K, TSource> ToDictionary<TSource, K> (
1542                         IQueryable<TSource> source,
1543                         Func<TSource, K> keySelector,
1544                         IEqualityComparer<K> comparer)
1545                 {
1546                         if (source == null || keySelector == null)
1547                                 throw new ArgumentNullException ();
1548
1549                         Dictionary<K, TSource> dictionary = new Dictionary<K, TSource> (comparer ?? EqualityComparer<K>.Default);
1550                         foreach (TSource element in source) {
1551                                 K key = keySelector (element);
1552                                 if (key == null)
1553                                         throw new ArgumentNullException ();
1554                                 else if (dictionary.ContainsKey (key))
1555                                         throw new ArgumentException ();
1556                                 else
1557                                         dictionary.Add (key, element);
1558                         }
1559                         return dictionary;
1560                 }
1561
1562                 [System.Runtime.CompilerServices.Extension]
1563                 public static Dictionary<K, E> ToDictionary<TSource, K, E> (
1564                         IQueryable<TSource> source,
1565                         Func<TSource, K> keySelector,
1566                         Func<TSource, E> elementSelector)
1567                 {
1568                         return ToDictionary<TSource, K, E> (source, keySelector, elementSelector, null);
1569                 }
1570
1571                 [System.Runtime.CompilerServices.Extension]
1572                 public static Dictionary<K, E> ToDictionary<TSource, K, E> (
1573                         IQueryable<TSource> source,
1574                         Func<TSource, K> keySelector,
1575                         Func<TSource, E> elementSelector,
1576                         IEqualityComparer<K> comparer)
1577                 {
1578                         if (source == null || keySelector == null || elementSelector == null)
1579                                 throw new ArgumentNullException ();
1580
1581                         Dictionary<K, E> dictionary = new Dictionary<K, E>(comparer ?? EqualityComparer<K>.Default);
1582                         foreach (TSource element in source)
1583                         {
1584                                 K key = keySelector (element);
1585                                 if (key == null)
1586                                         throw new ArgumentNullException ();
1587                                 else if (dictionary.ContainsKey (key))
1588                                         throw new ArgumentException ();
1589                                 else
1590                                         dictionary.Add(key, elementSelector (element));
1591                         }
1592                         return dictionary;
1593                 }
1594
1595                 #endregion
1596
1597                 #region ToLookup
1598
1599                 [System.Runtime.CompilerServices.Extension]
1600                 public static Lookup<K, TSource> ToLookup<TSource, K> (
1601                         IQueryable<TSource> source,
1602                         Func<TSource, K> keySelector)
1603                 {
1604                         return ToLookup<TSource, K> (source, keySelector, null);
1605                 }
1606
1607                 [System.Runtime.CompilerServices.Extension]
1608                 public static Lookup<K, TSource> ToLookup<TSource, K> (
1609                         IQueryable<TSource> source,
1610                         Func<TSource, K> keySelector,
1611                         IEqualityComparer<K> comparer)
1612                 {
1613                         if (source == null || keySelector == null)
1614                                 throw new ArgumentNullException ();
1615
1616                         Dictionary<K, List<TSource>> dictionary = new Dictionary<K, List<TSource>> (comparer ?? EqualityComparer<K>.Default);
1617                         foreach (TSource element in source) {
1618                                 K key = keySelector (element);
1619                                 if (key == null)
1620                                         throw new ArgumentNullException ();
1621                                 if (!dictionary.ContainsKey (key))
1622                                         dictionary.Add (key, new List<TSource> ());
1623                                 dictionary[key].Add (element);
1624                         }
1625                         return new Lookup<K, TSource> (dictionary);
1626                 }
1627
1628                 [System.Runtime.CompilerServices.Extension]
1629                 public static Lookup<K, E> ToLookup<TSource, K, E> (
1630                         IQueryable<TSource> source,
1631                         Func<TSource, K> keySelector,
1632                         Func<TSource, E> elementSelector)
1633                 {
1634                         return ToLookup<TSource, K, E> (source, keySelector, elementSelector, null);
1635                 }
1636
1637                 [System.Runtime.CompilerServices.Extension]
1638                 public static Lookup<K, E> ToLookup<TSource, K, E> (
1639                         IQueryable<TSource> source,
1640                         Func<TSource, K> keySelector,
1641                         Func<TSource, E> elementSelector,
1642                         IEqualityComparer<K> comparer)
1643                 {
1644                         if (source == null || keySelector == null || elementSelector == null)
1645                                 throw new ArgumentNullException ();
1646
1647                         Dictionary<K, List<E>> dictionary = new Dictionary<K, List<E>>(comparer ?? EqualityComparer<K>.Default);
1648                         foreach (TSource element in source)
1649                         {
1650                                 K key = keySelector (element);
1651                                 if (key == null)
1652                                         throw new ArgumentNullException ();
1653                                 if (!dictionary.ContainsKey (key))
1654                                         dictionary.Add (key, new List<E> ());
1655                                 dictionary[key].Add (elementSelector (element));
1656                         }
1657                         return new Lookup<K, E> (dictionary);
1658                 }
1659
1660                 #endregion
1661   */
1662                 #region OfType
1663
1664                 public static IEnumerable<TResult> OfType<TResult> (this IQueryable source)
1665                 {
1666                         if (source == null)
1667                                 throw new ArgumentNullException ();
1668
1669                         foreach (object element in source)
1670                                 if (element is TResult)
1671                                         yield return (TResult)element;
1672                 }
1673
1674                 #endregion
1675
1676                 #region Cast
1677
1678                 public static IEnumerable<TResult> Cast<TResult> (this IQueryable source)
1679                 {
1680                         if (source == null)
1681                                 throw new ArgumentNullException ();
1682
1683                         foreach (object element in source)
1684                                 yield return (TResult)element;
1685                 }
1686
1687                 #endregion
1688
1689                 #region First
1690
1691                 public static TSource First<TSource> (this IQueryable<TSource> source)
1692                 {
1693                         if (source == null)
1694                                 throw new ArgumentNullException ();
1695
1696                         foreach (TSource element in source)
1697                                 return element;
1698
1699                         throw new InvalidOperationException ();
1700                 }
1701
1702                 public static TSource First<TSource> (
1703                         this IQueryable<TSource> source,
1704                         Func<TSource, bool> predicate)
1705                 {
1706                         if (source == null || predicate == null)
1707                                 throw new ArgumentNullException ();
1708
1709                         foreach (TSource element in source) {
1710                                 if (predicate (element))
1711                                         return element;
1712                         }
1713
1714                         throw new InvalidOperationException ();
1715                 }
1716
1717                 #endregion
1718
1719                 #region FirstOrDefault
1720
1721                 public static TSource FirstOrDefault<TSource> (this IQueryable<TSource> source)
1722                 {
1723                         if (source == null)
1724                                 throw new ArgumentNullException ();
1725
1726                         foreach (TSource element in source)
1727                                 return element;
1728
1729                         return default (TSource);
1730                 }
1731
1732                 public static TSource FirstOrDefault<TSource> (
1733                         this IQueryable<TSource> source,
1734                         Func<TSource, bool> predicate)
1735                 {
1736                         if (source == null || predicate == null)
1737                                 throw new ArgumentNullException ();
1738
1739                         foreach (TSource element in source) {
1740                                 if (predicate (element))
1741                                         return element;
1742                         }
1743
1744                         return default (TSource);
1745                 }
1746
1747                 #endregion
1748
1749                 #region Last
1750
1751                 public static TSource Last<TSource> (this IQueryable<TSource> source)
1752                 {
1753                         if (source == null)
1754                                 throw new ArgumentNullException ();
1755
1756                         bool noElements = true;
1757                         TSource lastElement = default (TSource);
1758                         foreach (TSource element in source)
1759                         {
1760                                 if (noElements) noElements = false;
1761                                 lastElement = element;
1762                         }
1763
1764                         if (!noElements)
1765                                 return lastElement;
1766                         else
1767                                 throw new InvalidOperationException();
1768                 }
1769
1770                 public static TSource Last<TSource> (
1771                         this IQueryable<TSource> source,
1772                         Func<TSource, bool> predicate)
1773                 {
1774                         if (source == null || predicate == null)
1775                                 throw new ArgumentNullException ();
1776
1777                         bool noElements = true;
1778                         TSource lastElement = default (TSource);
1779                         foreach (TSource element in source) {
1780                                 if (predicate (element))
1781                                 {
1782                                         if (noElements) noElements = false;
1783                                         lastElement = element;
1784                                 }
1785                         }
1786
1787                         if (!noElements)
1788                                 return lastElement;
1789                         else
1790                                 throw new InvalidOperationException ();
1791                 }
1792
1793                 #endregion
1794
1795                 #region LastOrDefault
1796
1797                 public static TSource LastOrDefault<TSource> (this IQueryable<TSource> source)
1798                 {
1799                         if (source == null)
1800                                 throw new ArgumentNullException ();
1801
1802                         TSource lastElement = default (TSource);
1803                         foreach (TSource element in source)
1804                                 lastElement = element;
1805
1806                         return lastElement;
1807                 }
1808
1809                 public static TSource LastOrDefault<TSource> (
1810                         this IQueryable<TSource> source,
1811                         Func<TSource, bool> predicate)
1812                 {
1813                         if (source == null || predicate == null)
1814                                 throw new ArgumentNullException ();
1815
1816                         TSource lastElement = default (TSource);
1817                         foreach (TSource element in source) {
1818                                 if (predicate (element))
1819                                         lastElement = element;
1820                         }
1821
1822                         return lastElement;
1823                 }
1824
1825                 #endregion
1826
1827                 #region Single
1828
1829                 public static TSource Single<TSource> (this IQueryable<TSource> source)
1830                 {
1831                         if (source == null)
1832                                 throw new ArgumentNullException ();
1833
1834                         bool otherElement = false;
1835                         TSource singleElement = default (TSource);
1836                         foreach (TSource element in source)
1837                         {
1838                                 if (otherElement) throw new InvalidOperationException ();
1839                                 if (!otherElement) otherElement = true;
1840                                 singleElement = element;
1841                         }
1842
1843                         if (otherElement)
1844                                 return singleElement;
1845                         else
1846                                 throw new InvalidOperationException();
1847                 }
1848
1849                 public static TSource Single<TSource> (
1850                         this IQueryable<TSource> source,
1851                         Func<TSource, bool> predicate)
1852                 {
1853                         if (source == null || predicate == null)
1854                                 throw new ArgumentNullException ();
1855
1856                         bool otherElement = false;
1857                         TSource singleElement = default (TSource);
1858                         foreach (TSource element in source) {
1859                                 if (predicate (element))
1860                                 {
1861                                         if (otherElement) throw new InvalidOperationException ();
1862                                         if (!otherElement) otherElement = true;
1863                                         singleElement = element;
1864                                 }
1865                         }
1866
1867                         if (otherElement)
1868                                 return singleElement;
1869                         else
1870                                 throw new InvalidOperationException ();
1871                 }
1872
1873                 #endregion
1874
1875                 #region SingleOrDefault
1876
1877                 public static TSource SingleOrDefault<TSource> (this IQueryable<TSource> source)
1878                 {
1879                         if (source == null)
1880                                 throw new ArgumentNullException ();
1881
1882                         bool otherElement = false;
1883                         TSource singleElement = default (TSource);
1884                         foreach (TSource element in source)
1885                         {
1886                                 if (otherElement) throw new InvalidOperationException ();
1887                                 if (!otherElement) otherElement = true;
1888                                 singleElement = element;
1889                         }
1890
1891                         return singleElement;
1892                 }
1893
1894                 public static TSource SingleOrDefault<TSource> (
1895                         this IQueryable<TSource> source,
1896                         Func<TSource, bool> predicate)
1897                 {
1898                         if (source == null || predicate == null)
1899                                 throw new ArgumentNullException ();
1900
1901                         bool otherElement = false;
1902                         TSource singleElement = default (TSource);
1903                         foreach (TSource element in source) {
1904                                 if (predicate (element))
1905                                 {
1906                                         if (otherElement) throw new InvalidOperationException ();
1907                                         if (!otherElement) otherElement = true;
1908                                         singleElement = element;
1909                                 }
1910                         }
1911
1912                         return singleElement;
1913                 }
1914
1915                 #endregion
1916
1917                 #region ElementAt
1918
1919                 public static TSource ElementAt<TSource> (
1920                         this IQueryable<TSource> source,
1921                         int index)
1922                 {
1923                         if (source == null)
1924                                 throw new ArgumentNullException ();
1925                         if (index < 0)
1926                                 throw new ArgumentOutOfRangeException ();
1927
1928                         if (source is IList<TSource>)
1929                                 return ((IList<TSource>)source)[index];
1930                         else {
1931                                 int counter = 0;
1932                                 foreach (TSource element in source) {
1933                                         if (counter == index)
1934                                                 return element;
1935                                         counter++;
1936                                 }
1937                                 throw new ArgumentOutOfRangeException();
1938                         }
1939                 }
1940
1941                 #endregion
1942
1943                 #region ElementAtOrDefault
1944
1945                 public static TSource ElementAtOrDefault<TSource> (
1946                         this IQueryable<TSource> source,
1947                         int index)
1948                 {
1949                         if (source == null)
1950                                 throw new ArgumentNullException ();
1951                         if (index < 0)
1952                                 return default(TSource);
1953
1954                         if (source is IList<TSource>)
1955                         {
1956                                 if (((IList<TSource>)source).Count >= index)
1957                                         return default(TSource);
1958                                 else
1959                                         return ((IList<TSource>)source)[index];
1960                         }
1961                         else {
1962                                 int counter = 0;
1963                                 foreach (TSource element in source) {
1964                                         if (counter == index)
1965                                                 return element;
1966                                         counter++;
1967                                 }
1968                                 return default (TSource);
1969                         }
1970                 }
1971
1972                 #endregion
1973
1974                 #region DefaultIfEmpty
1975
1976                 public static IEnumerable<TSource> DefaultIfEmpty<TSource> (
1977                         this IQueryable<TSource> source)
1978                 {
1979                         if (source == null)
1980                                 throw new ArgumentNullException ();
1981
1982                         bool noYield = true;
1983                         foreach (TSource item in source)
1984                         {
1985                                 noYield = false;
1986                                 yield return item;
1987                         }
1988
1989                         if (noYield)
1990                                 yield return default (TSource);
1991                 }
1992
1993                 public static IEnumerable<TSource> DefaultIfEmpty<TSource> (
1994                         this IQueryable<TSource> source,
1995                         TSource defaultValue)
1996                 {
1997                         if (source == null)
1998                                 throw new ArgumentNullException ();
1999
2000                         bool noYield = true;
2001                         foreach (TSource item in source)
2002                         {
2003                                 noYield = false;
2004                                 yield return item;
2005                         }
2006
2007                         if (noYield)
2008                                 yield return defaultValue;
2009                 }
2010
2011                 #endregion
2012
2013 /*                #region EqualAll
2014
2015                 [System.Runtime.CompilerServices.Extension]
2016                 public static bool EqualAll<TSource> (
2017                         IQueryable<TSource> first,
2018                         IQueryable<TSource> second)
2019                 {
2020                         if (first == null || second == null)
2021                                 throw new ArgumentNullException ();
2022
2023                         List<TSource> firstList = new List<TSource> (first);
2024                         List<TSource> secondList = new List<TSource> (second);
2025
2026                         if (firstList.Count != firstList.Count)
2027                                 return false;
2028
2029                         for (int i = 0; i < firstList.Count; i++) {
2030                                 if (!System.Object.Equals (firstList [i], secondList [i]))
2031                                         return false;
2032                         }
2033                         // If no pair of elements is different, then everything is equal
2034                         return true;
2035                 }
2036
2037                 #endregion
2038
2039                 #region Range
2040
2041                 [System.Runtime.CompilerServices.Extension]
2042                 public static IEnumerable<int> Range (
2043                         int start, int count)
2044                 {
2045                         if (count < 0 || (start + count - 1) > int.MaxValue)
2046                                 throw new ArgumentOutOfRangeException ();
2047
2048                         for (int i = start; i < (start + count - 1); i++)
2049                                 yield return i;
2050                 }
2051
2052                 #endregion
2053 */
2054                 #region Repeat
2055
2056                 public static IEnumerable<TSource> Repeat<TSource> (this TSource element, int count)
2057                 {
2058                         if (count < 0)
2059                                 throw new ArgumentOutOfRangeException ();
2060
2061                         for (int i = 0; i < count; i++)
2062                                 yield return element;
2063                 }
2064
2065                 #endregion
2066
2067                 /** A NOTE ON IMPLEMENTATION REGARDING NULL KEYS
2068                  *
2069                  *  GroupBy specification states that null-key values
2070                  *  are allowed. However, all implementations of
2071                  *  Dictionary<K, TSource> ban null keys.
2072                  *  Because of this, a small trick has to be done:
2073                  *  a special List<TSource> variable is created in order to
2074                  *  be filled with this null-key values.
2075                  *  Also, groups must be yielded in the order their
2076                  *  keys were found for first time, so we need to keep
2077                  *  a record on when the null-key values appeared
2078                  *  (that is nullCounter variable).
2079                  *  Then, when results are iterated and yielded, we
2080                  *  mantain a counter and if null-key values were
2081                  *  found, they are yielded in the order needed.
2082                  *  Because K can be a valuetype, compilers expose a
2083                  *  restriction on null values, that's why default(TSource)
2084                  *  is used. However, default(TSource) is null for
2085                  *  reference types, and values with selectors that
2086                  *  return value types can't return null. **/
2087
2088                 #region GroupBy
2089
2090                 private static List<TSource> ContainsGroup<K, TSource>(
2091                         Dictionary<K, List<TSource>> items, K key, IEqualityComparer<K> comparer)
2092                 {
2093                         IEqualityComparer<K> comparerInUse = (comparer ?? EqualityComparer<K>.Default);
2094                         foreach (KeyValuePair<K, List<TSource>> value in items) {
2095                                 if (comparerInUse.Equals(value.Key, key))
2096                                     return value.Value;
2097                         }
2098                         return null;
2099                 }
2100
2101                 public static IQueryable<IGrouping<K, TSource>> GroupBy<TSource, K> (
2102                         this IQueryable<TSource> source,
2103                         Func<TSource, K> keySelector)
2104                 {
2105                         throw new NotImplementedException ();
2106                         //return GroupBy<TSource, K> (source, keySelector, null);
2107                 }
2108 /*
2109                 [System.Runtime.CompilerServices.Extension]
2110                 public static IQueryable<IGrouping<K, TSource>> GroupBy<TSource, K> (
2111                         IQueryable<TSource> source,
2112                         Func<TSource, K> keySelector,
2113                         IEqualityComparer<K> comparer)
2114                 {
2115                         if (source == null || keySelector == null)
2116                                 throw new ArgumentNullException ();
2117
2118                         Dictionary<K, List<TSource>> groups = new Dictionary<K, List<TSource>> ();
2119                         List<TSource> nullList = new List<TSource> ();
2120                         int counter = 0;
2121                         int nullCounter = -1;
2122
2123                         foreach (TSource element in source) {
2124                                 K key = keySelector (element);
2125                                 if (key == null) {
2126                                         nullList.Add (element);
2127                                         if (nullCounter == -1) {
2128                                                 nullCounter = counter;
2129                                                 counter++;
2130                                         }
2131                                 }
2132                                 else {
2133                                         List<TSource> group = ContainsGroup<K, TSource> (groups, key, comparer);
2134                                         if (group == null) {
2135                                                 group = new List<TSource> ();
2136                                                 groups.Add (key, group);
2137                                                 counter++;
2138                                         }
2139                                         group.Add (element);
2140                                 }
2141                         }
2142
2143                         counter = 0;
2144                         foreach (KeyValuePair<K, List<TSource>> group in groups) {
2145                                 if (counter == nullCounter) {
2146                                         Grouping<K, TSource> nullGroup = new Grouping<K, TSource> (default (K), nullList);
2147                                         yield return nullGroup;
2148                                         counter++;
2149                                 }
2150                                 Grouping<K, TSource> grouping = new Grouping<K, TSource> (group.Key, group.Value);
2151                                 yield return grouping;
2152                                 counter++;
2153                         }
2154                 }
2155 */
2156
2157                 public static IQueryable<IGrouping<K, E>> GroupBy<TSource, K, E> (
2158                         this IQueryable<TSource> source,
2159                         Func<TSource, K> keySelector,
2160                         Func<TSource, E> elementSelector)
2161                 {
2162                         return GroupBy<TSource, K, E> (source, keySelector, elementSelector);
2163                 }
2164
2165                 public static IEnumerable<IGrouping<K, E>> GroupBy<TSource, K, E> (
2166                         this IQueryable<TSource> source,
2167                         Func<TSource, K> keySelector,
2168                         Func<TSource, E> elementSelector,
2169                         IEqualityComparer<K> comparer)
2170                 {
2171                         if (source == null || keySelector == null || elementSelector == null)
2172                                 throw new ArgumentNullException ();
2173
2174                         Dictionary<K, List<E>> groups = new Dictionary<K, List<E>> ();
2175                         List<E> nullList = new List<E> ();
2176                         int counter = 0;
2177                         int nullCounter = -1;
2178
2179                         foreach (TSource item in source) {
2180                                 K key = keySelector (item);
2181                                 E element = elementSelector (item);
2182                                 if (key == null) {
2183                                         nullList.Add(element);
2184                                         if (nullCounter == -1) {
2185                                                 nullCounter = counter;
2186                                                 counter++;
2187                                         }
2188                                 }
2189                                 else {
2190                                         List<E> group = ContainsGroup<K, E> (groups, key, comparer);
2191                                         if (group == null) {
2192                                                 group = new List<E> ();
2193                                                 groups.Add (key, group);
2194                                                 counter++;
2195                                         }
2196                                         group.Add (element);
2197                                 }
2198                         }
2199
2200                         counter = 0;
2201                         foreach (KeyValuePair<K, List<E>> group in groups) {
2202                                 if (counter == nullCounter) {
2203                                         Grouping<K, E> nullGroup = new Grouping<K, E> (default (K), nullList);
2204                                         yield return nullGroup;
2205                                         counter++;
2206                                 }
2207                                 Grouping<K, E> grouping = new Grouping<K, E> (group.Key, group.Value);
2208                                 yield return grouping;
2209                                 counter++;
2210                         }
2211                 }
2212
2213                 #endregion
2214
2215                 #region OrderBy
2216
2217                 public static OrderedSequence<TSource> OrderBy<TSource, K> (
2218                         this IQueryable<TSource> source,
2219                         Func<TSource, K> keySelector)
2220                 {
2221                         return OrderBy<TSource, K> (source, keySelector, null);
2222                 }
2223
2224                 public static OrderedSequence<TSource> OrderBy<TSource, K> (
2225                         this IQueryable<TSource> source,
2226                         Func<TSource, K> keySelector,
2227                         IComparer<K> comparer)
2228                 {
2229                         if (source == null || keySelector == null)
2230                                 throw new ArgumentNullException ();
2231
2232                         return new InternalOrderedSequence<TSource, K> (
2233                                 source, keySelector, (comparer ?? Comparer<K>.Default), false, null);
2234                 }
2235
2236                 #endregion
2237
2238                 #region OrderByDescending
2239
2240                 public static OrderedSequence<TSource> OrderByDescending<TSource, K> (
2241                         this IQueryable<TSource> source,
2242                         Func<TSource, K> keySelector)
2243                 {
2244                         return OrderByDescending<TSource, K> (source, keySelector, null);
2245                 }
2246
2247                 public static OrderedSequence<TSource> OrderByDescending<TSource, K> (
2248                         this IQueryable<TSource> source,
2249                         Func<TSource, K> keySelector,
2250                         IComparer<K> comparer)
2251                 {
2252                         if (source == null || keySelector == null)
2253                                 throw new ArgumentNullException ();
2254
2255                         return new InternalOrderedSequence<TSource, K> (
2256                                 source, keySelector, (comparer ?? Comparer<K>.Default), true, null);
2257                 }
2258
2259                 #endregion
2260
2261                 #region ThenBy
2262
2263                 public static OrderedSequence<TSource> ThenBy<TSource, K> (
2264                         this OrderedSequence<TSource> source,
2265                         Func<TSource, K> keySelector)
2266                 {
2267                         return ThenBy<TSource, K> (source, keySelector, null);
2268                 }
2269
2270                 public static OrderedSequence<TSource> ThenBy<TSource, K> (
2271                         this OrderedSequence<TSource> source,
2272                         Func<TSource, K> keySelector,
2273                         IComparer<K> comparer)
2274                 {
2275                         if (source == null || keySelector == null)
2276                                 throw new ArgumentNullException ();
2277
2278                         return new InternalOrderedSequence<TSource, K> (
2279                                 source, keySelector, (comparer ?? Comparer<K>.Default), false, source);
2280                 }
2281
2282                 #endregion
2283
2284                 #region ThenByDescending
2285
2286                 public static OrderedSequence<TSource> ThenByDescending<TSource, K> (
2287                         this OrderedSequence<TSource> source,
2288                         Func<TSource, K> keySelector)
2289                 {
2290                         return ThenByDescending<TSource, K> (source, keySelector, null);
2291                 }
2292
2293                 public static OrderedSequence<TSource> ThenByDescending<TSource, K> (
2294                         this OrderedSequence<TSource> source,
2295                         Func<TSource, K> keySelector,
2296                         IComparer<K> comparer)
2297                 {
2298                         if (source == null || keySelector == null)
2299                                 throw new ArgumentNullException ();
2300
2301                         return new InternalOrderedSequence<TSource, K> (
2302                                 source, keySelector, (comparer ?? Comparer<K>.Default), true, source);
2303                 }
2304
2305                 #endregion
2306
2307                 #region Reverse
2308
2309                 public static IQueryable<TSource> Reverse<TSource> (
2310                         this IQueryable<TSource> source)
2311                 {
2312                         if (source == null)
2313                                 throw new ArgumentNullException ();
2314
2315                         //List<TSource> list = new List<TSource> (source);
2316                         //list.Reverse ();
2317                         //return list;
2318                         throw new NotImplementedException ();
2319                 }
2320
2321                 #endregion
2322
2323                 #region Take
2324
2325                 public static IEnumerable<TSource> Take<TSource> (
2326                         this IQueryable<TSource> source,
2327                         int count)
2328                 {
2329                         if (source == null)
2330                                 throw new ArgumentNullException ();
2331
2332                         if (count <= 0)
2333                                 yield break;
2334                         else {
2335                                 int counter = 0;
2336                                 foreach (TSource element in source) {
2337                                         yield return element;
2338                                         counter++;
2339                                         if (counter == count)
2340                                                 yield break;
2341                                 }
2342                         }
2343                 }
2344
2345                 #endregion
2346
2347                 #region Skip
2348
2349                 public static IEnumerable<TSource> Skip<TSource> (
2350                         this IQueryable<TSource> source,
2351                         int count)
2352                 {
2353                         if (source == null)
2354                                 throw new ArgumentNullException ();
2355
2356                         int counter = 0;
2357                         bool yield = false;
2358                         if (count <= 0)
2359                                 yield = true;
2360
2361                         foreach (TSource element in source) {
2362                                 if (yield)
2363                                         yield return element;
2364                                 else {
2365                                         counter++;
2366                                         if (counter == count)
2367                                                 yield = true;
2368                                 }
2369                         }
2370                 }
2371
2372                 #endregion
2373
2374                 #region TakeWhile
2375
2376                 public static IEnumerable<TSource> TakeWhile<TSource> (
2377                         this IQueryable<TSource> source,
2378                         Func<TSource, bool> predicate)
2379                 {
2380                         if (source == null || predicate == null)
2381                                 throw new ArgumentNullException ();
2382
2383                         foreach (TSource element in source) {
2384                                 if (predicate (element))
2385                                         yield return element;
2386                                 else
2387                                         yield break;
2388                         }
2389                 }
2390
2391                 public static IEnumerable<TSource> TakeWhile<TSource> (
2392                         this IQueryable<TSource> source,
2393                         Func<TSource, int, bool> predicate)
2394                 {
2395                         if (source == null || predicate == null)
2396                                 throw new ArgumentNullException ();
2397
2398                         int counter = 0;
2399                         foreach (TSource element in source)
2400                         {
2401                                 if (predicate (element, counter))
2402                                         yield return element;
2403                                 else
2404                                         yield break;
2405                                 counter++;
2406                         }
2407                 }
2408
2409                 #endregion
2410
2411                 #region SkipWhile
2412
2413                 public static IEnumerable<TSource> SkipWhile<TSource> (
2414                         this IQueryable<TSource> source,
2415                         Func<TSource, bool> predicate)
2416                 {
2417                         if (source == null || predicate == null)
2418                                 throw new ArgumentNullException ();
2419
2420                         bool yield = false;
2421
2422                         foreach (TSource element in source) {
2423                                 if (yield)
2424                                         yield return element;
2425                                 else
2426                                         if (!predicate (element)) {
2427                                                 yield return element;
2428                                                 yield = true;
2429                                         }
2430                         }
2431                 }
2432
2433                 public static IEnumerable<TSource> SkipWhile<TSource> (
2434                         this IQueryable<TSource> source,
2435                         Func<TSource, int, bool> predicate)
2436                 {
2437                         if (source == null || predicate == null)
2438                                 throw new ArgumentNullException();
2439
2440                         int counter = 0;
2441                         bool yield = false;
2442
2443                         foreach (TSource element in source) {
2444                                 if (yield)
2445                                         yield return element;
2446                                 else
2447                                         if (!predicate (element, counter)) {
2448                                                 yield return element;
2449                                                 yield = true;
2450                                         }
2451                                 counter++;
2452                         }
2453                 }
2454
2455                 #endregion
2456
2457                 #region Select
2458
2459                 public static IEnumerable<TResult> Select<TSource, TResult> (
2460                         this IQueryable<TSource> source,
2461                         Func<TSource, TResult> selector)
2462                 {
2463                         if (source == null || selector == null)
2464                                 throw new ArgumentNullException ();
2465
2466                         foreach (TSource element in source)
2467                                 yield return selector (element);
2468                 }
2469
2470                 public static IEnumerable<TResult> Select<TSource, TResult> (
2471                         this IQueryable<TSource> source,
2472                         Func<TSource, int, TResult> selector)
2473                 {
2474                         if (source == null || selector == null)
2475                                 throw new ArgumentNullException ();
2476
2477                         int counter = 0;
2478                         foreach (TSource element in source) {
2479                                 yield return selector (element, counter);
2480                                 counter++;
2481                         }
2482                 }
2483
2484                 #endregion
2485
2486                 #region SelectMany
2487
2488                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (
2489                         this IQueryable<TSource> source,
2490                         Func<TSource, IQueryable<TResult>> selector)
2491                 {
2492                         if (source == null || selector == null)
2493                                 throw new ArgumentNullException ();
2494
2495                         foreach (TSource element in source)
2496                                 foreach (TResult item in selector (element))
2497                                         yield return item;
2498                 }
2499
2500                 public static IEnumerable<TResult> SelectMany<TSource, TResult> (
2501                         this IQueryable<TSource> source,
2502                         Func<TSource, int, IQueryable<TResult>> selector)
2503                 {
2504                         if (source == null || selector == null)
2505                                 throw new ArgumentNullException ();
2506
2507                         int counter = 0;
2508                         foreach (TSource element in source) {
2509                                 foreach (TResult item in selector (element, counter))
2510                                         yield return item;
2511                                 counter++;
2512                         }
2513                 }
2514
2515                 #endregion
2516
2517                 #region Any
2518
2519                 public static bool Any<TSource> (this IQueryable<TSource> source)
2520                 {
2521                         if (source == null)
2522                                 throw new ArgumentNullException ();
2523
2524                         foreach (TSource element in source)
2525                                 return true;
2526                         return false;
2527                 }
2528
2529                 public static bool Any<TSource> (
2530                         this IQueryable<TSource> source,
2531                         Func<TSource, bool> predicate)
2532                 {
2533                         if (source == null || predicate == null)
2534                                 throw new ArgumentNullException ();
2535
2536                         foreach (TSource element in source)
2537                                 if (predicate(element))
2538                                         return true;
2539                         return false;
2540                 }
2541
2542                 #endregion
2543
2544                 #region All
2545
2546                 public static bool All<TSource> (
2547                         this IQueryable<TSource> source,
2548                         Func<TSource, bool> predicate)
2549                 {
2550                         if (source == null || predicate == null)
2551                                 throw new ArgumentNullException ();
2552
2553                         foreach (TSource element in source)
2554                                 if (!predicate(element))
2555                                         return false;
2556                         return true;
2557                 }
2558
2559                 #endregion
2560
2561                 #region Contains
2562
2563                 public static bool Contains<TSource> (this IQueryable<TSource> source, TSource value)
2564                 {
2565                         if (source is ICollection<TSource>) {
2566                                 ICollection<TSource> collection = (ICollection<TSource>)source;
2567                                 return collection.Contains(value);
2568                         }
2569                         else {
2570                                 foreach (TSource element in source)
2571                                         if (Equals(element, value))
2572                                                 return true;
2573                                 return false;
2574                         }
2575                 }
2576
2577                 #endregion
2578
2579                 #region Where
2580
2581                 public static IEnumerable<TSource> Where<TSource> (
2582                         this IQueryable<TSource> source,
2583                         Func<TSource, bool> predicate)
2584                 {
2585                         if (source == null || predicate == null)
2586                                 throw new ArgumentNullException ();
2587
2588                         foreach (TSource element in source)
2589                                 if (predicate (element))
2590                                         yield return element;
2591                 }
2592
2593                 public static IEnumerable<TSource> Where<TSource> (
2594                         this IQueryable<TSource> source,
2595                         Func<TSource, int, bool> predicate)
2596                 {
2597                         if (source == null || predicate == null)
2598                                 throw new ArgumentNullException ();
2599
2600                         int counter = 0;
2601                         foreach (TSource element in source) {
2602                                 if (predicate (element, counter))
2603                                         yield return element;
2604                                 counter++;
2605                         }
2606                 }
2607
2608                 #endregion
2609
2610                 #region Distinct
2611
2612 /*                [System.Runtime.CompilerServices.Extension]
2613                 public static IQueryable<TSource> Distinct<TSource> (
2614                         IQueryable<TSource> source)
2615                 {
2616                         if (source == null)
2617                                 throw new ArgumentNullException ();
2618
2619                         List<TSource> items = new List<TSource> ();
2620                         foreach (TSource element in source) {
2621                                 if (IndexOf (items, element) == -1) {
2622                                         items.Add (element);
2623                                         yield return element;
2624                                 }
2625                         }
2626                 }*/
2627
2628                 #endregion
2629
2630                 #region Union
2631
2632 /*                [System.Runtime.CompilerServices.Extension]
2633                 public static IQueryable<TSource> Union<TSource> (
2634                         IQueryable<TSource> first,
2635                         IQueryable<TSource> second)
2636                 {
2637                         if (first == null || second == null)
2638                                 throw new ArgumentNullException ();
2639
2640                         List<TSource> items = new List<TSource> ();
2641                         foreach (TSource element in first)  {
2642                                 if (IndexOf (items, element) == -1) {
2643                                         items.Add (element);
2644                                         yield return element;
2645                                 }
2646                         }
2647                         foreach (TSource element in second)  {
2648                                 if (IndexOf (items, element) == -1) {
2649                                         items.Add (element);
2650                                         yield return element;
2651                                 }
2652                         }
2653                 }*/
2654
2655                 #endregion
2656
2657                 #region Intersect
2658
2659 /*                [System.Runtime.CompilerServices.Extension]
2660                 public static IQueryable<TSource> Intersect<TSource> (
2661                         IQueryable<TSource> first,
2662                         IQueryable<TSource> second)
2663                 {
2664                         if (first == null || second == null)
2665                                 throw new ArgumentNullException ();
2666
2667                         List<TSource> items = new List<TSource> (Distinct (first));
2668                         bool[] marked = new bool [items.Count];
2669                         for (int i = 0; i < marked.Length; i++)
2670                                 marked[i] = false;
2671
2672                         foreach (TSource element in second) {
2673                                 int index = IndexOf (items, element);
2674                                 if (index != -1)
2675                                         marked [index] = true;
2676                         }
2677                         for (int i = 0; i < marked.Length; i++) {
2678                                 if (marked [i])
2679                                         yield return items [i];
2680                         }
2681                 }*/
2682
2683                 #endregion
2684
2685                 #region Except
2686
2687                 /*[System.Runtime.CompilerServices.Extension]
2688                 public static IQueryable<TSource> Except<TSource> (
2689                         IQueryable<TSource> first,
2690                         IQueryable<TSource> second)
2691                 {
2692                         if (first == null || second == null)
2693                                 throw new ArgumentNullException ();
2694
2695                         List<TSource> items = new List<TSource> (Distinct (first));
2696                         foreach (TSource element in second) {
2697                                 int index = IndexOf (items, element);
2698                                 if (index == -1)
2699                                         items.Add (element);
2700                                 else
2701                                         items.RemoveAt (index);
2702                         }
2703                         foreach (TSource item in items)
2704                                 yield return item;
2705                 }*/
2706
2707                 #endregion
2708
2709                 # region Join
2710
2711                 public static IEnumerable<V> Join<TSource, U, K, V> (
2712                         this IQueryable<TSource> outer,
2713                         IQueryable<U> inner,
2714                         Func<TSource, K> outerKeySelector,
2715                         Func<U, K> innerKeySelector,
2716                         Func<TSource, U, V> resultSelector)
2717                 {
2718                         if (outer == null || inner == null || outerKeySelector == null ||
2719                                 innerKeySelector == null || resultSelector == null)
2720                                 throw new ArgumentNullException ();
2721
2722                         /*Lookup<K, U> innerKeys = ToLookup<U, K> (inner, innerKeySelector);
2723                         /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
2724                         foreach (U element in inner)
2725                         {
2726                                 K innerKey = innerKeySelector (element);
2727                                 if (!innerKeys.ContainsKey (innerKey))
2728                                         innerKeys.Add (innerKey, new List<U> ());
2729                                 innerKeys[innerKey].Add (element);
2730                         }*/
2731                         /*
2732                         foreach (TSource element in outer)
2733                         {
2734                                 K outerKey = outerKeySelector (element);
2735                                 if (innerKeys.Contains (outerKey))
2736                                 {
2737                                         foreach (U innerElement in innerKeys [outerKey])
2738                                                 yield return resultSelector (element, innerElement);
2739                                 }
2740                         }*/
2741                         throw new NotImplementedException ();
2742                 }
2743
2744                 # endregion
2745
2746                 # region GroupJoin
2747
2748                 /*[System.Runtime.CompilerServices.Extension]
2749                 public static IQueryable<V> GroupJoin<TSource, U, K, V> (
2750                         IQueryable<TSource> outer,
2751                         IQueryable<U> inner,
2752                         Func<TSource, K> outerKeySelector,
2753                         Func<U, K> innerKeySelector,
2754                         Func<TSource, IQueryable<U>, V> resultSelector)
2755                 {
2756                         if (outer == null || inner == null || outerKeySelector == null ||
2757                                 innerKeySelector == null || resultSelector == null)
2758                                 throw new ArgumentNullException ();
2759
2760                         Lookup<K, U> innerKeys = ToLookup<U, K> (inner, innerKeySelector);
2761                         /*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
2762                         foreach (U element in inner)
2763                         {
2764                                 K innerKey = innerKeySelector (element);
2765                                 if (!innerKeys.ContainsKey (innerKey))
2766                                         innerKeys.Add (innerKey, new List<U> ());
2767                                 innerKeys[innerKey].Add (element);
2768                         }*/
2769
2770                         /*foreach (TSource element in outer)
2771                         {
2772                                 K outerKey = outerKeySelector (element);
2773                                 if (innerKeys.Contains (outerKey))
2774                                         yield return resultSelector (element, innerKeys [outerKey]);
2775                         }
2776                 }*/
2777
2778                 # endregion
2779
2780                 // These methods are not included in the
2781                 // .NET Standard Query Operators Specification,
2782                 // but they provide additional useful commands
2783
2784                 #region Compare
2785
2786                 private static bool Equals<TSource> (
2787                         this TSource first, TSource second)
2788                 {
2789                         // Mostly, values in Enumerable<TSource>
2790                         // sequences need to be compared using
2791                         // Equals and GetHashCode
2792
2793                         if (first == null || second == null)
2794                                 return (first == null && second == null);
2795                         else
2796                                 return ((first.Equals (second) ||
2797                                          first.GetHashCode () == second.GetHashCode ()));
2798                 }
2799
2800                 #endregion
2801 /*
2802                 #region IndexOf
2803
2804                 [System.Runtime.CompilerServices.Extension]
2805                 public static int IndexOf<TSource>(
2806                         IQueryable<TSource> source,
2807                         TSource item)
2808                 {
2809                         int counter = 0;
2810                         foreach (TSource element in source) {
2811                                 if (Equals(element, item))
2812                                         return counter;
2813                                 counter++;
2814                         }
2815                         // The item was not found
2816                         return -1;
2817                 }
2818
2819                 #endregion
2820 */
2821         }
2822 }