C# - SortedList<TKey, TValue>

i. The SortedList<TKey, TValue>, and SortedList are

collection classes that can store key-value pairs that are
sorted by the keys based on the associated IComparer
implementation.
ii. For example, if the keys are of primitive types, then
sorted in ascending order of keys.
iii. C# supports generic and non-generic SortedList.
iv. It is recommended to use generic SortedList<TKey,
TValue> because it performs faster and less error-prone
than the non-generic SortedList.
SortedList Characteristics
• SortedList<TKey, TValue> is an array of key-value pairs sorted
by keys.
• Sorts elements as soon as they are added.
• Sorts primitive type keys in ascending order and object keys
based on IComparer<T>.
• Comes under System.Collection.Generic namespace.
• A key must be unique and cannot be null.
• A value can be null or duplicate.
• A value can be accessed by passing associated key in the indexer
mySortedList[key]
• Contains elements of type KeyValuePair<TKey, TValue>
• It uses less memory than SortedDictionary<TKey,TValue>.
• It is faster in the retrieval of data once sorted, whereas
SortedDictionary<TKey, TValue> is faster in insertion and
removing key-value pairs.
• Primitive Types: int , float , double , char ,
boolean , etc. Non-Primitive Types: String ,
Array , Class objects, and various data
structures like ArrayList , HashMap , etc.
Creating a SortedList
The following example demonstrates how to create a
generic SortedList<TKey, TValue>, and add key-value
pairs in it.
Example: Create a SortedList and Add Elements
//SortedList of int keys, string values
SortedList<int, string> numberNames = new SortedList<int, string>();
numberNames.Add(3, "Three");
numberNames.Add(1, "One");
numberNames.Add(2, "Two");
numberNames.Add(4, null);
numberNames.Add(10, "Ten");
numberNames.Add(5, "Five");
//The following will throw exceptions
//Compile-time error: key must be int type
numberNames.Add("Three", 3);

//Run-time exception: duplicate key

numberNames.Add(1, "One");

//Run-time exception: key cannot be null

numberNames.Add(null, "Five");
In the above example, a generic SortedList<TKey,
TValue> object is created by specifying the type of
keys and values it is going to store. The
SortedList<int, string> will store keys of int type and
values of string type.

The Add() method is used to add a single key-value

pair in a SortedList. Keys cannot be null or
duplicate. If found, it will throw a run-time
exception. Values can be duplicate and null if the
type is nullable.
Use the collection-initializer syntax to initialize a
SortedList with multiple key-value pairs at the time of
instantiating, as shown below.
//Creating a SortedList of string keys, string values
//using collection-initializer syntax
SortedList<string,string> cities = new SortedList<string,string>()
{
{"London", "UK"},
{"New York", "USA"},
{ "Mumbai", "India"},
{"Johannesburg", "South Africa"}
};
The SortedList rearranges key-value pairs in the ascending order of
keys as soon as a key-value pair added.
The following example displays all the keys and values using
foreach loop.
Example: SortedList Elements Default Sorting Order
SortedList<int,string> numberNames = new SortedList<int,string>()
{
{3, "Three"},
{5, "Five"},
{1, "One"}
};

Console.WriteLine("---Initial key-values--");
foreach(KeyValuePair<int, string> kvp in numberNames)
Console.WriteLine("key: {0}, value: {1}", kvp.Key , kvp.Value );

numberNames.Add(6, "Six");
numberNames.Add(2, "Two");
numberNames.Add(4, "Four");

Console.WriteLine("---After adding new key-values--");

foreach(var kvp in numberNames)

Console.WriteLine("key: {0}, value: {1}", kvp.Key , kvp.Value );
Accessing SortedList
Specify a key in the indexer sortedList[key], to get or set a value in
the SortedList.
Example: Access SortedList Values
SortedList<int,string> numberNames = new SortedList<int,string>()
{
{3, "Three"},
{1, "One"},
{2, "Two"}
};
Console.WriteLine(numberNames[1]);
Console.WriteLine(numberNames[2]);
Console.WriteLine(numberNames[3]);
//run-time KeyNotFoundException
Console.WriteLine(numberNames[10]);

numberNames[2] = "TWO"; //updates value

numberNames[4] = "Four"; //adds a new key-value if a key does not
exists.

• Above, numberNames[10] will throw a KeyNotFoundException

because specified key 10 does not exist in a sortedlist.
• To prevent this exception, use ContainsKey() or TryGetValue()
methods,
Example: ContainsKey() and TryGetValue()
SortedList<int, string> numberNames = new SortedList<int,string>()
{
{3, "Three"},
{1, "One"},
{2, "Two"}
};
if(numberNames.ContainsKey(4)){
numberNames[4] = "four";
}
int result;
if(numberNames.TryGetValue(4, out result))
Console.WriteLine("Key: {0}, Value: {1}", 4, result);
Use Keys and Values properties if you want to iterate a SortedList
using a for loop.
Example: Iterate SortedList using For Loop
SortedList<int, string> numberNames = new SortedList<int,string>()
{
{3, "Three"},
{1, "One"},
{2, "Two"}
};
for (int i = 0; i < numberNames.Count; i++)
{
Console.WriteLine("key: {0}, value: {1}", numberNames.Keys[i],
numberNames.Values[i]);
}
Remove Elements from SortedList
Use the Remove(key) and RemoveAt(index) methods to remove key-
value pairs from a SortedList.
Example: Remove Elements
SortedList<int,string> numberNames = new SortedList<int,string>()
{
{3, "Three"},
{1, "One"},
{2, "Two"},
{5, "Five"},
{4, "Four"}
};
numberNames.Remove(1); / /removes key 1 pair
numberNames.Remove(10); / /removes key 1 pair, no error if not
exists
numberNames.RemoveAt(0); //removes key-value pair
from index 0

numberNames.RemoveAt(10); //run-time exception:

ArgumentOutOfRangeException

foreach(var kvp in numberNames)

Console.WriteLine("key: {0}, value: {1}", kvp.Key , kvp.Value );
SortedList Class Hierarchy
The following diagram illustrates the SortedList hierarchy.
Use the SortedSet class in C#
The SortedSet<T> class pertaining to the
System.Collections.Generic namespace represents a
generic collection of objects present in sorted order. It
provides support for mathematical operations (intersection,
union, etc.) and it is a dynamic collection, meaning that the
size of an object of this collection will grow or shrink as
you add and remove elements.
A SortedSet contains only unique elements and is
used to store data in a collection that needs to be in
sorted order. By default, the elements of a
SortedSet are in ascending order. The SortedSet<T>
class implements the following interfaces:
•IReadOnlyCollection
•IDeserializationCallBack
•IEnumerable
•ISet
•ISerializable
The number of elements that you can store in an instance of
a SortedSet<T> is known as its capacity. The following
code snippet illustrates how you can create a SortedSet of
integers and store values into it.
SortedSet<int> sortedIntegers = new SortedSet<int>();
sortedIntegers.Add(1);
sortedIntegers.Add(5);
sortedIntegers.Add(3);
sortedIntegers.Add(2);
sortedIntegers.Add(4);
The following code snippet shows how you can retrieve the
elements of the SortedSet.
foreach (var x in sortedIntegers)
{
Console.WriteLine(x);
}
Practice :
How you can store strings in a SortedSet of strings
and then display them at the console window.