Advertisement

---

Top

< Prev

Next >

The generic SortedList<TKey, TValue> collection class stores a sorted collection of key-value pairs, where:

• keys are a same type of objects, and
• values are a same type of objects.

InSortedList<TKey, TValue>, the key-value pairs are sorted by the keys, where each key is used as an index at which its associated value is stored.

SortedList<TKey, TValue> collection class is defined in the System.Collections.Generic namespace and it implements IDictionary, IDictionary<TKey, TValue>, ICollection, IEnumerable<KeyValuePair<TKey, TValue>> and many other interfaces.

Some important features ofSortedList<TKey, TValue>

• A null cannot be stored as a key.
• A null can be stored as a value.
• SortedList<TKey, TValue> elements are ordered on the basis of the ordering of the keys.
• In SortedList<TKey, TValue>, each key and each value can also be referred by an index position.

The commonly used constructors of SortedList<TKey, TValue>

Constructor	Description
SortedList<T>()	This constructor creates an empty instance of the SortedList<TKey, TValue> class by using the default initial capacity, hash code provider, and comparer. The capacity of a SortedList<TKey, TValue> is the number of elements it can hold, as the new elements are added to the SortedList<TKey, TValue>, its capacity is automatically increased.
SortedList<T>(int capacity)	This constructor initializes created anSortedList<TKey, TValue> that is empty and has the specified initial capacity..
SortedList<T>(IDictionary<TKey, TValue>)	This constructor creates an SortedList<T> initialized with the elements of an IDictionary<TKey, TValue> collection.

Properties of SortedList<TKey, TValue>:

Properties	Description
Capacity	This property is used to get or set the total number of elements a SortedList<TKey, TValue> can hold.
Count	This property gives total number of elements in a SortedList<TKey, TValue>.
IsFixedSize	This property determines whether a SortedList<TKey, TValue> has a fixed size or not.
IsReadOnly	This property determines whether a SortedList<TKey, TValue> is read-only or not.
IsSynchronzied	This property determines whether a SortedList<TKey, TValue> is thread-safe or not.
Item[Object key]	This property gets or sets a value associated with the specified key in the SortedList<TKey, TValue>. To use this property, you should not type Item, but you only need to specify the specific key within a pair of square brackets [ ]
Keys	This property gets an ICollection<TKey> containing the keys of the SortedList<TKey, TValue>.
Values	This property gets an ICollection<TValue containing the values of the SortedList<TKey, TValue>.

Some methods in a SortedList<TKey, TValue>.

Methods	Description
void Add(TKey key, TValue value)	This method adds the specified key-value pair in SortedList<TKey, TValue>.
bool ContainsKey(TKey key)	This method checks if SortedList<TKey, TValue> contains a specific key.
bool ContainsValue(TKey key)	This method checks if SortedList<TKey, TValue> contains a specific value.
void Clear()	This method removes all of the elements from the SortedList<TKey, TValue>.
int IndexOfKey(TKey key)	This method returns the zero-based index of the specified key in a SortedList<TKey, TValue> object
int IndexOfValue(TValue value)	This method returns the zero-based index of the first occurrence of the specified value in a SortedList<TKey, TValue> object.
<Generic.KeyValuePair<TKey,TValue>> GetEnumerator()	This method returns to enumerate the entire SortedList<TKey, TValue>.
void Remove(TKey key)	This method removes the element with the specified key in the SortedList<TKey, TValue>.
void RemoveAt(int index)	This method removes the element at the specified index in the SortedList<TKey, TValue>.

Note: Please know that passing an invalid/out-of-range index to any method that takes index position, will throw an ArgumentOutOfRangeException.

SortedList<T> example

In the upcoming example, we will create the SortedList<TKey, TValue> to store a sorted key-value pair of objects, where:
• Each key is a String object.
• Each key's associated value is an int and because C# has a unified type system, so any primitive values like int, char, float, etc are implicitly boxed into an Object references.

We will iterate over all the key-value pairs(sorted on the basis of keys) and we will also obtain a value on the basis its key.

//C# Example of SortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating a SortedList<TKey, TValue> of type, SortedList<String,int>
	//Where keys are of type String and values are of type int
	SortedList<String,int> sl = new SortedList<String, int>();

	//Adding key-value pairs by the Add() method
	sl.Add("Max", 1000);
	sl.Add("John", 4000);
	sl.Add("Tom", 2000);
	sl.Add("Ana", 6000);
	sl.Add("Rick", 5000);

	//Getting a collection of the keys using property Keys
	ICollection<String> c = sl.Keys;
	
	// Use the keys to obtain the values.
	Console.WriteLine("The sorted key-value pairs of SortedList<String, Key>:");
	foreach(String str in c)
		Console.WriteLine(str + ": " + sl[str]);

	//Using the property Item to retrieve the value of key "Tom"
	//Remember the property Item is not used with its name
	Console.WriteLine("Value at the key, Tom is "+ sl["Tom"]);

	//Using the property Item to retrieve the value of key "Ana"
	Console.WriteLine("Value at the key, Ana is "+ sl["Ana"]);
}
}

Output is :

The sorted key-value pairs of SortedList<String, int>:
Ana: 6000
John: 4000
Max: 1000
Rick: 5000
Tom: 2000
Value at the key, Tom is 2000
Value at the key, Ana is 6000

Program Analysis

• The method Add() is called to add the values of Key-Value pair by specifying the Key and its Value.
• Next, we have retrieved a collection of the keys stored in the SortedList<TKey, TValue>, by using its property Keys, and using which, we have iterated over each value stored in the SortedList<TKey, TValue>.
• Next we have used the Item[key] property of the SortedList<TKey, TValue>(which is used without specifying the word Item), to obtain a value associated with a particular key in a SortedList<TKey, TValue>.

Advertisement

Checking ifSortedList<TKey, TValue> contains a specific key or a specific value

In this example ofSortedList<TKey, TValue> we will perform two operations:
• We will determine if the SortedList<TKey, TValue> contains a specific key by using the methods, ContainsKey(Object).
• We will determine if the SortedList<TKey, TValue> contains a specific value by using the method, ContainsValue(Object).




//C# Example ofSortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating a SortedList<TKey, TValue> of type, SortedList<String,int>
	//Where keys are of type String and values are of type int
	SortedList<String,int> sl = new SortedList<String, int>();


	//Adding key-value pairs by the Add() method
	sl.Add("Max", 1000);
	sl.Add("John", 4000);
	sl.Add("Tom", 2000);
	sl.Add("Ana", 6000);
	sl.Add("Rick", 5000);


	//Getting a collection of the keys using property Keys
	ICollection<String> c = sl.Keys;
	

	// Use the keys to obtain the values.
	Console.WriteLine("The contents of SortedList<String, int>:");
	foreach(String str in c)
		Console.WriteLine(str + ": " + sl[str]);


	//Calling the method ContainsKey() to see ifSortedList<TKey, TValue> contains key "Ana"
	Console.WriteLine("Does our SortedList<TKey, TValue> contains the key, Tom: "+ sl.ContainsKey("Ana"));


	//Calling the method ContainsKey() to see ifSortedList<TKey, TValue> contains key "Jack"
	Console.WriteLine("Does our SortedList<TKey, TValue> contains the key, Jack: "+ sl.ContainsKey("Jack"));


	//Calling the method ContainsValue() to see ifSortedList<TKey, TValue> contains value 4000
	Console.WriteLine("Does our SortedList<TKey, TValue> contains the value, 4000: "+ sl.ContainsValue(4000));


	//Calling the method ContainsValue() to see ifSortedList<TKey, TValue> contains value 10000
	Console.WriteLine("Does our SortedList<TKey, TValue> contains the value, 10000: "+ sl.ContainsValue(10000));
}
}





Output is :

The contents of SortedList<String, int>:
Ana: 6000
John: 4000
Max: 1000
Rick: 5000
Tom: 2000
Does our SortedList<TKey, TValue> contains the key, Tom: True
Does our SortedList<TKey, TValue> contains the key, Jack: False
Does our SortedList<TKey, TValue> contains the value, 4000: True
Does our SortedList<TKey, TValue> contains the value, 10000: False








Accessing index position of key and value.



As we have said in in the beginning of this article, in SortedList<TKey, TValue>, each key and each value can also be referred by an index position. Let us show you an example.



//C# Accessing index position of key and value in a SortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating the SortedList<TKey, TValue> of type, SortedList<char,String>
	//Where keys are of type char and values are of type String
	SortedList<char, String> sl = new SortedList<char, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	sl.Add('B', "Banana");
	sl.Add('M', "Mango");
	sl.Add('G', "Grapes");
	sl.Add('A', "Apple");
	sl.Add('O', "Orange");


	//Getting a collection of the keys using property Keys
	ICollection<char> c = sl.Keys;
	
	//Using the keys to obtain the values.
	Console.WriteLine("The sorted key-value pairs of SortedList<String, Key>:");
	foreach(char str in c)
		Console.WriteLine(str + ": " + sl[str]);


	//Getting the index of the key 'B'(it is char value)
	//where, the first key is stored at zero-index position
	Console.WriteLine("The index of key B: " + sl.IndexOfKey('B'));


	//Getting the index of value "Mango"
	Console.WriteLine("The index of value Mango: " + sl.IndexOfValue("Mango"));	


	//Getting the index of the key 'M'(it is char value)
	//where, the first key is stored at zero-index position
	Console.WriteLine("The index of key BM: " + sl.IndexOfKey('M'));


	//Getting the index of value "Orange"
	Console.WriteLine("The index of value Mango: " + sl.IndexOfValue("Orange"));	
}
}





Output is :

The sorted key-value pairs of SortedList<String, Key>:
A: Apple
B: Banana
G: Grapes
M: Mango
O: Orange
The index of key B: 1
The index of value Mango: 3
The index of key BM: 3
The index of value Mango: 4








Removing elements from the SortedList<TKey, TValue>



In this example of SortedList<TKey, TValue> we will call the Remove(TKey key) and RemoveAt(int index) method to remove the elements of the SortedList<TKey, TValue>.
• The Remove(TKey key) removes the element with the specified key in the SortedList<TKey, TValue>.
• The Remove(int index) method removes the element at the specified index in the SortedList<TKey, TValue>.




//C# Example of SortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating a SortedList<TKey, TValue> of type, SortedList<char,String>
	//Where keys are of type char and values are of type String
	SortedList<char, String> sl = new SortedList<char, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	sl.Add('B', "Banana");
	sl.Add('M', "Mango");
	sl.Add('G', "Grapes");
	sl.Add('A', "Apple");
	sl.Add('O',"Orange");


	//Getting a collection of the keys using property Keys
	ICollection<char> c = sl.Keys;
	

	// Use the keys to obtain the values.
	Console.WriteLine("The contents of SortedList<TKey, TValue>:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + sl[ch]);


	//Calling the method Remove() to remove a key 'A' and its associated value
	sl.Remove('A');

	//Calling the method Remove() to remove a key 'M' and its associated value
	sl.Remove('M');


	//Printing all elements ofSortedList<TKey, TValue>
	Console.WriteLine("The updated contents of SortedList<TKey, TValue> after removing keys 'A' and 'M' and their values:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + sl[ch]);


	//Calling the method RemoveAt() to remove the element at index 3
	sl.RemoveAt(2);


	//Printing all elements ofSortedList<TKey, TValue>
	Console.WriteLine("The updated contents of SortedList<TKey, TValue> after removing the element at index 2:");
	foreach(char ch in c)
		Console.WriteLine(ch + ": " + sl[ch]);
}
}





Output is :

The contents of SortedList<TKey, TValue>:
A: Apple
B: Banana
G: Grapes
M: Mango
O: Orange
The updated contents of SortedList<TKey, TValue> after removing keys 'A' and 'M' and their values:
B: Banana
G: Grapes
O: Orange
The updated contents of SortedList<TKey, TValue> after removing the element at index 2:
B: Banana
G: Grapes



As you can see in the just concluded example, we have created a SortedList<TKey, TValue> to store objects in the form of key-value pair of objects, where:
• Each key is a char value, and because C# has a unified type system, so any primitive values like int, char, float, etc are implicitly boxed into an Object references.
• Each value is a String object.






A key in SortedList<TKey, TValue> cannot be null



In this example of SortedList<TKey, TValue>, we will show you how inserting a null value for a key, throws an exception.



//C# Key cannot be null in a SortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating the SortedList<TKey, TValue> of type, SortedList<String,String>
	//Where keys are of type String and values are of type String
	SortedList<String, String> sl = new SortedList<String, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	sl.Add("B", "Banana");
	sl.Add("Ma", "Mango");
	sl.Add("Gr", "Grapes");
	sl.Add("Ap", "Apple");
	sl.Add("Or", "Orange");
	sl.Add(null, "no value");	//Trying to store a null as a key
}
}





Output

Unhandled Exception: System.ArgumentNullException: Value cannot be null.
Parameter name: key
   at System.ThrowHelper.ThrowArgumentNullException(ExceptionArgument argument)
   at System.Collections.Generic.SortedList`2.Add(TKey key, TValue value)
   at SortedListDemo.Main(String[] ar)


As you can see, the program has thrown a ArgumentNullException because a Key cannot be null.






A value inSortedList<TKey, TValue> can be null



In this example of SortedList<TKey, TValue>, we will show you how inserting a null for a value is completely allowed and doesn't throws an exception.



//C# A value can  be null in a SortedList<TKey, TValue>

using System;
using System.Collections.Generic;

class SortedListDemo
{
public static void Main(String[] ar)
{
	//Creating the SortedList<TKey, TValue> of type, SortedList<String,String>
	//Where keys are of type char and values are of type String
	SortedList<String, String> sl = new SortedList<String, String>();


	//Adding key-value pairs by the Add() method
	//Where, each key is a character and each value is a String.
	sl.Add("B", "Banana");
	sl.Add("Ma", "Mango");
	sl.Add("Gr", "Grapes");
	sl.Add("Ap", "Apple");
	sl.Add("Or", "Orange");
	sl.Add("Nu", null);	//Trying to store a null as a value


	//Getting a collection of the keys using property Keys
	ICollection<String> c = sl.Keys;
	

	//Printing the key-value pairs by using the collection of keys to obtain their values.
	Console.WriteLine("The contents of SortedList<String, String>:");
	foreach(string key in c)
		Console.WriteLine(key + ": " + sl[key]);

}
}





Output

The contents of SortedList:
Ap: Apple
B: Banana
Gr: Grapes
Ma: Mango
Nu:
Or: Orange


As you can see, the program has not thown any exception even when we have specified a null as a value for a key Nu.





Please share this article -






< Prev
Next >
< C# Queue
C# Generic Stack >



Advertisement