// CSortedList.cs

// http://svc.luckstar.com.tw/CodeHelper/cs/index.html
// 2017-03-28, honda@luckstar.com.tw, CodeHelper for SortedList() and SortedList<TKey, TValue>.
// 2017-04-23, Honda, Add SortedList<CString2, int>.

// KeyWord: SortedList(Object, Object), SortedList<TKey, TValue>, IList, KeyValuePair, DictionaryEntry
// Related: CString2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// add
using System.Collections;

namespace ConsoleBase
{
    public class CSortedList
    {
        SortedList mList1 = new SortedList(); // SortedList(Object, Object)
        SortedList<string, string> mList2 = new SortedList<string, string>(); // Generic of SortedList<TKey, TValue>
        CSortedListStringInt mList3 = new CSortedListStringInt(); // Inherits from Generic of SortedList<TKey, TValue>
        SortedList<CString2, int> mList4 = new SortedList<CString2, int>(); // Generic of SortedList<TKey, TValue>
        public void Run()
        {
            Console.WriteLine("CSortedList.Run(), 20170423:");
            Console.WriteLine();


            Console.WriteLine("mList1: SortedList(Object, Object)");

            mList1 = new SortedList();
            mList1.Add("Third", "!");
            mList1.Add("Second", "World");
            mList1.Add("First", "Hello");
            mList1.Add("A", 1.234);
            try
            {
                Console.WriteLine("mList1.Add(2.345, \"B\")");
                mList1.Add(2.345, "B"); // Key 欄位必須互相可比較大小才能存入.
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            mList1.Add(2.345.ToString(), "B");

            // Displays the properties and values of the SortedList.
            Console.WriteLine();
            Console.WriteLine("  Count:    {0}", mList1.Count);
            Console.WriteLine("  Capacity: {0}", mList1.Capacity);
            Console.WriteLine("  Keys and Values:");
            PrintKeysAndValues(mList1);

            Console.WriteLine();
            Console.WriteLine("----------");
            Console.WriteLine("list1: SortedList(Object, Object)");
            SortedList list1 = new SortedList();
            list1.Add(1.3, "fox");
            list1.Add(1.4, "jumped");
            list1.Add(1.5, "over");
            list1.Add(1.2, "brown");
            list1.Add(1.1, "quick");
            list1.Add(1.0, "The");
            list1.Add(1.6, "the");
            list1.Add(1.8, "dog");
            list1.Add(1.7, "lazy");

            // Gets the key and the value based on the index.
            int iIndex = 3;
            Console.WriteLine("The key   at index {0} is {1}.", iIndex, list1.GetKey(iIndex));
            Console.WriteLine("The value at index {0} is {1}.", iIndex, list1.GetByIndex(iIndex));

            // Gets the list of keys and the list of values.
            IList listKey = list1.GetKeyList();
            IList listValue = list1.GetValueList();

            // Prints the keys in the first column and the values in the second column.
            Console.WriteLine("\t-KEY-\t-VALUE-");
            for (int i = 0; i < list1.Count; i++)
                Console.WriteLine("\t{0}\t{1}", listKey[i], listValue[i]);

            Console.WriteLine();
            Console.WriteLine("----------");
            Console.WriteLine("list2: SortedList(Object, Object)");
            SortedList list2 = new SortedList();
            list2.Add(2, "cats");
            list2.Add(3, "in");
            list2.Add(1, "napping");
            list2.Add(4, "the");
            list2.Add(0, "three");
            list2.Add(5, "barn");

            // Creates and initializes the one-dimensional target Array.
            String[] tempArray = new String[] { "The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog" };
            DictionaryEntry[] myTargetArray = new DictionaryEntry[15];
            int i1 = 0;
            foreach (String s in tempArray)
            {
                myTargetArray[i1].Key = i1;
                myTargetArray[i1].Value = s;
                i1++;
            }

            // Displays the values of the target Array.
            Console.WriteLine("The target Array contains the following (before and after copying):");
            PrintValues(myTargetArray, ' ');

            // Copies the entire source SortedList to the target SortedList, starting at index 6.
            list2.CopyTo(myTargetArray, 6);

            // Displays the values of the target Array.
            PrintValues(myTargetArray, ' ');

            Console.WriteLine();
            Console.WriteLine("----------");
            Console.WriteLine("mList2 Generic SortedList<TKey, TValue>:");
            // Add some elements to the list. There are no 
            // duplicate keys, but some of the values are duplicates.
            mList2.Add("txt", "notepad.exe");
            mList2.Add("bmp", "paint.exe");
            mList2.Add("dib", "paint.exe");
            mList2.Add("rtf", "wordpad.exe");

            // The Add method throws an exception if the new key is 
            // already in the list.
            try
            {
                mList2.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}.", mList2["rtf"]);

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

            // If a key does not exist, setting the indexer for that key
            // adds a new key/value pair.
            mList2["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}.", mList2["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 (mList2.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 (!mList2.ContainsKey("ht"))
            {
                mList2.Add("ht", "hypertrm.exe");
                Console.WriteLine("Value added for key = \"ht\": {0}", mList2["ht"]);
            }

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

            // To get the values alone, use the Values property.
            IList<string> ilistValues = mList2.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}", mList2.Values[2]);

            // To get the keys alone, use the Keys property.
            IList<string> ilistKeys = mList2.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}", mList2.Keys[2]);

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

            if (!mList2.ContainsKey("doc"))
            {
                Console.WriteLine("Key \"doc\" is not found.");
            }
            PrintGeneric(mList2);

            Console.WriteLine();
            Console.WriteLine("----------");
            Console.WriteLine("mList3: ");
            mList3.Add("s1", 123);
            mList3.Add("s4", 456);
            mList3.Add("s3", 345);
            mList3.Add("s2", 234);
            mList3.Add("remove", 345);
            if (mList3.ContainsKey("remove"))
                mList3.Remove("remove");
            try
            {
                mList3.Add("s3", 333);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Add ccc: {0}.", ex.Message);
            }

            Console.WriteLine("s3={0}.", mList3["s3"]);

            Console.WriteLine("fori");
            for (int i = 0; i < mList3.Count; i++)
            {
                Console.WriteLine("{0},{1}={2}.", i, mList3.Keys[i], mList3.Values[i]);
            }

            Console.WriteLine();
            Console.WriteLine("foreach");
            i1 = 0;
            foreach (string sKey in mList3.Keys)
            {
                Console.WriteLine("{0},{1}={2}.", i1, sKey, mList3[sKey]);
                i1++;
            }

            Console.WriteLine();
            PrintInheritGeneric(mList3);


            Console.WriteLine();
            Console.WriteLine("----------");
            Console.WriteLine("mList4: ");
            CString2 oS21;
            for (int i = 0; i < 3; i++)
            {
                oS21 = new CString2("A" + i.ToString(), i.ToString());
                mList4.Add(oS21, i);
            }

            CString2 oA21 = new CString2("A2", "1");
            CString2 oA22 = new CString2("A2", "2");
            if (!mList4.ContainsKey(oA21))
                mList4.Add(oA21, 1);
            if (!mList4.ContainsKey(oA22))
                mList4.Add(oA22, 2);

            Console.WriteLine("(\tms1,\tms2):\ti");
            for (int i = 0; i < mList4.Count; i++)
            {
                Console.WriteLine("(\t{0},\t{1}):\t{2}", mList4.Keys[i].ms1, mList4.Keys[i].ms2, mList4.Values[i]);
            }

        }
        public static void PrintKeysAndValues(SortedList list1)
        {
            Console.WriteLine("\t-KEY-\t-VALUE-");
            for (int i = 0; i < list1.Count; i++)
            {
                Console.WriteLine("\t{0}:\t{1}", list1.GetKey(i), list1.GetByIndex(i));
            }
            Console.WriteLine();
        }
        public static void PrintValues(DictionaryEntry[] ea1, char cSeparator)
        {
            Console.WriteLine("by DictionaryEntry[]");
            for (int i = 0; i < ea1.Length; i++)
                Console.Write("{0}{1}", cSeparator, ea1[i].Value);
            Console.WriteLine();
        }

        public static void PrintGeneric(SortedList<string, string> list1)
        {
            Console.WriteLine("PrintGeneric(): inherit from generic:");
            Console.WriteLine("\t-KEY-\t-VALUE-");
            for (int i = 0; i < list1.Count; i++)
            {
                Console.WriteLine("\t{0}:\t{1}", list1.Keys[i], list1.Values[i]);
            }
            Console.WriteLine();
        }

        public void PrintInheritGeneric(CSortedListStringInt list1)
        {
            Console.WriteLine("PrintInheritGeneric():");
            for (int i = 0; i < list1.Count; i++)
                Console.WriteLine("{0}, {1}={2}", i, list1.Keys[i], list1.Values[i]);
            Console.WriteLine();


        }
    }

    public class CSortedListStringInt : SortedList<string, int>
    { }
}


/* 
result:
CSortedList.Run(), 20170423:

mList1: SortedList(Object, Object)
mList1.Add(2.345, "B")
無法比較陣列中的兩個元素。

  Count:    5
  Capacity: 16
  Keys and Values:
	-KEY-	-VALUE-
	2.345:	B
	A:	1.234
	First:	Hello
	Second:	World
	Third:	!


----------
list1: SortedList(Object, Object)
The key   at index 3 is 1.3.
The value at index 3 is fox.
	-KEY-	-VALUE-
	1	The
	1.1	quick
	1.2	brown
	1.3	fox
	1.4	jumped
	1.5	over
	1.6	the
	1.7	lazy
	1.8	dog

----------
list2: SortedList(Object, Object)
The target Array contains the following (before and after copying):
by DictionaryEntry[]
 The quick brown fox jumped over the lazy dog      
by DictionaryEntry[]
 The quick brown fox jumped over three napping cats in the barn   

----------
mList2 Generic SortedList<TKey, TValue>:
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.
PrintGeneric(): inherit from generic:
	-KEY-	-VALUE-
	bmp:	paint.exe
	dib:	paint.exe
	ht:	hypertrm.exe
	rtf:	winword.exe
	txt:	notepad.exe


----------
mList3: 
Add ccc: 已經存在使用相同索引鍵的項目。.
s3=345.
fori
0,s1=123.
1,s2=234.
2,s3=345.
3,s4=456.

foreach
0,s1=123.
1,s2=234.
2,s3=345.
3,s4=456.

PrintInheritGeneric():
0, s1=123
1, s2=234
2, s3=345
3, s4=456


----------
mList4: 
(	ms1,	ms2):	i
(	A0,	0):	0
(	A1,	1):	1
(	A2,	1):	1
(	A2,	2):	2


 */