Doh! Didn't want to send that yet.
In essence we need to automap in a nested fashion. The reason you spotted is
possibly the same reason that inheritance isn't yet supported, but thinking
about this a little more this morning, I wonder if  this could be resolved
through some sort of recursion. So you send the parent object through the
AutoMapper class again, sounds complicated and unfortunately I've not got a
huge amount of time on my hands at the moment to investigate.
However, Inheritance is making my AutoMappings large too, so it's definitely
on my hit list of things to tidy up.
I need to apply some patch's so I'll have a noise over the source and see if
this is possible.

Cheers

Andy

On Mon, Oct 6, 2008 at 9:15 AM, Andrew Stewart <[EMAIL PROTECTED]
> wrote:

> Hi Gabriel
> This sound similar to the problem I've had trying to make inheritence work
> aswell.
>
> AutoPersistenceModel
>    .MapEntitiesFromAssemblyOf<Company>().Where(t => t.Namespace ==
> "Something")
>                  .ForTypesThatDeriveFrom<Contact>
> (map =>
>                                             {
>                                                 var mapping =
> map.HasManyToMany<SiteRoleCompanyWithContacts>(t => t.SiteRoles)
>
>  .WithTableName("SiteRoleCompanyWithContactsToContact");
>
>
>  mapping.SetAttribute("lazy", "true");
>
>  mapping.SetAttribute("cascade", "all");
>
>  mapping.SetAttribute("inverse", "true");
>
>                                                 map.References(t
> =>t.Address)
>
>  .SetAttribute("unique","true");
>                                             })
>
> Cheers
>
> Andy
>
>
> On Mon, Oct 6, 2008 at 7:22 AM, Gabriel Schenker <[EMAIL PROTECTED]>wrote:
>
>> @Andy: I'm a little bit lost... and need your help
>> I can see what you are doing for things like References and HasMany. But
>> the Component part is special in that it has an additional action of type
>> Action<ComponentPart<C>> to be handled (auto-mapped). And there my problems
>> start... How can I "inject" or "auto-generate" this action part?
>> Any help is appreciated.
>> Note: I think this component stuff is really important since in a decent
>> domain model you will always have lots of value objects. And thus they
>> should be handled as first class citizen by auto-mapping ;-)
>>
>>
>> On Fri, Oct 3, 2008 at 10:21 AM, Andrew Stewart <
>> [EMAIL PROTECTED]> wrote:
>>
>>> Hi
>>> I've had a "very" quick look at what your trying to do, and here's the
>>> problem. I don't see a reason why this can't be achieved, although we don't
>>> currently support it - to add support you'd have to do something like below:
>>>
>>> Modify the convention class to hold your convention and create a class
>>> that can perform your mapping automatically, and inject it into AutoMapper
>>> as below:
>>>
>>>> i        public AutoMapper(Conventions conventions)
>>>>
>>>         {
>>>>
>>>             _mappingRules = new List<IAutoMapper>
>>>>
>>>                                 {
>>>>
>>>                                     new AutoMapIdentity(conventions),
>>>>
>>>                                     new AutoMapVersion(conventions),
>>>>
>>>                                     new AutoMapColumn(conventions),
>>>
>>>                                        new
>>> AutoMapComponent(conventions),
>>>
>>>>                                     new AutoMapManyToOne(),
>>>>
>>>                                     new AutoMapOneToMany(),
>>>>
>>>                                 };
>>>>
>>>         }
>>>
>>>
>>> You'd then have to modify create the AutoMapComponent class which will
>>> implement the logic to automapping logic for a component. Which is basically
>>> a class that implments IAutoMapper, you see examples in any of the above
>>> classes. Hope that helps, if you manage to achieve it, please send me a
>>> patch and i'll get it put into the trunk.
>>>
>>> Cheers
>>>
>>> Andy
>>>
>>> On Fri, Oct 3, 2008 at 8:16 AM, Gabriel Schenker <[EMAIL PROTECTED]>wrote:
>>>
>>>> I have now a working version with (code snippet...)
>>>>
>>>>
>>>> .ForTypesThatDeriveFrom<Person>(map=>map.Component<Address>(t=>t.Address,
>>>>                     c=>
>>>>                         {
>>>>                             c.Map(p => p.Line1);
>>>>                             c.Map(p => p.Line2);
>>>>                             c.Map(p => p.PostalCode);
>>>>                             c.Map(p => p.City);
>>>>                             c.References(p => p.Country);
>>>>                         }))
>>>>
>>>> but since I have many different value objects this cannot be the
>>>> solution! I don't want to manually define all my mappings of value objects
>>>>
>>>> I wonder if it is not possible to define a convention for the mapping of
>>>> value objects? Something like
>>>>
>>>> AutoPersistenceModel
>>>>         .MapEntitiesFromAssemblyOf<Person>()
>>>>         *.WithConvention(c => c.MapAsComponent = type =>
>>>> IsValueObject(type))*
>>>>
>>>> where the function *IsValueObject(...) *is a user defined function...
>>>>
>>>> would this be possible?
>>>>
>>>>
>>>>  On Thu, Oct 2, 2008 at 11:37 PM, Andrew Stewart <
>>>> [EMAIL PROTECTED]> wrote:
>>>>
>>>>> Hi Gabriel
>>>>> To be honest mate, no idea- as I've never actually done it with the
>>>>> normal fluent-nhibernate.
>>>>>
>>>>> However if fluent-nhibernate supports it then AutoMapper supports it.
>>>>> Basically AutoPersitenceModel will map out as much of your model as it can
>>>>> figure out by it self then it's down to you to provide the extra's. To
>>>>> attempt to point you in the write direction it should be something like 
>>>>> the
>>>>> below:
>>>>>
>>>>> AutopersistenceModel
>>>>> .MapEntitiesFromAssembly<EntityName>()
>>>>> .Where( t => t.Namespace=="YourNamespace")
>>>>> .ForTypesDerivedFromType<Person>( map =>
>>>>> {
>>>>> /// Normal Fluent nibernate code goes here.
>>>>> })
>>>>> .Configure();
>>>>>
>>>>> This is all from memory, so it's probably slightly off. I'll be in work
>>>>> in the morning and can probably send you a more accurate example then.
>>>>>
>>>>> Good luck, let me know how you get on.
>>>>>
>>>>> Andy
>>>>>
>>>>> On Thu, Oct 2, 2008 at 10:13 PM, Gabriel Schenker <
>>>>> [EMAIL PROTECTED]> wrote:
>>>>>
>>>>>>
>>>>>> How do I configure my AutoPersistenceModel when using components? E.g
>>>>>>
>>>>>> Person-->Address
>>>>>>
>>>>>> where Person is an entity and Address is a value object (=component)?
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> =================
>>>>> I-nnovate Software - Bespoke Software Development, uk wirral.
>>>>> http://www.i-nnovate.net
>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>> --
>>> =================
>>> I-nnovate Software - Bespoke Software Development, uk wirral.
>>> http://www.i-nnovate.net
>>>
>>>
>>>
>>
>> >>
>>
>
>
> --
> =================
> I-nnovate Software - Bespoke Software Development, uk wirral.
> http://www.i-nnovate.net
>



-- 
=================
I-nnovate Software - Bespoke Software Development, uk wirral.
http://www.i-nnovate.net

--~--~---------~--~----~------------~-------~--~----~
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 [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/fluent-nhibernate?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to