C# SortedList類概念和示例

SortedList 類 [C#]
　　命名空間: System.Collections

　　表示鍵/值對的集合，這些鍵和值按鍵排序並可按照鍵和索引訪問。

　　SortedList 是 Hashtable 和 Array 的混合。當使用 Item 索引器屬性按照元素的鍵訪問元素時，其行為類似於 Hashtable。當使用 GetByIndex 或 SetByIndex 按照元素的索引訪問元素時，其行為類似於 Array。

　　SortedList 在內部維護兩個數組以將數組存儲到列表中；即，一個數組用於鍵，另一個數組用於相關聯的值。每個元素都是一個可作為 DictionaryEntry 對象進行訪問的鍵/值對。鍵不能為空引用（Visual Basic 中為 Nothing），但值可以。
SortedList 的容量是列表可擁有的元素數。隨着向 SortedList 中添加元素，容量通過重新分配按需自動增加。可通過調用 TrimToSize 或通過顯式設置 Capacity 屬性減少容量。
　　SortedList 的元素將按照特定的 IComparer 實現（在創建 SortedList 時指定）或按照鍵本身提供的 IComparable 實現並依據鍵來進行排序。不論在哪種情況下，SortedList 都不允許重復鍵。

　　索引順序基於排序順序。當添加元素時，元素將按正確的排序順序插入 SortedList，同時索引會相應地進行調整。若移除了元素，索引也會相應地進行調整。因此，當在 SortedList 中添加或移除元素時，特定鍵/值對的索引可能會更改。
由於要進行排序，所以在 SortedList 上操作比在 Hashtable 上操作要慢。但是，SortedList 允許通過相關聯鍵或通過索引對值進行訪問，可提供更大的靈活性。
此集合中的索引從零開始。

　　 C# 語言中的 foreach 語句（在 Visual Basic 中為 for each）需要集合中每個元素的類型。由於 SortedList 的每個元素都是一個鍵/值對，因此元素類型既不是鍵的類型，也不是值的類型。而是 DictionaryEntry 類型。

 

如：

foreach (DictionaryEntry de in list)
            {
                Console.WriteLine("遍歷");
                Console.WriteLine("/t鍵：{0}/t值：{1}", de.Key, de.Value);
            }

 

System.Object
System.Collections.Generic.SortedList<TKey, TValue>
命名空間： System.Collections.Generic
程序集： System（在 System.dll 中）

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class SortedList<TKey, TValue> : IDictionary<TKey, TValue>, 
    ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
    IDictionary, ICollection, IEnumerable

類型參數

TKey

集合中鍵的類型。

TValue

集合中值的類型。

SortedList<TKey, TValue> 類型公開以下成員。

 

SortedList<TKey, TValue> 泛型類是具有 O(log n) 檢索的鍵/值對數組，其中 n 是字典中元素的數目。 就這一點而言，它與 SortedDictionary<TKey, TValue> 泛型類相似。 這兩個類具有相似的對象模型，並且都具有 O(log n) 的檢索運算復雜度。 這兩個類的區別在於內存的使用以及插入和移除元素的速度：
SortedList<TKey, TValue> 使用的內存比 SortedDictionary<TKey, TValue> 少。
SortedDictionary<TKey, TValue> 可對未排序的數據執行更快的插入和移除操作，它的運算復雜度為 O(log n)，而 SortedList<TKey, TValue> 的運算復雜度為 O(n)。
如果使用排序數據一次性填充列表，則 SortedList<TKey, TValue> 比 SortedDictionary<TKey, TValue> 快。
SortedDictionary<TKey, TValue> 類和 SortedList<TKey, TValue> 類之間的另一個區別是：SortedList<TKey, TValue> 支持通過由 Keys 和 Values 屬性返回的集合對鍵和值執行高效的索引檢索。 訪問此屬性時無需重新生成列表，因為列表只是鍵和值的內部數組的包裝。 下面的代碼演示如何使用 Values 屬性從已排序的字符串列表中按索引檢索值：

string v = mySortedList.Values[3];

SortedList<TKey, TValue> 作為鍵/值對的數組來實現，它按鍵排序。 每個元素都可以作為一個 KeyValuePair<TKey, TValue> 對象進行檢索。
只要鍵對象用作 SortedList<TKey, TValue> 中的鍵，它們就必須是永遠不變的。 SortedList<TKey, TValue> 中的每個鍵必須是唯一的。 鍵不能為 null，但如果列表中值的類型 TValue 為引用類型，則值可以。

SortedList<TKey, TValue> 需要比較器實現來排序和執行比較。 默認比較器 Comparer<T>.Default 檢查鍵類型 TKey 是否實現 System.IComparable<T> 以及是否使用該實現（如果可用）。 否則，Comparer<T>.Default 將檢查鍵類型 TKey 是否實現 System.IComparable。 如果鍵類型 TKey 未實現任一接口，則您可以在構造函數重載中指定一個接受 comparer 參數的 System.Collections.Generic.IComparer<T> 實現。

SortedList<TKey, TValue> 的容量是指 SortedList<TKey, TValue> 可以保存的元素數。 當向 SortedList<TKey, TValue> 中添加元素時，將通過重新分配內部數組來根據需要自動增大容量。 可通過調用 TrimExcess 或通過顯式設置 Capacity 屬性減少容量。 減少容量會重新分配內存並復制 SortedList<TKey, TValue> 中的所有元素。
C# 語言中的 foreach 語句（在 C++ 中為 for each，在 Visual Basic 中為 For Each）需要集合中的元素類型。 由於 SortedList<TKey, TValue> 的元素是鍵/值對，因此元素類型既不是鍵的類型，也不是值的類型。 而是 KeyValuePair<TKey, TValue> 類型。 例如：

foreach( KeyValuePair<int, string> kvp in mySortedList )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

foreach 語句是對枚舉數的包裝，它只允許從集合中讀取，不允許寫入集合。

下面的代碼示例使用字符串鍵創建一個空的字符串 SortedList<TKey, TValue>，並使用 Add 方法添加一些元素。 此示例演示了當嘗試添加重復鍵時，Add 方法會引發 ArgumentException。

此示例使用 Item 屬性（C# 中的索引器）檢索值，演示了當請求的鍵不存在時會引發 KeyNotFoundException，以及與鍵關聯的值可以被替換。
此示例演示如果程序必須經常嘗試排序列表中不存在的鍵值，如何將 TryGetValue 方法作為更有效的值檢索方法，以及在調用 Add 方法前，如何使用 ContainsKey 方法測試鍵是否存在。

此示例演示如何在排序列表中枚舉鍵和值，以及如何使用 Keys 屬性和 Values 屬性分別枚舉鍵和值。
最后，此示例演示了 Remove 方法。

 

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<string, string> openWith = 
            new SortedList<string, string>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the list.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate list elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        IList<string> ilistValues = openWith.Values;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SorteList values.
        Console.WriteLine();
        foreach( string s in ilistValues )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console.WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith.Values[2]);

        // To get the keys alone, use the Keys property.
        IList<string> ilistKeys = openWith.Keys;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SortedList keys.
        Console.WriteLine();
        foreach( string s in ilistKeys )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // The Keys property is an efficient way to retrieve
        // keys by index.
        Console.WriteLine("\nIndexed retrieval using the Keys " +
            "property: Keys[2] = {0}", openWith.Keys[2]);

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}
 // http://www.cnblogs.com/roucheng/
/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */

 http://www.cnblogs.com/roucheng/