ReflectionUtil.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Client / System / Data / Services / Client / ALinq / ReflectionUtil.cs / 1305376 / ReflectionUtil.cs

                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner  [....]
//--------------------------------------------------------------------- 
 
namespace System.Data.Services.Client
{ 
    #region Namespaces.

    using System.Collections.Generic;
    using System.Globalization; 
    using System.Linq;
    using System.Reflection; 
    using System.Text; 

    #endregion Namespaces. 

    /// 
    /// Static utility class for identifying methods in Queryable, Sequence, and IEnumerable
    /// and 
    /// 
    internal static class ReflectionUtil 
    { 
        #region Static information on sequence methods
        private static readonly Dictionary s_methodMap; 
        private static readonly Dictionary s_inverseMap;

        // Initialize method map
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline")] 
        static ReflectionUtil()
        { 
            // register known canonical method names 
            Dictionary map = new Dictionary(EqualityComparer.Default);
 
            map.Add(@"Sum(IQueryable`1, Expression`1>)->Double", SequenceMethod.SumDoubleSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.SumNullableDoubleSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>)->Decimal", SequenceMethod.SumDecimalSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.SumNullableDecimalSelector); 
            map.Add(@"Average(IQueryable`1, Expression`1>)->Double", SequenceMethod.AverageIntSelector);
            map.Add(@"Average(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.AverageNullableIntSelector); 
            map.Add(@"Average(IQueryable`1, Expression`1>)->Single", SequenceMethod.AverageSingleSelector); 
            map.Add(@"Average(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.AverageNullableSingleSelector);
            map.Add(@"Average(IQueryable`1, Expression`1>)->Double", SequenceMethod.AverageLongSelector); 
            map.Add(@"Average(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.AverageNullableLongSelector);
            map.Add(@"Average(IQueryable`1, Expression`1>)->Double", SequenceMethod.AverageDoubleSelector);
            map.Add(@"Average(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.AverageNullableDoubleSelector);
            map.Add(@"Average(IQueryable`1, Expression`1>)->Decimal", SequenceMethod.AverageDecimalSelector); 
            map.Add(@"Average(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.AverageNullableDecimalSelector);
            map.Add(@"Aggregate(IQueryable`1, Expression`1>)->T0", SequenceMethod.Aggregate); 
            map.Add(@"Aggregate(IQueryable`1, T1, Expression`1>)->T1", SequenceMethod.AggregateSeed); 
            map.Add(@"Aggregate(IQueryable`1, T1, Expression`1>, Expression`1>)->T2", SequenceMethod.AggregateSeedSelector);
            map.Add(@"AsQueryable(IEnumerable`1)->IQueryable`1", SequenceMethod.AsQueryableGeneric); 
            map.Add(@"Where(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.Where);
            map.Add(@"Where(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.WhereOrdinal);
            map.Add(@"OfType(IQueryable)->IQueryable`1", SequenceMethod.OfType);
            map.Add(@"Cast(IQueryable)->IQueryable`1", SequenceMethod.Cast); 
            map.Add(@"Select(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.Select);
            map.Add(@"Select(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.SelectOrdinal); 
            map.Add(@"SelectMany(IQueryable`1, Expression`1>>)->IQueryable`1", SequenceMethod.SelectMany); 
            map.Add(@"SelectMany(IQueryable`1, Expression`1>>)->IQueryable`1", SequenceMethod.SelectManyOrdinal);
            map.Add(@"SelectMany(IQueryable`1, Expression`1>>, Expression`1>)->IQueryable`1", SequenceMethod.SelectManyOrdinalResultSelector); 
            map.Add(@"SelectMany(IQueryable`1, Expression`1>>, Expression`1>)->IQueryable`1", SequenceMethod.SelectManyResultSelector);
            map.Add(@"Join(IQueryable`1, IEnumerable`1, Expression`1>, Expression`1>, Expression`1>)->IQueryable`1", SequenceMethod.Join);
            map.Add(@"Join(IQueryable`1, IEnumerable`1, Expression`1>, Expression`1>, Expression`1>, IEqualityComparer`1)->IQueryable`1", SequenceMethod.JoinComparer);
            map.Add(@"GroupJoin(IQueryable`1, IEnumerable`1, Expression`1>, Expression`1>, Expression`1, T3>>)->IQueryable`1", SequenceMethod.GroupJoin); 
            map.Add(@"GroupJoin(IQueryable`1, IEnumerable`1, Expression`1>, Expression`1>, Expression`1, T3>>, IEqualityComparer`1)->IQueryable`1", SequenceMethod.GroupJoinComparer);
            map.Add(@"OrderBy(IQueryable`1, Expression`1>)->IOrderedQueryable`1", SequenceMethod.OrderBy); 
            map.Add(@"OrderBy(IQueryable`1, Expression`1>, IComparer`1)->IOrderedQueryable`1", SequenceMethod.OrderByComparer); 
            map.Add(@"OrderByDescending(IQueryable`1, Expression`1>)->IOrderedQueryable`1", SequenceMethod.OrderByDescending);
            map.Add(@"OrderByDescending(IQueryable`1, Expression`1>, IComparer`1)->IOrderedQueryable`1", SequenceMethod.OrderByDescendingComparer); 
            map.Add(@"ThenBy(IOrderedQueryable`1, Expression`1>)->IOrderedQueryable`1", SequenceMethod.ThenBy);
            map.Add(@"ThenBy(IOrderedQueryable`1, Expression`1>, IComparer`1)->IOrderedQueryable`1", SequenceMethod.ThenByComparer);
            map.Add(@"ThenByDescending(IOrderedQueryable`1, Expression`1>)->IOrderedQueryable`1", SequenceMethod.ThenByDescending);
            map.Add(@"ThenByDescending(IOrderedQueryable`1, Expression`1>, IComparer`1)->IOrderedQueryable`1", SequenceMethod.ThenByDescendingComparer); 
            map.Add(@"Take(IQueryable`1, Int32)->IQueryable`1", SequenceMethod.Take);
            map.Add(@"TakeWhile(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.TakeWhile); 
            map.Add(@"TakeWhile(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.TakeWhileOrdinal); 
            map.Add(@"Skip(IQueryable`1, Int32)->IQueryable`1", SequenceMethod.Skip);
            map.Add(@"SkipWhile(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.SkipWhile); 
            map.Add(@"SkipWhile(IQueryable`1, Expression`1>)->IQueryable`1", SequenceMethod.SkipWhileOrdinal);
            map.Add(@"GroupBy(IQueryable`1, Expression`1>)->IQueryable`1>", SequenceMethod.GroupBy);
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1>)->IQueryable`1>", SequenceMethod.GroupByElementSelector);
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, IEqualityComparer`1)->IQueryable`1>", SequenceMethod.GroupByComparer); 
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1>, IEqualityComparer`1)->IQueryable`1>", SequenceMethod.GroupByElementSelectorComparer);
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1>, Expression`1, T3>>)->IQueryable`1", SequenceMethod.GroupByElementSelectorResultSelector); 
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1, T2>>)->IQueryable`1", SequenceMethod.GroupByResultSelector); 
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1, T2>>, IEqualityComparer`1)->IQueryable`1", SequenceMethod.GroupByResultSelectorComparer);
            map.Add(@"GroupBy(IQueryable`1, Expression`1>, Expression`1>, Expression`1, T3>>, IEqualityComparer`1)->IQueryable`1", SequenceMethod.GroupByElementSelectorResultSelectorComparer); 
            map.Add(@"Distinct(IQueryable`1)->IQueryable`1", SequenceMethod.Distinct);
            map.Add(@"Distinct(IQueryable`1, IEqualityComparer`1)->IQueryable`1", SequenceMethod.DistinctComparer);
            map.Add(@"Concat(IQueryable`1, IEnumerable`1)->IQueryable`1", SequenceMethod.Concat);
            map.Add(@"Union(IQueryable`1, IEnumerable`1)->IQueryable`1", SequenceMethod.Union); 
            map.Add(@"Union(IQueryable`1, IEnumerable`1, IEqualityComparer`1)->IQueryable`1", SequenceMethod.UnionComparer);
            map.Add(@"Intersect(IQueryable`1, IEnumerable`1)->IQueryable`1", SequenceMethod.Intersect); 
            map.Add(@"Intersect(IQueryable`1, IEnumerable`1, IEqualityComparer`1)->IQueryable`1", SequenceMethod.IntersectComparer); 
            map.Add(@"Except(IQueryable`1, IEnumerable`1)->IQueryable`1", SequenceMethod.Except);
            map.Add(@"Except(IQueryable`1, IEnumerable`1, IEqualityComparer`1)->IQueryable`1", SequenceMethod.ExceptComparer); 
            map.Add(@"First(IQueryable`1)->T0", SequenceMethod.First);
            map.Add(@"First(IQueryable`1, Expression`1>)->T0", SequenceMethod.FirstPredicate);
            map.Add(@"FirstOrDefault(IQueryable`1)->T0", SequenceMethod.FirstOrDefault);
            map.Add(@"FirstOrDefault(IQueryable`1, Expression`1>)->T0", SequenceMethod.FirstOrDefaultPredicate); 
            map.Add(@"Last(IQueryable`1)->T0", SequenceMethod.Last);
            map.Add(@"Last(IQueryable`1, Expression`1>)->T0", SequenceMethod.LastPredicate); 
            map.Add(@"LastOrDefault(IQueryable`1)->T0", SequenceMethod.LastOrDefault); 
            map.Add(@"LastOrDefault(IQueryable`1, Expression`1>)->T0", SequenceMethod.LastOrDefaultPredicate);
            map.Add(@"Single(IQueryable`1)->T0", SequenceMethod.Single); 
            map.Add(@"Single(IQueryable`1, Expression`1>)->T0", SequenceMethod.SinglePredicate);
            map.Add(@"SingleOrDefault(IQueryable`1)->T0", SequenceMethod.SingleOrDefault);
            map.Add(@"SingleOrDefault(IQueryable`1, Expression`1>)->T0", SequenceMethod.SingleOrDefaultPredicate);
            map.Add(@"ElementAt(IQueryable`1, Int32)->T0", SequenceMethod.ElementAt); 
            map.Add(@"ElementAtOrDefault(IQueryable`1, Int32)->T0", SequenceMethod.ElementAtOrDefault);
            map.Add(@"DefaultIfEmpty(IQueryable`1)->IQueryable`1", SequenceMethod.DefaultIfEmpty); 
            map.Add(@"DefaultIfEmpty(IQueryable`1, T0)->IQueryable`1", SequenceMethod.DefaultIfEmptyValue); 
            map.Add(@"Contains(IQueryable`1, T0)->Boolean", SequenceMethod.Contains);
            map.Add(@"Contains(IQueryable`1, T0, IEqualityComparer`1)->Boolean", SequenceMethod.ContainsComparer); 
            map.Add(@"Reverse(IQueryable`1)->IQueryable`1", SequenceMethod.Reverse);
            map.Add(@"SequenceEqual(IQueryable`1, IEnumerable`1)->Boolean", SequenceMethod.SequenceEqual);
            map.Add(@"SequenceEqual(IQueryable`1, IEnumerable`1, IEqualityComparer`1)->Boolean", SequenceMethod.SequenceEqualComparer);
            map.Add(@"Any(IQueryable`1)->Boolean", SequenceMethod.Any); 
            map.Add(@"Any(IQueryable`1, Expression`1>)->Boolean", SequenceMethod.AnyPredicate);
            map.Add(@"All(IQueryable`1, Expression`1>)->Boolean", SequenceMethod.All); 
            map.Add(@"Count(IQueryable`1)->Int32", SequenceMethod.Count); 
            map.Add(@"Count(IQueryable`1, Expression`1>)->Int32", SequenceMethod.CountPredicate);
            map.Add(@"LongCount(IQueryable`1)->Int64", SequenceMethod.LongCount); 
            map.Add(@"LongCount(IQueryable`1, Expression`1>)->Int64", SequenceMethod.LongCountPredicate);
            map.Add(@"Min(IQueryable`1)->T0", SequenceMethod.Min);
            map.Add(@"Min(IQueryable`1, Expression`1>)->T1", SequenceMethod.MinSelector);
            map.Add(@"Max(IQueryable`1)->T0", SequenceMethod.Max); 
            map.Add(@"Max(IQueryable`1, Expression`1>)->T1", SequenceMethod.MaxSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>)->Int32", SequenceMethod.SumIntSelector); 
            map.Add(@"Sum(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.SumNullableIntSelector); 
            map.Add(@"Sum(IQueryable`1, Expression`1>)->Int64", SequenceMethod.SumLongSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.SumNullableLongSelector); 
            map.Add(@"Sum(IQueryable`1, Expression`1>)->Single", SequenceMethod.SumSingleSelector);
            map.Add(@"Sum(IQueryable`1, Expression`1>>)->Nullable`1", SequenceMethod.SumNullableSingleSelector);
            map.Add(@"AsQueryable(IEnumerable)->IQueryable", SequenceMethod.AsQueryable);
            map.Add(@"Sum(IQueryable`1)->Int32", SequenceMethod.SumInt); 
            map.Add(@"Sum(IQueryable`1>)->Nullable`1", SequenceMethod.SumNullableInt);
            map.Add(@"Sum(IQueryable`1)->Int64", SequenceMethod.SumLong); 
            map.Add(@"Sum(IQueryable`1>)->Nullable`1", SequenceMethod.SumNullableLong); 
            map.Add(@"Sum(IQueryable`1)->Single", SequenceMethod.SumSingle);
            map.Add(@"Sum(IQueryable`1>)->Nullable`1", SequenceMethod.SumNullableSingle); 
            map.Add(@"Sum(IQueryable`1)->Double", SequenceMethod.SumDouble);
            map.Add(@"Sum(IQueryable`1>)->Nullable`1", SequenceMethod.SumNullableDouble);
            map.Add(@"Sum(IQueryable`1)->Decimal", SequenceMethod.SumDecimal);
            map.Add(@"Sum(IQueryable`1>)->Nullable`1", SequenceMethod.SumNullableDecimal); 
            map.Add(@"Average(IQueryable`1)->Double", SequenceMethod.AverageInt);
            map.Add(@"Average(IQueryable`1>)->Nullable`1", SequenceMethod.AverageNullableInt); 
            map.Add(@"Average(IQueryable`1)->Double", SequenceMethod.AverageLong); 
            map.Add(@"Average(IQueryable`1>)->Nullable`1", SequenceMethod.AverageNullableLong);
            map.Add(@"Average(IQueryable`1)->Single", SequenceMethod.AverageSingle); 
            map.Add(@"Average(IQueryable`1>)->Nullable`1", SequenceMethod.AverageNullableSingle);
            map.Add(@"Average(IQueryable`1)->Double", SequenceMethod.AverageDouble);
            map.Add(@"Average(IQueryable`1>)->Nullable`1", SequenceMethod.AverageNullableDouble);
            map.Add(@"Average(IQueryable`1)->Decimal", SequenceMethod.AverageDecimal); 
            map.Add(@"Average(IQueryable`1>)->Nullable`1", SequenceMethod.AverageNullableDecimal);
            map.Add(@"First(IEnumerable`1)->T0", SequenceMethod.First); 
            map.Add(@"First(IEnumerable`1, Func`2)->T0", SequenceMethod.FirstPredicate); 
            map.Add(@"FirstOrDefault(IEnumerable`1)->T0", SequenceMethod.FirstOrDefault);
            map.Add(@"FirstOrDefault(IEnumerable`1, Func`2)->T0", SequenceMethod.FirstOrDefaultPredicate); 
            map.Add(@"Last(IEnumerable`1)->T0", SequenceMethod.Last);
            map.Add(@"Last(IEnumerable`1, Func`2)->T0", SequenceMethod.LastPredicate);
            map.Add(@"LastOrDefault(IEnumerable`1)->T0", SequenceMethod.LastOrDefault);
            map.Add(@"LastOrDefault(IEnumerable`1, Func`2)->T0", SequenceMethod.LastOrDefaultPredicate); 
            map.Add(@"Single(IEnumerable`1)->T0", SequenceMethod.Single);
            map.Add(@"Single(IEnumerable`1, Func`2)->T0", SequenceMethod.SinglePredicate); 
            map.Add(@"SingleOrDefault(IEnumerable`1)->T0", SequenceMethod.SingleOrDefault); 
            map.Add(@"SingleOrDefault(IEnumerable`1, Func`2)->T0", SequenceMethod.SingleOrDefaultPredicate);
            map.Add(@"ElementAt(IEnumerable`1, Int32)->T0", SequenceMethod.ElementAt); 
            map.Add(@"ElementAtOrDefault(IEnumerable`1, Int32)->T0", SequenceMethod.ElementAtOrDefault);
            map.Add(@"Repeat(T0, Int32)->IEnumerable`1", SequenceMethod.NotSupported);
            map.Add(@"Empty()->IEnumerable`1", SequenceMethod.Empty);
            map.Add(@"Any(IEnumerable`1)->Boolean", SequenceMethod.Any); 
            map.Add(@"Any(IEnumerable`1, Func`2)->Boolean", SequenceMethod.AnyPredicate);
            map.Add(@"All(IEnumerable`1, Func`2)->Boolean", SequenceMethod.All); 
            map.Add(@"Count(IEnumerable`1)->Int32", SequenceMethod.Count); 
            map.Add(@"Count(IEnumerable`1, Func`2)->Int32", SequenceMethod.CountPredicate);
            map.Add(@"LongCount(IEnumerable`1)->Int64", SequenceMethod.LongCount); 
            map.Add(@"LongCount(IEnumerable`1, Func`2)->Int64", SequenceMethod.LongCountPredicate);
            map.Add(@"Contains(IEnumerable`1, T0)->Boolean", SequenceMethod.Contains);
            map.Add(@"Contains(IEnumerable`1, T0, IEqualityComparer`1)->Boolean", SequenceMethod.ContainsComparer);
            map.Add(@"Aggregate(IEnumerable`1, Func`3)->T0", SequenceMethod.Aggregate); 
            map.Add(@"Aggregate(IEnumerable`1, T1, Func`3)->T1", SequenceMethod.AggregateSeed);
            map.Add(@"Aggregate(IEnumerable`1, T1, Func`3, Func`2)->T2", SequenceMethod.AggregateSeedSelector); 
            map.Add(@"Sum(IEnumerable`1, Func`2)->Int32", SequenceMethod.SumIntSelector); 
            map.Add(@"Sum(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.SumNullableIntSelector);
            map.Add(@"Sum(IEnumerable`1, Func`2)->Int64", SequenceMethod.SumLongSelector); 
            map.Add(@"Sum(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.SumNullableLongSelector);
            map.Add(@"Sum(IEnumerable`1, Func`2)->Single", SequenceMethod.SumSingleSelector);
            map.Add(@"Sum(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.SumNullableSingleSelector);
            map.Add(@"Sum(IEnumerable`1, Func`2)->Double", SequenceMethod.SumDoubleSelector); 
            map.Add(@"Sum(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.SumNullableDoubleSelector);
            map.Add(@"Sum(IEnumerable`1, Func`2)->Decimal", SequenceMethod.SumDecimalSelector); 
            map.Add(@"Sum(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.SumNullableDecimalSelector); 
            map.Add(@"Min(IEnumerable`1)->T0", SequenceMethod.Min);
            map.Add(@"Min(IEnumerable`1, Func`2)->Int32", SequenceMethod.MinIntSelector); 
            map.Add(@"Min(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MinNullableIntSelector);
            map.Add(@"Min(IEnumerable`1, Func`2)->Int64", SequenceMethod.MinLongSelector);
            map.Add(@"Min(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MinNullableLongSelector);
            map.Add(@"Min(IEnumerable`1, Func`2)->Single", SequenceMethod.MinSingleSelector); 
            map.Add(@"Min(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MinNullableSingleSelector);
            map.Add(@"Min(IEnumerable`1, Func`2)->Double", SequenceMethod.MinDoubleSelector); 
            map.Add(@"Min(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MinNullableDoubleSelector); 
            map.Add(@"Min(IEnumerable`1, Func`2)->Decimal", SequenceMethod.MinDecimalSelector);
            map.Add(@"Min(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MinNullableDecimalSelector); 
            map.Add(@"Min(IEnumerable`1, Func`2)->T1", SequenceMethod.MinSelector);
            map.Add(@"Max(IEnumerable`1)->T0", SequenceMethod.Max);
            map.Add(@"Max(IEnumerable`1, Func`2)->Int32", SequenceMethod.MaxIntSelector);
            map.Add(@"Max(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MaxNullableIntSelector); 
            map.Add(@"Max(IEnumerable`1, Func`2)->Int64", SequenceMethod.MaxLongSelector);
            map.Add(@"Max(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MaxNullableLongSelector); 
            map.Add(@"Max(IEnumerable`1, Func`2)->Single", SequenceMethod.MaxSingleSelector); 
            map.Add(@"Max(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MaxNullableSingleSelector);
            map.Add(@"Max(IEnumerable`1, Func`2)->Double", SequenceMethod.MaxDoubleSelector); 
            map.Add(@"Max(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MaxNullableDoubleSelector);
            map.Add(@"Max(IEnumerable`1, Func`2)->Decimal", SequenceMethod.MaxDecimalSelector);
            map.Add(@"Max(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.MaxNullableDecimalSelector);
            map.Add(@"Max(IEnumerable`1, Func`2)->T1", SequenceMethod.MaxSelector); 
            map.Add(@"Average(IEnumerable`1, Func`2)->Double", SequenceMethod.AverageIntSelector);
            map.Add(@"Average(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.AverageNullableIntSelector); 
            map.Add(@"Average(IEnumerable`1, Func`2)->Double", SequenceMethod.AverageLongSelector); 
            map.Add(@"Average(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.AverageNullableLongSelector);
            map.Add(@"Average(IEnumerable`1, Func`2)->Single", SequenceMethod.AverageSingleSelector); 
            map.Add(@"Average(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.AverageNullableSingleSelector);
            map.Add(@"Average(IEnumerable`1, Func`2)->Double", SequenceMethod.AverageDoubleSelector);
            map.Add(@"Average(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.AverageNullableDoubleSelector);
            map.Add(@"Average(IEnumerable`1, Func`2)->Decimal", SequenceMethod.AverageDecimalSelector); 
            map.Add(@"Average(IEnumerable`1, Func`2>)->Nullable`1", SequenceMethod.AverageNullableDecimalSelector);
            map.Add(@"Where(IEnumerable`1, Func`2)->IEnumerable`1", SequenceMethod.Where); 
            map.Add(@"Where(IEnumerable`1, Func`3)->IEnumerable`1", SequenceMethod.WhereOrdinal); 
            map.Add(@"Select(IEnumerable`1, Func`2)->IEnumerable`1", SequenceMethod.Select);
            map.Add(@"Select(IEnumerable`1, Func`3)->IEnumerable`1", SequenceMethod.SelectOrdinal); 
            map.Add(@"SelectMany(IEnumerable`1, Func`2>)->IEnumerable`1", SequenceMethod.SelectMany);
            map.Add(@"SelectMany(IEnumerable`1, Func`3>)->IEnumerable`1", SequenceMethod.SelectManyOrdinal);
            map.Add(@"SelectMany(IEnumerable`1, Func`3>, Func`3)->IEnumerable`1", SequenceMethod.SelectManyOrdinalResultSelector);
            map.Add(@"SelectMany(IEnumerable`1, Func`2>, Func`3)->IEnumerable`1", SequenceMethod.SelectManyResultSelector); 
            map.Add(@"Take(IEnumerable`1, Int32)->IEnumerable`1", SequenceMethod.Take);
            map.Add(@"TakeWhile(IEnumerable`1, Func`2)->IEnumerable`1", SequenceMethod.TakeWhile); 
            map.Add(@"TakeWhile(IEnumerable`1, Func`3)->IEnumerable`1", SequenceMethod.TakeWhileOrdinal); 
            map.Add(@"Skip(IEnumerable`1, Int32)->IEnumerable`1", SequenceMethod.Skip);
            map.Add(@"SkipWhile(IEnumerable`1, Func`2)->IEnumerable`1", SequenceMethod.SkipWhile); 
            map.Add(@"SkipWhile(IEnumerable`1, Func`3)->IEnumerable`1", SequenceMethod.SkipWhileOrdinal);
            map.Add(@"Join(IEnumerable`1, IEnumerable`1, Func`2, Func`2, Func`3)->IEnumerable`1", SequenceMethod.Join);
            map.Add(@"Join(IEnumerable`1, IEnumerable`1, Func`2, Func`2, Func`3, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.JoinComparer);
            map.Add(@"GroupJoin(IEnumerable`1, IEnumerable`1, Func`2, Func`2, Func`3, T3>)->IEnumerable`1", SequenceMethod.GroupJoin); 
            map.Add(@"GroupJoin(IEnumerable`1, IEnumerable`1, Func`2, Func`2, Func`3, T3>, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.GroupJoinComparer);
            map.Add(@"OrderBy(IEnumerable`1, Func`2)->IOrderedEnumerable`1", SequenceMethod.OrderBy); 
            map.Add(@"OrderBy(IEnumerable`1, Func`2, IComparer`1)->IOrderedEnumerable`1", SequenceMethod.OrderByComparer); 
            map.Add(@"OrderByDescending(IEnumerable`1, Func`2)->IOrderedEnumerable`1", SequenceMethod.OrderByDescending);
            map.Add(@"OrderByDescending(IEnumerable`1, Func`2, IComparer`1)->IOrderedEnumerable`1", SequenceMethod.OrderByDescendingComparer); 
            map.Add(@"ThenBy(IOrderedEnumerable`1, Func`2)->IOrderedEnumerable`1", SequenceMethod.ThenBy);
            map.Add(@"ThenBy(IOrderedEnumerable`1, Func`2, IComparer`1)->IOrderedEnumerable`1", SequenceMethod.ThenByComparer);
            map.Add(@"ThenByDescending(IOrderedEnumerable`1, Func`2)->IOrderedEnumerable`1", SequenceMethod.ThenByDescending);
            map.Add(@"ThenByDescending(IOrderedEnumerable`1, Func`2, IComparer`1)->IOrderedEnumerable`1", SequenceMethod.ThenByDescendingComparer); 
            map.Add(@"GroupBy(IEnumerable`1, Func`2)->IEnumerable`1>", SequenceMethod.GroupBy);
            map.Add(@"GroupBy(IEnumerable`1, Func`2, IEqualityComparer`1)->IEnumerable`1>", SequenceMethod.GroupByComparer); 
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`2)->IEnumerable`1>", SequenceMethod.GroupByElementSelector); 
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`2, IEqualityComparer`1)->IEnumerable`1>", SequenceMethod.GroupByElementSelectorComparer);
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`3, T2>)->IEnumerable`1", SequenceMethod.GroupByResultSelector); 
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`2, Func`3, T3>)->IEnumerable`1", SequenceMethod.GroupByElementSelectorResultSelector);
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`3, T2>, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.GroupByResultSelectorComparer);
            map.Add(@"GroupBy(IEnumerable`1, Func`2, Func`2, Func`3, T3>, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.GroupByElementSelectorResultSelectorComparer);
            map.Add(@"Concat(IEnumerable`1, IEnumerable`1)->IEnumerable`1", SequenceMethod.Concat); 
            map.Add(@"Distinct(IEnumerable`1)->IEnumerable`1", SequenceMethod.Distinct);
            map.Add(@"Distinct(IEnumerable`1, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.DistinctComparer); 
            map.Add(@"Union(IEnumerable`1, IEnumerable`1)->IEnumerable`1", SequenceMethod.Union); 
            map.Add(@"Union(IEnumerable`1, IEnumerable`1, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.UnionComparer);
            map.Add(@"Intersect(IEnumerable`1, IEnumerable`1)->IEnumerable`1", SequenceMethod.Intersect); 
            map.Add(@"Intersect(IEnumerable`1, IEnumerable`1, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.IntersectComparer);
            map.Add(@"Except(IEnumerable`1, IEnumerable`1)->IEnumerable`1", SequenceMethod.Except);
            map.Add(@"Except(IEnumerable`1, IEnumerable`1, IEqualityComparer`1)->IEnumerable`1", SequenceMethod.ExceptComparer);
            map.Add(@"Reverse(IEnumerable`1)->IEnumerable`1", SequenceMethod.Reverse); 
            map.Add(@"SequenceEqual(IEnumerable`1, IEnumerable`1)->Boolean", SequenceMethod.SequenceEqual);
            map.Add(@"SequenceEqual(IEnumerable`1, IEnumerable`1, IEqualityComparer`1)->Boolean", SequenceMethod.SequenceEqualComparer); 
            map.Add(@"AsEnumerable(IEnumerable`1)->IEnumerable`1", SequenceMethod.AsEnumerable); 
            map.Add(@"ToArray(IEnumerable`1)->TSource[]", SequenceMethod.NotSupported);
            map.Add(@"ToList(IEnumerable`1)->List`1", SequenceMethod.ToList); 
            map.Add(@"ToDictionary(IEnumerable`1, Func`2)->Dictionary`2", SequenceMethod.NotSupported);
            map.Add(@"ToDictionary(IEnumerable`1, Func`2, IEqualityComparer`1)->Dictionary`2", SequenceMethod.NotSupported);
            map.Add(@"ToDictionary(IEnumerable`1, Func`2, Func`2)->Dictionary`2", SequenceMethod.NotSupported);
            map.Add(@"ToDictionary(IEnumerable`1, Func`2, Func`2, IEqualityComparer`1)->Dictionary`2", SequenceMethod.NotSupported); 
            map.Add(@"ToLookup(IEnumerable`1, Func`2)->ILookup`2", SequenceMethod.NotSupported);
            map.Add(@"ToLookup(IEnumerable`1, Func`2, IEqualityComparer`1)->ILookup`2", SequenceMethod.NotSupported); 
            map.Add(@"ToLookup(IEnumerable`1, Func`2, Func`2)->ILookup`2", SequenceMethod.NotSupported); 
            map.Add(@"ToLookup(IEnumerable`1, Func`2, Func`2, IEqualityComparer`1)->ILookup`2", SequenceMethod.NotSupported);
            map.Add(@"DefaultIfEmpty(IEnumerable`1)->IEnumerable`1", SequenceMethod.DefaultIfEmpty); 
            map.Add(@"DefaultIfEmpty(IEnumerable`1, T0)->IEnumerable`1", SequenceMethod.DefaultIfEmptyValue);
            map.Add(@"OfType(IEnumerable)->IEnumerable`1", SequenceMethod.OfType);
            map.Add(@"Cast(IEnumerable)->IEnumerable`1", SequenceMethod.Cast);
            map.Add(@"Range(Int32, Int32)->IEnumerable`1", SequenceMethod.NotSupported); 
            map.Add(@"Sum(IEnumerable`1)->Int32", SequenceMethod.SumInt);
            map.Add(@"Sum(IEnumerable`1>)->Nullable`1", SequenceMethod.SumNullableInt); 
            map.Add(@"Sum(IEnumerable`1)->Int64", SequenceMethod.SumLong); 
            map.Add(@"Sum(IEnumerable`1>)->Nullable`1", SequenceMethod.SumNullableLong);
            map.Add(@"Sum(IEnumerable`1)->Single", SequenceMethod.SumSingle); 
            map.Add(@"Sum(IEnumerable`1>)->Nullable`1", SequenceMethod.SumNullableSingle);
            map.Add(@"Sum(IEnumerable`1)->Double", SequenceMethod.SumDouble);
            map.Add(@"Sum(IEnumerable`1>)->Nullable`1", SequenceMethod.SumNullableDouble);
            map.Add(@"Sum(IEnumerable`1)->Decimal", SequenceMethod.SumDecimal); 
            map.Add(@"Sum(IEnumerable`1>)->Nullable`1", SequenceMethod.SumNullableDecimal);
            map.Add(@"Min(IEnumerable`1)->Int32", SequenceMethod.MinInt); 
            map.Add(@"Min(IEnumerable`1>)->Nullable`1", SequenceMethod.MinNullableInt); 
            map.Add(@"Min(IEnumerable`1)->Int64", SequenceMethod.MinLong);
            map.Add(@"Min(IEnumerable`1>)->Nullable`1", SequenceMethod.MinNullableLong); 
            map.Add(@"Min(IEnumerable`1)->Single", SequenceMethod.MinSingle);
            map.Add(@"Min(IEnumerable`1>)->Nullable`1", SequenceMethod.MinNullableSingle);
            map.Add(@"Min(IEnumerable`1)->Double", SequenceMethod.MinDouble);
            map.Add(@"Min(IEnumerable`1>)->Nullable`1", SequenceMethod.MinNullableDouble); 
            map.Add(@"Min(IEnumerable`1)->Decimal", SequenceMethod.MinDecimal);
            map.Add(@"Min(IEnumerable`1>)->Nullable`1", SequenceMethod.MinNullableDecimal); 
            map.Add(@"Max(IEnumerable`1)->Int32", SequenceMethod.MaxInt); 
            map.Add(@"Max(IEnumerable`1>)->Nullable`1", SequenceMethod.MaxNullableInt);
            map.Add(@"Max(IEnumerable`1)->Int64", SequenceMethod.MaxLong); 
            map.Add(@"Max(IEnumerable`1>)->Nullable`1", SequenceMethod.MaxNullableLong);
            map.Add(@"Max(IEnumerable`1)->Double", SequenceMethod.MaxDouble);
            map.Add(@"Max(IEnumerable`1>)->Nullable`1", SequenceMethod.MaxNullableDouble);
            map.Add(@"Max(IEnumerable`1)->Single", SequenceMethod.MaxSingle); 
            map.Add(@"Max(IEnumerable`1>)->Nullable`1", SequenceMethod.MaxNullableSingle);
            map.Add(@"Max(IEnumerable`1)->Decimal", SequenceMethod.MaxDecimal); 
            map.Add(@"Max(IEnumerable`1>)->Nullable`1", SequenceMethod.MaxNullableDecimal); 
            map.Add(@"Average(IEnumerable`1)->Double", SequenceMethod.AverageInt);
            map.Add(@"Average(IEnumerable`1>)->Nullable`1", SequenceMethod.AverageNullableInt); 
            map.Add(@"Average(IEnumerable`1)->Double", SequenceMethod.AverageLong);
            map.Add(@"Average(IEnumerable`1>)->Nullable`1", SequenceMethod.AverageNullableLong);
            map.Add(@"Average(IEnumerable`1)->Single", SequenceMethod.AverageSingle);
            map.Add(@"Average(IEnumerable`1>)->Nullable`1", SequenceMethod.AverageNullableSingle); 
            map.Add(@"Average(IEnumerable`1)->Double", SequenceMethod.AverageDouble);
            map.Add(@"Average(IEnumerable`1>)->Nullable`1", SequenceMethod.AverageNullableDouble); 
            map.Add(@"Average(IEnumerable`1)->Decimal", SequenceMethod.AverageDecimal); 
            map.Add(@"Average(IEnumerable`1>)->Nullable`1", SequenceMethod.AverageNullableDecimal);
 
            // by redirection through canonical method names, determine sequence enum value
            // for all know LINQ operators
            s_methodMap = new Dictionary(EqualityComparer.Default);
            s_inverseMap = new Dictionary(EqualityComparer.Default); 
            foreach (MethodInfo method in GetAllLinqOperators())
            { 
                SequenceMethod sequenceMethod; 
                string canonicalMethod = GetCanonicalMethodDescription(method);
                if (map.TryGetValue(canonicalMethod, out sequenceMethod)) 
                {
                    s_methodMap.Add(method, sequenceMethod);
                    s_inverseMap[sequenceMethod] = method;
                } 
            }
        } 
        #endregion 

        ///  
        /// Identifies methods as instances of known sequence operators.
        /// 
        /// Method info to identify
        /// Identified sequence operator 
        /// true if method is known; false otherwise
        internal static bool TryIdentifySequenceMethod(MethodInfo method, out SequenceMethod sequenceMethod) 
        { 
            method = method.IsGenericMethod ? method.GetGenericMethodDefinition() :
                method; 
            return s_methodMap.TryGetValue(method, out sequenceMethod);
        }

        internal static bool IsSequenceMethod(MethodInfo method, SequenceMethod sequenceMethod) 
        {
            bool result; 
            SequenceMethod foundSequenceMethod; 
            if (ReflectionUtil.TryIdentifySequenceMethod(method, out foundSequenceMethod))
            { 
                result = foundSequenceMethod == sequenceMethod;
            }
            else
            { 
                result = false;
            } 
 
            return result;
        } 

#if false
        /// 
        /// Identifies method call expressions as calls to known sequence operators. 
        /// 
        ///  
        ///     Expression that may represent a call to a known sequence method 
        /// 
        ///  
        ///     If true, and the  argument is a LambdaExpression,
        ///     the Body of the LambdaExpression argument will be retrieved, and that expression will
        ///     then be examined for a sequence method call instead of the Lambda itself.
        ///  
        /// 
        ///     Identified sequence operator 
        ///  
        /// 
        ///     true if  is a  
        ///     and its target method is known; false otherwise
        /// 
        internal static bool TryIdentifySequenceMethod(Expression expression, bool unwrapLambda, out SequenceMethod sequenceMethod)
        { 
            if (expression.NodeType == ExpressionType.Lambda && unwrapLambda)
            { 
                expression = ((LambdaExpression)expression).Body; 
            }
 
            if (expression.NodeType == ExpressionType.Call)
            {
                MethodCallExpression methodCall = (MethodCallExpression)expression;
                return ReflectionUtil.TryIdentifySequenceMethod(methodCall.Method, out sequenceMethod); 
            }
 
            sequenceMethod = default(SequenceMethod); 
            return false;
        } 

        /// 
        /// Looks up some implementation of a sequence method.
        ///  
        /// Sequence method to find
        /// Known method 
        /// true if some method is found; false otherwise 
        internal static bool TryLookupMethod(SequenceMethod sequenceMethod, out MethodInfo method)
        { 
            return s_inverseMap.TryGetValue(sequenceMethod, out method);
        }
#endif
 
        /// 
        /// Requires: 
        /// - no collisions on type names 
        /// - no output or reference method parameters
        ///  
        /// 
        /// Produces a string description of a method consisting of the name and all parameters,
        /// where all generic type parameters have been substituted with number identifiers.
        ///  
        /// Method to identify.
        /// Canonical description of method (suitable for lookup) 
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies")] 
        internal static string GetCanonicalMethodDescription(MethodInfo method)
        { 
            // retrieve all generic type arguments and assign them numbers based on order
            Dictionary genericArgumentOrdinals = null;
            if (method.IsGenericMethodDefinition)
            { 
                genericArgumentOrdinals = method.GetGenericArguments()
                    .Where(t => t.IsGenericParameter) 
                    .Select((t, i) => new KeyValuePair(t, i)) 
                    .ToDictionary(r => r.Key, r => r.Value);
            } 

            StringBuilder description = new StringBuilder();
            description.Append(method.Name).Append("(");
 
            // append types for all method parameters
            bool first = true; 
            foreach (ParameterInfo parameter in method.GetParameters()) 
            {
                if (first) { first = false; } 
                else { description.Append(", "); }
                AppendCanonicalTypeDescription(parameter.ParameterType, genericArgumentOrdinals, description);
            }
 
            description.Append(")");
 
            // include return type 
            if (null != method.ReturnType)
            { 
                description.Append("->");
                AppendCanonicalTypeDescription(method.ReturnType, genericArgumentOrdinals, description);
            }
 
            return description.ToString();
        } 
 
        private static void AppendCanonicalTypeDescription(Type type, Dictionary genericArgumentOrdinals, StringBuilder description)
        { 
            int ordinal;

            // if this a type argument for the method, substitute
            if (null != genericArgumentOrdinals && genericArgumentOrdinals.TryGetValue(type, out ordinal)) 
            {
                description.Append("T").Append(ordinal.ToString(CultureInfo.InvariantCulture)); 
                return; 
            }
 
            // always include the name (note: we omit the namespace/assembly; assuming type names do not collide)
            description.Append(type.Name);

            if (type.IsGenericType) 
            {
                description.Append("<"); 
                bool first = true; 
                foreach (Type genericArgument in type.GetGenericArguments())
                { 
                    if (first) { first = false; }
                    else { description.Append(", "); }
                    AppendCanonicalTypeDescription(genericArgument, genericArgumentOrdinals, description);
                } 
                description.Append(">");
            } 
        } 

        ///  
        /// Returns all static methods in the Queryable and Enumerable classes.
        /// 
        internal static IEnumerable GetAllLinqOperators()
        { 
            return typeof(Queryable).GetMethods(BindingFlags.Static | BindingFlags.Public).Concat(
                typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)); 
        } 
    }
 
    /// 
    /// Enumeration of known extension methods
    /// 
    internal enum SequenceMethod 
    {
        Where, 
        WhereOrdinal, 
        OfType,
        Cast, 
        Select,
        SelectOrdinal,
        SelectMany,
        SelectManyOrdinal, 
        SelectManyResultSelector,
        SelectManyOrdinalResultSelector, 
        Join, 
        JoinComparer,
        GroupJoin, 
        GroupJoinComparer,
        OrderBy,
        OrderByComparer,
        OrderByDescending, 
        OrderByDescendingComparer,
        ThenBy, 
        ThenByComparer, 
        ThenByDescending,
        ThenByDescendingComparer, 
        Take,
        TakeWhile,
        TakeWhileOrdinal,
        Skip, 
        SkipWhile,
        SkipWhileOrdinal, 
        GroupBy, 
        GroupByComparer,
        GroupByElementSelector, 
        GroupByElementSelectorComparer,
        GroupByResultSelector,
        GroupByResultSelectorComparer,
        GroupByElementSelectorResultSelector, 
        GroupByElementSelectorResultSelectorComparer,
        Distinct, 
        DistinctComparer, 
        Concat,
        Union, 
        UnionComparer,
        Intersect,
        IntersectComparer,
        Except, 
        ExceptComparer,
        First, 
        FirstPredicate, 
        FirstOrDefault,
        FirstOrDefaultPredicate, 
        Last,
        LastPredicate,
        LastOrDefault,
        LastOrDefaultPredicate, 
        Single,
        SinglePredicate, 
        SingleOrDefault, 
        SingleOrDefaultPredicate,
        ElementAt, 
        ElementAtOrDefault,
        DefaultIfEmpty,
        DefaultIfEmptyValue,
        Contains, 
        ContainsComparer,
        Reverse, 
        Empty, 
        SequenceEqual,
        SequenceEqualComparer, 

        Any,
        AnyPredicate,
        All, 

        Count, 
        CountPredicate, 
        LongCount,
        LongCountPredicate, 

        Min,
        MinSelector,
        Max, 
        MaxSelector,
 
        MinInt, 
        MinNullableInt,
        MinLong, 
        MinNullableLong,
        MinDouble,
        MinNullableDouble,
        MinDecimal, 
        MinNullableDecimal,
        MinSingle, 
        MinNullableSingle, 
        MinIntSelector,
        MinNullableIntSelector, 
        MinLongSelector,
        MinNullableLongSelector,
        MinDoubleSelector,
        MinNullableDoubleSelector, 
        MinDecimalSelector,
        MinNullableDecimalSelector, 
        MinSingleSelector, 
        MinNullableSingleSelector,
 
        MaxInt,
        MaxNullableInt,
        MaxLong,
        MaxNullableLong, 
        MaxDouble,
        MaxNullableDouble, 
        MaxDecimal, 
        MaxNullableDecimal,
        MaxSingle, 
        MaxNullableSingle,
        MaxIntSelector,
        MaxNullableIntSelector,
        MaxLongSelector, 
        MaxNullableLongSelector,
        MaxDoubleSelector, 
        MaxNullableDoubleSelector, 
        MaxDecimalSelector,
        MaxNullableDecimalSelector, 
        MaxSingleSelector,
        MaxNullableSingleSelector,

        SumInt, 
        SumNullableInt,
        SumLong, 
        SumNullableLong, 
        SumDouble,
        SumNullableDouble, 
        SumDecimal,
        SumNullableDecimal,
        SumSingle,
        SumNullableSingle, 
        SumIntSelector,
        SumNullableIntSelector, 
        SumLongSelector, 
        SumNullableLongSelector,
        SumDoubleSelector, 
        SumNullableDoubleSelector,
        SumDecimalSelector,
        SumNullableDecimalSelector,
        SumSingleSelector, 
        SumNullableSingleSelector,
 
        AverageInt, 
        AverageNullableInt,
        AverageLong, 
        AverageNullableLong,
        AverageDouble,
        AverageNullableDouble,
        AverageDecimal, 
        AverageNullableDecimal,
        AverageSingle, 
        AverageNullableSingle, 
        AverageIntSelector,
        AverageNullableIntSelector, 
        AverageLongSelector,
        AverageNullableLongSelector,
        AverageDoubleSelector,
        AverageNullableDoubleSelector, 
        AverageDecimalSelector,
        AverageNullableDecimalSelector, 
        AverageSingleSelector, 
        AverageNullableSingleSelector,
 
        Aggregate,
        AggregateSeed,
        AggregateSeedSelector,
 
        AsQueryable,
        AsQueryableGeneric, 
        AsEnumerable, 

        ToList, 

        NotSupported,
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK