C#

/// <summary>
/// C# implementation of Visual Basics With statement
/// </summary>
public static void With<T>(this T _object, Action<T> _action)
{
    _action(_object);
}

LongInstanceOfPersonVariableName.With(x => {
     x.AgeIntVar = 21;
     x.NameStrVar = "John";
     x.NameStrVar += " Smith";
     //etc..
});

var value = d["c"];

KeyValuePair<string, double> i_item = d.ElementAt(2); // if d is a Dictionary it is not possible

KeyValuePair<string, double> i_item = d.ElementAt(2);

Quote:

For purposes of enumeration, each item in the dictionary is treated as a KeyValuePair<tkey, tvalue=""> structure representing a value and its key. The order in which the items are returned is undefined.

public class IndexedKVPList<K, V> : List<KeyValuePair<K, V>>
{
    private readonly List<K> keyList = new List<K>();
    private readonly List<V> valueList = new List<V>();

    // modified to use 'new
    new public void Add(KeyValuePair<K, V> newKVP)
    {
        keyList.Add(newKVP.Key);
        valueList.Add(newKVP.Value);
        base.Add(newKVP);
    }

    // new function to Remove KeyValue pair
    new public void Remove(KeyValuePair<K, V> killKVP)
    {
        if(! this.Contains(killKVP)) throw new Exception("error in Remove in IndexedKVPPair");

        keyList.Remove(killKVP.Key);
        valueList.Remove(killKVP.Value);
        base.Remove(killKVP);
    }

    public KeyValuePair<K, V> GetKVPByValue(V theValue)
    {
        return this[valueList.IndexOf(theValue)];
    }

    public K GetKeyByValue(V theValue)
    {
        return this[valueList.IndexOf(theValue)].Key;
    }

    // new function to get the index by KeyValue pair
    public int GetIndexByKVP(KeyValuePair<K, V> theKVPPair)
    {
        return this.IndexOf(theKVPPair);
    }

    // new function to get the index by Value
    // what happens if there are multiple identical values ?
    public int GetIndexByValue(V theValue)
    {
        return (valueList.IndexOf(theValue));
    }

    public KeyValuePair<K, V> GetKVPByKey(K theKey)
    {
        return this[keyList.IndexOf(theKey)];
    }

    public V GetValueByKey(K theKey)
    {
        return this[keyList.IndexOf(theKey)].Value;
    }

    // new function to get the index by Key
    public int GetIndexByKey(K theKey)
    {
        return (keyList.IndexOf(theKey));
    }
}

private void TestIKVP()
{
    var iKVList = new IndexedKVPList<string, double>();

    for (int i = 0; i < 10; i++)
    {
        iKVList.Add(new KeyValuePair<string, double>("Key: " + i, i));
    }

    var kvp1 = iKVList.GetKVPByKey("Key: 8");
    var kvp2 = iKVList.GetKVPByValue(6);

    Console.WriteLine(kvp1 + " " + kvp2);

    // test Remove function
    iKVList.Remove(iKVList[4]);

    foreach (var theKVP in iKVList)
    {
        Console.WriteLine(theKVP.Key + " Value:" + theKVP.Value.GetType());
    }

    Console.WriteLine(iKVList.GetIndexByKVP(kvp2));
    Console.WriteLine(iKVList.GetIndexByKey("Key: 9"));
    Console.WriteLine(iKVList.GetIndexByValue(3));
}

Dictionary<string, double> d = new Dictionary<string, double>();

           d.Add("z", 1);
           d.Add("a", 2);
           d.Add("c", 3);
           d.Add("b", 4);

           foreach (KeyValuePair<string, double> k in d)
           {
               Console.WriteLine(k.Key + " " + k.Value);
           }



           KeyValuePair<string, double> i_item = d.ElementAt(2);

           int myIndex = Array.IndexOf(d.Keys.ToArray<string>(), "a");

private int theIndex;
//
theIndex = dictionaryStringInt.Keys.ToList<string>().IndexOf("KeyString");

The order of the keys in the Dictionary<tkey, tvalue="">.KeyCollection is unspecified