mahdness wrote:

I was thinking about this same idea the other day...

Does it offer any benefits over the traditional approach of adding an EntitySet<customvalues> property to your entities?

I guess one benefit is that you can index by these fields since they would be in the same DB table

Dmitri Maximov (Xtensive) wrote:

Hello guys,

Let me introduce one of the DataObjects.Net 4 unknown treasures. ;) Probably, you've already met IModule interface but haven't known the purpose of OnDefinitionsBuild method. Let me remind you the signature:

/// <summary>
  /// The contract of extension module.
  /// </summary>
  public interface IModule
  {
    /// <summary>
    /// Called when the build of <see cref="DomainModelDef"/> is completed.
    /// </summary>
    /// <param name="context">The domain building context.</param>
    /// <param name="model">The domain model definition.</param>
    void OnDefinitionsBuilt(BuildingContext context, DomainModelDef model);

    ...
  }

As one might knows, Domain model building process consists of 2 phases: during the first one we build definitions of persistent types, fields, indexes, etc. (this is so-called 'Definition model'), whereas during the second phase we construct full-fledged model objects such as TypeInfo, FieldInfo, IndexInfo, AssociationInfo and everything. The reason why we're using such a 2-phase process is that we want to allow user-code to get a control over Definition model and make all necessary changes to it in right time in right place.

The method I'm talking about (OnDefinitionsBuilt) is exactly for this purpose. It allows you to redefine anything in the Definition model, even to create it from scratch.

Let's look at the following example:

public class MyModule : IModule
  {
    public void OnBuilt(Domain domain)
    {
      // Nothing interesting here
    }

    public void OnDefinitionsBuilt(BuildingContext context, DomainModelDef model)
    {
      // Here model parameter is the Definition model, it contains a collection of TypeDef, HierarchyDef instances
      // You can register additional persistent types
      model.DefineType(typeof (MyClass));
      // Or remove already registered
      model.Types.Clear();

      // Add, modify, remove fields
      model.Types[typeof(MyClass)].DefineField("MyDynamicField", typeof(string));
      model.Types["MyClass"].Fields["MyDynamicField"].Length = 50;

      // Manage indexes
      indexDef = model.Types["MyClass"].DefineIndex("IX_MYDYNAMICFIELD");
      indexDef.KeyFields.Add("MyDynamicField", Direction.Positive);

      // And much more, e.g. HierarchyDef & FullTextIndexDef management
    }

Notice that the process is being taken place during the Domain build procedure. So it is not in pure runtime as you may think as DO 4 need complete and built model to perform database schema upgrade at the very beginning of its work.

Hope that helps.

P.S. Is such a material worth inclusion in DO Samples or at least publishing with more details in DO blog? It might be a bit specific & geek-oriented, imho.