Skip to main content

A 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:

    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".

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


Popular posts from this blog

Scaling Policies

This post is part of a bigger topic Autoscaling Publishers in AWS . In a previous post we talked about the Auto Scaling Groups , but we didn't go into details on the Scaling Policies. This is the purpose of this blog post. As defined earlier, the Scaling Policies define the rules according to which the group size is increased or decreased. These rules are based on instance metrics (e.g. CPU), CloudWatch custom metrics, or even CloudWatch alarms and their states and values. We defined a Scaling Policy with Steps, called 'increase_group_size', which is triggered first by the CloudWatch Alarm 'Publish_Alarm' defined earlier. Also depending on the size of the monitored CloudWatch custom metric 'Waiting for Publish', the Scaling Policy with Steps can add a difference number of instances to the group. The scaling policy sets the number of instances in group to 1 if there are between 1000 and 2000 items Waiting for Publish in the queue. It also sets the

Toolkit - Dynamic Content Queries

This post if part of a series about the  File System Toolkit  - a custom content delivery API for SDL Tridion. This post presents the Dynamic Content Query capability. The requirements for the Toolkit API are that it should be able to provide CustomMeta queries, pagination, and sorting -- all on the file system, without the use third party tools (database, search engines, indexers, etc). Therefore I had to implement a simple database engine and indexer -- which is described in more detail in post Writing My Own Database Engine . The querying logic does not make use of cache. This means the query logic is executed every time. When models are requested, the models are however retrieved using the ModelFactory and those are cached. Query Class This is the main class for dynamic content queries. It is the entry point into the execution logic of a query. The class takes as parameter a Criterion (presented below) which triggers the execution of query in all sub-criteria of a Criterio

Running sp_updatestats on AWS RDS database

Part of the maintenance tasks that I perform on a MSSQL Content Manager database is to run stored procedure sp_updatestats . exec sp_updatestats However, that is not supported on an AWS RDS instance. The error message below indicates that only the sa  account can perform this: Msg 15247 , Level 16 , State 1 , Procedure sp_updatestats, Line 15 [Batch Start Line 0 ] User does not have permission to perform this action. Instead there are several posts that suggest using UPDATE STATISTICS instead: I stumbled upon the following post from 2008 (!!!), , which describes a way to wrap the call to sp_updatestats and execute it under a different user: create procedure dbo.sp_updstats with execute as 'dbo' as