# IEnumerable\_out\_T

***

**1. Filtering a Collection**

```csharp
IEnumerable<int> evenNumbers = numbers.Where(n => n % 2 == 0);
```

**2. Transforming a Collection**

```csharp
IEnumerable<string> upperCaseNames = names.Select(n => n.ToUpper());
```

**3. Grouping a Collection**

```csharp
var groupedNumbers = numbers.GroupBy(n => n % 3);
```

**4. Ordering a Collection**

```csharp
IEnumerable<int> sortedNumbers = numbers.OrderBy(n => n);
```

**5. Projecting a Collection**

```csharp
IEnumerable<(int, int)> numberPairs = numbers.Select((n, i) => (n, i));
```

**6. Aggregating a Collection**

```csharp
int sum = numbers.Sum();
```

**7. Concatenating Collections**

```csharp
IEnumerable<int> allNumbers = numbers.Concat(moreNumbers);
```

**8. Intersecting Collections**

```csharp
IEnumerable<int> commonNumbers = numbers.Intersect(moreNumbers);
```

**9. Unioning Collections**

```csharp
IEnumerable<int> allUniqueNumbers = numbers.Union(moreNumbers);
```

**10. Excepting Collections**

```csharp
IEnumerable<int> numbersOnlyInFirstCollection = numbers.Except(moreNumbers);
```

**11. Zipping Collections**

```csharp
IEnumerable<(int, string)> zippedCollection = numbers.Zip(names);
```

**12. Distincting Elements**

```csharp
IEnumerable<int> uniqueNumbers = numbers.Distinct();
```

**13. Skipping Elements**

```csharp
IEnumerable<int> skippedNumbers = numbers.Skip(5);
```

**14. Taking Elements**

```csharp
IEnumerable<int> takenNumbers = numbers.Take(5);
```

**15. Reversing a Collection**

```csharp
IEnumerable<int> reversedNumbers = numbers.Reverse();
```

**16. Ranging over a Collection**

```csharp
foreach (int number in numbers)
{
    // Do something with number
}
```

**17. Joining Collections**

```csharp
var joinedCollection = numbers.Join(moreNumbers, n => n % 2, n => n % 2, (n, m) => n + m);
```

**18. GroupJoining Collections**

```csharp
var groupJoinedCollection = numbers.GroupJoin(moreNumbers, n => n % 2, n => n % 2, (n, m) => new { Number = n, Matches = m });
```

**19. ToLookup**

```csharp
var lookup = numbers.ToLookup(n => n % 2);
```

**20. ToDictionary**

```csharp
var dictionary = numbers.ToDictionary(n => n, n => n * 2);
```

**21. Converting to an Array**

```csharp
int[] numbersArray = numbers.ToArray();
```

**22. Converting to a List**

```csharp
List<int> numbersList = numbers.ToList();
```

**23. Converting to a HashSet**

```csharp
HashSet<int> numbersSet = numbers.ToHashSet();
```

**24. Converting to a Stack**

```csharp
Stack<int> numbersStack = numbers.ToStack();
```

**25. Converting to a Queue**

```csharp
Queue<int> numbersQueue = numbers.ToQueue();
```

**26. Converting to a LinkedList**

```csharp
LinkedList<int> numbersLinkedList = numbers.ToLinkedList();
```

**27. Converting to a SortedList**

```csharp
SortedList<int, int> numbersSortedList = numbers.ToSortedList();
```

**28. Converting to a SortedDictionary**

```csharp
SortedDictionary<int, int> numbersSortedDictionary = numbers.ToSortedDictionary();
```

**29. Converting to a SortedSet**

```csharp
SortedSet<int> numbersSortedSet = numbers.ToSortedSet();
```

**30. Converting to a BITSET**

```csharp
BITSET numbersBITSET = numbers.ToBITSET();
```

**31. Converting to a ConcurrentBag**

```csharp
ConcurrentBag<int> numbersConcurrentBag = numbers.ToConcurrentBag();
```

**32. Converting to a ConcurrentDictionary**

```csharp
ConcurrentDictionary<int, int> numbersConcurrentDictionary = numbers.ToConcurrentDictionary();
```

**33. Converting to a BlockingCollection**

```csharp
BlockingCollection<int> numbersBlockingCollection = numbers.ToBlockingCollection();
```

**34. Converting to a ConcurrentQueue**

```csharp
ConcurrentQueue<int> numbersConcurrentQueue = numbers.ToConcurrentQueue();
```

**35. Converting to a ConcurrentStack**

```csharp
ConcurrentStack<int> numbersConcurrentStack = numbers.ToConcurrentStack();
```

**36. Converting to a ThreadSafeList**

```csharp
ThreadSafeList<int> numbersThreadSafeList = numbers.ToThreadSafeList();
```

**37. Converting to a CircularBuffer**

```csharp
CircularBuffer<int> numbersCircularBuffer = numbers.ToCircularBuffer();
```

**38. Converting to a RingBuffer**

```csharp
RingBuffer<int> numbersRingBuffer = numbers.ToRingBuffer();
```

**39. Converting to a PriorityQueue**

```csharp
PriorityQueue<int> numbersPriorityQueue = numbers.ToPriorityQueue();
```

**40. Converting to a MinHeap**

```csharp
MinHeap<int> numbersMinHeap = numbers.ToMinHeap();
```

**41. Converting to a MaxHeap**

```csharp
MaxHeap<int> numbersMaxHeap = numbers.ToMaxHeap();
```

**42. Converting to a FibHeap**

```csharp
FibHeap<int> numbersFibHeap = numbers.ToFibHeap();
```

**43. Converting to a BinarySearchTree**

```csharp
BinarySearchTree<int> numbersBinarySearchTree = numbers.ToBinarySearchTree();
```

**44. Converting to a RedBlackTree**

```csharp
RedBlackTree<int> numbersRedBlackTree = numbers.ToRedBlackTree();
```

**45. Converting to a AVLTree**

```csharp
AVLTree<int> numbersAVLTree = numbers.ToAVLTree();
```

**46. Converting to a SplayTree**

```csharp
SplayTree<int> numbersSplayTree = numbers.ToSplayTree();
```

**47. Converting to a Treap**

```csharp
Treap<int> numbersTreap = numbers.ToTreap();
```

**48. Converting to a BTree**

```csharp
BTree<int> numbersBTree = numbers.ToBTree();
```

**49. Converting to a SkipList**

```csharp
SkipList<int> numbersSkipList = numbers.ToSkipList();
```

**50. Converting to a CuckooHashTable**

```csharp
CuckooHashTable<int, int> numbersCuckooHashTable = numbers.ToCuckooHashTable();
```