Appendix A. Enumeration Extension Methods

LINQ Reporting Engine enables you to perform common manipulations on a sequential data through the engine’s built-in extension methods for IEnumerable. These extension methods mimic some extension methods of IEnumerable<T> providing the same signatures and behavior features. Thus you can group, sort and perform other sequential data manipulations in template expressions in a familiar way.

The following table describes these built-in extension methods. The following notation conventions are used within the table:

Selector stands for a lambda function returning a value and taking an enumeration item as its single argument. See “Using Lambda Functions” for more information.
ComparableSelector stands for Selector returning IComparable.
EnumerationSelector stands for Selector returning IEnumerable.
Predicate stands for Selector returning a Boolean value.

Examples in the following table are given using persons and otherPersons, enumerations of instances of the Person class that is defined as follows.

public class Person
{
    public String Name { get { ... } }
    public int Age { get { ... } }
    public IEnumerable<Person> Children { get { ... } }
    ...
}

Extension Method	Examples and Notes
`All(Predicate)`	`persons.All(p => p.Age < 50)`
`Any()`	`persons.Any()`
`Any(Predicate)`	`persons.Any(p => p.Name == "John Smith")`
`Average(Selector)`	`persons.Average(p => p.Age)` The input selector must return a value of any type that has predefined or user-defined addition and division operators.
`Concat(IEnumerable)`	`persons.Concat(otherPersons)` An implicit reference conversion must exist between types of items of concatenated enumerations.
`Contains(Object)`	`persons.Contains(otherPersons.First())`
`Count()`	`persons.Count()`
`Count(Predicate)`	`persons.Count(p => p.Age > 30)`
`Distinct()`	`persons.Distinct()`
`ElementAt(int)`	`persons.ElementAt(3)`
`ElementAtOrDefault(int)`	`persons.ElementAtOrDefault(5)`
`First()`	`persons.First()`
`First(Predicate)`	`persons.First(p => p.Age > 30)`
`FirstOrDefault()`	`persons.FirstOrDefault()`
`FirstOrDefault(Predicate)`	`persons.FirstOrDefault(p => p.Age > 30)`
`GroupBy(Selector)`	`persons.GroupBy(p => p.Age)` Or `persons.GroupBy( p => new { Age = p.Age, Count = p.Children.Count() })` This method returns an enumeration of group objects. Each group has a unique key defined by the input selector and contains items of the source enumeration associated with this key. You can access the key of a group instance using the `Key` property. You can treat a group itself as an enumeration of items that the group contains.
`Last()`	`persons.Last()`
`Last(Predicate)`	`persons.Last(p => p.Age > 100)`
`LastOrDefault()`	`persons.LastOrDefault()`
`LastOrDefault(Predicate)`	`persons.LastOrDefault(p => p.Age > 100)`
`Max(ComparableSelector)`	`persons.Max(p => p.Age)`
`Min(ComparableSelector)`	`persons.Min(p => p.Age)`
`OrderBy(ComparableSelector)`	`persons.OrderBy(p => p.Age)` Or `persons.OrderBy(p => p.Age).ThenByDescending(p => p.Name)` Or `persons.OrderBy(p => p.Age).ThenByDescending(p => p.Name).ThenBy(p => p.Children.Count())` This method returns an enumeration ordered by a single key. To specify additional ordering keys, you can use the following extension methods of an ordered enumeration: - ThenBy(ComparableSelector) - ThenByDescending(ComparableSelector)
`OrderByDescending(ComparableSelector)`	`persons.OrderByDescending(p => p.Age)` Or `persons.OrderByDescending(p => p.Age).ThenByDescending(p => p.Name)` Or `persons.OrderByDescending(p => p.Age).ThenByDescending(p => p.Name).ThenBy(p => p.Children.Count())` See the previous note.
`Select(Selector)`	`persons.Select(p => p.Name)`
`SelectMany(EnumerationSelector)`	`persons.SelectMany(p => p.Children)`
`Single()`	`persons.Single()`
`Single(Predicate)`	`persons.Single(p => p.Name == "John Smith")`
`SingleOrDefault()`	`persons.SingleOrDefault()`
`SingleOrDefault(Predicate)`	`persons.SingleOrDefault(p => p.Name == "John Smith")`
`Skip(int)`	`persons.Skip(10)`
`SkipWhile(Predicate)`	`persons.SkipWhile(p => p.Age < 21)`
`Sum(Selector)`	`persons.Sum(p => p.Children.Count())` The input selector must return a value of any type that has a predefined or user-defined addition operator.
`Take(int)`	`persons.Take(5)`
`TakeWhile(Predicate)`	`persons.TakeWhile(p => p.Age < 50)`
`Union(IEnumerable)`	`persons.Union(otherPersons)` An implicit reference conversion must exist between types of items of united enumerations.
`Where(Predicate)`	`persons.Where(p => p.Age > 18)`

LINQ Reporting Engine API in C# Appendix B. Technical FAQ in C#