# Collections\_Generic\_ICollection\_T

***

**1. Creating a List of Strings**

```csharp
var listOfStrings = new List<string>() { "Item1", "Item2", "Item3" };
```

**2. Adding Elements to a List**

```csharp
listOfStrings.Add("Item4");
```

**3. Removing Elements from a List**

```csharp
listOfStrings.Remove("Item2");
```

**4. Iterating Over a List**

```csharp
foreach (var item in listOfStrings)
{
    Console.WriteLine(item);
}
```

**5. Creating a Set of Integers**

```csharp
var setOfIntegers = new HashSet<int>() { 1, 2, 3 };
```

**6. Adding Elements to a Set**

```csharp
setOfIntegers.Add(4);
```

**7. Removing Elements from a Set**

```csharp
setOfIntegers.Remove(2);
```

**8. Iterating Over a Set**

```csharp
foreach (var item in setOfIntegers)
{
    Console.WriteLine(item);
}
```

**9. Creating a Dictionary of Key-Value Pairs**

```csharp
var dictionaryOfKeyValuePairs = new Dictionary<string, int>() { { "Key1", 1 }, { "Key2", 2 } };
```

**10. Adding Key-Value Pairs to a Dictionary**

```csharp
dictionaryOfKeyValuePairs.Add("Key3", 3);
```

**11. Removing Key-Value Pairs from a Dictionary**

```csharp
dictionaryOfKeyValuePairs.Remove("Key2");
```

**12. Iterating Over a Dictionary**

```csharp
foreach (var item in dictionaryOfKeyValuePairs)
{
    Console.WriteLine($"Key: {item.Key}, Value: {item.Value}");
}
```

**13. Creating a Stack**

```csharp
var stack = new Stack<int>();
```

**14. Pushing Elements onto a Stack**

```csharp
stack.Push(1);
```

**15. Popping Elements from a Stack**

```csharp
var poppedItem = stack.Pop();
```

**16. Iterating Over a Stack**

```csharp
foreach (var item in stack)
{
    Console.WriteLine(item);
}
```

**17. Creating a Queue**

```csharp
var queue = new Queue<int>();
```

**18. Enqueuing Elements into a Queue**

```csharp
queue.Enqueue(1);
```

**19. Dequeuing Elements from a Queue**

```csharp
var dequeuedItem = queue.Dequeue();
```

**20. Iterating Over a Queue**

```csharp
foreach (var item in queue)
{
    Console.WriteLine(item);
}
```

**21. Creating a Linked List**

```csharp
var linkedList = new LinkedList<int>();
```

**22. Adding Nodes to a Linked List**

```csharp
linkedList.AddFirst(1);
linkedList.AddLast(2);
```

**23. Removing Nodes from a Linked List**

```csharp
linkedList.RemoveFirst();
linkedList.RemoveLast();
```

**24. Iterating Over a Linked List**

```csharp
foreach (var item in linkedList)
{
    Console.WriteLine(item);
}
```

**25. Generating a Sequence of Numbers**

```csharp
var sequenceOfNumbers = Enumerable.Range(1, 10);
```

**26. Filtering a Sequence**

```csharp
var filteredSequence = sequenceOfNumbers.Where(x => x % 2 == 0);
```

**27. Projecting a Sequence**

```csharp
var projectedSequence = sequenceOfNumbers.Select(x => x * x);
```

**28. Grouping a Sequence**

```csharp
var groupedSequence = sequenceOfNumbers.GroupBy(x => x % 3);
```

**29. Ordering a Sequence**

```csharp
var orderedSequence = sequenceOfNumbers.OrderBy(x => x);
```

**30. Concatenating Sequences**

```csharp
var concatenatedSequence = sequenceOfNumbers.Concat(new[] { 11, 12 });
```

**31. Unioning Sequences**

```csharp
var unionedSequence = sequenceOfNumbers.Union(new[] { 11, 12 });
```

**32. Intersecting Sequences**

```csharp
var intersectedSequence = sequenceOfNumbers.Intersect(new[] { 2, 4, 6 });
```

**33. Excepting Sequences**

```csharp
var exceptedSequence = sequenceOfNumbers.Except(new[] { 2, 4, 6 });
```

**34. Aggregating a Sequence**

```csharp
var sum = sequenceOfNumbers.Sum();
```

**35. Calculating the Average of a Sequence**

```csharp
var average = sequenceOfNumbers.Average();
```

**36. Finding the Minimum Value in a Sequence**

```csharp
var minimum = sequenceOfNumbers.Min();
```

**37. Finding the Maximum Value in a Sequence**

```csharp
var maximum = sequenceOfNumbers.Max();
```

**38. Determining Whether a Sequence Contains a Value**

```csharp
var containsValue = sequenceOfNumbers.Contains(7);
```

**39. Converting a Sequence to an Array**

```csharp
var array = sequenceOfNumbers.ToArray();
```

**40. Converting a Sequence to a List**

```csharp
var list = sequenceOfNumbers.ToList();
```

**41. Converting a Sequence to a HashSet**

```csharp
var hashSet = sequenceOfNumbers.ToHashSet();
```

**42. Converting a Sequence to a Dictionary**

```csharp
var dictionary = sequenceOfNumbers.ToDictionary(x => x, x => x * x);
```

**43. Generating Random Numbers**

```csharp
var randomNumbers = Enumerable.Range(1, 10).Select(x => new Random().Next(1, 101));
```

**44. Shuffling a Sequence**

```csharp
var shuffledSequence = sequenceOfNumbers.OrderBy(x => Guid.NewGuid());
```

**45. Performing a Binary Search on a Sorted Sequence**

```csharp
var sortedSequence = sequenceOfNumbers.OrderBy(x => x);
var index = sortedSequence.BinarySearch(7);
```

**46. Reversing a Sequence**

```csharp
var reversedSequence = sequenceOfNumbers.Reverse();
```

**47. Zipping Two Sequences Together**

```csharp
var firstSequence = Enumerable.Range(1, 10);
var secondSequence = Enumerable.Range(11, 10);
var zippedSequence = firstSequence.Zip(secondSequence, (x, y) => x + y);
```

**48. Joining Two Sequences**

```csharp
var firstSequence = Enumerable.Range(1, 10);
var secondSequence = Enumerable.Range(11, 10);
var joinedSequence = firstSequence.Join(secondSequence, x => x, y => y, (x, y) => x + y);
```

**49. Aggregating Multiple Sequences**

```csharp
var firstSequence = Enumerable.Range(1, 10);
var secondSequence = Enumerable.Range(11, 10);
var thirdSequence = Enumerable.Range(21, 10);
var aggregatedSequence = firstSequence.Concat(secondSequence).Concat(thirdSequence);
```

**50. Creating a Custom Collection Type**

```csharp
public class MyCollection<T> : ICollection<T>
{
    // Implement the ICollection<T> interface members...
}
```