# Collections\_IEnumerable

***

**1. Iterate Over an Array Using IEnumerable**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
IEnumerable<int> result = numbers.AsEnumerable();
foreach (int number in result)
{
    Console.WriteLine(number);
}
```

**2. Iterate Over a List Using IEnumerable**

```csharp
List<string> names = new List<string> { "John", "Mary", "Bob" };
IEnumerable<string> nameQuery = names.AsEnumerable();
foreach (string name in nameQuery)
{
    Console.WriteLine(name);
}
```

**3. Use Where Clause to Filter Elements Using IEnumerable**

```csharp
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
IEnumerable<int> evenNumbers = numbers.AsEnumerable().Where(n => n % 2 == 0);
foreach (int number in evenNumbers)
{
    Console.WriteLine(number);
}
```

**4. Use Select Clause to Project Elements Using IEnumerable**

```csharp
string[] names = { "John", "Mary", "Bob" };
IEnumerable<string> uppercaseNames = names.AsEnumerable().Select(name => name.ToUpper());
foreach (string name in uppercaseNames)
{
    Console.WriteLine(name);
}
```

**5. Use FirstOrDefault Method to Return the First Element That Matches a Condition**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int firstEvenNumber = numbers.AsEnumerable().FirstOrDefault(n => n % 2 == 0);
Console.WriteLine(firstEvenNumber); // 2
```

**6. Use Any Method to Check if Any Element Matches a Condition**

```csharp
string[] names = { "John", "Mary", "Bob" };
bool containsJohn = names.AsEnumerable().Any(name => name == "John");
Console.WriteLine(containsJohn); // true
```

**7. Use Count Method to Get the Number of Elements in a Collection**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int count = numbers.AsEnumerable().Count();
Console.WriteLine(count); // 5
```

**8. Use Sum Method to Calculate the Sum of Elements in a Collection**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int sum = numbers.AsEnumerable().Sum();
Console.WriteLine(sum); // 15
```

**9. Use Average Method to Calculate the Average of Elements in a Collection**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
double average = numbers.AsEnumerable().Average();
Console.WriteLine(average); // 3
```

**10. Use Max Method to Get the Maximum Element in a Collection**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int max = numbers.AsEnumerable().Max();
Console.WriteLine(max); // 5
```

**11. Use Min Method to Get the Minimum Element in a Collection**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int min = numbers.AsEnumerable().Min();
Console.WriteLine(min); // 1
```

**12. Use OrderBy Method to Sort Elements in Ascending Order**

```csharp
string[] names = { "John", "Mary", "Bob" };
IEnumerable<string> sortedNames = names.AsEnumerable().OrderBy(name => name);
foreach (string name in sortedNames)
{
    Console.WriteLine(name);
}
```

**13. Use OrderByDescending Method to Sort Elements in Descending Order**

```csharp
string[] names = { "John", "Mary", "Bob" };
IEnumerable<string> sortedNames = names.AsEnumerable().OrderByDescending(name => name);
foreach (string name in sortedNames)
{
    Console.WriteLine(name);
}
```

**14. Use ThenBy Method to Sort Elements by Multiple Criteria**

```csharp
string[] names = { "John Doe", "Mary Smith", "Bob Brown" };
IEnumerable<string> sortedNames = names.AsEnumerable()
                                      .OrderBy(name => name.Split(' ')[0])
                                      .ThenBy(name => name.Split(' ')[1]);
foreach (string name in sortedNames)
{
    Console.WriteLine(name);
}
```

**15. Use Reverse Method to Reverse the Order of Elements**

```csharp
string[] names = { "John", "Mary", "Bob" };
IEnumerable<string> reversedNames = names.AsEnumerable().Reverse();
foreach (string name in reversedNames)
{
    Console.WriteLine(name);
}
```

**16. Use Skip Method to Skip the Specified Number of Elements**

```csharp
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
IEnumerable<int> skippedNumbers = numbers.AsEnumerable().Skip(5);
foreach (int number in skippedNumbers)
{
    Console.WriteLine(number);
}
```

**17. Use Take Method to Take the Specified Number of Elements**

```csharp
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
IEnumerable<int> takenNumbers = numbers.AsEnumerable().Take(5);
foreach (int number in takenNumbers)
{
    Console.WriteLine(number);
}
```

**18. Use ToArray Method to Create an Array from an IEnumerable**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int[] array = numbers.AsEnumerable().ToArray();
```

**19. Use ToList Method to Create a List from an IEnumerable**

```csharp
string[] names = { "John", "Mary", "Bob" };
List<string> list = names.AsEnumerable().ToList();
```

**20. Use ToDictionary Method to Create a Dictionary from an IEnumerable**

```csharp
string[] names = { "John", "Mary", "Bob" };
int[] ages = { 30, 25, 40 };
Dictionary<string, int> ageDictionary = names.AsEnumerable()
                                            .Zip(ages, (name, age) => new KeyValuePair<string, int>(name, age))
                                            .ToDictionary(pair => pair.Key, pair => pair.Value);
```

**21. Use GroupBy Method to Group Elements by a Key**

```csharp
string[] names = { "John Doe", "Mary Smith", "Bob Brown", "Jane Doe" };
var groupedNames = names.AsEnumerable()
                        .GroupBy(name => name.Split(' ')[1]);
foreach (var group in groupedNames)
{
    Console.WriteLine(group.Key);
    foreach (var name in group)
    {
        Console.WriteLine("\t" + name);
    }
}
```

**22. Use Join Method to Join Two Sequences**

```csharp
string[] names = { "John", "Mary", "Bob" };
int[] ages = { 30, 25, 40 };
var joinedData = names.AsEnumerable()
                    .Join(ages, name => name, age => age, (name, age) => new { Name = name, Age = age });
foreach (var data in joinedData)
{
    Console.WriteLine(data.Name + " - " + data.Age);
}
```

**23. Use Union Method to Combine Two Sequences**

```csharp
string[] names1 = { "John", "Mary", "Bob" };
string[] names2 = { "Tom", "Susan", "Bob" };
var combinedNames = names1.AsEnumerable().Union(names2);
foreach (string name in combinedNames)
{
    Console.WriteLine(name);
}
```

**24. Use Intersect Method to Find the Intersection of Two Sequences**

```csharp
string[] names1 = { "John", "Mary", "Bob" };
string[] names2 = { "Tom", "Susan", "Bob" };
var intersectedNames = names1.AsEnumerable().Intersect(names2);
foreach (string name in intersectedNames)
{
    Console.WriteLine(name);
}
```

**25. Use Except Method to Find the Difference Between Two Sequences**

```csharp
string[] names1 = { "John", "Mary", "Bob" };
string[] names2 = { "Tom", "Susan", "Bob" };
var differentNames = names1.AsEnumerable().Except(names2);
foreach (string name in differentNames)
{
    Console.WriteLine(name);
}
```

**26. Use Zip Method to Pair Elements from Two Sequences**

```csharp
string[] names = { "John", "Mary", "Bob" };
int[] ages = { 30, 25, 40 };
var pairs = names.AsEnumerable().Zip(ages, (name, age) => new { Name = name, Age = age });
foreach (var pair in pairs)
{
    Console.WriteLine(pair.Name + " - " + pair.Age);
}
```

**27. Use Concat Method to Combine Multiple Sequences**

```csharp
string[] names1 = { "John", "Mary" };
string[] names2 = { "Bob", "Susan" };
var combinedNames = names1.AsEnumerable().Concat(names2);
foreach (string name in combinedNames)
{
    Console.WriteLine(name);
}
```

**28. Use Distinct Method to Remove Duplicate Elements**

```csharp
int[] numbers = { 1, 2, 3, 4, 5, 1, 2, 3 };
var distinctNumbers = numbers.AsEnumerable().Distinct();
foreach (int number in distinctNumbers)
{
    Console.WriteLine(number);
}
```

**29. Use Linq-to-Objects Query Syntax**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from number in numbers
                  where number % 2 == 0
                  select number;
foreach (int number in evenNumbers)
{
    Console.WriteLine(number);
}
```

**30. Use Linq-to-XML Query Syntax**

```csharp
XDocument doc = XDocument.Load("file.xml");
var elements = from element in doc.Descendants("element")
               where element.Attribute("name").Value == "value"
               select element;
foreach (XElement element in elements)
{
    Console.WriteLine(element.Value);
}
```

**31. Use Linq-to-SQL Query Syntax**

```csharp
using System.Linq;
using System.Data.Linq;
DataContext db = new DataContext("connectionString");
var customers = from customer in db.Customers
                 where customer.Name == "John"
                 select customer;
foreach (Customer customer in customers)
{
    Console.WriteLine(customer.Name);
}
```

**32. Use Linq-to-Entities Query Syntax**

```csharp
using System.Linq;
using System.Data.Entity;
DbContext db = new DbContext("connectionString");
var customers = from customer in db.Customers
                 where customer.Name == "John"
                 select customer;
foreach (Customer customer in customers)
{
    Console.WriteLine(customer.Name);
}
```

**33. Use ConcurrentBag**

```csharp
ConcurrentBag<int> numbers = new ConcurrentBag<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
foreach (int number in numbers)
{
    Console.WriteLine(number);
}
```

**34. Use BlockingCollection**

```csharp
BlockingCollection<int> numbers = new BlockingCollection<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
foreach (int number in numbers.GetConsumingEnumerable())
{
    Console.WriteLine(number);
}
```

**35. Use Parallel.ForEach**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
Parallel.ForEach(numbers, number =>
{
    Console.WriteLine(number);
});
```

**36. Use Parallel.Invoke**

```csharp
Parallel.Invoke(() =>
{
    Console.WriteLine("Task 1");
},
() =>
{
    Console.WriteLine("Task 2");
},
() =>
{
    Console.WriteLine("Task 3");
});
```

**37. Use Parallel.For**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
Parallel.For(0, numbers.Length, i =>
{
    Console.WriteLine(numbers[i]);
});
```

**38. Use Parallel.ForEach** with Options

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
Parallel.ForEach(numbers, new ParallelOptions
{
    MaxDegreeOfParallelism = 2
}, number =>
{
    Console.WriteLine(number);
});
```

**39. Use Parallel.Break**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
Parallel.ForEach(numbers, new ParallelOptions
{
    CancellationToken = new CancellationToken()
}, number =>
{
    if (number == 3)
    {
        Parallel.Break();
    }
    Console.WriteLine(number);
});
```

**40. Use Parallel.Synchronize**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
object lockObject = new object();
Parallel.ForEach(numbers, new ParallelOptions
{
    CancellationToken = new CancellationToken()
}, number =>
{
    lock (lockObject)
    {
        Console.WriteLine(number);
    }
});
```

**41. Use Aggregate Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int sum = numbers.AsEnumerable().Aggregate((total, n) => total + n);
Console.WriteLine(sum); // 15
```

**42. Use All Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
bool allEven = numbers.AsEnumerable().All(n => n % 2 == 0);
Console.WriteLine(allEven); // false
```

**43. Use Any Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
bool anyEven = numbers.AsEnumerable().Any(n => n % 2 == 0);
Console.WriteLine(anyEven); // true
```

**44. Use Contains Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
bool contains3 = numbers.AsEnumerable().Contains(3);
Console.WriteLine(contains3); // true
```

**45. Use DefaultIfEmpty Method**

```csharp
int[] numbers = new int[] { };
IEnumerable<int> withDefault = numbers.AsEnumerable().DefaultIfEmpty(0);
foreach (int number in withDefault)
{
    Console.WriteLine(number);
}
```

**46. Use ElementAt Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int secondNumber = numbers.AsEnumerable().ElementAt(1);
Console.WriteLine(secondNumber); // 2
```

**47. Use First Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int firstEvenNumber = numbers.AsEnumerable().First(n => n % 2 == 0);
Console.WriteLine(firstEvenNumber); // 2
```

**48. Use GroupBy Method**

```csharp
string[] names = { "John", "Mary", "Bob", "Jane" };
var groupedNames = names.AsEnumerable().GroupBy(name => name[0]);
foreach (var group in groupedNames)
{
    Console.WriteLine(group.Key);
    foreach (var name in group)
    {
        Console.WriteLine("\t" + name);
    }
}
```

**49. Use Intersect Method**

```csharp
int[] numbers1 = { 1, 2, 3, 4, 5 };
int[] numbers2 = { 3, 4, 5, 6, 7 };
var intersection = numbers1.AsEnumerable().Intersect(numbers2);
foreach (int number in intersection)
{
    Console.WriteLine(number);
}
```

**50. Use Last Method**

```csharp
int[] numbers = { 1, 2, 3, 4, 5 };
int lastEvenNumber = numbers.AsEnumerable().Last(n => n % 2 == 0);
Console.WriteLine(lastEvenNumber); // 4
```