100 C# Code Snippets for Everyday Problems✨
Tags: csharp, dotnet, programming, productivity
Published: 2023-05-15 09:56:37

Welcome to this comprehensive compilation of 100 C# code snippets designed to tackle everyday problems! This article is inspired by Jeremy Grifski’s original work, “[100 Python code snippets for everyday problems](https://therenegadecoder.com/code/python-code-snippets-for-everyday-problems/)“- As developers, we often seek practical solutions to common challenges, and C# provides a powerful and versatile platform for addressing these issues.

In this article, we’ve curated a collection of C# code snippets that cover a wide range of scenarios you might encounter during software development. These snippets not only showcase the capabilities of C# but also serve as a valuable resource for enhancing your programming toolkit. So, whether you’re a seasoned developer or a newcomer to C#, dive in and explore these handy solutions!

Please note that this article’s inspiration, the Python version, was masterfully crafted by [Jeremy Grifski](https://jeremygrifski.com/), and you can find his insightful work “[100 Python code snippets for everyday problems](https://therenegadecoder.com/code/python-code-snippets-for-everyday-problems/)“. Happy coding!

## Dictionaries (9 Snippets)

In C#, dictionaries serve as a robust and flexible data structure for connecting pairs of elements. Consider using a dictionary to tally the frequency of words present in this text.

The dictionary’s keys would represent distinct words found in this text, with each word linked to its respective count. This type of structure proves highly beneficial in numerous scenarios. Now, let’s delve into a few prevalent dictionary operations in C#!

### Merging Two Dictionaries

Combining two dictionaries is a common operation when working with data structures in C#. However, merging dictionaries can be tricky, especially when there are duplicate keys. Here are some solutions to handle these cases:

```csharp
Dictionary<string, string> dict1 = new Dictionary<string, string> { { "Superman", "Flight" } };
Dictionary<string, string> dict2 = new Dictionary<string, string> { { "Batman", "Gadgets" } };

// Using LINQ
var merged = dict1.Concat(dict2).ToDictionary(x => x.Key, x => x.Value);

// Using a foreach loop
foreach (var item in dict2)
{
    dict1[item.Key] = item.Value;
}

// Using the Union extension method
var merged2 = dict1.Union(dict2).ToDictionary(x => x.Key, x => x.Value);
```

### Inverting a Dictionary

Is there a scenario where you might consider swapping the keys and values of a dictionary? This operation can be complicated, especially when dealing with non-unique values or non-hashable values. Here are some solutions for simple cases:

```csharp
Dictionary<string, string> heroesAbilities = new Dictionary<string, string>
{
    { "Flash", "Super Speed" },
    { "Green Lantern", "Power Ring" },
    { "Aquaman", "Atlantean Strength" }
};

// Inverting the dictionary using LINQ
var inverted = heroesAbilities.ToDictionary(x => x.Value, x => x.Key);

// Inverting the dictionary using a foreach loop
Dictionary<string, string> inverted2 = new Dictionary<string, string>();
foreach (var item in heroesAbilities)
{
    inverted2[item.Value] = item.Key;
}
```

### Performing a Reverse Dictionary Lookup

In some cases, you might want to perform a reverse lookup in a dictionary, meaning, you want to find a key based on a given value. This can be useful when the dictionary is too large to be inverted. Here are some ways to achieve this:

```csharp
Dictionary<string, int> dimensions = new Dictionary<string, int>
{
    { "length", 10 },
    { "width", 20 },
    { "height", 30 }
};

int valueToFind = 20;

// Brute force solution -- single key
foreach (var item in dimensions)
{
    if (item.Value == valueToFind)
    {
        Console.WriteLine($"{item.Key}: {item.Value}");
        break;
    }
}

// Brute force solution -- multiple keys
foreach (var item in dimensions)
{
    if (item.Value == valueToFind)
    {
        Console.WriteLine($"{item.Key}: {item.Value}");
    }
}

// Using LINQ -- single key
var key = dimensions.FirstOrDefault(x => x.Value == valueToFind).Key;
Console.WriteLine($"{key}: {valueToFind}");

// Using LINQ -- multiple keys
var keys = dimensions.Where(x => x.Value == valueToFind).Select(x => x.Key);
foreach (var k in keys)
{
    Console.WriteLine($"{k}: {valueToFind}");
}
```

The above snippets demonstrate different ways to perform a reverse dictionary lookup in C#. Depending on the size of the dictionary and the desired output, you can choose the most appropriate method for your use case.

## Input/Output (4 Snippets)

Frequent instances of I/O involve interactions with databases, files, and command-line interfaces. While C# effectively simplifies I/O operations, certain complexities remain. Let’s examine a few of these challenges!

### Writing to the Same Line

Sometimes you just need to write to the same line in your C# console application. The `Console.Write` method allows you to do this without adding a newline at the end of your string:

```csharp
Console.Write("The Office");
Console.Write(" Parks and Recreation");
```

### Creating a C# Script Shortcut

Is there a way to conveniently execute a script with just a click of a button after developing it? Luckily, various methods enable you to achieve this.

One approach is to generate a batch file containing the subsequent code:

```csharp
@echo off
csc /path/to/MyProgram.cs
MyProgram.exe
```

### Checking if a File Exists

Luckily in C# it’s easy. The `System.IO` namespace provides a set of methods for working with files, such as checking if a file exists:

```csharp
using System.IO;

// Check if file exists using File.Exists method
bool exists = File.Exists("/path/to/file");
```

### Parsing a CSV File

C# offers intriguing applications in the realm of data manipulation, which often requires dealing with substantial amounts of raw data in diverse formats, such as text files and CSV files.

Fortunately, C# comes equipped with numerous built-in tools for handling various file formats. For instance, parsing a CSV file can be accomplished effortlessly:

```csharp
using System;
using System.IO;

// Read all lines from the CSV file
string[] lines = File.ReadAllLines("/path/to/data.csv");

// Process each line
foreach (string line in lines)
{
    // Split the line into fields
    string[] fields = line.Split(',');

    // Do something with the fields, e.g., print them
    Console.WriteLine($"{fields[0]} - {fields[1]} - {fields[2]}");
}
```

## Lists (27 Snippets)

Among various data structures, [lists](https://www.bytehide.com/blog/list-csharp/ "Lists in C#: A Guide to Dynamic Data Storage") stand out as the most prevalent. In C#, a list represents a dynamic [array](https://www.bytehide.com/blog/array-csharp/ "Arrays in C#: In-Depth Guide with Examples") that utilizes zero-based indexing. This means we can add and remove items without concerning ourselves with the underlying implementation, making lists highly intuitive.

Naturally, like other data structures mentioned here, lists present their own set of challenges. Let’s explore further!

### Appending an Element to a List

As my interest in this collection grew, I became intrigued by the basics of C#. In other words, what tasks might beginners want to perform, and how many alternative approaches exist for accomplishing them? One such task is appending an element to a list.

C# offers numerous methods for adding items to lists. For instance, the widely-used `Add()` method is available. However, there are plenty of other options as well. Here are five:

```csharp
// Statically defined list
List<int> myList = new List<int> {2, 5, 6};
// Appending using Add()
myList.Add(5);  // [2, 5, 6, 5]
// Appending using AddRange()
myList.AddRange(new List<int> {9});  // [2, 5, 6, 5, 9]
// Appending using Insert()
myList.Insert(myList.Count, -4);  // [2, 5, 6, 5, 9, -4]
// Appending using InsertRange()
myList.InsertRange(myList.Count, new List<int> {3});  // [2, 5, 6, 5, 9, -4, 3]
```

### Retrieving the Last Item of a List

As we delve into lists, let’s discuss acquiring the final element of a list. In numerous languages, this typically requires a complex mathematical expression related to the list’s length. Would you believe that C# offers several more intriguing alternatives?

```csharp
List<string> myList = new List<string> {"red", "blue", "green"};
// Get the last item with brute force using Count
string lastItem = myList[myList.Count - 1];
// Remove the last item from the list using RemoveAt
myList.RemoveAt(myList.Count - 1); 
// Get the last item using Linq Last() method
lastItem = myList.Last();
```

### Checking if a List Is Empty

For those with a background in statically typed languages such as Java or C++, the absence of static types in C# might seem unsettling. Indeed, not being aware of a variable’s type can be challenging at times; however, it also offers certain advantages

For example, C#’s type flexibility allows us to verify whether a list is empty through various techniques:

```csharp
List<int> myList = new List<int>();
// Check if a list is empty by its Count
if (myList.Count == 0)
{
    // the list is empty
}
// Check if a list is empty by its type flexibility **preferred method**
if (!myList.Any())
{
    // the list is empty
}
```

### Cloning a List

A fascinating aspect of programming for me is duplicating data types. In the context of the reference-based environment that we inhabit, it’s rarely a simple task, and this holds true for C# too.

Fortunately, when it comes to replicating a list, there are several methods available:

```csharp
List<int> myList = new List<int> {27, 13, -11, 60, 39, 15};
// Clone a list by brute force
List<int> myDuplicateList = myList.Select(item => item).ToList();
// Clone a list with the List constructor
myDuplicateList = new List<int>(myList); 
// Clone a list with the ToList() Linq extension method
myDuplicateList = myList.ToList();  // preferred method
// Clone a list with the DeepCopy method (requires custom implementation)
myDuplicateList = DeepCopy(myList);
```

### Writing a List Comprehension

List comprehensions are a powerful feature in Python, but C# doesn’t have a direct equivalent. However, we can achieve similar functionality using LINQ (Language Integrated Query) in C#. LINQ is a powerful querying syntax that provides a concise and expressive way to work with collections. Here are some examples using LINQ:

```csharp
var myList = new List<int> { 2, 5, -4, 6 };

// Duplicate a 1D list of constants
var duplicatedList = myList.Select(item => item).ToList();

// Duplicate and scale a 1D list of constants
var scaledList = myList.Select(item => 2 * item).ToList();

// Duplicate and filter out non-negatives from 1D list of constants
var filteredList = myList.Where(item => item < 0).ToList();

// Duplicate, filter, and scale a 1D list of constants
var filteredAndScaledList = myList.Where(item => item < 0).Select(item => 2 * item).ToList();

// Generate all possible pairs from two lists
var list1 = new List<int> { 1, 3, 5 };
var list2 = new List<int> { 2, 4, 6 };
var pairsList = list1.SelectMany(a => list2, (a, b) => (a, b)).ToList();
```

### Summing Elements of Two Lists

Imagine having two lists, and your goal is to combine them into one list by merging their elements pairwise. In other words, you aim to add the first element of the first list to the first element of the second list and save the outcome in a new list. C# offers several methods to achieve this:

```csharp
var ethernetDevices = new List<int> { 1, 7, 2, 8374163, 84302738 };
var usbDevices = new List<int> { 1, 7, 1, 2314567, 0 };

// Using LINQ's Zip method
var allDevices = ethernetDevices.Zip(usbDevices, (x, y) => x + y).ToList();

// Using a for loop
var allDevicesForLoop = new List<int>();
for (int i = 0; i < ethernetDevices.Count; i++)
{
    allDevicesForLoop.Add(ethernetDevices[i] + usbDevices[i]);
}
```

### Converting Two Lists Into a Dictionary

You might want to create a dictionary by mapping one list onto the other. Here’s how you can do that using LINQ in C#:

```csharp
var columnNames = new List<string> { "id", "color", "style" };
var columnValues = new List<object> { 1, "red", "bold" };

// Convert two lists into a dictionary with LINQ
var nameToValueDict = columnNames.Zip(columnValues, (key, value) => new { key, value }).ToDictionary(x => x.key, x => x.value);
```

### Sorting a List of Strings

Sorting strings can be a bit more complicated than sorting numbers, but fortunately, C# provides several options for sorting strings:

```csharp
var myList = new List<string> { "leaf", "cherry", "fish" };

// Using the Sort method
myList.Sort();

// Using the Sort method with StringComparison.OrdinalIgnoreCase for case-insensitive sorting
myList.Sort(StringComparer.OrdinalIgnoreCase);

// Using the OrderBy method with LINQ
var sortedList = myList.OrderBy(x => x).ToList();

// Using the OrderBy method with LINQ for case-insensitive sorting
var sortedIgnoreCaseList = myList.OrderBy(x => x, StringComparer.OrdinalIgnoreCase).ToList();
```

### Sorting a List of Dictionaries

You most likely want to organize a list of dictionaries in some order, right? Here’s how you can sort a list of dictionaries in C# using LINQ:

```csharp
var csvMappingList = new List<Dictionary<string, object>>
{
    new Dictionary<string, object> { { "Name", "Johnny" }, { "Age", 23 }, { "Favorite Color", "Blue" } },
    new Dictionary<string, object> { { "Name", "Ally" }, { "Age", 41 }, { "Favorite Color", "Magenta" } },
    new Dictionary<string, object> { { "Name", "Jasmine" }, { "Age", 29 }, { "Favorite Color", "Aqua" } }
};

// Sort by Age using LINQ's OrderBy method
var sortedList = csvMappingList.OrderBy(dict => (int)dict["Age"]).ToList();
```

These examples demonstrate some common use cases for collections in C#. Using these code snippets, you’ll be able to tackle everyday programming challenges more efficiently.

It has been said that programming is about understanding code rather than writing it. In this case here are some tests for exactly that. Take a look at it:

Comments are important in the code. Many times it has happened to read a code without comments from a couple of months ago and not understand where it comes from, what it does or why it is there. For that reason here are the options to make comments in C#:

```csharp
// Here is an inline comment in C#

/* Here
   is
   a
   multiline
   comment
   in
   C#
*/

/// <summary>
/// Here is an XML documentation comment in C#.
/// This is often used to provide additional information
/// about the code and is displayed by IntelliSense.
/// </summary>
```

### Testing Performance

Sometimes you want to compare the performance of different code snippets. C# provides a few straightforward options, including the `Stopwatch` class and the `BenchmarkDotNet` library. Take a look:

```csharp
// Stopwatch solution
using System;
using System.Diagnostics;

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();

// example snippet
var result = new List<(int, int)>();
foreach (int a in new[] { 1, 3, 5 })
{
    foreach (int b in new[] { 2, 4, 6 })
    {
        result.Add((a, b));
    }
}

stopwatch.Stop();
Console.WriteLine($"Elapsed time: {stopwatch.Elapsed}");

// BenchmarkDotNet solution
// Install the BenchmarkDotNet NuGet package to use this solution
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class MyBenchmark
{
    [Benchmark]
    public List<(int, int)> TestSnippet()
    {
        var result = new List<(int, int)>();
        foreach (int a in new[] { 1, 3, 5 })
        {
            foreach (int b in new[] { 2, 4, 6 })
            {
                result.Add((a, b));
            }
        }
        return result;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<MyBenchmark>();
    }
}
```

## Strings (14 Snippets)

They are commonly utilized for storing and manipulating text data such as names, email addresses, and more. Due to their importance, there are numerous string-related problems that developers often encounter. In this section, we will explore a few of those problems in the context of C#.

### Comparing Strings

When working with strings, what I usually ask is: Is there any way to be able to compare them without much complexity?

Or if we go deeper: Do we need to know the alphabetical order? If the two strings are different? Or what?

There are different tools we can use for each scenario. Here’s a quick list of options:

```csharp
string player1 = "Crosby";
string player2 = "Malkin";
string player3 = "Guentzel";

// Brute force comparison (equality only)
bool isSamePlayer = player1.Length == player3.Length;
if (isSamePlayer)
{
    for (int i = 0; i < player1.Length; i++)
    {
        if (player1[i] != player3[i])
        {
            isSamePlayer = false;
            break;
        }
    }
}

// Direct comparison
bool isEqual = player1 == player3; // False
bool isGreater = player1.CompareTo(player3) > 0; // False
bool isLessOrEqual = player2.CompareTo(player2) <= 0; // True

// Reference checking
bool isSameReference = ReferenceEquals(player1, player1); // True
bool isDifferentReference = ReferenceEquals(player2, player1); // False
```

Here you can see some options. For instance, we can check for equality using the `==` operator. If we only need to check alphabetical ordering, we can use the `CompareTo()` method. Likewise, C# has the `ReferenceEquals()` method for checking reference equality.

### Checking for Substrings

A common task when working with strings is determining if a string contains a specific substring. In C#, there are a few ways to solve this problem:

```csharp
string[] addresses = {
    "123 Elm Street",
    "531 Oak Street",
    "678 Maple Street"
};

string street = "Elm Street";

// Brute force (not recommended)
foreach (string address in addresses)
{
    int addressLength = address.Length;
    int streetLength = street.Length;
    for (int index = 0; index <= addressLength - streetLength; index++)
    {
        string substring = address.Substring(index, streetLength);
        if (substring == street)
        {
            Console.WriteLine(address);
        }
    }
}

// The IndexOf() method
foreach (string address in addresses)
{
    if (address.IndexOf(street) >= 0)
    {
        Console.WriteLine(address);
    }
}

// The Contains() method (preferred)
foreach (string address in addresses)
{
    if (address.Contains(street))
    {
        Console.WriteLine(address);
    }
}
```

### Formatting a String

Oftentimes, we need to format strings to display information in a more readable or structured manner. Here are some options:

```csharp
string name = "John";
int age = 25;

// String formatting using concatenation
Console.WriteLine("My name is " + name + ", and I am " + age + " years old.");

// String formatting using composite formatting
Console.WriteLine("My name is {0}, and I am {1} years old.", name, age);

// String formatting using interpolation (C# 6.0+)
Console.WriteLine($"My name is {name}, and I am {age} years old");
```

Feel free to use any of these methods wherever you need them.

### Converting a String to Lowercase

When formatting or comparing strings, sometimes it’s useful to convert all characters to lowercase. This can be helpful when checking for equality between two strings while ignoring casing differences. Here are a few ways to do that:

```csharp
string hero = "All Might";

// Using ToLower() method
string output = hero.ToLower();
```

### Splitting a String by Whitespace

Handling language concepts such as words and sentences can be challenging. The way to divide a string into words that almost everyone will think of at first is with spaces. Here’s how to do that in C#:

```csharp
string myString = "Hi, fam!";

// Using the built-in Split() method
string[] words = myString.Split();
foreach (string word in words)
{
    Console.WriteLine(word);
}
```

## File Operations (10 Snippets)

File operations are a common requirement in many programming tasks. In this section, we will explore how to work with files and directories in C# using the `System.IO` namespace.

### Reading a Text File

To read a text file in C#, you can use the `File` class and its `ReadAllText()` method:

```csharp
using System.IO;

string filePath = "example.txt";
string fileContent = File.ReadAllText(filePath);
Console.WriteLine(fileContent);
```

### Writing a Text File

To write a text file in C#, you can use the `File` class and its `WriteAllText()` method:

```csharp
using System.IO;

string filePath = "output.txt";
string content = "Hello, World!";
File.WriteAllText(filePath, content);
```

### Appending Text to a File

To append text to an existing file in C#, you can use the `File` class and its `AppendAllText()` method:

```csharp
using System.IO;

string filePath = "log.txt";
string logEntry = "New log entry";
File.AppendAllText(filePath, logEntry);
```

### Reading a File Line by Line

To read a file line by line in C#, you can use the `File` class and its `ReadLines()` method:

```csharp
using System.IO;

string filePath = "example.txt";
foreach (string line in File.ReadLines(filePath))
{
    Console.WriteLine(line);
}
```

### Creating a Directory

To create a directory in C#, you can use the `Directory` class and its `CreateDirectory()` method:

```csharp
using System.IO;

string directoryPath = "new_directory";
Directory.CreateDirectory(directoryPath);
```

### Deleting a Directory

To delete a directory in C#, you can use the `Directory` class and its `Delete()` method:

```csharp
using System.IO;

string directoryPath = "old_directory";
Directory.Delete(directoryPath, true);
```

### Checking if a File or Directory Exists

To check if a file or directory exists in C#, you can use the `File` and `Directory` classes with their respective `Exists()` methods:

```csharp
using System.IO;

string filePath = "example.txt";
string directoryPath = "example_directory";

bool fileExists = File.Exists(filePath);
bool directoryExists = Directory.Exists(directoryPath);
```

### Getting Files in a Directory

To get a list of files in a directory in C#, you can use the `Directory` class and its `GetFiles()` method:

```csharp
using System.IO;

string directoryPath = "example_directory";
string[] files = Directory.GetFiles(directoryPath);

foreach (string file in files)
{
    Console.WriteLine(file);
}
```

### Copying a File

To copy a file in C#, you can use the `File` class and its `Copy()` method:

```csharp
using System.IO;

string sourceFile = "example.txt";
string destinationFile = "copy_example.txt";
File.Copy(sourceFile, destinationFile);
```

### Moving a File

To move a file in C#, you can use the `File` class and its `Move()` method:

```csharp
using System.IO;

string sourceFile = "example.txt";
string destinationFile = "moved_example.txt";
File.Move(sourceFile, destinationFile);
```

## Exception Handling (3 Snippets)

Handling [exceptions](https://www.bytehide.com/blog/5-good-practices-for-error-handling-in-c/ "Mastering C# Exception Handling: Techniques and Best Practices") is an essential part of writing robust and maintainable code. In this section, we will explore a few common ways to handle exceptions in C#.

### Basic Try-Catch Block

To handle exceptions using a try-catch block in C#:

```csharp
try
{
    // Code that may throw an exception
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
```

### Catching Specific Exceptions

To catch specific exceptions in C#, you can use multiple catch blocks:

```csharp
try
{
    // Code that may throw different exceptions
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"File not found: {ex.FileName}");
}
catch (IOException ex)
{
    Console.WriteLine($"I/O error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General error: {ex.Message}");
}
```

### Using Finally Block

To execute code regardless of whether an exception was thrown or not, you can use the finally block in C#:

```csharp
try
{
    // Code that may throw an exception
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
finally
{
    // Code that will always be executed
}
```

## LINQ (10 Snippets)

Language Integrated Query (LINQ) is a powerful feature in C# for querying and manipulating data. In this section, we will explore some common LINQ operations using the `System.Linq` namespace.

### Filtering a Collection

To filter a collection using LINQ, you can use the `Where()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
List<int> evenNumbers = numbers.Where(x => x % 2 == 0).ToList();
```

### Selecting a Property from a Collection

To select a specific property from a collection using LINQ, you can use the `Select()` method:

```csharp
using System.Linq;

List<string> names = new List<string> { "John", "Jane", "Doe" };
List<int> nameLengths = names.Select(x => x.Length).ToList();
```

### Sorting a Collection

To sort a collection using LINQ, you can use the `OrderBy()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
List<int> sortedNumbers = numbers.OrderBy(x => x).ToList();
```

### Grouping a Collection

To group a collection using LINQ, you can use the `GroupBy()` method:

```csharp
using System.Linq;

List<string> names = new List<string> { "John", "Jane", "Doe" };
var groups = names.GroupBy(x => x.Length);

foreach (var group in groups)
{
    Console.WriteLine($"Names with {group.Key} characters:");
    foreach (string name in group)
    {
        Console.WriteLine(name);
    }
}
```

### Joining Collections

To join two collections using LINQ, you can use the `Join()` method:

```csharp
using System.Linq;

List<string> names = new List<string> { "John", "Jane", "Doe" };
List<int> ages = new List<int> { 30, 25, 35 };

var nameAgePairs = names.Join(ages, name => names.IndexOf(name), age => ages.IndexOf(age), (name, age) => new { Name = name, Age = age });
foreach (var pair in nameAgePairs)
{
    Console.WriteLine($"{pair.Name}: {pair.Age}");
}
```

### Taking the First n Elements

To take the first n elements from a collection using LINQ, you can use the `Take()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
List<int> firstThreeNumbers = numbers.Take(3).ToList();
```

### Skipping the First n Elements

To skip the first n elements from a collection using LINQ, you can use the `Skip()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
List<int> remainingNumbers = numbers.Skip(2).ToList();
```

### Checking if an Element Exists

To check if an element exists in a collection using LINQ, you can use the `Any()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
bool hasEvenNumber = numbers.Any(x => x % 2 == 0);
```

### Counting Elements

To count the number of elements in a collection using LINQ, you can use the `Count()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int evenNumberCount = numbers.Count(x => x % 2 == 0);
```

### Aggregating Elements

To aggregate elements in a collection using LINQ, you can use the `Aggregate()` method:

```csharp
using System.Linq;

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
int sum = numbers.Aggregate((x, y) => x + y);
```

## Threading (9 Snippets)

Threading is an important aspect of concurrent programming in C#. In this section, we will explore how to work with threads using the `System.Threading` namespace.

### Creating a New Thread

To create a new thread in C#, you can use the `Thread` class:

```csharp
using System.Threading;

void PrintNumbers()
{
    for (int i = 1; i <= 5; i++)
    {
        Console.WriteLine(i);
    }
}

Thread newThread = new Thread(PrintNumbers);
```

### Starting a Thread

To start a thread in C#, you can use the `Start()` method:

### Joining a Thread

To wait for a thread to finish executing in C#, you can use the `Join()` method:

### Thread Sleep

To pause the current thread for a specified time in C#, you can use the `Sleep()` method:

```csharp
Thread.Sleep(1000); // Sleep for 1 second
```

### Using Thread Pools

To use a thread pool in C#, you can use the `ThreadPool` class:

```csharp
using System.Threading;

ThreadPool.QueueUserWorkItem(PrintNumbers);
```

### Using Tasks

To create and run a task in C#, you can use the `Task` class:

```csharp
using System.Threading.Tasks;

Task.Run(PrintNumbers);
```

### Waiting for Tasks

To wait for a task to complete in C#, you can use the `Wait()` method:

```csharp
Task task = Task.Run(PrintNumbers);
task.Wait();
```

### Cancelling a Task

To cancel a task in C#, you can use the `CancellationTokenSource` class:

```csharp
using System.Threading;
using System.Threading.Tasks;

CancellationTokenSource cts = new CancellationTokenSource();
Task.Run(() => PrintNumbers(cts.Token), cts.Token);
cts.Cancel();
```

### Handling Task Exceptions

To handle exceptions in a task, you can use a try-catch block inside the task:

```csharp
using System.Threading.Tasks;

Task.Run(() =>
{
    try
    {
        // Code that may throw an exception
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
    }
});
```

We hope this diverse assortment of 100 C# code snippets has proven to be both enlightening and useful in your everyday programming endeavors.
If you found this compilation helpful or have any favorites, we'd love to hear from you! Feel free to share your thoughts and experiences in the comments section below.
Remember, the C# community thrives on the exchange of knowledge and ideas, so don't hesitate to contribute your insights for the benefit of fellow developers. Happy coding!