Does anybody have any views on this?
I just would like to know if I can expect this to be a future feature
or if I will need to keep patching future versions?
On Oct 31, 5:00 pm, Dries Samyn <dries.sa...@googlemail.com> wrote:
> I have been playing around with Fluent for a while now, and have been
> trying to build a convention that echos how I usually write mapping
> files.
>
> One thing I was missing was good support for using Interfaces as
> proxies, and generally in the model.
> I was pleased to see the "Proxy" patch on ClassInstance, but one thing
> that I think was also missing is to be able to set/override the
> standard class mapping on a one-to-many mapping.
> I'll try to explain.
> I usually like to model my collections in my objects like this:
> (pseudo code)
>
> public class AutomapProduct : IAutomapProduct
> {
> protected IList<IProductAttribute> _attributes = new
> List<IProductAttribute>();
>
> public IEnumerable<IProductAttribute> Attributes
> {
> get { return _attributes; }
> protected set { _attributes =
> value.ToList<IProductAttribute>(); }//only here for fluent nh
> }
>
> }
>
> So the collection is declared with IProductAttribute instead of
> ProductAttribute.
> Obviously, when mapping this, one has to map this to a concrete type.
> I know some people consider the above an anti-pattern, but here's not
> the place to discuss this, the above is possible in nHibernate, and
> it's now possible in Fluent too by using:
>
> HasMany<ProductAttribute>(x => x.Attributes);
>
> However, I don't think it was possible before to set up a convention
> that, by default, would try to map it to a concrete type based on the
> interface's name.
>
> For this, I added a SetManyClass method on OneToManyInstance to allow
> this to be set in a convention.
> This allows me to do something like:
>
> public class HasManyConvetion : IHasManyConvention
> {
>
> public void Apply(IOneToManyCollectionInstance instance)
> {
> //collection may be declared to return interface ->
> default to obvious candidate for mapping.
> if (instance.Relationship.ManyClass.GetUnderlyingSystemType
> ().IsInterface)
> {
> string name =
> instance.Relationship.ManyClass.Name.Substring(1);//remove I
> string namesp =
> instance.Relationship.ManyClass.GetUnderlyingSystemType().Namespace;
> string assem =
> instance.Relationship.ManyClass.GetUnderlyingSystemType
> ().Assembly.ToString();
> instance.Relationship.SetManyClass(Type.GetType
> (string.Concat(namesp, ".", name, ", ", assem)));
> }
> }
> }
>
> Again, I don't really want to discuss the pattern here, I personally
> like to use interfaces in collections, but here's not the place to
> discuss this pattern, I just want to discuss the Fluent implementation
> and conventions ;)
>
> The patch to implement this is is below.
>
> Is this useful? Is it worth adding?
>
> --
> Index: Conventions/Instances/IOneToManyInstance.cs
> ===================================================================
> --- Conventions/Instances/IOneToManyInstance.cs (revision 647)
> +++ Conventions/Instances/IOneToManyInstance.cs (working copy)
> @@ -1,9 +1,17 @@
> using FluentNHibernate.Conventions.Inspections;
> +using System;
> +using FluentNHibernate.MappingModel;
>
> namespace FluentNHibernate.Conventions.Instances
> {
> public interface IOneToManyInstance : IOneToManyInspector,
> IRelationshipInstance
> {
> INotFoundInstance NotFound { get; }
> +
> + TypeReference ManyClass { get; }
> +
> + void SetManyClass<T>();
> + void SetManyClass(Type type);
> + void SetManyClass(string type);
> }
> }
> \ No newline at end of file
> Index: Conventions/Instances/OneToManyInstance.cs
> ===================================================================
> --- Conventions/Instances/OneToManyInstance.cs (revision 647)
> +++ Conventions/Instances/OneToManyInstance.cs (working copy)
> @@ -1,5 +1,7 @@
> using FluentNHibernate.Conventions.Inspections;
> using FluentNHibernate.MappingModel.Collections;
> +using System;
> +using FluentNHibernate.MappingModel;
>
> namespace FluentNHibernate.Conventions.Instances
> {
> @@ -24,5 +26,28 @@
> });
> }
> }
> +
> + public TypeReference ManyClass
> + {
> + get
> + {
> + return mapping.Class;
> + }
> + }
> +
> + public void SetManyClass<T>()
> + {
> + SetManyClass(typeof(T));
> + }
> + public void SetManyClass(Type type)
> + {
> + if(!mapping.IsSpecified("class"))
> + mapping.Class = new TypeReference(type);
> + }
> + public void SetManyClass(string type)
> + {
> + if(!mapping.IsSpecified("class"))
> + mapping.Class = new TypeReference(type);
> + }
> }
> }
> \ No newline at end of file
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Fluent NHibernate" group.
To post to this group, send email to fluent-nhibernate@googlegroups.com
To unsubscribe from this group, send email to
fluent-nhibernate+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/fluent-nhibernate?hl=en
-~----------~----~----~----~------~----~------~--~---
