Question

I have this abstract factory pattern that I use in as3 that I am pretty used to and I am trying to implement it in C# but lack some knowledge, here how it goes.

    public class Factory{

        static public ID_LOGIC_CLASS:int = AddClassLink(MyLogicClass);

        static private classLib:Array;

        public Factory(){
            classLib = new Array();
        }


        static public AddClassLink(logicClass:Class):int {
             classLib.push(logicClass);
             return classLib.length-1;
        }

        static public CreateClassFromId(int id, 
                                  constructorData:DataObject):FactoryObject{
             var c:Class = classLib[id];
             var obj:FactoryObject = new c();
             obj.Init(constructorData);
             return obj;
        }
    }

This is the implementation I use and it is very good. It allows you to instantiate objects with a simple int and a data object that holds all of your constructor values.

Only thing that I am missing really is how to make a list of classes object in C# and how to create a new object of that class with a reference to the class type.

I think it could be done by using delegate’s constructors.

Tell me what you think.

Answer 1

Here’s a verbatim port:

      // Untested code
public class Factory
{
    private static int _id = 0;

    // Use Dictionary to store the mapping from int to Type
    // instead of ActionScript "classLib = new Array();"
    private static readonly IDictionary<int, Type> _typeMappings = new Dictionary<int, Type>();

    public Factory()
    {
    }

    public static int AddClassLink(Type type)
    {
        // To insure uniqueness, increment a static local id and use that
        int localId = ++_id;

        // Store the Type of the class to instantiate against the integer ID
        // Similar to ActionScript "classLib.push(logicClass); "
        _typeMappings[localId] = type;          // Set in dictionary
        return localId;
    }

    pubilc static FactoryObject CreateClassFromId(int id, DataObject constructorDataObject)
    {
        // Get the class type by integer Id. 
        // You can also use _typeMappings.Contains and _typeMappings.TryGetValue() to 
        // add some checking first
        var type = _typeMappings[id];

        // This is equivalent to new DerivedFactoryObject() where Type
        // is the runtime Type of the class registered in AddClassLink
        var obj = (FactoryObject)Activator.CreateInstance(type);

        // Initialise and return 
        obj.Init(constructorDataObject);
        return obj;
    }
}

In this example I’ve used a Dictionary<TKey, TValue instead of Array so that removals from the type dictionary don’t mess up the ID you are returning. In the above example, so long as AddClassLink is not called on multiple threads, you will get a unique ID every time, even if classes are deregistered.

Regarding instantiation of a type, use the System.Type overload of Activator.CreateInstance. This can construct an object given its runtime type only.

Regarding usage of this class, if you have a class you want to register with it you would use this notation

var myFactory = new Factory();
int id = myFactory.AddClassLink(typeof(SomeClassIWantInstantiated))
// ... 
SomeClassIWantInstantiated instance = myFactory.CreateClassFromId(id, new DataObject())

The above should work (Disclaimer: Untested!) and should be an accurate port of your actionscript code. *That is not to say it is a good idea or best practices! *

I recommend taking a look into Dependency Injection containers and looking at the Factory Pattern in .NET as the power of reflection, runtime typing etc allow this pattern to be implemented elegantly and robustly in C#. In particular, DI Containers will allow you to register and resolve a class as follows

var myFactory = new DependencyInjectionContainerTm();
myFactory.Register(typeof(SomeClassIWantInstantiated))
// ... 
SomeClassIWantInstantiated instance = myFactory.Resolve<SomeClassIWantInstantiated>();

The main use of the container is to wire up dependencies and allow constructor injection as interfaces, leading to well decoupled, easily testable code, however it is essentially a typed object factory.