Sitecore Code Generator and O/R mapper

You probably have never used a code generator for the same reason I never used a code generator:

• It was not developed by yourself
• It’s not generating the code you need
• You cannot extend it with the stuff you need
• They create the same code for all of your Sitecore templates
• It’s difficult to install
• It was not developed by yourself.

A code generator that creates an O/R relationship between your Sitecore templates and your code can save you a ton of work though:

• Automatically update your code when new templates are created
• There is never any mismatch between your code and Sitecore templates
• Code class names matches Sitecore template names
• All field names are mapped correctly

That is why I introduce the open-source, freeware, use-as-you-please:

SITECOREORM, The object/relational code generator for Sitecore.

You can download it here for free, including the source code:

SitecoreORM

http://marketplace.sitecore.net/en/Modules/SitecoreORM_Object-relational_Code_Generator.aspx

The SitecoreORM is a code generator framework that allows you to create code templates based on well-known user controls (.aspx) pages, and generate code from all of your Sitecore templates.

There is no Sitecore package; all you do is to place the code in your solution and call \sitecore modules\Shell\SitecoreORM\Execute.aspx to execute the code generation.

Out of the box, SitecoreORM generates simple classes that maps all fields on a Sitecore template, references to inherited templates, and a static struct of field names to be used by Sitecore’s sc:FieldRenderer.

But the idea behind SitecoreORM is that you define yourself how your classes should look like.

Changing the output is done by simply changing some .aspx pages. For example, the code template is an .aspx page. This is an example of how it looks (simplified, download the code for the complete example):

namespace <%# Namespace %>
{
  public class <%# ClassName %> : BaseItem
  {
    public <%# ClassName %>(Item innerItem)
    {
      InnerItem = innerItem;
    }

    public Item InnerItem { get; private set; }

    public override FieldCollection Fields
    {
      get { return InnerItem.Fields; }
    }

    #region Inherited Templates
<%# ExecuteCodeProvider("SomeClass, SomeDll", "SomeParameter") %>
    #endregion
  }
}

Generating fields, inherited templates or other thing you need, is done using code providers, that you plug in. SitecoreORM uses reflection to find the code, and your class only needs to implement an ICodeProvider interface that has 1 method: Get().

Here is an example of an .aspx file that generates a Sitecore field (a CheckBox field):

<%@ Page Language="C#" AutoEventWireup="true" %>
<%@ Import Namespace="Sitecore.Data.Items" %>
<%@ Import Namespace="SitecoreORM.CodeProviders" %>
<%@ Import Namespace="SitecoreORM.Services" %>
<script runat="server">

  void Page_Load(object sender, System.EventArgs e)
  {
    DataBind();
  }

  private TemplateFieldItem Field
  {
    get { return GenerateFieldProperties.Field; }
  }

  private string PropertyName
  {
    get { return NameNormalizerService.GetValidName(Field.Name); }
  }

</script>

    /// <summary>
    /// <%# TemplateFieldItemCommentService.GetComment(Field) %>
    /// </summary>
    public Sitecore.Data.Fields.CheckboxField <%# PropertyName %>
    {
      get { return InnerItem.Fields["<%# Field.Name %>"]; }
    }

The SitecoreORM framework is written with the fewest lines of code that will do the job. The code is as simple as possible, making it easier to extend, and for you to understand.

Features of SitecoreORM includes:

• O/R mapping Sitecore templates to C# code.
• Every aspect of the code generation can be customized:
  • .aspx page based code generation allows you to choose the class format yourself.
  • Each field type from Sitecore can be mapped by .aspx pages, making it easy to determine how each field type from Sitecore should be mapped.
  • Inherited templates can be mapped as well.
  • Field names can be mapped to be used by sc:FieldRenderer
  • Plug in your own code; SitecoreORM uses reflection to find the code generators.
• Customizable output using an include file (/app_config/include/sitecoreorm.config)
  • Determine class name suffixes
  • Determine name space prefixes
  • Determine removing of parts of template path from namespace
  • Determine file destination for generated classes
  • Specify which template folders to ignore (for example /system/ and /common/)
  • Specify which template folders to include
  • Specify file destination for each template folder to include, hence supporting component based development
• Simple code. Less than 20 classes makes up the framework. 5 services and one repository does most of the job.

Check out SitecoreORM here:

http://marketplace.sitecore.net/en/Modules/SitecoreORM_Object-relational_Code_Generator.aspx