A DD4T.net Implementation - The Model Factory

Now that we have Strongly Typed Models, Umbrella Models, Model Builders, Umbrella Model Builders and even a Model Generator Tool, we are still missing a little bit of functionality -- the model factory.

The ModelFactory class should simply take the TcmUri of a Component and give us the model for it. The models should be cached, in order to gain performance, and the cache should listen to publish flush notification (but more about caching in a subsequent post). In this post, I'll focus of the ModelFactory class and its methods.

I started by defining an interface IModelFactory that I can then hookup in Ninject as singleton, pointing to the only instance of its implementing class -- ModelFactory.

    public interface IModelFactory

    {

        T GetModel<T>(string componentUri, string viewOrTemplateUri) where T : ModelBase;

        T GetModel<T>(IComponent component) where T : ModelBase;

        T ResolveModel<T>(T model, string viewOrTemplateUri) where T : ModelBase;

        IList<T> ResolveModels<T>(IList<T> models, string viewOrTemplateUri) where T : ModelBase;

    }

The methods of interest are GetModel, which take a generic parameter in the type of model to build and either a TcmUri or a IComponent object. Based on the model type T to build, the correct subclass model of ModelBase is created and returned. I will talk about the ResolveModel methods in a follow-up post.

In the previous builders that we have defined, we need either an IComponent for Web Schemas, or IFieldsSet for Embedded Schemas.

The sample code we need to run would be, for example for the Device model:

    Device device = DeviceBuilder.Instance.Build(component);

Using the ModelFactory class, the same code would be:

    Device device = modelFactory.GetModel<Device>(component);

or if we used TcmUris:

    Device device = modelFactory.GetModel<Device>("tcm:1-2", "tcm:1-3-32");

One thing to note is the TcmUri parameter for the Component Template. This is needed in order to retrieve the Component Presentation that contains the IComponent loosely-typed model. In my implementation, this can be either a TcmUri or a ViewName. This implies there is a mapping from ViewName to Component Template TcmUri, but again, more information about that, in a follow-up post.

The two GetModel methods are as follows:

    public T GetModel<T>(string componentUri, string viewOrTemplateUri) where T : ModelBase

    {

        string templateUri = DD4TResourceProvider.GetViewLabel(viewOrTemplateUri);

        IComponent component = ComponentFactory.GetComponent(componentUri, templateUri);

        T model = BuildModel<T>(component);

        return model;

    }

    public T GetModel<T>(IComponent component) where T : ModelBase

    {

        T model = BuildModel<T>(component);

        return model;

    }

For simplicity, I left out the CachingProvider part (which I shamelessly copied from Rob's Labels in DD4T), as well as all error handling.

The ComponentFactory is simply a "Ninject"-ed property, which will also be presented later:

    [Inject]

    public virtual IComponentFactory ComponentFactory { get; set; }

The worker method is of course the BuildModel that takes a generic T being the type of model to create and the IComponent to build from.

The BuildModel method does nothing else than finding the Builder class for the given Model class using reflection, call it's Instance static property, then calling Build method on the builder instance:

    private T BuildModel<T>(IComponent component) where T : ModelBase

    {

        Type modelType = typeof(T);

        string builderTypeName = string.Format("{0}.{1}{2}", BUILDER_NAMESPACE, modelType.Name, BUILDER_SUFFIX);

        Type builderType = Type.GetType(builderTypeName);

        var builderInstance = builderType.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static).GetValue(null);

        MethodInfo buildMethod = builderInstance.GetType().GetMethod("Build", new[] { typeof(IComponent) });

        T result = (T)buildMethod.Invoke(builderInstance, new object[] { component });

        return result;

    }

For reference, the two constants look like this:

    private const string BUILDER_NAMESPACE = "Mitza.Model.Builders";

    private const string BUILDER_SUFFIX = "Builder";

The builder logic expects a naming convention between the builder class for a specific model and the model class name. Namely, the builder class name should consist of the model class name appended with string "Builder".

Example:

• for a model called Device
• the corresponding builder is expected to be Mitza.Model.Builders.DeviceBuilder