NHibernate 'Bags' Implementation in Entity Framework

Question

I started using EF with Code First recently and have come upon this issue which has left me rather perplexed. I will appreciate any feedback on this topic which will help me in resolving the said issue.

Please consider the following sample....

public class SomeType
{
    public SomeType()
    {
        Properties = new List<BaseProperty>();
    }

    public int PrimaryKey { get; set; }
    public string Name { get; set; }
    public List<BaseProperty> Properties { get; set; }
}

public abstract class BaseProperty
{
    public int PrimaryKey { get; set; } 
    public string PropertyName { get; set; }

    // FK set through Type Configuration File.
    public SomeType ParentInstance { get; set; }
}

public class PropertyA : BaseProperty
{
    // some unique properties.
}

public class PropertyB : BaseProperty
{
    // some unique properties.
}

public class PropertyC : BaseProperty
{
    // some unique properties.
}

public class PropertyD : BaseProperty
{
    // some unique properties.
}

All of this works great with the appropriate type configuration classes which map to 2 tables (1 for 'SomeType' and the second for 'BaseProperty' along with the remaining derived entities through the use of a discriminator column).

Now, due to circumstances beyond my control, I am being forced to modify 'SomeType' to something like this....

public class SomeType
{
    public SomeType()
    {
        PropertiesAB = new List<BaseProperty>();
        PropertiesC = new List<PropertyC>();
        PropertiesD = new List<PropertyD>();
    }

    public int PrimaryKey { get; set; }
    public string Name { get; set; }

    public List<BaseProperty> PropertiesAB { get; set; }        // collection of PropertyA and PropertyB
    public List<PropertyC> PropertiesC { get; set; }        // collection of PropertyC
    public List<PropertyD> PropertiesD { get; set; }        // collection of PropertyD
}

This would be very fairly easy to do in NHibernate using bags but is there an equivalent implimentation for this in EF using Code First? Any thoughts? I do not want to write my own implimentation of a Collection which will forward and manipulate all operations to be performed on these new lists to a master list which will be actually mapped to the database.

Please ignore any missing "virtual" modifiers or anything else in the above code since it is only meant to be a sample and is NOT actually what I am using.

Thank you for your replies.

Answer 1

Worse comes to Worse, you can do something like this:

public class SomeType
{
   public SomeType()
   {
      Properties = new List<BaseProperty>();
   }

   public int PrimaryKey { get; set; }
   public string Name { get; set; }
   public List<BaseProperty> Properties { get; set; }

   public List<BaseProperty> PropertiesAB 
   { 
      get
      {
         return Properties.Where(p=>p is PropertyA || p is PropertyB);
      } 
      set
      {
         //Remove all the properties already in the Properties collection of
         //the type A and B and then
         Properties.AddRange(value)
      } 
   }
   //Same with rest of the properties
}

You can also make the Properties property internal if the class is being used outside the domain layer