Comparing two lists in C# is a common task, but choosing the right method is crucial for performance and accuracy. This comprehensive guide on compare.edu.vn explores various techniques to compare lists in C#, providing code examples and explanations to help you make informed decisions. Discover how to compare lists effectively, considering factors like list size, data types, and specific comparison requirements, ensuring optimal results for your C# applications.
1. What Are The Common Methods To Compare Two Lists In C#?
There are several ways to compare two lists in C# including using SequenceEqual, Intersect, Except, and custom comparison logic with IEqualityComparer. Each method has its advantages depending on the specific comparison requirements and the type of data in the lists.
1.1 Using SequenceEqual For Exact Matching
The SequenceEqual method checks if two sequences are identical by comparing elements at corresponding positions.
When to use: Use SequenceEqual when the order of elements matters, and you need to ensure that both lists have the same elements in the same order. This method is suitable for scenarios where the lists represent a specific sequence, such as a log of events or a series of commands.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class SequenceEqualExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c" };
List<string> list2 = new List<string>() { "a", "b", "c" };
List<string> list3 = new List<string>() { "a", "c", "b" };
bool areEqual1 = list1.SequenceEqual(list2); // True
bool areEqual2 = list1.SequenceEqual(list3); // False
Console.WriteLine($"List1 and List2 are equal: {areEqual1}");
Console.WriteLine($"List1 and List3 are equal: {areEqual2}");
}
}In this example, list1 and list2 are considered equal because they have the same elements in the same order. list1 and list3 are not equal because, although they contain the same elements, the order is different.
1.2 Using Intersect To Find Common Elements
The Intersect method identifies the elements that are present in both lists. It returns a new sequence containing only the common elements.
When to use: Use Intersect when you need to find the common elements between two lists, regardless of their order. This is useful in scenarios such as identifying shared customers between two databases or finding common features between two products.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class IntersectExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d" };
List<string> list2 = new List<string>() { "c", "d", "e", "f" };
IEnumerable<string> commonElements = list1.Intersect(list2);
Console.WriteLine("Common elements:");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}This example finds the common elements between list1 and list2, which are “c” and “d”. The output displays these common elements.
1.3 Using Except To Find Differences
The Except method identifies the elements that are present in the first list but not in the second list. It returns a new sequence containing these distinct elements.
When to use: Use Except when you need to find the elements that are unique to one list compared to another. This is useful in scenarios such as identifying new customers in a marketing campaign or finding the differences between two versions of a document.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class ExceptExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d" };
List<string> list2 = new List<string>() { "c", "d", "e", "f" };
IEnumerable<string> uniqueElements = list1.Except(list2);
Console.WriteLine("Unique elements in List1:");
foreach (var element in uniqueElements)
{
Console.WriteLine(element);
}
}
}This example finds the elements that are in list1 but not in list2, which are “a” and “b”. The output displays these unique elements.
1.4 Using IEqualityComparer For Custom Object Comparison
When comparing lists of custom objects, you often need to define your own logic for determining equality. The IEqualityComparer interface allows you to specify how objects should be compared.
When to use: Use IEqualityComparer when you need to compare lists of custom objects based on specific properties or criteria. This is useful in scenarios such as comparing products based on their names or comparing employees based on their IDs.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public Product(int id, string name)
{
Id = id;
Name = name;
}
}
public class ProductNameComparer : IEqualityComparer<Product>
{
public bool Equals(Product x, Product y)
{
if (x == null && y == null)
return true;
if (x == null || y == null)
return false;
return x.Name == y.Name;
}
public int GetHashCode(Product obj)
{
return obj.Name.GetHashCode();
}
}
public class EqualityComparerExample
{
public static void Main(string[] args)
{
List<Product> list1 = new List<Product>()
{
new Product(1, "Laptop"),
new Product(2, "Keyboard"),
new Product(3, "Mouse")
};
List<Product> list2 = new List<Product>()
{
new Product(4, "Keyboard"),
new Product(5, "Monitor"),
new Product(6, "Laptop")
};
var commonProducts = list1.Intersect(list2, new ProductNameComparer());
Console.WriteLine("Common products (by name):");
foreach (var product in commonProducts)
{
Console.WriteLine(product.Name);
}
}
}In this example, the ProductNameComparer class implements IEqualityComparer<Product> to compare Product objects based on their names. The Intersect method uses this comparer to find the common products between list1 and list2.
2. How Can I Compare Two Lists And Find The Differences?
To find the differences between two lists, you can use the Except method. This method returns the elements that are present in the first list but not in the second list, effectively highlighting the differences.
2.1 Identifying Unique Elements In Each List
To identify unique elements in both lists, you can use Except in both directions. This provides a comprehensive view of the differences between the two lists.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class FindDifferencesExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d" };
List<string> list2 = new List<string>() { "c", "d", "e", "f" };
IEnumerable<string> uniqueToList1 = list1.Except(list2);
IEnumerable<string> uniqueToList2 = list2.Except(list1);
Console.WriteLine("Unique elements in List1:");
foreach (var element in uniqueToList1)
{
Console.WriteLine(element);
}
Console.WriteLine("nUnique elements in List2:");
foreach (var element in uniqueToList2)
{
Console.WriteLine(element);
}
}
}This example finds the elements that are unique to list1 (“a”, “b”) and the elements that are unique to list2 (“e”, “f”). The output displays these unique elements for each list.
2.2 Comparing Lists Of Objects For Differences
When comparing lists of objects, you can use Except in conjunction with IEqualityComparer to identify differences based on specific properties.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public Product(int id, string name)
{
Id = id;
Name = name;
}
}
public class ProductNameComparer : IEqualityComparer<Product>
{
public bool Equals(Product x, Product y)
{
if (x == null && y == null)
return true;
if (x == null || y == null)
return false;
return x.Name == y.Name;
}
public int GetHashCode(Product obj)
{
return obj.Name.GetHashCode();
}
}
public class ObjectDifferencesExample
{
public static void Main(string[] args)
{
List<Product> list1 = new List<Product>()
{
new Product(1, "Laptop"),
new Product(2, "Keyboard"),
new Product(3, "Mouse")
};
List<Product> list2 = new List<Product>()
{
new Product(4, "Keyboard"),
new Product(5, "Monitor"),
new Product(6, "Laptop")
};
var uniqueToList1 = list1.Except(list2, new ProductNameComparer());
var uniqueToList2 = list2.Except(list1, new ProductNameComparer());
Console.WriteLine("Unique products in List1 (by name):");
foreach (var product in uniqueToList1)
{
Console.WriteLine(product.Name);
}
Console.WriteLine("nUnique products in List2 (by name):");
foreach (var product in uniqueToList2)
{
Console.WriteLine(product.Name);
}
}
}In this example, the Except method uses the ProductNameComparer to find the products that are unique to each list based on their names. The output displays these unique products for each list.
3. How Do I Compare Two Lists Of Objects In C# Based On A Specific Property?
To compare two lists of objects based on a specific property, you can use IEqualityComparer or LINQ’s Join method. Both methods allow you to define the criteria for comparing objects based on the chosen property.
3.1 Using IEqualityComparer For Property-Based Comparison
The IEqualityComparer interface allows you to define custom equality logic for objects. By implementing this interface, you can specify which property to use for comparison.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
}
public class EmployeeIdComparer : IEqualityComparer<Employee>
{
public bool Equals(Employee x, Employee y)
{
if (x == null && y == null)
return true;
if (x == null || y == null)
return false;
return x.Id == y.Id;
}
public int GetHashCode(Employee obj)
{
return obj.Id.GetHashCode();
}
}
public class PropertyComparisonExample
{
public static void Main(string[] args)
{
List<Employee> list1 = new List<Employee>()
{
new Employee { Id = 1, Name = "John" },
new Employee { Id = 2, Name = "Alice" },
new Employee { Id = 3, Name = "Bob" }
};
List<Employee> list2 = new List<Employee>()
{
new Employee { Id = 2, Name = "Charlie" },
new Employee { Id = 3, Name = "David" },
new Employee { Id = 4, Name = "Eve" }
};
var commonEmployees = list1.Intersect(list2, new EmployeeIdComparer());
Console.WriteLine("Common employees (by ID):");
foreach (var employee in commonEmployees)
{
Console.WriteLine($"ID: {employee.Id}, Name: {employee.Name}");
}
}
}In this example, the EmployeeIdComparer class implements IEqualityComparer<Employee> to compare Employee objects based on their IDs. The Intersect method uses this comparer to find the common employees between list1 and list2.
3.2 Using LINQ’s Join Method For Property-Based Comparison
The Join method allows you to combine elements from two sequences based on a common key. This is useful for comparing lists based on a specific property and performing actions on the matched elements.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
}
public class JoinComparisonExample
{
public static void Main(string[] args)
{
List<Employee> list1 = new List<Employee>()
{
new Employee { Id = 1, Name = "John" },
new Employee { Id = 2, Name = "Alice" },
new Employee { Id = 3, Name = "Bob" }
};
List<Employee> list2 = new List<Employee>()
{
new Employee { Id = 2, Name = "Charlie" },
new Employee { Id = 3, Name = "David" },
new Employee { Id = 4, Name = "Eve" }
};
var commonEmployees = list1.Join(
list2,
e1 => e1.Id,
e2 => e2.Id,
(e1, e2) => new { Employee1 = e1, Employee2 = e2 }
);
Console.WriteLine("Common employees (by ID):");
foreach (var employee in commonEmployees)
{
Console.WriteLine($"ID: {employee.Employee1.Id}, Name1: {employee.Employee1.Name}, Name2: {employee.Employee2.Name}");
}
}
}In this example, the Join method combines Employee objects from list1 and list2 based on their IDs. The output displays the common employees and their names from both lists.
4. How To Compare Two Lists Of Different Types In C#?
Comparing two lists of different types requires mapping the elements to a common type or using a custom comparison logic that can handle the type differences.
4.1 Mapping Elements To A Common Type
One approach is to project the elements of both lists to a common type using LINQ’s Select method. This allows you to compare the lists based on the projected values.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class DifferentTypesExample
{
public static void Main(string[] args)
{
List<int> list1 = new List<int>() { 1, 2, 3 };
List<string> list2 = new List<string>() { "2", "3", "4" };
var commonElements = list1.Select(x => x.ToString())
.Intersect(list2);
Console.WriteLine("Common elements (as strings):");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}In this example, the Select method is used to convert the integers in list1 to strings. The Intersect method then finds the common elements between the two lists, treating them as strings.
4.2 Using A Custom Comparison Logic
Another approach is to create a custom comparison logic that can handle the type differences. This involves implementing IEqualityComparer and defining how elements of different types should be compared.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class CustomComparerExample
{
public static void Main(string[] args)
{
List<int> list1 = new List<int>() { 1, 2, 3 };
List<string> list2 = new List<string>() { "2", "3", "4" };
var commonElements = list1.Where(x => list2.Contains(x.ToString()));
Console.WriteLine("Common elements:");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}This example uses the Where method to filter list1 based on whether the string representation of each integer is present in list2. This effectively compares the two lists despite their different types.
5. How Do I Compare Two Lists In C# Ignoring Order?
To compare two lists in C# ignoring order, you can use methods like Intersect and Except to find common and unique elements, or you can sort both lists and then use SequenceEqual.
5.1 Using Intersect And Except To Ignore Order
The Intersect and Except methods do not consider the order of elements. You can use these methods to find common and unique elements, effectively comparing the lists without regard to order.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class IgnoreOrderExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c" };
List<string> list2 = new List<string>() { "c", "a", "b" };
var commonElements = list1.Intersect(list2);
var uniqueToList1 = list1.Except(list2);
var uniqueToList2 = list2.Except(list1);
Console.WriteLine("Common elements:");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
Console.WriteLine("nUnique elements in List1:");
foreach (var element in uniqueToList1)
{
Console.WriteLine(element);
}
Console.WriteLine("nUnique elements in List2:");
foreach (var element in uniqueToList2)
{
Console.WriteLine(element);
}
}
}In this example, the Intersect method finds the common elements (“a”, “b”, “c”), and the Except methods find the unique elements in each list (which are none in this case since both lists contain the same elements).
5.2 Sorting And Using SequenceEqual
Another approach is to sort both lists and then use SequenceEqual to compare them. This ensures that the order of elements is the same before comparison, effectively ignoring the original order.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class SortAndCompareExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c" };
List<string> list2 = new List<string>() { "c", "a", "b" };
list1.Sort();
list2.Sort();
bool areEqual = list1.SequenceEqual(list2);
Console.WriteLine($"Lists are equal (ignoring order): {areEqual}");
}
}In this example, both lists are sorted alphabetically, and then SequenceEqual is used to compare them. The output indicates that the lists are equal because they contain the same elements in the same order after sorting.
6. How Can I Optimize The Performance Of List Comparison In C#?
Optimizing the performance of list comparison in C# involves choosing the right method for the task, minimizing unnecessary operations, and using data structures that improve efficiency.
6.1 Choosing The Right Comparison Method
The choice of comparison method can significantly impact performance. For example, SequenceEqual is faster for exact matching, while Intersect and Except are more efficient for finding common or unique elements.
6.2 Using HashSets For Faster Lookups
When comparing large lists, using HashSet<T> can improve performance. HashSet<T> provides faster lookups compared to List<T>, making Intersect and Except operations more efficient.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class HashSetExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d", "e" };
List<string> list2 = new List<string>() { "c", "d", "e", "f", "g" };
HashSet<string> hashSet1 = new HashSet<string>(list1);
HashSet<string> hashSet2 = new HashSet<string>(list2);
var commonElements = hashSet1.Intersect(hashSet2);
Console.WriteLine("Common elements:");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}In this example, the lists are converted to HashSet<string>, and the Intersect method is used to find the common elements. This approach is more efficient for large lists because HashSet<T> provides faster lookups.
6.3 Minimizing Unnecessary Operations
Avoid unnecessary operations such as iterating through the entire list when only a subset of elements needs to be compared. Use LINQ’s filtering and projection capabilities to narrow down the scope of the comparison.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class MinimizeOperationsExample
{
public static void Main(string[] args)
{
List<int> list1 = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
List<int> list2 = new List<int>() { 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };
var commonElements = list1.Where(x => x > 5)
.Intersect(list2.Where(x => x < 12));
Console.WriteLine("Common elements (filtered):");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}In this example, the Where method is used to filter both lists before finding the common elements. This reduces the number of elements that need to be compared, improving performance.
7. How Do I Handle Null Values When Comparing Two Lists In C#?
Handling null values when comparing two lists in C# requires careful consideration to avoid NullReferenceException errors and ensure accurate comparison results.
7.1 Using Null-Conditional Operator And Null Coalescing Operator
The null-conditional operator (?.) and null coalescing operator (??) can be used to safely handle null values when comparing elements.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class NullConditionalExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", null, "d" };
List<string> list2 = new List<string>() { "c", null, "e", "f" };
var commonElements = list1.Where(x => list2.Any(y => string.Equals(x, y)));
Console.WriteLine("Common elements (handling nulls):");
foreach (var element in commonElements)
{
Console.WriteLine(element);
}
}
}In this example, the string.Equals method is used to compare elements, which handles null values gracefully. The Where method filters list1 based on whether each element is equal to any element in list2, considering null values.
7.2 Implementing IEqualityComparer For Null Handling
When comparing lists of objects, you can implement IEqualityComparer to handle null values in a custom manner. This allows you to define how null values should be treated during comparison.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Product
{
public int? Id { get; set; }
public string Name { get; set; }
}
public class ProductIdComparer : IEqualityComparer<Product>
{
public bool Equals(Product x, Product y)
{
if (x == null && y == null)
return true;
if (x == null || y == null)
return false;
if (x.Id == null && y.Id == null)
return true;
if (x.Id == null || y.Id == null)
return false;
return x.Id == y.Id;
}
public int GetHashCode(Product obj)
{
return obj.Id?.GetHashCode() ?? 0;
}
}
public class NullHandlingExample
{
public static void Main(string[] args)
{
List<Product> list1 = new List<Product>()
{
new Product { Id = 1, Name = "Laptop" },
new Product { Id = null, Name = "Keyboard" },
new Product { Id = 3, Name = "Mouse" }
};
List<Product> list2 = new List<Product>()
{
new Product { Id = null, Name = "Monitor" },
new Product { Id = 3, Name = "Laptop" },
new Product { Id = 4, Name = "Eve" }
};
var commonProducts = list1.Intersect(list2, new ProductIdComparer());
Console.WriteLine("Common products (by ID, handling nulls):");
foreach (var product in commonProducts)
{
Console.WriteLine($"ID: {product.Id}, Name: {product.Name}");
}
}
}In this example, the ProductIdComparer class implements IEqualityComparer<Product> to compare Product objects based on their IDs, handling null values appropriately. The Intersect method uses this comparer to find the common products between list1 and list2.
8. How To Compare Two Lists For Partial Matches In C#?
Comparing two lists for partial matches involves finding elements that are similar but not necessarily identical. This can be achieved using string comparison methods or custom logic for comparing objects.
8.1 Using String Comparison Methods For Partial String Matches
For lists of strings, you can use methods like Contains, StartsWith, and EndsWith to find partial matches.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class PartialStringMatchExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "apple", "banana", "orange" };
List<string> list2 = new List<string>() { "app", "ban", "ora" };
var partialMatches = list1.Where(x => list2.Any(y => x.StartsWith(y)));
Console.WriteLine("Partial matches:");
foreach (var element in partialMatches)
{
Console.WriteLine(element);
}
}
}In this example, the StartsWith method is used to find elements in list1 that start with any of the elements in list2. The output displays the partial matches (“apple”, “banana”, “orange”).
8.2 Implementing Custom Logic For Partial Object Matches
For lists of objects, you can implement custom logic to define how partial matches should be determined. This involves comparing specific properties and defining a threshold for similarity.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class Product
{
public string Name { get; set; }
public string Description { get; set; }
}
public class PartialObjectMatchExample
{
public static void Main(string[] args)
{
List<Product> list1 = new List<Product>()
{
new Product { Name = "Laptop", Description = "High-performance laptop" },
new Product { Name = "Keyboard", Description = "Ergonomic keyboard" },
new Product { Name = "Mouse", Description = "Wireless mouse" }
};
List<Product> list2 = new List<Product>()
{
new Product { Name = "Laptop Pro", Description = "Professional laptop" },
new Product { Name = "Keyboard Pro", Description = "Advanced keyboard" }
};
var partialMatches = list1.Where(x => list2.Any(y => x.Name.Contains(y.Name)));
Console.WriteLine("Partial matches:");
foreach (var product in partialMatches)
{
Console.WriteLine($"Name: {product.Name}, Description: {product.Description}");
}
}
}In this example, the Contains method is used to find products in list1 whose names contain the names of products in list2. The output displays the partial matches (“Laptop”, “Keyboard”).
9. How Do I Compare Two Lists And Get The Matching And Non-Matching Elements?
To compare two lists and get both the matching and non-matching elements, you can use a combination of Intersect and Except methods. This allows you to identify the elements that are common to both lists and the elements that are unique to each list.
9.1 Using Intersect And Except To Get Matching And Non-Matching Elements
The Intersect method returns the elements that are present in both lists, while the Except method returns the elements that are present in one list but not in the other.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class MatchingNonMatchingExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d" };
List<string> list2 = new List<string>() { "c", "d", "e", "f" };
var matchingElements = list1.Intersect(list2);
var nonMatchingList1 = list1.Except(list2);
var nonMatchingList2 = list2.Except(list1);
Console.WriteLine("Matching elements:");
foreach (var element in matchingElements)
{
Console.WriteLine(element);
}
Console.WriteLine("nNon-matching elements in List1:");
foreach (var element in nonMatchingList1)
{
Console.WriteLine(element);
}
Console.WriteLine("nNon-matching elements in List2:");
foreach (var element in nonMatchingList2)
{
Console.WriteLine(element);
}
}
}In this example, the Intersect method finds the common elements (“c”, “d”), and the Except methods find the unique elements in each list (“a”, “b” in list1 and “e”, “f” in list2). The output displays the matching and non-matching elements for each list.
9.2 Using LINQ’s GroupJoin Method
The GroupJoin method can also be used to compare two lists and get the matching and non-matching elements. This method allows you to group elements from one list based on a common key and then identify the matching and non-matching elements.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class GroupJoinExample
{
public static void Main(string[] args)
{
List<string> list1 = new List<string>() { "a", "b", "c", "d" };
List<string> list2 = new List<string>() { "c", "d", "e", "f" };
var result = list1.GroupJoin(
list2,
x => x,
y => y,
(x, y) => new
{
Element = x,
IsMatching = y.Any()
});
Console.WriteLine("Matching and non-matching elements:");
foreach (var item in result)
{
Console.WriteLine($"Element: {item.Element}, IsMatching: {item.IsMatching}");
}
}
}In this example, the GroupJoin method groups elements from list1 based on whether they are present in list2. The output displays each element from list1 and indicates whether it is a matching element.
10. How Do I Compare Two Lists And Identify Added, Removed, And Modified Elements?
To compare two lists and identify added, removed, and modified elements, you can use a combination of Intersect, Except, and custom comparison logic. This allows you to track the changes between the two lists.
10.1 Using Intersect And Except To Identify Added And Removed Elements
The Intersect method identifies the elements that are present in both lists, while the Except method identifies the elements that are present in one list but not in the other. This can be used to find added and removed elements.
Code Example:
using System;
using System.Collections.Generic;
using System.Linq;
public class AddedRemovedExample
{
public static void Main(string[] args)
{
List<string> oldList = new List<string>() { "a", "b", "c", "d" };
List<string> newList = new List<string>() { "b", "c", "e", "f" };
var removedElements = oldList.Except(newList);
var addedElements = newList.Except(oldList);
var commonElements = oldList.Intersect(newList);
Console.WriteLine("Removed elements:");
foreach (var element in