// Объявление интерфейса который будут реализовывать все объекты,
    // содержащие в себе объекты карты.
    public interface IEveMapObjectsCollection
    {
        int Count { get;}
        TEveMapObject this[int ID] { get;}
        IEnumerator GetEnumerator();
    }


    // собственно объект карты
    // объект можно создать двумя способами в зависимости от ситуации
    // 1 . Собственно сам объект TEveMapObject obj = new TEveMapObject(код объекта в БД)
    // 2 . Объект создаеться автоматически при первом требовании.
    //Например
    //TEveMapObject Universe = new TEveMapObject( 0 ) // вселенная EVE
    //TEveMapObject SomeConstellation = Universe.ContainedObjects[ 1394 ].ContainedObjects[ 20 ]
    //Последней строчкой в объект вселенной подгрузились все регионы,затем для региона  1394 
    //подгрузились все созвездия и переменная SomeConstellation инициализировалась созвездием  20 
    //Далее объект может быть сам собой и содержать в своей коллекции свои внутренние объекты,
    //которые в свою очередь содержут свои внутренние объекты и связи между ними
    //либо (обычный вариант) если в конструктор передаеться Storage то ссылки на объекты содержуться в
    //в этом хранилище и во внутренних коллекциях.
    //Т.е. Storage это коллекция хранящая ссылки на все созданные объекты.
    //На метод загрузки объектов влияет св-во PreloadObjects. Если true то  при первом требовании
    //будет загружены все внутренние объекты коллекции и их связи.
    public class TEveMapObject : IComparable
    {
        // Класс идентифицирующий объект.
        // там его ID, treel,treer и тип из БД,
        // а так же перегруженные операторы отношений и метод сравнения
        public TEveMapObjectID ObjectID;

        public String Name { get { return ObjectID.Name; } }
        public TEveMapObject Parent;
        public TEveMapObjects Storage;
        // Коллекция внутренних объектов
        private TEveMapObjects _ContainedObjects;
        // Коллекция связанных объектов
        private TEveMapObjects _ConnectedObjects;

        #region Конструкторы, деструкторы

        public TEveMapObject(int ID) : this(ID, null, null) { }
        private TEveMapObject(TEveMapObjectID EveMapObjectID, TEveMapObject Parent, TEveMapObjects Storage)
            : base()
        {
            ObjectID = EveMapObjectID;
            if (Storage != null) { this.Storage = Storage; Storage.AddObject(this); }
            if (Parent != null) { this.Parent = Parent; }
        }
        public TEveMapObject(int ID, TEveMapObject Parent, TEveMapObjects Storage)
            : base()
        {
            ObjectID = new TEveMapObjectID(ID);
            SqlCommand cmd = GlobalRoot.Connection.CreateCommand();
            cmd.CommandText = String.Format("Select ObjectID,ObjectName,ObjectType,ObjectParent,treel,treer from MapObjects where ObjectID = {0}", ID);
            long StartTicks = DateTime.Now.Ticks;
            SqlDataReader mapobject = cmd.ExecuteReader();
            mapobject.Read();
            ObjectID.ID = mapobject.GetInt32( 0 );
            ObjectID.Type = (TEveMapObjectType)mapobject.GetInt32( 2 );
            ObjectID.Name = mapobject.GetString( 1 );
            ObjectID.ParentID = mapobject.IsDBNull( 3 ) ? null : (int?)mapobject.GetSqlInt32( 3 );
            ObjectID.Frontier.treel = (int)mapobject.GetSqlInt32( 4 );
            ObjectID.Frontier.treer = (int)mapobject.GetSqlInt32( 5 );
            // Если границы смежные, значит внутренних объектов нет!.
            mapobject.Close();
            if (Storage != null) Storage.Stat.LoadObject.NewStat(DateTime.Now.Ticks - StartTicks);
            if (Storage != null) { this.Storage = Storage; Storage.AddObject(this); }
            if (Parent != null) { this.Parent = Parent; }
        }
        ~TEveMapObject()
        {
            if (_ContainedObjects != null) { _ContainedObjects.ClearObjects(); }
            if (_ConnectedObjects != null) { _ConnectedObjects.ClearObjects(); }
        }

        #endregion
        #region Перегрузка функциональных методов и операторов
        public override String ToString()
        {
            String Result;
            Result = String.Format("{0} {1}[{2}]", GetSqlTablePrefix(TEvePrefixType.eptColumn), Name, ObjectID.ID);
            return Result;
        }
        // Перегрузка операторов равенства с защитой от нулевых ссылок.
        // Физическое сравнение происходит в методе ==
        public static bool operator ==(TEveMapObject obj1, TEveMapObject obj2)
        {
            if (object.ReferenceEquals(obj1, obj2)) return true;
            if (object.ReferenceEquals(obj1, null) || object.ReferenceEquals(obj2, null)) return false;
            return ((obj1.ObjectID.ID == obj2.ObjectID.ID) & (obj1.ObjectID.Type == obj2.ObjectID.Type));
        }
        public static bool operator !=(TEveMapObject obj1, TEveMapObject obj2)
        {
            return !(obj1 == obj2);
        }
        public override bool Equals(object obj)
        {
            return (this == (TEveMapObject)obj);
        }
        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
        public int CompareTo(object EveMapObject)
        {
            TEveMapObject temp = (TEveMapObject)EveMapObject;
            if (this.Equals(temp)) return  0 ;
            else if (this.ObjectID.ID > temp.ObjectID.ID) return  1 ;
            else return - 1 ;
        }
        #endregion
        private String GetSqlTablePrefix(TEvePrefixType PrefixType)
        {
            string Result = "";
            switch (this.ObjectID.Type)
            {
                case TEveMapObjectType.moUniverse: Result = ""; break;
                case TEveMapObjectType.moRegion: Result = "Region"; break;
                case TEveMapObjectType.moConstellation: Result = "Constellation"; break;
                case TEveMapObjectType.moSolarSystem: Result = "SolarSystem"; break;
                case TEveMapObjectType.moStation: Result = "Station"; break;
            }
            if (PrefixType == TEvePrefixType.eptTable) { Result += "s"; }
            return Result;

        }
        public TEveMapObject GetParentMapObject()
        {
            if (Storage == null) return Parent;
            else if (ObjectID.ParentID.HasValue) return Storage[(int)ObjectID.ParentID];
            else return null;

        }
        public TEveMapObject GetParentOfType(TEveMapObjectType ParentType)
        {
            TEveMapObject Result = this;
            while ((Result != null) && (Result.ObjectID.Type != ParentType))
            {
                Result = Result.GetParentMapObject();
            }
            return Result;

        }
        public String GetFullPath()
        {
            TEveMapObject ParentObj = this;
            String Result = "";

            while (ParentObj != null)
            {
                Result += ((Result != "") ? "\\" : "") + ParentObj.Name;
                ParentObj = ParentObj.GetParentMapObject();
            }
            return Result;

        }

        # region Закрытые методы добавления в коллекции
        // для PreloadObjects = true
        private void AddContainedObject(TEveMapObject EveMapObject)
        {
            if (EveMapObject.ObjectID.ParentID != ObjectID.ID) { throw new EveTraderException(); }
            else
            {
                if (_ContainedObjects == null) _ContainedObjects = new TEveMapObjects();
                _ContainedObjects.AddObject(EveMapObject);
            }
        }
        private void AddConnectedObject(TEveMapObject EveMapObject)
        {
            if (EveMapObject.ObjectID.Type != ObjectID.Type) { throw new EveTraderException(); }
            else
            {
                if (_ConnectedObjects == null) _ConnectedObjects = new TEveMapObjects();
                if (EveMapObject.ObjectID.ID != ObjectID.ID) _ConnectedObjects.AddObject(EveMapObject);
            }
        }
        #endregion
        // Свойство "внутренние объекты"
        public TEveMapObjects ContainedObjects
        {
            get
            {
                if (_ContainedObjects == null)
                {
                    _ContainedObjects = new TEveMapObjects();
                    // Если границы смежные, значит внутренних объектов нет.
                    if (ObjectID.treer == ObjectID.treel +  1 ) return this._ContainedObjects;

                    // Получаем из БД список содержимого

                    // В таких местах остро ощущаеться нехватка оператора Text...EndText
                    // но может я просто не нашел его?
                    String cSqlQuery;
                    if ((Storage != null) && Storage.PreloadObjects)
                        cSqlQuery = String.Format("Select ObjectID,ObjectName,ObjectType,ObjectParent,treel,treer from MapObjects where (treel>{0}) and (treer<{1}) order by treel", this.ObjectID.treel, this.ObjectID.treer);
                    else cSqlQuery = String.Format("Select ObjectID from MapObjects where ObjectParent={0}", this.ObjectID.ID);

                    long StartTicks = DateTime.Now.Ticks;
                    SqlDataReader MapObjects = GlobalRoot.GetReader(cSqlQuery);
                    // для каждого ID
                    while (MapObjects.Read())
                    {
                        int EveObjectID = MapObjects.GetInt32( 0 );
                        TEveMapObject EveMapObject;
                        // Ищем объект в хранилище
                        if (Storage != null)
                        {
                            EveMapObject = Storage[EveObjectID];
                            // Если не найден или хранилище не задано, создаем объект в своем хранилище
                            if (Storage.PreloadObjects)
                            {
                                if (EveMapObject == null)
                                {
                                    TEveMapObjectID oID = new TEveMapObjectID(EveObjectID);
                                    oID.Name = MapObjects.GetString( 1 );
                                    oID.Type = (TEveMapObjectType)MapObjects.GetInt32( 2 );
                                    oID.ParentID = MapObjects.IsDBNull( 3 ) ? null : (int?)MapObjects.GetSqlInt32( 3 );
                                    oID.Frontier.treel = (int)MapObjects.GetSqlInt32( 4 );
                                    oID.Frontier.treer = (int)MapObjects.GetSqlInt32( 5 );
                                    EveMapObject = new TEveMapObject(oID, this, Storage);
                                }
                                if (EveMapObject.ObjectID.ParentID == this.ObjectID.ID) { _ContainedObjects.AddObject(EveMapObject); }
                                else
                                {
                                    Storage[(int)EveMapObject.ObjectID.ParentID].AddContainedObject(EveMapObject);
                                }
                            }
                            else
                            {
                                if (EveMapObject == null) EveMapObject = new TEveMapObject(EveObjectID, this, Storage);
                                _ContainedObjects.AddObject(EveMapObject);
                            }
                        }
                        else
                        {
                            new TEveMapObject(EveObjectID, this, _ContainedObjects);
                        }
                    }
                    MapObjects.Close();
                    if (Storage != null) Storage.Stat.LoadContained.NewStat(DateTime.Now.Ticks - StartTicks);
                }
                return this._ContainedObjects;
            }
        }
        // Связанные объекты
        public TEveMapObjects ConnectedObjects
        {
            get
            {
                if (_ConnectedObjects == null)
                {
                    _ConnectedObjects = new TEveMapObjects();
                    /*
                        Составляем запрос на соединенные воротами объекты:
                        Если Storage НЕ используеться
                            Если указан родитель:
                                Запрашиваем соединения себя с объектами из Parent.ContainedObjects
                            Если родитель не указан
                                Сведений о соединенных объектах нет
                        Если Storage Используеться
                            Если режим PreloadObjects Включен
                                Запрашиваем все соединения себя и своих внутренних объектов
                            Если режим PreloadObjects Отключен
                                Запрашиваем все свои соединения, надеясь что целевые объекты уже загружены в Storage

                    */
                                        if (this.Parent != null | Storage != null)
                                         {
                                                 String cSqlQuery;
                                                 if (((Storage != null) && (Storage.PreloadObjects)) | (this.ObjectID.Type == TEveMapObjectType.moRegion) | (this.ObjectID.Type == TEveMapObjectType.moConstellation))
                                                 {
                                                         cSqlQuery = "WITH ObjectsJumps AS (SELECT Source.solarsystemID AS fromSolarSystemID,\n";
                            cSqlQuery += "                             Source.constellationID AS fromConstellationID,\n";
                            cSqlQuery += "                             Source.regionID AS fromRegionID,\n";
                            cSqlQuery += "                             Target.solarsystemID AS toSolarSystemID,\n";
                            cSqlQuery += "                             Target.constellationID AS toConstellationID,\n";
                            cSqlQuery += "                             Target.regionID AS toRegionID\n";
                            cSqlQuery += "                      FROM dbo.AllGates AS jumps\n";
                            cSqlQuery += "                      INNER JOIN dbo.solarsystems AS Source ON jumps.fromSolarSystemID = Source.solarsystemID\n";
                            cSqlQuery += "                      INNER JOIN dbo.solarsystems AS Target ON jumps.toSolarSystemID = Target.solarsystemID\n";
                            if ((Storage != null) && (Storage.PreloadObjects))
                                cSqlQuery += String.Format("WHERE (Source.treel>={0} and Source.treer<={1})\n", ObjectID.treel, ObjectID.treer);
                            else if (ObjectID.Type != TEveMapObjectType.moUniverse) cSqlQuery += String.Format("WHERE Source.{0}ID = {1}\n", GetSqlTablePrefix(TEvePrefixType.eptColumn), ObjectID.ID);
                            cSqlQuery += ")";

                            if ((Storage != null) && (Storage.PreloadObjects))
                            {
                                cSqlQuery += "SELECT toSolarSystemID AS JumpTo, fromSolarSystemID AS JumpFrom\n";
                                cSqlQuery += "FROM ObjectsJumps\n";
                                cSqlQuery += "UNION\n";
                                cSqlQuery += "SELECT DISTINCT toConstellationID, fromConstellationID\n";
                                cSqlQuery += "FROM ObjectsJumps\n";
                                cSqlQuery += "UNION\n";
                                cSqlQuery += "SELECT DISTINCT toRegionID, fromRegionID\n";
                                cSqlQuery += "FROM ObjectsJumps\n";
                            }
                            else cSqlQuery += String.Format("SELECT distinct to{0}ID as JumpTo, from{0}ID as JumpFrom from ObjectsJumps where to{0}ID<>from{0}ID", GetSqlTablePrefix(TEvePrefixType.eptColumn));
                        }
                        else cSqlQuery = String.Format("Select toSolarSystemID as JumpTo from AllGates jumps where (fromSolarSystemID = {0} and toSolarSystemID <> {0})", this.ObjectID.ID);

                        long StartTicks = DateTime.Now.Ticks;
                        SqlDataReader MapObjects = GlobalRoot.GetReader(cSqlQuery);
                        while (MapObjects.Read())
                        {
                            TEveMapObject TargetObject, SourceObject;
                            if ((Storage != null) && (Storage.PreloadObjects)) TargetObject = Storage[MapObjects.GetInt32( 0 )];
                            else if (Storage != null) TargetObject = Storage[MapObjects.GetInt32( 0 )];
                            else TargetObject = Parent.ContainedObjects[MapObjects.GetInt32( 0 )];

                            if (((Storage != null) && (Storage.PreloadObjects)) && (MapObjects.GetInt32( 1 ) == ObjectID.ID)) SourceObject = this;
                            else if ((Storage != null) && (Storage.PreloadObjects)) SourceObject = Storage[MapObjects.GetInt32( 1 )];
                            else SourceObject = this;

                            if (SourceObject != null && TargetObject != null)
                                SourceObject.AddConnectedObject(TargetObject);

                        }
                        MapObjects.Close();
                        if (Storage != null) Storage.Stat.LoadConnected.NewStat(DateTime.Now.Ticks - StartTicks);

                    }

                }
                return this._ConnectedObjects;
            }
        }

    }
    //Коллекция объектов вселенной EVE
    public class TEveMapObjects : IEnumerable, IEnumerator, IEveMapObjectsCollection
    {
        public bool PreloadObjects;
        private Hashtable Objects = new Hashtable();
        private IDictionaryEnumerator DictionaryEnumerator;
        private TEveTraderStatistic _Stat = new TEveTraderStatistic();
        public TEveTraderStatistic Stat { get { return _Stat; } }
        public int Count { get { return Objects.Count; } }
        public void AddObject(TEveMapObject Object) { Objects.Add(Object.ObjectID.ID, Object); }
        public void RemoveObject(TEveMapObject Object) { Objects.Remove(Object.ObjectID.ID); }
        public void ClearObjects() { Objects.Clear(); }
        public bool Contains(TEveMapObject Object) { return Objects.Contains(Object.ObjectID.ID); }
        public bool Contains(TEveMapObjectID ObjectID) { return Objects.Contains(ObjectID.ID); }
        public bool Contains(int ID) { return Objects.Contains(ID); }
        public TEveMapObject this[int ID]
        {
            get
            {
                TEveMapObject Result = null;
                long StartTicks = DateTime.Now.Ticks;
                Result = (TEveMapObject)Objects[ID];
                _Stat.FindObject.NewStat(DateTime.Now.Ticks - StartTicks);
                return Result;
            }
            set { Objects[ID] = value; }
        }
        public TEveMapObject GetContainer() { return null; }

        public void Reset() { DictionaryEnumerator.Reset(); }
        public object Current { get { return DictionaryEnumerator.Value; } }
        public bool MoveNext() { return DictionaryEnumerator.MoveNext(); }

        public IEnumerator GetEnumerator()
        {
            DictionaryEnumerator = Objects.GetEnumerator();
            return (IEnumerator)this;
        }

        public TEveMapObjects() : base() { }
        public TEveMapObjects(bool PreloadObjects) : this() { this.PreloadObjects = PreloadObjects; }
        ~TEveMapObjects() { Objects.Clear(); }
    }

    // Вселенная с хранилищем объектов карты внутри
    public class TEveUniverse : TEveMapObject
    {
        //private TEveMapObjects _Storage;
        //public TEveMapObjects Storage { get { return _Storage; } }
        public TEveUniverse()
            : base( 0 )
        {
            this.Storage = new TEveMapObjects(true);
            if (this.ContainedObjects.Count + this.ConnectedObjects.Count ==  0 ) throw new EveTraderException();

        }
        ~TEveUniverse()
        {

        }
    }

    #region Маршруты

    //Вычисление кратчайшего пути.
    //Собственно Маршрут - класс TEveRoot
    //Свойство TEveRoot.Async собственно определяет как будет считаться маршрут
    //в отдельном потоке или в вызывающем. Когда только начинал реализовывать
    //маршруты считались долго. Сейчас необходимость в потоковом вычислении маршрута отпала
    //посколько маршрут через всю карту считаеться за  200 - 400  милисекунд (Athlon  850 ).
    //И это еще не предел.
    //кроме того основной алгоритм расчета прибыльности сделок будет работать
    //в отдельном потоке, в нем же будут считаться и маршруты.
    //Внутри TEveRoot содержит массив с результатом расчета. Т.е. путь.
    //сохраняються так же и ветвления пути. Т.е. если от точки до точки
    //самый короткий маршрут составляет  14  джампов и таких маршрутов три,
    //в результате выполнения можно увидеть все три оптимальных маршрута.
    //Весь код я сдесь покоцал оставил только то что относиться к потоку.

    public delegate void OnRootProgressHandler(TEveRoot Root, int Percent);
    public delegate void OnRootDoneHandler(TEveRoot Root);
    internal delegate void ForkDelegate(RootRecord node);

    public enum TEveRootState { ertProcessed =  0 , ertUnreachable = - 1 , ertNotProcessed = - 2  };
    public class TEveRoot : IEveMapObjectsCollection, IEnumerator, IEnumerable
    {
        private int _index = - 1 ;
        private int _Count =  0 ;
        private RootNodesList _S;
        private RootNodesList _V;
        private TEveRootFilter _Filter;
        private TEveMapObject _FromMapObject;
        private TEveMapObject _ToMapObject;
        private TEveMapObjects _Storage;
        private Thread RootThread;
        private ReaderWriterLock rwlock;
        private AutoResetEvent _startevent;
        public TEveRootState State = TEveRootState.ertNotProcessed;

        private int _ForkCount;
        private int _ForkTurn;
        private int _Variant =  0 ;
        private void _SetForkCount(RootRecord node) {...}
        private Boolean _SelectFork(RootRecord node)
        public int ForkCount { get { return _ForkCount; } }{...}
        public int Variant{ get {...}}
        public int Count { get { return _Count; } }

        public TEveMapObject this[int index]{...}

        public object Current { get { return this[_index]; } }
        public void Reset() { _index = - 1 ; }
        public bool MoveNext() { if (_index < Count) { _index++; return true; } else return false; }
        public IEnumerator GetEnumerator() { _index = - 1 ; return (IEnumerator)this; }

        private void Done()
        {
            ...
            if (Async && (OnRootDone != null)) OnRootDone(this);
        }
        public bool Async = false;
        //Типа операторные скобки на работу с маршрутом
        //Между ними код. Во время его выполнения никакой поток не сможет
        //Ничего изменить касающегося пути и исходных данных, хотя сможет спокойно
        //считывать эти данные. Накладываеться блокировка чтения (Shared в терминологии SQL)
        public void BeginWork() { rwlock.AcquireReaderLock(Timeout.Infinite); }
        public void EndWork() { rwlock.ReleaseReaderLock(); }

        public event OnRootProgressHandler OnRootProgress;
        public event OnRootDoneHandler OnRootDone;

        //Исходная точка маршрута. Читаеться свободно.
        //Перед установкой пытаемся установить блокировку на запись (Exclusive)
        //Если в это время уже наложена любая блокировка то приложение ждет ее снятия.
        public TEveMapObject FromMapObject
        {
            get { return _FromMapObject; }
            set
            {
                try
                {
                    rwlock.AcquireWriterLock(Timeout.Infinite);
                    _FromMapObject = value;
                }
                finally { rwlock.ReleaseWriterLock(); }
            }
        }
        //Конечная точка маршрута.
        public TEveMapObject ToMapObject
        {
            get { return _ToMapObject; }
            set
            {
                try
                {
                    rwlock.AcquireWriterLock(Timeout.Infinite);
                    _ToMapObject = value;
                }
                finally { rwlock.ReleaseWriterLock(); }
            }
        }
        public TEveRootFilter Filter{...}
        public TEveRoot(TEveMapObjects Storage): base()
        {
            if (Storage == null) throw new EveTraderRootException();
            _Storage = Storage;
            _S = new RootNodesList();
            _V = new RootNodesList();
            rwlock = new ReaderWriterLock();
            _Filter = new TEveRootFilter();
            _startevent = new AutoResetEvent(false);
        }
        ~TEveRoot()
        {
            _startevent.Close();
        }
        // Заглушка на метод расчета
        public void CalcRoot()
        {
            if ((_FromMapObject == null) || (_ToMapObject == null)) throw new EveTraderRootException();
            if (_FromMapObject.ObjectID.ID == _ToMapObject.ObjectID.ID) throw new EveTraderRootException();
            if (_FromMapObject.ObjectID.Type != _ToMapObject.ObjectID.Type) throw new EveTraderRootException();

            if (Async)
            {
                // Создали поток :)
                RootThread = new Thread(_CalcRoot);
                // Стартовали
                RootThread.Start();
                // По логике необходимо что бы поток с расчетом маршрута
                //физически запустился до выхода из этого метода.
                //Поэтому вешаем Event
                _startevent.WaitOne();
            }
            else _CalcRoot();
        }
        public void _CalcRoot()
        {
            try
            {
                if (Async)
                {
                    // Накладываем блокировку и сигналим о том что поток запустился.
                    rwlock.AcquireWriterLock(Timeout.Infinite);
                    _startevent.Set();
                }

                long StartTicks = DateTime.Now.Ticks;
                    {...код расчета оптимального маршрута(ов)}

                    if ((Async) && (OnRootProgress != null))
                    {
                        int Progress;
                        Progress = (_S.Count *  100 ) / (_S.Count + _V.Count);
                        OnRootProgress(this, Progress);
                    }

                }
                if ((Async)&&(OnRootProgress != null)) OnRootProgress(this,  100 );
                Done();
                _Storage.Stat.ProcessRoot.NewStat(DateTime.Now.Ticks - StartTicks);

            }
            finally { if (Async) rwlock.ReleaseWriterLock(); }
        }
        public override string ToString()
        {
            String Result = "";
            if (State == TEveRootState.ertNotProcessed) Result = "Not processed";
            else if (State == TEveRootState.ertUnreachable) Result = "Unreachable";
            else for (int i =  0 ; i <= Count; i++) Result += String.Format("{0}: {1}\n", i, this[i].ToString());
            return Result;
        }

    }

    #endregion
}

Применение:

TEveUniverse Universe = new TEveUniverse();

TEveRoot LongRoot = new TEveRoot(Universe.Storage);
Roots.Add(LongRoot);
LongRoot.Async=true;
LongRoot.OnRootProgress += new OnRootProgressHandler(this.RootProgressHandler);
LongRoot.OnRootDone += new OnRootDoneHandler(this.RootDoneHandler);
LongRoot.FromMapObject = Universe.Storage[ 30004969 ];
LongRoot.ToMapObject = Universe.Storage[ 30004386 ];
LongRoot.CalcRoot();

Можно даже вот так:

TEveRoot Root = new TEveRoot(Universe.Storage);
Roots.Add(Root);
Root.Async=true;
Root.FromMapObject = Universe.Storage[ 10000023 ];
Root.ToMapObject = Universe.Storage[ 10000086 ];
Root.CalcRoot();

Строчки ниже будут прекрасно работать так как при попытке
установки новых свойств маршрута приложение остановиться и будет ждать
завершения первого потока расчета.

Root.FromMapObject = Universe.Storage[ 30004969 ];
Root.ToMapObject = Universe.Storage[ 30004386 ];
Root.Filter.RestrictToObjects = Root;
Root.CalcRoot();