LightSpeed and Generics

Hello,

Consider the following class library that I'd like to map to a database.

namespace Sample
{
    public Permission<TResource>
    {
        // properties related to permissions
    }

    public AccessRule<TResource>
    {
        public Permission<TResource> Permission { get; set; }
        public User User { get; set; }
        public TResource { get; set; }
       // additional properties
    }

    public class User 
    {
       // additional properties
    }

    public class Blog
    {
        public List<AccessRule<Blog>> AccessRules { get; set; } 
        public List<Post> Posts { get; set; }
       // additional properties
    }

    public class Post
    {
        public Blog Blog {get; set; }
        public List<AccessRule<Post>> AccessRules { get; set; } 
       // additional properties
    }
}

Trying to map that to LightSpeed requires that I subclass Permission and AccessRule for every single type of resource (aka Blog and Post). Is there a way in LightSpeed that I can define those as "generic" entities and have LightSpeed resolve them accordingly? If so, where can I find information about it?

Thanks, Werner

No, I don't believe that's possible. I think the closest you could get would to to have generic interfaces, and implement those on the entity classes.

Hi Ivan,

The problem with that approach is a proliferation of types in my data layer. Supporting generics may reduce code, improve maintenance, reduce errors and simplify my schema. I did an little experiment to see how it mat work. Consider the following non generic version:

public class Blog : Entity<int>
{
    [ValidateLength(0, 255)]
    private string _name;

    [ReverseAssociation("Resource")]
    private readonly EntityCollection<BlogPermission> _permissions = new EntityCollection<BlogPermission>();

    [ReverseAssociation("Blog")]
    private readonly EntityCollection<Post> _posts = new EntityCollection<Post>();

    public EntityCollection<Post> Posts
    {
        get
        {
            return Get(_posts);
        }
    }

    public EntityCollection<BlogPermission> Permissions
    {
        get
        {
            return Get(_permissions);
        }
    }

    public string Name
    {
        get
        {
            return Get(ref _name, "Name");
        }
        set
        {
            Set(ref _name, value, "Name");
        }
    }
}

public class Post : Entity<int>
{
    private int _blogId;
    private string _body;

    [ValidateLength(0, 255)]
    private string _title;

    [ReverseAssociation("Posts")]
    private readonly EntityHolder<Blog> _blog = new EntityHolder<Blog>();

    [ReverseAssociation("Resource")]
    private readonly EntityCollection<PostPermission> _permissions = new EntityCollection<PostPermission>();

    public EntityCollection<PostPermission> Permissions
    {
        get
        {
            return Get(_permissions);
        }
    }

    public Blog Blog
    {
        get
        {
            return Get(_blog);
        }
        set
        {
            Set(_blog, value);
        }
    }

    public string Title
    {
        get
        {
            return Get(ref _title, "Title");
        }
        set
        {
            Set(ref _title, value, "Title");
        }
    }

    public string Body
    {
        get
        {
            return Get(ref _body, "Body");
        }
        set
        {
            Set(ref _body, value, "Body");
        }
    }

    public int BlogId
    {
        get
        {
            return Get(ref _blogId, "BlogId");
        }
        set
        {
            Set(ref _blogId, value, "BlogId");
        }
    }
}

public class Permission : Entity<int>
{
    [ValidateLength(0, 255)]
    private string _discriminator;

    [ValidateLength(0, 255)]
    private string _name;

    public string Discriminator
    {
        get
        {
            return Get(ref _discriminator, "Discriminator");
        }
        set
        {
            Set(ref _discriminator, value, "Discriminator");
        }
    }

    public string Name
    {
        get
        {
            return Get(ref _name, "Name");
        }
        set
        {
            Set(ref _name, value, "Name");
        }
    }
}

[Discriminator(Attribute = "Discriminator", Value = "Blog")]
public class BlogPermission : Permission
{
    private int? _resourceId;

    [ReverseAssociation("Permissions")]
    private readonly EntityHolder<Blog> _resource = new EntityHolder<Blog>();

    public Blog Resource
    {
        get
        {
            return Get(_resource);
        }
        set
        {
            Set(_resource, value);
        }
    }

    public int? ResourceId
    {
        get
        {
            return Get(ref _resourceId, "ResourceId");
        }
        set
        {
            Set(ref _resourceId, value, "ResourceId");
        }
    }
}

[Discriminator(Attribute = "Discriminator", Value = "Post")]
public class PostPermission : Permission
{
    private int? _resourceId;

    public const string ResourceIdField = "ResourceId";

    [ReverseAssociation("Permissions")]
    private readonly EntityHolder<Post> _resource = new EntityHolder<Post>();

    public Post Resource
    {
        get
        {
            return Get(_resource);
        }
        set
        {
            Set(_resource, value);
        }
    }

    public int? ResourceId
    {
        get
        {
            return Get(ref _resourceId, "ResourceId");
        }
        set
        {
            Set(ref _resourceId, value, "ResourceId");
        }
    }

    #endregion
}

public class LightSpeedModel1UnitOfWork : UnitOfWork
{
    public IQueryable<Blog> Blogs
    {
        get
        {
            return this.Query<Blog>();
        }
    }

    public IQueryable<Post> Posts
    {
        get
        {
            return this.Query<Post>();
        }
    }

    public IQueryable<Permission> Permissions
    {
        get
        {
            return this.Query<Permission>();
        }
    }

    public IQueryable<BlogPermission> BlogPermissions
    {
        get
        {
            return this.Query<BlogPermission>();
        }
    }

    public IQueryable<PostPermission> PostPermissions
    {
        get
        {
            return this.Query<PostPermission>();
        }
    }
}

I can add and view the data in this model, however can't delete it (see this post). Now if I was to generalize it, the model may look as follows:

public class Blog : Entity<int>
{
    [ValidateLength(0, 255)]
    private string _name;

    [ReverseAssociation("Resource")]
    private readonly EntityCollection<Permission<Blog>> _permissions = new EntityCollection<Permission<Blog>>();

    [ReverseAssociation("Blog")]
    private readonly EntityCollection<Post> _posts = new EntityCollection<Post>();

    public EntityCollection<Post> Posts
    {
        get
        {
            return Get(_posts);
        }
    }

    public EntityCollection<Permission<Blog>> Permissions
    {
        get
        {
            return Get(_permissions);
        }
    }

    public string Name
    {
        get
        {
            return Get(ref _name, "Name");
        }
        set
        {
            Set(ref _name, value, "Name");
        }
    }
}

public class Post : Entity<int>
{
    private int _blogId;
    private string _body;

    [ValidateLength(0, 255)]
    private string _title;

    [ReverseAssociation("Posts")]
    private readonly EntityHolder<Blog> _blog = new EntityHolder<Blog>();

    [ReverseAssociation("Resource")]
    private readonly EntityCollection<Permission<Post>> _permissions = new EntityCollection<Permission<Post>>();

    public EntityCollection<Permission<Post>> Permissions
    {
        get
        {
            return Get(_permissions);
        }
    }

    public Blog Blog
    {
        get
        {
            return Get(_blog);
        }
        set
        {
            Set(_blog, value);
        }
    }

    public string Title
    {
        get
        {
            return Get(ref _title, "Title");
        }
        set
        {
            Set(ref _title, value, "Title");
        }
    }

    public string Body
    {
        get
        {
            return Get(ref _body, "Body");
        }
        set
        {
            Set(ref _body, value, "Body");
        }
    }

    public int BlogId
    {
        get
        {
            return Get(ref _blogId, "BlogId");
        }
        set
        {
            Set(ref _blogId, value, "BlogId");
        }
    }
}

public class Permission<TResource> : Entity<int> where TResource:TEntity<long>
{
    [ValidateLength(0, 255)]
    private string _discriminator;

    [ValidateLength(0, 255)]
    private string _name;

    public string Discriminator
    {
        get
        {
            return Get(ref _discriminator, "Discriminator");
        }
        set
        {
            Set(ref _discriminator, value, "Discriminator");
        }
    }

    public string Name
    {
        get
        {
            return Get(ref _name, "Name");
        }
        set
        {
            Set(ref _name, value, "Name");
        }
    }

    private int? _resourceId;

    [ReverseAssociation("Permissions")]
    private readonly EntityHolder<TResource> _resource = new EntityHolder<TResource>();

    public TResource Resource
    {
        get
        {
            return Get(_resource);
        }
        set
        {
            Set(_resource, value);
        }
    }

    public int? ResourceId
    {
        get
        {
            return Get(ref _resourceId, "ResourceId");
        }
        set
        {
            Set(ref _resourceId, value, "ResourceId");
        }
    }
}

This reduces the number of classes in this simple model by 2. Imagine I had 60 classes that had some relationship with permissions, then I would reduce the number of classes by at least 60. Imagine the number of entities I can save if I 10 or so entities that could be "flagged", supports "voting", "comments", "marked as read" or "auditing". The savings in additional types are rather huge.

To support this doesn't seem complicated based on how LightSpeed works today. If it encounters a generic type that isn't abstract, it can simply use the type name as the table and generic argument as the discriminator. Thus, "Permission" will be stored in the "Permissions" table (considering all the ways it could be saved) and "Blog" will be the discriminator. This assumes that the discriminator is a string big enough to hold class names. I'm assuming that resolving the generic types to tables is the most complex of all of this, but that is just my assumption.

Any change you guys can consider something like this in the near future? It would greatly simplify data access layers and enable certain models to be reused across applications, which is otherwise not that reusable.

Thanks, Werner

One caveat is that many people eschew this kind of design because it doesn't play nicely with foreign keys. In your Permission table, the ResourceId column can't have a foreign key constraint because it could point to either the Post or Blog table. I'm not sure whether this is something that concerns you, though, as the same thing occurs the 'inheritance' version of your model too.

That consideration aside, this does seem like a nice way to avoid hierarchies where you have a utility entity that you want to be attachable to a wide variety of other entities. I've committed a preliminary implementation for you to try out, which will be in the next nightly build. Just apply the new DiscriminatedGenericEntityAttribute to your class and it should Just Work.

Some caveats and extra info:

• The discriminator field defaults to "Type". If you prefer the name "Discriminator", specify DiscriminatorAttribute="Discriminator" on the attribute.
• The discriminator field must exist. Virtual discriminators are not supported.
• The discriminator field must be a string. At present, we populate the discriminator with the unqualified name of the generic type parameter e.g. "Blog" or "Post" rather than "MyNamespace.Blog". There is no way to remap these if you change a class name, e.g. if you renamed "Post" to "BlogPost" when there were already records in the database. We're open to some sort of policy hook for this.
• The generic entity type must be sealed. We don't want the hassle of mixing generic discrimination with inheritance discrimination! Since the use case for this is utility classes, we don't expect this to be a problem.
• The generic entity type must have exactly one type parameter, and it must be an entity type. Again, since the use case is attaching the same utility class to different kinds of entity, we believe this is an acceptable limitation.
• You can only query using closed constructed types (e.g. Permission<Post>), not the open generic type (Permission<>). This is a consequence of the C# type system.

If this meets your needs, or if it needs only minor enhancements, then let us know. If it looks like it's going to require major enhancements or fixes to be useful in a real-world scenario, we may have to back it out and come back to it later, as we don't have huge resources to invest in this feature right now. We look forward to your feedback!

Thanks Ivan. I'll check it out tomorrow and see how well it works. I'm more of the pragmatic type when using foreign keys and other database features. I'll monitor performance and resource utilization and decide whether it is acceptable. I'm more than happy to live with the constraints.

Is the following scenario supported? You don't explicitly say. It is not a train smash if it is not.

public abstract Permission : Entity<long>
{
  /* some stuff */ 
}

public sealed Permission<T> : Permission 
{
  /* other stuff */
}

One way to get around the foreign key issue is to allow one to specify a "template" for table names, such as:

[Table("{0}Permission")]
public sealed class Permission<T> : Entity<long> where T : Entity
{
    /* */
}

So that means Permission<Blog> and Permission<Post> will map respectively to "BlogPermission" and "PostPermission". This, with the change you already made, may allow generic entities to be used when resolving the table names in TPH, TPC and TPT mappings. Further, one should be able to use foreign keys if needed. There is only one caveat, namely the challenge to keep things consistent between whether one pluralize table names across the system or not. But then, one can use the INamingStrategy to determine the correct table names. However, I may be oversimplifying things.

Werner

We have not tested the 'non-generic base class' scenario. I think it would probably work as long as the base class contained only scalar fields, but I'm not making any promises! Give it a try and if there are problems let us know -- if we can see a quick fix we will make it, but if it looks like it will require major work then we will defer it since it is not critical for you.

Generic classes mapping to multiple tables is an interesting idea and we could probably explore that at some future date. I think we could do that without breaking compatibility with the current implementation -- we would probably add an option to the DiscriminatedGenericEntityAttribute to specify single table or table per type, similar to the way the InheritanceMappingAttribute selects between single and class table inheritance. But I believe you wanted to use a single table, so we are unlikely to put effort into this unless a customer specifically asks for it. Thanks for the suggestion though -- we will certainly keep it in mind!

Howzit,

This feature has proven invaluable, especially when implementing "infrastructure" like tables, like that used for security while limiting the classes and tables in my system. However, I'm having a small problem. Consider the following:

[DiscriminatedGenericEntity]
public sealed class Permission<TResource> : Entity<long> where TResource : Entity<long>
{
    /* other properties such as name */

    private long? _resourceId;

    [ReverseAssociation("Security")]
    private readonly EntityHolder<TResource> _resource = new EntityHolder<TResource>();

    private long _principalId;

    [ValidateLength(0, 255)]
    private string _discriminator;

    public TResource Resource
    {
        get
        {
            return Get(_resource);
        }
        set
        {
            Set(_resource, value);
        }
    }

    public long? ResourceId
    {
        get
        {
            return Get(ref _resourceId, "ResourceId");
        }
        set
        {
            Set(ref _resourceId, value, "ResourceId");
        }
    }

    public long PrincipalId
    {
        get
        {
            return Get(ref _principalId, "PrincipalId");
        }
        set
        {
            Set(ref _principalId, value, "PrincipalId");
        }
    }

    public string Discriminator
    {
        get
        {
            return Get(ref _discriminator, "Discriminator");
        }
        set
        {
            Set(ref _discriminator, value, "Discriminator");
        }
    }
}

public abstract class Principal : Entity<long>
{
    /* fields common to principal */
}

public sealed class User : Principal
{
}

How would I add a property Principal on the Permission entity? When I do, LightSpeed complains that it can't resolve the association. Creating a non-generic permission table (with a Principal relationship) and inheriting the generic "Permission" from it also gives me issues.

The question I'm trying to answer is given a resource, "who" [aka principal] has specific access to a resource. The idea is to say Bob (user), Sam (user), MyApp (service) has read access to resource with if 123, Tim has write access and Bill owns the resource.

Werner

This is working for me (adapted from above) - does this give you what you are after?

[DiscriminatedGenericEntity(DiscriminatorAttribute="Discriminator")]
public sealed class Permission<TResource> : Entity<long> where TResource : Entity<long>
{
  private long? _resourceId;

  [ReverseAssociation("Security")]
  private readonly EntityHolder<TResource> _resource = new EntityHolder<TResource>();

  private long _principalId;

  [ValidateLength(0, 255)]
  private string _discriminator;

  public TResource Resource
  {
    get
    {
      return Get(_resource);
    }
    set
    {
      Set(_resource, value);
    }
  }

  public long? ResourceId
  {
    get
    {
      return Get(ref _resourceId, "ResourceId");
    }
    set
    {
      Set(ref _resourceId, value, "ResourceId");
    }
  }

  public long PrincipalId
  {
    get
    {
      return Get(ref _principalId, "PrincipalId");
    }
    set
    {
      Set(ref _principalId, value, "PrincipalId");
    }
  }

  public string Discriminator
  {
    get
    {
      return Get(ref _discriminator, "Discriminator");
    }
    set
    {
      Set(ref _discriminator, value, "Discriminator");
    }
  }
}

public abstract class Principal : Entity<long>
{
  private int _principalType;

  [EagerLoad]
  [ReverseAssociation("Resource")]
  private readonly EntityCollection<Permission<Principal>> _security = new EntityCollection<Permission<Principal>>();

  public EntityCollection<Permission<Principal>> Security
  {
    get { return Get(_security); }
  }

  public int PrincipalType
  {
    get
    {
      return Get(ref _principalType, "PrincipalType");
    }
    set
    {
      Set(ref _principalType, value, "PrincipalType");
    }
  }
}

[Discriminator(Attribute="PrincipalType", Value="1")]
public sealed class User : Principal
{
}

}

Note: PrincipalId on Permission would seem to be superfluous as the association is being made across Resource.

Jeremy