Dictionary<Y,Z> yz;
if (!d.TryGetValue(x, out yz)) { yz = d[x] = new Dictionary<Y,Z>(); }

Z z;
if (!yz.TryGetValue(y, out z)) { z = yz[y] = new Z(); }

z.CallMethod();

d.GetOrAdd(x, _ => new Dictionary<Y,Z>()).GetOrAdd(y, _ => new Z()).CallMethod();

    public class MyDictionary<X, Y> : Dictionary<X, Y>
        where Y : new()
    {
        public new Y this[X index]
        {
            get
            {
                if (!base.ContainsKey(index))
                    base.Add(index, new Y());
                return base[index];
            }
        }
    }

    public class NestedDictionary<X, Y, Z> : MyDictionary<X, MyDictionary<Y, Z>>
        where Z : new()
    { }

    //использование
    nestedDictionary[x][y].CallMethod();

{
    unordered_map<int, unordered_map<int, int>> map;
    ++map[10][5];
    map[4][6] = 4;;
}

class Session : KeyValueCollection<int, Desktop> { ... }
class Desktop : KeyValueCollection<int, Process> { ... }
class Process : KeyValueCollection<int, Thread> { ... }
class Thread : KeyValueCollection<int, Data> { ... }
class Data { ... }

processes[someId].Thread[threadId];

_NN>class Session : KeyValueCollection<int, Desktop> { ... }
_NN>class Desktop : KeyValueCollection<int, Process> { ... }
…

class Session
{
  MyCollection<int, Desktop> Desktops { get; } = MyCollection.Create((Desktop d) => d.DesktopId); // c# 6
}

_NN>И все это вместо простых чисел ?

public TValue GetOrAdd(
    TKey key,
    Func<TKey, TValue> valueFactory
)

_NN>>class Session : KeyValueCollection<int, Desktop> { ... }
_NN>>class Desktop : KeyValueCollection<int, Process> { ... }
X>…
X>

class Session { Dictionary<int, Desktop> Desktops; }
class Desktop { Dictionary<int, Process> Processes;  }
и т.д.

_NN>d.GetOrAdd(x, _ => new Dictionary<Y,Z>()).GetOrAdd(y, _ => new Z()).CallMethod();
_NN>

Func<X, Y>  Конструктор1= _ => new Dictionary<Y,Z>();
Func<Y, Z>  Конструктор2= _ =>new Z();

d.GetOrAdd(x, Конструктор1).GetOrAdd(y,Конструктор2).CallMethod();

d.GetOrAdd(x).GetOrAdd(y).CallMethod();

Func<X, Y>  Конструктор1= _ => new Dictionary<Y,Z>(Конструктор2);

d=new Dictionary<Y,Z>(Конструктор1);

public class MyCoolDictionary<T>
        where T : new()
    {
        private Dictionary<string, T> _internalDictionary = new Dictionary<string, T>();

        public T this[object x, params object[] others]
        {
            get
            {
                var hash = this.GetHash(x, others);

                if (!_internalDictionary.ContainsKey(hash))
                    _internalDictionary.Add(hash, new T());

                return _internalDictionary[hash];
            }
        }

        private string GetHash(object x, params object[] others)
        {
            var str = new StringBuilder();
            str.Append(x.GetHashCode());
            foreach (var obj in others)
                str.Append(obj.GetHashCode());

            return str.ToString();
        }
    }

d[x, y, z /*...*/]

public struct MyStruct<X,Y>
    {
        public X СвойствоX;
        public Y СвойствоY;

        
        public MyStruct(X СвойствоX, Y СвойствоY)
            {
            this.СвойствоX = СвойствоX;
            this.СвойствоY = СвойствоY;
        }
        public override int GetHashCode()
        {
            //Упростим задачу и сделаем по простому
            string str= Convert.ToBase64String(BitConverter.GetBytes(СвойствоX.GetHashCode()))+ Convert.ToBase64String(BitConverter.GetBytes(СвойствоY.GetHashCode()));
            return str.GetHashCode();
        }

//Можно взять из Tuple

//internal static int CombineHashCodes(int h1, int h2)
//{
//    return (h1 << 5) + h1 ^ h2;
//}
        public override bool Equals(object obj)
        {
            if (obj.GetType()!= GetType()) return false;

            var Объект = (MyStruct<X, Y>)obj;
            return СвойствоX.Equals(Объект.СвойствоX) && СвойствоY.Equals(Объект.СвойствоY);
        }
    }

var ключи=d.Keys.Where(key=> key.Item1==x).Select(key=> key).ToList();


foreach (var ключ in ключи) d.Remove(ключ );

Вместо  d[x][y]
d[new Tuple<X,Y>(x,y)]

d.RemoveByFirst(x)

d[x,y]