FluentNHibernate convention issue

.NET
1

This should be a quick one for you guys.

Here’s mt entity:

using System;
using System.Collections.Generic;
using System.Linq;
namespace Venue.Domain
{
    using Venue.Infrastructure.Domain;
    public class Forum : Entity 
    {
        private IList<Forum> children = new List<Forum>();
        private IList<Moderator> moderators = new List<Moderator>();
        private IList<Post> posts = new List<Post>();
        public virtual int Sequence { get; set; }
        [Signature]
        public virtual string Title { get; set; }
        public virtual string Description { get; set; }
        public virtual bool Moderated { get; set; }
        public virtual bool Enabled { get; set; }
        public virtual bool Visible { get; set; }
        public virtual IEnumerable<Forum> Children
        {
            get { return children; }
        }
        public virtual IEnumerable<Moderator> Moderators
        {
            get { return moderators; }
        }
        public virtual IEnumerable<Post> Posts
        {
            get { return posts; }
        }
        public virtual void AddChild(Forum child)
        {
            if (!children.Contains(child)) children.Add(child);
        }
        public virtual Forum FindChild(Func<Forum, bool> predicate)
        {
            return children.Single(predicate);
        }
        public virtual void RemoveChild(Forum child)
        {
            if (children.Contains(child)) children.Remove(child);
        }
        public virtual void AddModerator(Moderator moderator)
        {
            if (!moderators.Contains(moderator)) moderators.Add(moderator);
        }
        public virtual Moderator FindModerator(Func<Moderator, bool> predicate)
        {
            return moderators.Single(predicate);
        }
        public virtual void RemoveModerator(Moderator moderator)
        {
            if (moderators.Contains(moderator)) moderators.Remove(moderator);
        }
        public virtual void AddPost(Post post)
        {
            if (!posts.Contains(post)) posts.Add(post);
        }
        public virtual Post FindPost(Func<Post, bool> predicate)
        {
            return posts.Single(predicate);
        }
        public virtual void RemovePost(Post post)
        {
            if (posts.Contains(post)) posts.Remove(post);
        }
    }
}

Here’s my class map:

using FluentNHibernate.Mapping;
namespace Venue.Persistence.Mapping
{
    using Venue.Domain;
    public class ForumMap : ClassMap<Forum>
    {
        public ForumMap()
        {
            Id(x => x.Id);
            Map(x => x.Sequence);
            Map(x => x.Title);
            Map(x => x.Description);
            Map(x => x.Moderated);
            Map(x => x.Enabled);
            Map(x => x.Visible);
            References<Forum>(x => x.Children);
            References<Moderator>(x => x.Moderators);
            References<Post>(x => x.Posts);
        }
    }
}

And here’s my convention:

using FluentNHibernate.Conventions;
using FluentNHibernate.Conventions.Instances;
namespace Venue.Persistence.Mapping.Conventions
{
    public class ReferenceConvention : IReferenceConvention
    {
        public void Apply(IManyToOneInstance instance)
        {
            instance.Column(instance.Property.Name + "Id");
        }
    }
}

I get the following message:

Could not find a setter for property Children …

Ok, so tell me what to change.

2

Because you are not defining how the Children property should be set, it expects the property to have a setter. You can change this using this line:

HasMany<Forum>(x => x.Children).AsBag().Access.CamelCaseField

IIRC :slight_smile: You’ll want to check the CamelCaseField part

3

aha…