yield (C# Reference)

You use a yield return statement to return each element one at a time.

//using System.Collections;  
//using System.Diagnostics; 
public static void Process()
{
    // Display powers of 2 up to the exponent of 8:  
    foreach (int number in Power(2, 8))
    {
        Debug.Write(number.ToString() + " ");
    }
    // Output: 2 4 8 16 32 64 128 256
}


public static IEnumerable Power(int baseNumber, int highExponent)
{
    int result = 1;

    for (int counter = 1; counter <= highExponent; counter++)
    {
        result = result * baseNumber;
        yield return result;
    }
}

public static class GalaxyClass
{
    public static void ShowGalaxies()
    {
        var theGalaxies = new Galaxies();
        foreach (Galaxy theGalaxy in theGalaxies.NextGalaxy)
        {
            Debug.WriteLine(theGalaxy.Name + " " + theGalaxy.MegaLightYears.ToString());
        }
    }

    public class Galaxies
    {

        public System.Collections.Generic.IEnumerable<Galaxy> NextGalaxy
        {
            get
            {
                yield return new Galaxy { Name = "Tadpole", MegaLightYears = 400 };
                yield return new Galaxy { Name = "Pinwheel", MegaLightYears = 25 };
                yield return new Galaxy { Name = "Milky Way", MegaLightYears = 0 };
                yield return new Galaxy { Name = "Andromeda", MegaLightYears = 3 };
            }
        }

    }

    public class Galaxy
    {
        public String Name { get; set; }
        public int MegaLightYears { get; set; }
    }

LINQPad

A good way to experiment with LINQ is to download LINQPad (http://www.linqpad.net). LINQPad lets you interactively query local collections and SQL database in
LINQ without any setup and is preloaded with numerous examples.

Selecting Second element from Array using LINQ

Selecting Second element from an Array using LINQ.

Sample1::
 string actnum = readLine.Split(',').ElementAt(1);

Sample2:
 var actnum1 = readLine.Split(',').Skip(1).Take(1);

Extract numbers from a string using LINQ.

Extract numbers from a string using LINQ.

Code Snippet


 string result = new String("y0urstr1ngW1thNumb3rs".
                    Where(x => Char.IsDigit(x)).ToArray());

Usage of LET in LINQ

Usage of LET in LINQ




    var query = from row in dt.AsEnumerable()
                                let ptrn = PaternMatch(row, out rw2Str)
                                where ptrn != null
                                select new { row, ptrn, rw2Str };

     foreach (var qry in query)

            {              

                string.Format("Ptrn:[{0}] row2Str:[{1}]", qry.ptrn, qry.rw2Str));

                qry.row.Delete();

            }

            dt.AcceptChanges();

    private string PaternMatch(DataRow dr , out string rw2Str){

            rw2Str = "test row to string";

            return "test patern";

        }

 

       

[Using list ForEach] Convert list values to string, appending with delimiter

Using Linq  we can convert list values to string appending with delimiter. Here it is appended with '|' (pipe)


Code snippet:

Example:1

            string strData = "World is Mine";
            string[] split = strData.Split(' ');

            //logic work done on split values.
            //  .
            //  .
            //  .
            //  .
            //  .
            //  .
            //


            StringBuilder stringBuilder = new StringBuilder();
            split.ToList().ForEach(n => stringBuilder.AppendFormat("{0}|", n));

            string strOut = stringBuilder.ToString();

Example:2


        List<string> itemArray = new List<string>()
            {
                 "CUSTOMERNAME","FIRST CROSS"
            };

            List<string> masterlst = new List<string>()
            {
                "CUSTOMERNAME","CUSTOMERNA","B","B1"
            };

            List<string> ptrn = new List<string>();
            itemArray.ForEach(n => ptrn.Add(masterlst.Find(n.Contains)));

VB Script to delete only .txt file(S)

VB Script to delete only .txt file(S) in the directory only if Date Last Modified is greater than 10 days.


Sub DeleteTxtFile()

Dim Directory
Dim Modified
Dim Files
Dim File

Set fso = CreateObject("Scripting.FileSystemObject")

Set Directory = fso.GetFolder("D:\test")

Set Files = Directory.Files

For Each folderIdx In Files

    If Right(folderIdx, 4) = ".txt" Then
        If DateDiff("D", folderIdx.DateLastModified, Now) > 10 Then folderIdx.Delete
    End If
   
Next

End Sub

Sample joining two object data

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

namespace CustomClass

{

    class Program

    {

        static void Main(string[] args)

        {

            CustomCustomerInfo[] cc = new []{

                new CustomCustomerInfo {accountnumber="100",name="ABC COMPANY",address1="ABC ADDRESS",address2="",city="ABC CITY",

                region="ABC REGION"},

                new CustomCustomerInfo {accountnumber="200",name="PQR COMPANY",address1="PQR ADDRESS",address2="",city="PQR CITY",

                region="PQR REGION"},

                new CustomCustomerInfo {accountnumber="300",name="XYZ COMPANY",address1="XYZ ADDRESS",address2="",city="XYZ CITY",

                region="XYZ REGION"}

            };

            CustomAgingInfo[] aa = new[]{

                new CustomAgingInfo {accountnumber="100",debtcurrent="11",debt30="15"},

                new CustomAgingInfo {accountnumber="100",debtcurrent="13",debt30="14"},

                new CustomAgingInfo {accountnumber="100",debtcurrent="12",debt30="10"},

                new CustomAgingInfo {accountnumber="200",debtcurrent="14",debt30="1"},

                new CustomAgingInfo {accountnumber="300",debtcurrent="15",debt30="9"},

                new CustomAgingInfo {accountnumber="300",debtcurrent="19",debt30="8"},

                new CustomAgingInfo {accountnumber="300",debtcurrent="18",debt30="16"},

            };

            var query = from cu in cc

                        join ag in aa on cu.accountnumber equals ag.accountnumber into agg

                        select new { cu, agg };

            foreach (var data in query)

            {

                foreach(var agi in data.agg){

                    Console.WriteLine(data.cu.accountnumber + "|" + data.cu.name + "|" + data.cu.address1

                        + "|" + data.cu.address2+ "|" + data.cu.city + "|" + data.cu.region

                        + "|" + agi.debtcurrent + "|" + agi.debt30);

                }

            }

        }

    }

    class CustomCustomerInfo

    {

        public string accountnumber

        {

            get;

            set;

        }

        public string name

        {

            get;

            set;

        }

        public string address1

        {

            get;

            set;

        }

        public string address2

        {

            get;

            set;

        }

        public string city

        {

            get;

            set;

        }

        public string region

        {

            get;

            set;

        }

        public override string ToString()

        {

            return string.Format("{0}|{1}|{2}|{3}|{4}|{5}", accountnumber, name, address1, address2, city, region);

        }

    }

    class CustomAgingInfo

    {

        public string accountnumber

        {

            get;

            set;

        }

        public string debtcurrent

        {

            get;

            set;

        }

        public string debt30

        {

            get;

            set;

        }

     

       

    }

}

Projecting New Data Types

Projecting New Data Types

Projecting New Data Types

LINQ As a Better Venn Diagramming Tool

LINQ As a Better Venn Diagramming Tool

LINQ As a Better Venn Diagramming Tool

Filtering Data Using OfType

Filtering Data Using OfType

Applying LINQ Queries to Nongeneric Collections

Applying LINQ Queries to Nongeneric Collections

Applying LINQ queries to Collection Objects

Applying LINQ queries to Collection Objects

LINQ SAMPLES

“LINQ is privileged to be called a compiler based technology”. 

Other technologies (ASP.Net, WCF) are only API driven. Where in .NET TYPES (classes, interfaces, enum, struct) dominates. LINQ on the other hand is first compiler driven and then API driven.

LINQ is known for providing you with consistent approach of accessing data from data source of any kind or creed.

Introduction

This sample shows different uses of Restriction Operators:

• Where - Simple 1
• Where - Simple 2
• Where - Simple 3
• Where - Drilldown
• Where - Indexed

Building the Sample

1. Open the Program.cs
2. Comment or uncomment the desired samples
3. Press Ctrl + F5

Description

Where - Simple 1

This sample uses where to find all elements of an array less than 5.

Source Code

C#

    public void Linq1()
    {
        int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
     
        var lowNums =
            from n in numbers
            where n < 5
            select n;
     
        Console.WriteLine("Numbers < 5:");
        foreach (var x in lowNums)
        {
            Console.WriteLine(x);
        }
    }

Result

Numbers < 5:
4
1
3
2
0

Where - Simple 2

This sample uses where to find all products that are out of stock.

Source Code

C#

    public void Linq2()
    {
        List<Product> products = GetProductList();
     
        var soldOutProducts =
            from p in products
            where p.UnitsInStock == 0
            select p;
     
        Console.WriteLine("Sold out products:");
        foreach (var product in soldOutProducts)
        {
            Console.WriteLine("{0} is sold out!", product.ProductName);
        }
    }

Result

Sold out products:
Chef Anton's Gumbo Mix is sold out!
Alice Mutton is sold out!
Thüringer Rostbratwurst is sold out!
Gorgonzola Telino is sold out!
Perth Pasties is sold out!

Where - Simple 3

This sample uses where to find all products that are in stock and cost more than 3.00 per unit.

Source Code

C#

    public void Linq3()
    {
        List<Product> products = GetProductList();
     
        var expensiveInStockProducts =
            from p in products
            where p.UnitsInStock > 0 && p.UnitPrice > 3.00M
            select p;
     
        Console.WriteLine("In-stock products that cost more than 3.00:");
        foreach (var product in expensiveInStockProducts)
        {
            Console.WriteLine("{0} is in stock and costs more than 3.00.", product.ProductName);
        }
    }

Result

In-stock products that cost more than 3.00:
Chai is in stock and costs more than 3.00.
Chang is in stock and costs more than 3.00.
Aniseed Syrup is in stock and costs more than 3.00.
Chef Anton's Cajun Seasoning is in stock and costs more than 3.00.
Grandma's Boysenberry Spread is in stock and costs more than 3.00.
Uncle Bob's Organic Dried Pears is in stock and costs more than 3.00.
Northwoods Cranberry Sauce is in stock and costs more than 3.00.
Mishi Kobe Niku is in stock and costs more than 3.00.
Ikura is in stock and costs more than 3.00.
Queso Cabrales is in stock and costs more than 3.00.
Queso Manchego La Pastora is in stock and costs more than 3.00.
Konbu is in stock and costs more than 3.00.
Tofu is in stock and costs more than 3.00.
Genen Shouyu is in stock and costs more than 3.00.
Pavlova is in stock and costs more than 3.00.
Carnarvon Tigers is in stock and costs more than 3.00.
Teatime Chocolate Biscuits is in stock and costs more than 3.00.
Sir Rodney's Marmalade is in stock and costs more than 3.00.
Sir Rodney's Scones is in stock and costs more than 3.00.
Gustaf's Knäckebröd is in stock and costs more than 3.00.
Tunnbröd is in stock and costs more than 3.00.
Guaraná Fantástica is in stock and costs more than 3.00.
NuNuCa Nuß-Nougat-Creme is in stock and costs more than 3.00.
Gumbär Gummibärchen is in stock and costs more than 3.00.
Schoggi Schokolade is in stock and costs more than 3.00.
Rössle Sauerkraut is in stock and costs more than 3.00.
Nord-Ost Matjeshering is in stock and costs more than 3.00.
Mascarpone Fabioli is in stock and costs more than 3.00.
Sasquatch Ale is in stock and costs more than 3.00.
Steeleye Stout is in stock and costs more than 3.00.
Inlagd Sill is in stock and costs more than 3.00.
Gravad lax is in stock and costs more than 3.00.
Côte de Blaye is in stock and costs more than 3.00.
Chartreuse verte is in stock and costs more than 3.00.
Boston Crab Meat is in stock and costs more than 3.00.
Jack's New England Clam Chowder is in stock and costs more than 3.00.
Singaporean Hokkien Fried Mee is in stock and costs more than 3.00.
Ipoh Coffee is in stock and costs more than 3.00.
Gula Malacca is in stock and costs more than 3.00.
Rogede sild is in stock and costs more than 3.00.
Spegesild is in stock and costs more than 3.00.
Zaanse koeken is in stock and costs more than 3.00.
Chocolade is in stock and costs more than 3.00.
Maxilaku is in stock and costs more than 3.00.
Valkoinen suklaa is in stock and costs more than 3.00.
Manjimup Dried Apples is in stock and costs more than 3.00.
Filo Mix is in stock and costs more than 3.00.
Tourtière is in stock and costs more than 3.00.
Pâté chinois is in stock and costs more than 3.00.
Gnocchi di nonna Alice is in stock and costs more than 3.00.
Ravioli Angelo is in stock and costs more than 3.00.
Escargots de Bourgogne is in stock and costs more than 3.00.
Raclette Courdavault is in stock and costs more than 3.00.
Camembert Pierrot is in stock and costs more than 3.00.
Sirop d'érable is in stock and costs more than 3.00.
Tarte au sucre is in stock and costs more than 3.00.
Vegie-spread is in stock and costs more than 3.00.
Wimmers gute Semmelknödel is in stock and costs more than 3.00.
Louisiana Fiery Hot Pepper Sauce is in stock and costs more than 3.00.
Louisiana Hot Spiced Okra is in stock and costs more than 3.00.
Laughing Lumberjack Lager is in stock and costs more than 3.00.
Scottish Longbreads is in stock and costs more than 3.00.
Gudbrandsdalsost is in stock and costs more than 3.00.
Outback Lager is in stock and costs more than 3.00.
Flotemysost is in stock and costs more than 3.00.
Mozzarella di Giovanni is in stock and costs more than 3.00.
Röd Kaviar is in stock and costs more than 3.00.
Longlife Tofu is in stock and costs more than 3.00.
Rhönbräu Klosterbier is in stock and costs more than 3.00.
Lakkalikööri is in stock and costs more than 3.00.
Original Frankfurter grüne Soße is in stock and costs more than 3.00.

Where - Drilldown

This sample uses where to find all customers in Washington and then uses the resulting sequence to drill down into their orders.

Source Code

C#

    public void Linq4()
    {
        List<Customer> customers = GetCustomerList();
     
        var waCustomers =
            from c in customers
            where c.Region == "WA"
            select c;
     
        Console.WriteLine("Customers from Washington and their orders:");
        foreach (var customer in waCustomers)
        {
            Console.WriteLine("Customer {0}: {1}", customer.CustomerID, customer.CompanyName);
            foreach (var order in customer.Orders)
            {
                Console.WriteLine("  Order {0}: {1}", order.OrderID, order.OrderDate);
            }
        }
    }

Result

Customers from Washington and their orders:
Customer LAZYK: Lazy K Kountry Store
Order 10482: 3/21/1997 12:00:00 AM
Order 10545: 5/22/1997 12:00:00 AM
Customer TRAIH: Trail's Head Gourmet Provisioners
Order 10574: 6/19/1997 12:00:00 AM
Order 10577: 6/23/1997 12:00:00 AM
Order 10822: 1/8/1998 12:00:00 AM
Customer WHITC: White Clover Markets
Order 10269: 7/31/1996 12:00:00 AM
Order 10344: 11/1/1996 12:00:00 AM
Order 10469: 3/10/1997 12:00:00 AM
Order 10483: 3/24/1997 12:00:00 AM
Order 10504: 4/11/1997 12:00:00 AM
Order 10596: 7/11/1997 12:00:00 AM
Order 10693: 10/6/1997 12:00:00 AM
Order 10696: 10/8/1997 12:00:00 AM
Order 10723: 10/30/1997 12:00:00 AM
Order 10740: 11/13/1997 12:00:00 AM
Order 10861: 1/30/1998 12:00:00 AM
Order 10904: 2/24/1998 12:00:00 AM
Order 11032: 4/17/1998 12:00:00 AM
Order 11066: 5/1/1998 12:00:00 AM

Where - Indexed

This sample demonstrates an indexed Where clause that returns digits whose name is shorter than their value.

Source Code

C#

    public void Linq5()
    {
        string[] digits = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
     
        var shortDigits = digits.Where((digit, index) => digit.Length < index);
     
        Console.WriteLine("Short digits:");
        foreach (var d in shortDigits)
        {
            Console.WriteLine("The word {0} is shorter than its value.", d);
        }
    }

Result

Short digits:
The word five is shorter than its value.
The word six is shorter than its value.
The word seven is shorter than its value.
The word eight is shorter than its value.
The word nine is shorter than its value.

LINQ - Set Operators

Introduction

This sample shows different uses of Set Operators:

• Distinct - 1
• Distinct - 2
• Union - 1
• Union - 2
• Intersect - 1
• Intersect - 2
• Except - 1
• Except - 2

Building the Sample

1. Open the Program.cs
2. Comment or uncomment the desired samples
3. Press Ctrl + F5

Description

Distinct - 1

This sample uses Distinct to remove duplicate elements in a sequence of factors of 300.

C#

public void Linq46()
{
    int[] factorsOf300 = { 2, 2, 3, 5, 5 };
 
    var uniqueFactors = factorsOf300.Distinct();
 
    Console.WriteLine("Prime factors of 300:");
    foreach (var f in uniqueFactors)
    {
        Console.WriteLine(f);
    }
}

Result

Prime factors of 300:
2
3
5

Distinct - 2

This sample uses Distinct to find the unique Category names.

C#

public void Linq47()
{
    List<Product> products = GetProductList();
 
    var categoryNames = (
        from p in products
        select p.Category)
        .Distinct();
 
    Console.WriteLine("Category names:");
    foreach (var n in categoryNames)
    {
        Console.WriteLine(n);
    }
}

 Result

Category names:
Beverages
Condiments
Produce
Meat/Poultry
Seafood
Dairy Products
Confections
Grains/Cereals

Union - 1

This sample uses Union to create one sequence that contains the unique values from both arrays.

C#

public void Linq48()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    var uniqueNumbers = numbersA.Union(numbersB);
 
    Console.WriteLine("Unique numbers from both arrays:");
    foreach (var n in uniqueNumbers)
    {
        Console.WriteLine(n);
    }
}

Result

Unique numbers from both arrays:
0
2
4
5
6
8
9
1
3
7

Union - 2

This sample uses Union to create one sequence that contains the unique first letter from both product and customer names.

C#

public void Linq49()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var uniqueFirstChars = productFirstChars.Union(customerFirstChars);
 
    Console.WriteLine("Unique first letters from Product names and Customer names:");
    foreach (var ch in uniqueFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

Unique first letters from Product names and Customer names:
C
A
G
U
N
M
I
Q
K
T
P
S
R
B
J
Z
V
F
E
W
L
O
D
H

Intersect - 1

This sample uses Intersect to create one sequence that contains the common values shared by both arrays.

C#

public void Linq50()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    var commonNumbers = numbersA.Intersect(numbersB);
 
    Console.WriteLine("Common numbers shared by both arrays:");
    foreach (var n in commonNumbers)
    {
        Console.WriteLine(n);
    }
}

 Result

Common numbers shared by both arrays:
5
8

Intersect - 2

This sample uses Intersect to create one sequence that contains the common first letter from both product and customer names.

C#

public void Linq51()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var commonFirstChars = productFirstChars.Intersect(customerFirstChars);
 
    Console.WriteLine("Common first letters from Product names and Customer names:");
    foreach (var ch in commonFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

Common first letters from Product names and Customer names:
C
A
G
N
M
I
Q
K
T
P
S
R
B
V
F
E
W
L
O

Except - 1

This sample uses Except to create a sequence that contains the values from numbersAthat are not also in numbersB.

C#

public void Linq52()
{
    int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
    int[] numbersB = { 1, 3, 5, 7, 8 };
 
    IEnumerable<int> aOnlyNumbers = numbersA.Except(numbersB);
 
    Console.WriteLine("Numbers in first array but not second array:");
    foreach (var n in aOnlyNumbers)
    {
        Console.WriteLine(n);
    }
}

 Result

Numbers in first array but not second array:
0
2
4
6
9

Except - 2

This sample uses Except to create one sequence that contains the first letters of product names that are not also first letters of customer names.

C#

public void Linq53()
{
    List<Product> products = GetProductList();
    List<Customer> customers = GetCustomerList();
 
    var productFirstChars =
        from p in products
        select p.ProductName[0];
    var customerFirstChars =
        from c in customers
        select c.CompanyName[0];
 
    var productOnlyFirstChars = productFirstChars.Except(customerFirstChars);
 
    Console.WriteLine("First letters from Product names, but not from Customer names:");
    foreach (var ch in productOnlyFirstChars)
    {
        Console.WriteLine(ch);
    }
}

Result

First letters from Product names, but not from Customer names:
U
J
Z

Various LINQ Query operations

Various LINQ Query operations

IEnumerable Interface

IEnumerable<T> Interface

.NET Framework 4.5

Other Versions

1 out of 2 rated this helpful - Rate this topic

Exposes the enumerator, which supports a simple iteration over a collection of a specified type.

Namespace:  System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

Syntax

---

C#

C++

F#

VB

public interface IEnumerable<out T> : IEnumerable

Type Parameters

outT

The type of objects to enumerate.

This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics.

The IEnumerable<T> type exposes the following members.

Methods

---

	Name	Description
	GetEnumerator()	Returns an enumerator that iterates through a collection. (Inherited from IEnumerable.)
	GetEnumerator()	Returns an enumerator that iterates through the collection.

Top

Extension Methods

---

	Name	Description
	Aggregate<TSource>(Func<TSource, TSource, TSource>)	Overloaded. Applies an accumulator function over a sequence. (Defined byEnumerable.)
	Aggregate<TSource, TAccumulate>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>)	Overloaded. Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value. (Defined by Enumerable.)
	Aggregate<TSource, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>)	Overloaded. Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value. (Defined by Enumerable.)
	All<TSource>	Determines whether all elements of a sequence satisfy a condition. (Defined by Enumerable.)
	Ancestors<T>()	Overloaded. Returns a collection of elements that contains the ancestors of every node in the source collection. (Defined by Extensions.)
	Ancestors<T>(XName)	Overloaded. Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Only elements that have a matching XName are included in the collection. (Defined by Extensions.)
	Any<TSource>()	Overloaded. Determines whether a sequence contains any elements. (Defined by Enumerable.)
	Any<TSource>(Func<TSource, Boolean>)	Overloaded. Determines whether any element of a sequence satisfies a condition. (Defined by Enumerable.)
	AsEnumerable<TSource>	Returns the input typed as IEnumerable<T>. (Defined by Enumerable.)
	AsParallel()	Overloaded. Enables parallelization of a query. (Defined byParallelEnumerable.)
	AsParallel<TSource>()	Overloaded. Enables parallelization of a query. (Defined byParallelEnumerable.)
	AsQueryable()	Overloaded. Converts an IEnumerable to an IQueryable. (Defined byQueryable.)
	AsQueryable<TElement>()	Overloaded. Converts a generic IEnumerable<T> to a generic IQueryable<T>.(Defined by Queryable.)
	Average<TSource>(Func<TSource, Decimal>)	Overloaded. Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Nullable<Decimal>>)	Overloaded. Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Double>)	Overloaded. Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Nullable<Double>>)	Overloaded. Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Int32>)	Overloaded. Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Nullable<Int32>>)	Overloaded. Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Int64>)	Overloaded. Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Nullable<Int64>>)	Overloaded. Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Single>)	Overloaded. Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Average<TSource>(Func<TSource, Nullable<Single>>)	Overloaded. Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Cast<TResult>	Casts the elements of an IEnumerable to the specified type. (Defined byEnumerable.)
	Concat<TSource>	Concatenates two sequences. (Defined by Enumerable.)
	Contains<TSource>(TSource)	Overloaded. Determines whether a sequence contains a specified element by using the default equality comparer. (Defined by Enumerable.)
	Contains<TSource>(TSource, IEqualityComparer<TSource>)	Overloaded. Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>. (Defined by Enumerable.)
	CopyToDataTable<T>()	Overloaded. Returns a DataTable that contains copies of the DataRowobjects, given an input IEnumerable<T> object where the generic parameterT is DataRow. (Defined by DataTableExtensions.)
	CopyToDataTable<T>(DataTable, LoadOption)	Overloaded. Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.(Defined by DataTableExtensions.)
	CopyToDataTable<T>(DataTable, LoadOption, FillErrorEventHandler)	Overloaded. Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.(Defined by DataTableExtensions.)
	Count<TSource>()	Overloaded. Returns the number of elements in a sequence. (Defined byEnumerable.)
	Count<TSource>(Func<TSource, Boolean>)	Overloaded. Returns a number that represents how many elements in the specified sequence satisfy a condition. (Defined by Enumerable.)
	DefaultIfEmpty<TSource>()	Overloaded. Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.(Defined by Enumerable.)
	DefaultIfEmpty<TSource>(TSource)	Overloaded. Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty. (Defined byEnumerable.)
	DescendantNodes<T>	Returns a collection of the descendant nodes of every document and element in the source collection. (Defined by Extensions.)
	Descendants<T>()	Overloaded. Returns a collection of elements that contains the descendant elements of every element and document in the source collection. (Defined by Extensions.)
	Descendants<T>(XName)	Overloaded. Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Only elements that have a matching XName are included in the collection. (Defined by Extensions.)
	Distinct<TSource>()	Overloaded. Returns distinct elements from a sequence by using the default equality comparer to compare values. (Defined by Enumerable.)
	Distinct<TSource>(IEqualityComparer<TSource>)	Overloaded. Returns distinct elements from a sequence by using a specifiedIEqualityComparer<T> to compare values. (Defined by Enumerable.)
	ElementAt<TSource>	Returns the element at a specified index in a sequence. (Defined byEnumerable.)
	ElementAtOrDefault<TSource>	Returns the element at a specified index in a sequence or a default value if the index is out of range. (Defined by Enumerable.)
	Elements<T>()	Overloaded. Returns a collection of the child elements of every element and document in the source collection. (Defined by Extensions.)
	Elements<T>(XName)	Overloaded. Returns a filtered collection of the child elements of every element and document in the source collection. Only elements that have a matching XName are included in the collection. (Defined by Extensions.)
	Except<TSource>(IEnumerable<TSource>)	Overloaded. Produces the set difference of two sequences by using the default equality comparer to compare values. (Defined by Enumerable.)
	Except<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Overloaded. Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values. (Defined byEnumerable.)
	First<TSource>()	Overloaded. Returns the first element of a sequence. (Defined byEnumerable.)
	First<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the first element in a sequence that satisfies a specified condition. (Defined by Enumerable.)
	FirstOrDefault<TSource>()	Overloaded. Returns the first element of a sequence, or a default value if the sequence contains no elements. (Defined by Enumerable.)
	FirstOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. (Defined byEnumerable.)
	GroupBy<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Groups the elements of a sequence according to a specified key selector function. (Defined by Enumerable.)
	GroupBy<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.(Defined by Enumerable.)
	GroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function. (Defined by Enumerable.)
	GroupBy<TSource, TKey, TResult>(Func<TSource, TKey>, Func<TKey, IEnumerable<TSource>, TResult>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.(Defined by Enumerable.)
	GroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. (Defined byEnumerable.)
	GroupBy<TSource, TKey, TResult>(Func<TSource, TKey>, Func<TKey, IEnumerable<TSource>, TResult>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer. (Defined by Enumerable.)
	GroupBy<TSource, TKey, TElement, TResult>(Func<TSource, TKey>, Func<TSource, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function. (Defined by Enumerable.)
	GroupBy<TSource, TKey, TElement, TResult>(Func<TSource, TKey>, Func<TSource, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Overloaded. Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function. (Defined byEnumerable.)
	GroupJoin<TOuter, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, IEnumerable<TInner>, TResult>)	Overloaded. Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys. (Defined by Enumerable.)
	GroupJoin<TOuter, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Overloaded. Correlates the elements of two sequences based on key equality and groups the results. A specified IEqualityComparer<T> is used to compare keys. (Defined by Enumerable.)
	InDocumentOrder<T>	Returns a collection of nodes that contains all nodes in the source collection, sorted in document order. (Defined by Extensions.)
	Intersect<TSource>(IEnumerable<TSource>)	Overloaded. Produces the set intersection of two sequences by using the default equality comparer to compare values. (Defined by Enumerable.)
	Intersect<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Overloaded. Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values. (Defined byEnumerable.)
	Join<TOuter, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, TInner, TResult>)	Overloaded. Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys. (Defined byEnumerable.)
	Join<TOuter, TInner, TKey, TResult>(IEnumerable<TInner>, Func<TOuter, TKey>, Func<TInner, TKey>, Func<TOuter, TInner, TResult>, IEqualityComparer<TKey>)	Overloaded. Correlates the elements of two sequences based on matching keys. A specified IEqualityComparer<T> is used to compare keys. (Defined byEnumerable.)
	Last<TSource>()	Overloaded. Returns the last element of a sequence. (Defined byEnumerable.)
	Last<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the last element of a sequence that satisfies a specified condition. (Defined by Enumerable.)
	LastOrDefault<TSource>()	Overloaded. Returns the last element of a sequence, or a default value if the sequence contains no elements. (Defined by Enumerable.)
	LastOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. (Defined by Enumerable.)
	LongCount<TSource>()	Overloaded. Returns an Int64 that represents the total number of elements in a sequence. (Defined by Enumerable.)
	LongCount<TSource>(Func<TSource, Boolean>)	Overloaded. Returns an Int64 that represents how many elements in a sequence satisfy a condition. (Defined by Enumerable.)
	Max<TSource>()	Overloaded. Returns the maximum value in a generic sequence. (Defined byEnumerable.)
	Max<TSource>(Func<TSource, Decimal>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum Decimal value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Nullable<Decimal>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Double>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum Double value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Nullable<Double>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum nullable Double value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Int32>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum Int32 value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Nullable<Int32>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Int64>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum Int64 value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Nullable<Int64>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Single>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum Single value. (Defined by Enumerable.)
	Max<TSource>(Func<TSource, Nullable<Single>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the maximum nullable Single value. (Defined by Enumerable.)
	Max<TSource, TResult>(Func<TSource, TResult>)	Overloaded. Invokes a transform function on each element of a generic sequence and returns the maximum resulting value. (Defined byEnumerable.)
	Min<TSource>()	Overloaded. Returns the minimum value in a generic sequence. (Defined byEnumerable.)
	Min<TSource>(Func<TSource, Decimal>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum Decimal value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Nullable<Decimal>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Double>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum Double value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Nullable<Double>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum nullable Double value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Int32>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum Int32 value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Nullable<Int32>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Int64>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum Int64 value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Nullable<Int64>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Single>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum Single value. (Defined by Enumerable.)
	Min<TSource>(Func<TSource, Nullable<Single>>)	Overloaded. Invokes a transform function on each element of a sequence and returns the minimum nullable Single value. (Defined by Enumerable.)
	Min<TSource, TResult>(Func<TSource, TResult>)	Overloaded. Invokes a transform function on each element of a generic sequence and returns the minimum resulting value. (Defined byEnumerable.)
	Nodes<T>	Returns a collection of the child nodes of every document and element in the source collection. (Defined by Extensions.)
	OfType<TResult>	Filters the elements of an IEnumerable based on a specified type. (Defined byEnumerable.)
	OrderBy<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Sorts the elements of a sequence in ascending order according to a key. (Defined by Enumerable.)
	OrderBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)	Overloaded. Sorts the elements of a sequence in ascending order by using a specified comparer. (Defined by Enumerable.)
	OrderByDescending<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Sorts the elements of a sequence in descending order according to a key. (Defined by Enumerable.)
	OrderByDescending<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)	Overloaded. Sorts the elements of a sequence in descending order by using a specified comparer. (Defined by Enumerable.)
	Remove<T>	Removes every node in the source collection from its parent node. (Defined by Extensions.)
	Reverse<TSource>	Inverts the order of the elements in a sequence. (Defined by Enumerable.)
	Select<TSource, TResult>(Func<TSource, TResult>)	Overloaded. Projects each element of a sequence into a new form. (Defined by Enumerable.)
	Select<TSource, TResult>(Func<TSource, Int32, TResult>)	Overloaded. Projects each element of a sequence into a new form by incorporating the element's index. (Defined by Enumerable.)
	SelectMany<TSource, TResult>(Func<TSource, IEnumerable<TResult>>)	Overloaded. Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence. (Defined by Enumerable.)
	SelectMany<TSource, TResult>(Func<TSource, Int32, IEnumerable<TResult>>)	Overloaded. Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. The index of each source element is used in the projected form of that element. (Defined byEnumerable.)
	SelectMany<TSource, TCollection, TResult>(Func<TSource, Int32, IEnumerable<TCollection>>, Func<TSource, TCollection, TResult>)	Overloaded. Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element. (Defined byEnumerable.)
	SelectMany<TSource, TCollection, TResult>(Func<TSource, IEnumerable<TCollection>>, Func<TSource, TCollection, TResult>)	Overloaded. Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. (Defined by Enumerable.)
	SequenceEqual<TSource>(IEnumerable<TSource>)	Overloaded. Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type. (Defined byEnumerable.)
	SequenceEqual<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Overloaded. Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>. (Defined byEnumerable.)
	Single<TSource>()	Overloaded. Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence. (Defined byEnumerable.)
	Single<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.(Defined by Enumerable.)
	SingleOrDefault<TSource>()	Overloaded. Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. (Defined by Enumerable.)
	SingleOrDefault<TSource>(Func<TSource, Boolean>)	Overloaded. Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. (Defined byEnumerable.)
	Skip<TSource>	Bypasses a specified number of elements in a sequence and then returns the remaining elements. (Defined by Enumerable.)
	SkipWhile<TSource>(Func<TSource, Boolean>)	Overloaded. Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. (Defined by Enumerable.)
	SkipWhile<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Decimal>)	Overloaded. Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Nullable<Decimal>>)	Overloaded. Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Double>)	Overloaded. Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Nullable<Double>>)	Overloaded. Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Int32>)	Overloaded. Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Nullable<Int32>>)	Overloaded. Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Int64>)	Overloaded. Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Nullable<Int64>>)	Overloaded. Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Single>)	Overloaded. Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Sum<TSource>(Func<TSource, Nullable<Single>>)	Overloaded. Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence. (Defined by Enumerable.)
	Take<TSource>	Returns a specified number of contiguous elements from the start of a sequence. (Defined by Enumerable.)
	TakeWhile<TSource>(Func<TSource, Boolean>)	Overloaded. Returns elements from a sequence as long as a specified condition is true. (Defined by Enumerable.)
	TakeWhile<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function. (Defined by Enumerable.)
	ToArray<TSource>	Creates an array from a IEnumerable<T>. (Defined by Enumerable.)
	ToDictionary<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Creates a Dictionary<TKey, TValue> from an IEnumerable<T>according to a specified key selector function. (Defined by Enumerable.)
	ToDictionary<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Creates a Dictionary<TKey, TValue> from an IEnumerable<T>according to a specified key selector function and key comparer. (Defined byEnumerable.)
	ToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Creates a Dictionary<TKey, TValue> from an IEnumerable<T>according to specified key selector and element selector functions. (Defined by Enumerable.)
	ToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. Creates a Dictionary<TKey, TValue> from an IEnumerable<T>according to a specified key selector function, a comparer, and an element selector function. (Defined by Enumerable.)
	ToList<TSource>	Creates a List<T> from an IEnumerable<T>. (Defined by Enumerable.)
	ToLookup<TSource, TKey>(Func<TSource, TKey>)	Overloaded. Creates a Lookup<TKey, TElement> from an IEnumerable<T>according to a specified key selector function. (Defined by Enumerable.)
	ToLookup<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)	Overloaded. Creates a Lookup<TKey, TElement> from an IEnumerable<T>according to a specified key selector function and key comparer. (Defined byEnumerable.)
	ToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)	Overloaded. Creates a Lookup<TKey, TElement> from an IEnumerable<T>according to specified key selector and element selector functions. (Defined by Enumerable.)
	ToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)	Overloaded. Creates a Lookup<TKey, TElement> from an IEnumerable<T>according to a specified key selector function, a comparer and an element selector function. (Defined by Enumerable.)
	Union<TSource>(IEnumerable<TSource>)	Overloaded. Produces the set union of two sequences by using the default equality comparer. (Defined by Enumerable.)
	Union<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Overloaded. Produces the set union of two sequences by using a specifiedIEqualityComparer<T>. (Defined by Enumerable.)
	Where<TSource>(Func<TSource, Boolean>)	Overloaded. Filters a sequence of values based on a predicate. (Defined byEnumerable.)
	Where<TSource>(Func<TSource, Int32, Boolean>)	Overloaded. Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function. (Defined by Enumerable.)
	Zip<TFirst, TSecond, TResult>	Merges two sequences by using the specified predicate function. (Defined byEnumerable.)

Top

Remarks

---

Many interfaces and classes in the System.Collections.Generic namespace inherit the IEnumerable<T> interface to implement enumerators. For an example, see the ICollection<T> interface.

Notes to Implementers

IEnumerable<T> is included for parity with non-generic collections; implementing IEnumerable<T> allows a generic collection to be passed to a method that expects an IEnumerable object.