RankedDictionaryTKey, TValue Class

[SerializableAttribute]
public class RankedDictionary<TKey, TValue> : Btree<TKey>, 
	IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, 
	IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IDictionary, 
	ICollection, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, 
	ISerializable, IDeserializationCallback

using System;
using System.Collections.Generic;
using Kaos.Collections;

namespace ExampleApp
{
    class RdExample01
    {
        static void Main()
        {
            // Instantiate with four ISO 3166-1 country codes:
            var cc = new RankedDictionary<string,string>
            {
              { "TO", "Tonga" },
              { "DD", "German Democratic Republic" },
              { "CH", "Switzerland" },
              { "RU", "Burundi" }
            };

            // The Add method throws an exception if the new key is
            // already in the dictionary.
            try
            {
                cc.Add ("DD", "East Germany");
            }
            catch (ArgumentException)
            {
                Console.WriteLine ("An element with Key = 'DD' already exists.");
            }

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

            // The indexer can be used to change the value associated with a key.
            cc["RU"] = "Russian Federation";

            // The indexer can be used to get a value for a key.
            Console.WriteLine ($"For key = 'RU', value = {cc["RU"]}.");

            // If a key does not exist, setting the indexer for that key
            // adds a new key/value pair.
            cc["SS"] = "South Sudan";

            // The indexer throws an exception if the supplied key is
            // not in the dictionary.
            try
            {
                Console.WriteLine ($"For key = 'ZZ', value = {cc["ZZ"]}.");
            }
            catch (KeyNotFoundException)
            {
                Console.WriteLine ("Key = 'ZZ' is not found.");
            }

            // When a program often has to try keys that are usually not in the
            // dictionary, TryGetValue can be a more efficient way to get values.
            if (cc.TryGetValue ("ZZ", out string value))
                Console.WriteLine ($"For key = 'ZZ', value = {value}.");
            else
                Console.WriteLine ("Key = 'ZZ' is not found.");

            // ContainsKey can be used to test keys before inserting them.
            if (! cc.ContainsKey ("GG"))
            {
                cc.Add ("GG", "Guernsey");
                Console.WriteLine ($"Value added for key = 'GG': {cc["GG"]}");
            }

            // When you use foreach to enumerate dictionary elements,
            // the elements are retrieved as KeyValuePair instances.
            Console.WriteLine();
            foreach (KeyValuePair<string,string> pair in cc)
                Console.WriteLine ($"Key = {pair.Key}, Value = {pair.Value}");

            // To get the values alone, use the Values property.
            RankedDictionary<string,string>.ValueCollection vals = cc.Values;

            // The elements of the ValueCollection are strongly typed
            // with the type that was specified for dictionary values.
            Console.WriteLine();
            foreach(string val in vals)
                Console.WriteLine ($"Value = {val}");

            // To get the keys alone, use the Keys property.
            RankedDictionary<string,string>.KeyCollection keys = cc.Keys;

            // The elements of the KeyCollection are strongly typed
            // with the type that was specified for dictionary keys.
            Console.WriteLine();
            foreach (string key in keys)
                Console.WriteLine ($"Key = {key}");

            // Use the Remove method to remove a key/value pair.
            Console.WriteLine ("\nRemoving 'DD'.");
            cc.Remove ("DD");

            Console.WriteLine ("\nChecking if 'DD' exists:");
            if (! cc.ContainsKey ("DD"))
                Console.WriteLine ("  Key 'DD' not found.");
        }

        /* Output:

        An element with Key = 'DD' already exists.
        For key = 'CH', value = Switzerland.
        For key = 'RU', value = Russian Federation.
        Key = 'ZZ' is not found.
        Key = 'ZZ' is not found.
        Value added for key = 'GG': Guernsey

        Key = CH, Value = Switzerland
        Key = DD, Value = German Democratic Republic
        Key = GG, Value = Guernsey
        Key = RU, Value = Russian Federation
        Key = SS, Value = South Sudan
        Key = TO, Value = Tonga

        Value = Switzerland
        Value = German Democratic Republic
        Value = Guernsey
        Value = Russian Federation
        Value = South Sudan
        Value = Tonga

        Key = CH
        Key = DD
        Key = GG
        Key = RU
        Key = SS
        Key = TO

        Removing 'DD'.

        Checking if 'DD' exists:
          Key 'DD' not found.

        */
    }
}

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using Kaos.Collections;

namespace ExampleApp
{
    [Serializable]
    public class PersonComparer : Comparer<Person>
    {
        public override int Compare (Person x, Person y)
        { return x==null? (y==null? 0 : -1) : (y==null? 1 : String.Compare (x.ToString(), y.ToString())); }
    }

    [Serializable]
    public class Person : ISerializable
    {
        public string First { get; private set; }
        public string Last { get; private set; }

        public Person (string first, string last)
        { this.First = first; this.Last = last; }

        protected Person (SerializationInfo info, StreamingContext context)
        {
            this.First = (string) info.GetValue ("First", typeof (String));
            this.Last = (string) info.GetValue ("Last", typeof (String));
        }

        public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
        {
            info.AddValue ("First", First, typeof (String));
            info.AddValue ("Last", Last, typeof (String));
        }

        public override string ToString() => Last + ", " + First;
    }


    class RdExample05
    {
        static void Main()
        {
            IFormatter formatter = new BinaryFormatter();
            var set1 = new RankedDictionary<Person,string> (new PersonComparer());

            set1.Add (new Person ("Hugh", "Mann"), "B+");
            set1.Add (new Person ("Hammond", "Egger"), "C-");

            SerializePersons ("Persons.bin", set1, formatter);
            Console.WriteLine ($"Wrote {set1.Count} key/value pairs.");
            Console.WriteLine ();

            RankedDictionary<Person,string> set2 = DeserializePersons ("Persons.bin", formatter);
            Console.WriteLine ("Read back:");

            foreach (var kv in set2)
                Console.WriteLine (kv);
        }

        public static void SerializePersons (string fn, RankedDictionary<Person,string> set, IFormatter formatter)
        {
            using (var fs = new FileStream (fn, FileMode.Create))
            { formatter.Serialize (fs, set); }
        }

        static RankedDictionary<Person,string> DeserializePersons (string fn, IFormatter formatter)
        {
            using (var fs = new FileStream (fn, FileMode.Open))
            { return (RankedDictionary<Person,string>) formatter.Deserialize (fs); }
        }

        /* Output:

        Wrote 2 key/value pairs.

        Read back:
        [Egger, Hammond, C-]
        [Mann, Hugh, B+]

        */
    }
}