Eine einfache ObjectRegistry

Beschreibung:

Eine einfache ObjectRegistry, die es erlaubt, Objekte aller Art mit einem Namen
in einem Namespace zu registrieren, und von dort über den Namen wieder raus zu holen, um diese objekte zu benutzen.

Siehe auch
Eine einfache ObjectFactory
Ein einfaches PropertySystem

using System;

namespace Nevada.Core
{
    public class ObjectRegistry
    {
        /// <summary>
        /// returns the singleton instance of the objectregistry
        /// </summary>
        public static ObjectRegistry Instance = new ObjectRegistry();

        private System.Collections.Generic.Dictionary<string, object> _objects;
        private char _delimetierChar = '.';

        /// <summary>
        /// creates a new instance of the objectregisty-class
        /// </summary>
        private ObjectRegistry()
        {
            this._objects = new System.Collections.Generic.Dictionary<string, object>();
        }

        /// <summary>
        /// Adds a new scope to the object registry
        /// </summary>
        /// <param name="scopeName">name of the new scope</param>
        public void Add(string scopeName)
        {
            System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(scopeName), "Invalid scope name !");
            int delimetierIndex = scopeName.IndexOf(this._delimetierChar);
            if (delimetierIndex == -1)
            {
                if (!this._objects.ContainsKey(scopeName))
                {
                    this._objects.Add(scopeName, new ObjectRegistry());
                }
            }
            else
            {
                string firstString = scopeName.Substring(0, delimetierIndex);
                string secondString = scopeName.Substring(delimetierIndex + this._delimetierChar.ToString().Length);
                System.Diagnostics.Debug.Assert(this._objects[firstString] is ObjectRegistry, "object '" + firstString + "' is not a objectregistry !");
                ((ObjectRegistry)this._objects[firstString]).Add(secondString);
            }
        }

        /// <summary>
        /// Adds a object to the objectregistry
        /// </summary>
        /// <param name="objectName">name of the object</param>
        /// <param name="obj">object</param>
        public void Add(string objectName, object obj)
        {
            System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(objectName), "Invalid object name !");
            System.Diagnostics.Debug.Assert(obj != null, "Invalid object !");
            int delimetierIndex = objectName.IndexOf(this._delimetierChar);
            if (delimetierIndex == -1)
            {
                System.Diagnostics.Debug.Assert(!this._objects.ContainsKey(objectName), "Object '" + objectName + "' already registered !");
                this._objects.Add(objectName, obj);
            }
            else
            {
                string firstString = objectName.Substring(0, delimetierIndex);
                string secondString = objectName.Substring(delimetierIndex + this._delimetierChar.ToString().Length);
                if (!this._objects.ContainsKey(firstString))
                {
                    this._objects.Add(firstString, new ObjectRegistry());
                }
                System.Diagnostics.Debug.Assert(this._objects[firstString] is ObjectRegistry, "object '" + firstString + "' is not a objectregistry !");
                ((ObjectRegistry)this._objects[firstString]).Add(secondString, obj);
            }
        }

        /// <summary>
        /// returns true, if the object for given name is registered
        /// </summary>
        /// <param name="objectName">name of the object</param>
        /// <returns>true, if the object for given name is registered</returns>
        public bool Contains(string objectName)
        {
            bool result = false;
            System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(objectName), "Invalid object name !");
            int delimetierIndex = objectName.IndexOf(this._delimetierChar);
            if (delimetierIndex == -1)
            {
                result = this._objects.ContainsKey(objectName);
            }
            else
            {
                string firstString = objectName.Substring(0, delimetierIndex);
                string secondString = objectName.Substring(delimetierIndex + this._delimetierChar.ToString().Length);
                if (this._objects.ContainsKey(firstString))
                {
                    result = ((ObjectRegistry)this._objects[firstString]).Contains(secondString);
                }
            }
            return result;
        }

        /// <summary>
        /// returns a casted object from the objectregistry
        /// </summary>
        /// <typeparam name="T">type of the object</typeparam>
        /// <param name="objectName">name of the object</param>
        /// <returns>casted object</returns>
        public T Get<T>(string objectName)
        {
            T result = default(T);
            System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(objectName), "Invalid object name !");
            int delimetierIndex = objectName.IndexOf(this._delimetierChar);
            if (delimetierIndex == -1)
            {
                System.Diagnostics.Debug.Assert(this._objects.ContainsKey(objectName), "No object for '" + objectName + "' registered !");
                result = (T)this._objects[objectName];
            }
            else
            {
                string firstString = objectName.Substring(0, delimetierIndex);
                string secondString = objectName.Substring(delimetierIndex + this._delimetierChar.ToString().Length);
                System.Diagnostics.Debug.Assert(this._objects.ContainsKey(firstString), "Objectregistry does not contain '" + firstString + "'");
                result = ((ObjectRegistry)this._objects[firstString]).Get<T>(secondString);
            }
            return result;
        }

        /// <summary>
        /// removes an object from the objectregistry
        /// </summary>
        /// <param name="objectName">name of the object to remove</param>
        public void Remove(string objectName)
        {
            System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(objectName), "Invalid object name !");
            int delimetierIndex = objectName.IndexOf(this._delimetierChar);
            if (delimetierIndex == -1)
            {
                if (this._objects.ContainsKey(objectName))
                {
                    this._objects.Remove(objectName);
                }
            }
            else
            {
                string firstString = objectName.Substring(0, delimetierIndex);
                string secondString = objectName.Substring(delimetierIndex + this._delimetierChar.ToString().Length);
                if (this._objects.ContainsKey(firstString))
                {
                    ((ObjectRegistry)this._objects[firstString]).Remove(secondString);
                }
            }
        }
    }
}

Beispiel:

// Hier wird der wert 12 (integer) im namespace "System.Werte" mit
// demNamen Int1 registriert.
Nevada.Core.ObjectRegistry.Instance.Add("System.Werte.Int1",12);
// Gibt true zurück, wenn das Objekt mit dem Namen "Int1" im
// namespace System.Werte vorhanden ist
if(Nevada.Core.ObjectRegistry.Instance.Contains("System.Werte.Int1"))
{
   // Gibt das Objekt aus der ObjectRegistry richtig gecastet zurück
    int wert = Nevada.Core.ObjectRegistry.Instance.Get<int>("System.Werte.Int1");
}

Schlagwörter: ObjectRegistry, Objekte verwalten, Globale Objekte

interessant... nur eine frage... könntest du ein Beispielt geben wofür man sowas benutzen kann ??
danke im voraus

Statt irgendwelchen globalen Objekten kannst du diese einfach in der Registry registrieren, und von überall in deinem Code über die Objekt-Registry benutzen.
Weiters kommt noch hinzu, dass man Objekte in XML-Dateien eintragen und richtig parametrisieren kann, und diese Objekte über (die noch fehlende ObjectFactory) AUTOMATISCH erzeugt und in der ObjectRegistry registriert werden, ohne eine Zeile Code zu schreiben (Ausser XML), aber dazu habe ich grade "Ein einfaches Property System" gepostet, dass die grundlage für die ObjectFactory und die XML-Importer sind.

also erweiterter Object-Pool?!^^
Nette sache