The CodeFluent Entities Blog

Following the previous post “Generating Custom Code For All Entities” a colleague showed me the greatest way ever to iterate on a collection of concepts and generate text a file for each from a template, so I thought I’d share it

In this post we’ll write a template to generate a C# file per entity extending the one generated by the Business Object Model producer. The generated file should look like this one:

namespace Sample
{
    public partial class Customer
    {
        public static Customer LoadFromLob(string entityKey)
        {
            // TODO: load from external LOB
        }
    
        public void SendToLob()
        {
            // TODO: save current instance to external LOB
        }
    }
}

To generate code like the one above I created a template file named “[Template]entity.tpl”.

Note: The “[Template]” prefix is important as it indicates the producer to run the template. Other than that, the rest of the name doesn’t matter as we’ll name our output files <EntityName>.g.cs and this will be done in the template.

Here’s my template:

[%@ template enumerable='Producer.Project.Entities' enumerableItemName="entity" enumerableTargetPathFunc='Path.Combine(Path.GetDirectoryName(TargetPath), entity.Name) + ".g.cs"' %]
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by the Template Producer.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace [%=entity.Namespace%]
{
    public partial class [%=entity.Name%]
    {
        public static [%=entity.Name%] LoadFromLob(string entityKey)
        {
            // TODO: load from external LOB
        }
    
        public void SendToLob()
        {
            // TODO: save current instance to external LOB
        }
    }
}

Instead of all the code which we used to have I now have a single line which will have the exact same effect. Here’s a description of what it does:

• the enumerable attribute takes an IEnumerable as an input. In our case, I’ve set it to take as input all entities of my project. This is possible as all producers have a Project property corresponding to the model inferred from your model.
• the enumerableItemName attribute corresponds to the item name which I named “entity” as I’m enumerating on all entities. That’s basically the variable name of my foreach, and that’s how I can use the “entity” variable in the rest of my template.
• the enumerableTargetPathFunc is a code snippet to be called to compute the target path of the generated file. This is thanks to this snippet that I’m generating files named as “<EntityName>.g.cs”.

Running my new template, here’s the result:

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by the Template Producer.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Sample
{
    public partial class Customer
    {
        public static Customer LoadFromLob(string entityKey)
        {
            // TODO: load from external LOB
        }
    
        public void SendToLob()
        {
            // TODO: save current instance to external LOB
        }
    }
}

Carl Anderson

We often have questions on our forums of CodeFluent Entities users who’d like to add custom methods to all entities of their project.

A convenient way to do this is by writing a template of those custom methods and run them on all entities, and this is what we’ll see in this post.

Scenario

Say I have some line of business, external to my application, but with which every now and then I want to be able to synchronize my generated classes. As a consequence, I’d like all my entity classes to have two extra methods: a SendToLob and LoadFromLob.

Solution

To do so we’re going to write a template which, for each entity, will add those two methods in a partial class, extending the generated code. To do so we’ll create a single template which will create one .CS file for each entity.

Here’s our template (named “[Template]entity.g.cs”):

[%@ template language="CSharp" output="false"%]
[%@ namespace name="System" %]
[%@ namespace name="CodeFluent.Model" %]
[%@ namespace name="CodeFluent.Producers.CodeDom" %]
[%@ namespace name="CodeFluent.Model.UI" %]
[%@ namespace name="CodeFluent.Model.UI.ControlDefinitions" %]
[%@ namespace name="CodeFluent.Producers.CodeDom.UI" %]
[%@ namespace name="System.IO" %]
[%

Entity entity = null;
if (Context["inTemplate"] == null)
{
    Context["inTemplate"] = true; // anything would do, other than null
    foreach(Entity e in Producer.Project.Entities)
    {
        // build a new target path & re-run ourselves
        string targetPath = Path.Combine(
            Path.GetDirectoryName(TargetPath),
            Path.GetFileName(TargetPath).Replace("entity", e.Name));
        using (GeneratedFile file = new GeneratedFile(Producer.Project, targetPath))
        {
            if ((file.HasBeenChanged) && ((e.ProductionFlags & ProductionFlags.Overwrite) == 0))
            {
                Producer.RaiseProduction(Producer, file.CreateFileSkipEvent("entity.g.cs"));
                continue;
            }

            // note: we don't care about the output="false" here
            Producer.RaiseProduction(Producer, ProductionEventArgs.CreateFileTemplateGenerateEvent(targetPath, Template.FilePath));
            file.Open(Producer, Producer.OutputEncoding);

            // add the entity to the context
            Context["entity"] = e;

            // update targetPath
            Context["TargetPath"] = targetPath;

            // go recursive, and this will jump to the else part of this file
            Template.Run(file.Writer, Context);
        }
    }
}
else
{
    entity = (Entity)Context["entity"];
%]
namespace [%=entity.Namespace%]
{
    public partial class [%=entity.Name%]
    {
        public static [%=entity.Name%] LoadFromLob(string entityKey)
        {
            // TODO: load from external LOB
        }

        public void SendToLob()
        {
            // TODO: save current instance to external LOB
        }
    }
}
[% }%]

The first part of the template iterates on all entities, and re-runs itself to create a file where the “entity” file name was replaced by the actual entity name. The second part of the template is the actual code to be placed in the generated file.

Then:

• Add an instance of the Template Producer to your model,
• Set its source directory to point to the directory containing our [Template]entity.g.cs file,
• Set its target directory to be the same as your Business Object Model Producer so the generated classes will be in the same directory.

You’re now ready to go, generate over!

Result

Extra files were generated (one per entity) extending your already existing generated classes:

And here’s the content of the Customer.g.cs file:

namespace Sample
{
    public partial class Customer
    {
        public static Customer LoadFromLob(string entityKey)
        {
            // TODO: load from external LOB
        }

        public void SendToLob()
        {
            // TODO: save current instance to external LOB
        }
    }
}

Remarks

Drawbacks of this method are that:

• it creates one extra file per entity,
• if entity classes are generated in subfolders (e.g. multiple namespaces) it will require extra code to handle.

Other options to obtain the same output but without those drawbacks could be to:

• Generate a single class file extending all classes (a little ugly, yet so effective )
• Create a CodeFluent Aspect instead of using templates to add code snippets to all entities!

Hope this helps,

Carl Anderson