A DD4T.net Implementation - Model Builders

In my previous post I was talking about the Strong Typed models and how they are used to give a class representation for Tridion Schemas. In this post I will talk about how we can build such models from Components.

The model builders are derived from a generic Builder class that converts either an IComponent or IFieldSet to an implementation of BaseModel class:

    public abstract class Builder<From, To> where To : BaseModel

    {

        public abstract To Build(From fromValue);

        public IList<To> Build(IList<From> fromValueList)

        {

            if (fromValueList == null || fromValueList.Count == 0)

            {

                return new List<To>();

            }

            return fromValueList.Select(x => Build(x)).ToList<To>();

        }

    }

The abstract Build(From object) needs to be implemented by all classes that extend Builder. That is where the actual building of the model takes place.

The other method IList<To> Build(IList<From> objects) is simply a convenience method that builds an array of model from an array of IComponent or IFieldSet objects.

A Builder implementation class can take an IComponent 'from' object and convert it into a derivative of BaseModel object. The Builder can also take IFieldSet 'from' object, in the case when building embedded models. This is needed because the embedded fields don't have a corresponding IComponent; they are simply identified by a set of DD4T.ContentModel.IField -- the IFieldSet.

Let's see further an actual implementation of a Builder for Device models. First let's look at the Device model class:

    public class Device : BaseModel

    {

        public Banner Banner { get; set; }

        public IList<EmbeddedParagraph> Body { get; set; }

        public IList<BaseModel> RelatedItems { get; set; }

        public DeviceMetadata Metadata { get; set; }

        public class DeviceMetadata

        {

            public double LegacyId { get; set; }

            public string ShortTitle { get; set; }

            public IList<IKeyword> Products { get; set; }

            public DateTime UpdateDate { get; set; }

        }

        public Device(IComponent component) : base(component) { }

    }

The corresponding DeviceBuilder for the sample model looks like this:

    public class DeviceBuilder : Builder<IComponent, Device>

    {

        private static readonly DeviceBuilder _instance = new DeviceBuilder();

        public static DeviceBuilder Instance { get { return _instance; } }

        private DeviceBuilder() {}

        public override Device Build(IComponent component)

        {

            IFieldSet fields = component.Fields;

            IFieldSet metadataFields = component.MetadataFields;

            Device device = new Device(component)

            {

                Banner = BannerBuilder.Instance.Build(fields.LinkedComponentValue("Banner")),

                Body = EmbeddedParagraphBuilder.Instance.Build(fields.EmbeddedValues("Body")),

                RelatedItems = RelatedItemBuilder.Instance.Build(fields.LinkedComponentValues("Related_Items")),

                Metadata = new Device.DeviceMetadata()

                {

                    LegacyId = metadataFields.NumericValue("Legacy_Id"),

                    ShortTitle = metadataFields.StringValue("Short_Title"),

                    Products = metadataFields.KeywordValues("Products"),

                    UpdateDate = metadataFields.DateTimeValue("Update_Date")

                }

            };

            return device;

        }

    }

First, DeviceBuilder is declared as a Builder that takes an IComponent as 'from' object and produces a Device as 'to' object.

Then comes the singleton declaration. We know this builder is thread-safe (it doesn't use any internal state other than what is passed to it from method parameters), so it can be declared a singleton to improve performance.

Next, the actual Build method: this is the main logic of the builder. It takes each field in the IComponent field collection and metadata field collection and populates the properties of the Device model. You might notice the methods on the 'fields' collection, such as NumericValues, KeywordValues, DateTimeValue... These are not standard methods on the IFieldSet object, but are declared as extension methods. But, more information about those in a future post.

The other Builders are very similar -- BannerBuilder, RelatedItemBuilder. But the EmbeddedParagraphBuilder stands out because it is a bit different. It doesn't take an IComponent to build an EmbeddedParagraph model. Instead it take the embedded set of fields to produce an EmbeddedParagraph.

The EmbeddedParagraphBuilder implementation is next:

    public class EmbeddedParagraphBuilder : Builder<IFieldSet, EmbeddedParagraph>

    {

        private static readonly EmbeddedParagraphBuilder _instance = new EmbeddedParagraphBuilder();

        public static EmbeddedParagraphBuilder Instance { get { return _instance; } }

        private EmbeddedParagraphBuilder() {}

        public override EmbeddedParagraph Build(IFieldSet fields)

        {

            EmbeddedParagraph paragraph = new EmbeddedParagraph()

            {

                Heading = fields.StringValue("Heading"),

                Body = fields.ResolveRichText("Body")

            };

            return paragraph;

        }

    }

Once the Builders are implemented, we simply use them by passing in an IComponent object. For example in a ComponentController:

        public ActionResult Device(string componentPresentationId)

        {

            IComponentPresentation cp = GetComponentPresentation();

            IComponent component = cp.Component;

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

            return View();

        }