Eine einfache ObjectFactory

Beschreibung:

Factory zum Erstellen von Objekten.
ACHTUNG:
Die OBjectFactory benötigt
Eine einfache ObjectRegistry
Ein einfaches PropertySystem

using System;

namespace Nevada.Core
{
    public class ObjectFactory
    {
        public static readonly ObjectFactory Instance = new ObjectFactory();

        private System.Collections.Generic.Dictionary<string, string> _aliasMap;

        private ObjectFactory()
        {
            this._aliasMap = new System.Collections.Generic.Dictionary<string, string>();
        }

        public void AddAliasName(string typeName, string aliasName)
        {
            System.Diagnostics.Debug.Assert(!this._aliasMap.ContainsKey(aliasName), "'" + aliasName + "' already defined !");
            this._aliasMap.Add(aliasName, typeName);
        }

        private System.Type ResolveType(string typeString)
        {
            int commaIndex = typeString.IndexOf(',');
            string className = typeString.Substring(0, commaIndex).Trim();
            string assemblyName = typeString.Substring(commaIndex + 1).Trim();
            System.Reflection.Assembly assembly = null;
            try
            {
                assembly = System.Reflection.Assembly.Load(assemblyName);
            }
            catch
            {
                throw new System.ArgumentException("Can't create assembly '" + assemblyName + "' !");
            }
            return assembly.GetType(className, false, false);
        }

        public T Create<T>(string typeName, Nevada.Collections.PropertyDictionary dictionary)
        {
            if (this._aliasMap.ContainsKey(typeName))
            {
                typeName = this._aliasMap[typeName];
            }
            System.Type targetType = ResolveType(typeName);
            System.Diagnostics.Debug.Assert(targetType != null, "Can't load type '" + typeName + "' !");
            if (targetType == null)
            {
                System.Console.WriteLine("Can't load type '" + typeName + "' !");
                throw new System.ArgumentException("Can't load type '" + typeName + "' !");
            }

            
            object targetObject = null;
            try
            {
                if (dictionary == null)
                {
                    targetObject = System.Activator.CreateInstance(targetType);
                }
                else
                {
                    targetObject = System.Activator.CreateInstance(targetType, dictionary);
                }
            }
            catch (System.Exception ex)
            {
                System.Console.WriteLine(ex.Message + " Can't load type '" + typeName + "' !");
                throw ex;
            }

            System.Diagnostics.Debug.Assert(targetObject != null, "Can't instantiate type '" + typeName + "' !");
            if (targetObject == null)
            {
                System.Console.WriteLine("Can't instantiate type '" + typeName + "' !");
                throw new System.ArgumentException("Can't instantiate type '" + typeName + "' !");
            }
            return (T)targetObject;
        }

        public T Create<T>(string typeName)
        {
            object result = null;
            if (this._aliasMap.ContainsKey(typeName))
            {
                typeName = this._aliasMap[typeName];
            }
            if (typeName == "System.String")
            {
                result = new System.String('\0', 0);
            }
            else
            {
                Type t = Type.GetType(typeName);
                result = this.Create<T>(typeName);
            }
            return (T)result;
        }

        /// <summary>
        /// Diese Methode muss benutzt werden, wenn aus der callingassembly
        /// objekte erstellt werden sollen !!!!!!!
        /// DIESE METHODE MUSS AUS DER CALLINGASSEMBLY AUFGERUFEN WERDEN !!!!!!!!!!!!
        /// ACHTUNG der Typ MUSS!! voll qualifiziert sein, inkl. aller namespaces !!!
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static string GetAssemblyTypeStringForType(string type)
        {
            return type + ", " + System.Reflection.Assembly.GetCallingAssembly().ToString();
        }
    }
}

Schlagwörter: <ObjectFactory>

Schaut alles wahnsinnig interessant aus. Hoffe ich finde Zeit mir das auch mal genauer anzuschaun!

Lg XXX

Und wieder einer, der das Rad neu erfindet, und auch einen neuen Namen dafür vergibt 😉

Das hier, mit den anderen beiden Projekten zusammen, ist genau das,
was man sonst als "dependency injection container" kennt.

Beispiele dafür sind z.B.:

Unity - > http://www.codeplex.com/unity ( nachfolger des ObjectBuilder von MS )
Spring.NET -> http://www.springframework.net/overview.html
Windsor -> http://www.castleproject.org/
Structuremap -> http://structuremap.sourceforge.net/
LinFu -> http://www.codeproject.com/KB/cs/LinFuPart1.aspx

Um nur ein paar zu nennen.

Warum auch nicht? Das Rad neu zu erfinden ist immerhin eine gute Methode, damit man versteht, wie das Rad denn nun aufgebaut ist oder auch wozu es eigentlich da ist. Das echte Rad ist sicher auch nicht nur einmal erfunden worden...

Und sich durch die Doku von solchen ja recht komplexen Microkernels zu lesen macht auch nicht wirklich mehr Spaß als sich selbst einen zu schreiben...

Das ist richtig, aber auch gleich einen neuen Namen für das Rad?

Natürlich macht es mehr spass soetwas selber zu schreiben, aber wenn
du das produktiv einsetzen willst/ musst, ist spring, castle oder CAB/SCSF die bessere Wahl, weil schon getestet.

Dass die Dinger intern eh alle ungefähr das selbe machen, sieht man an http://www.des-eisbaeren-blog.de/Blog/Permalink/2005/12/12/ServiceLocator.aspx

Ist vom Prinzip her der gleiche Quellcode wie oben das ... 😉