Question

I’ve a One to Many mapping.
An entity with a collection persisted on two table 1:N

This is the class and the mapping:

public class Test
    {
        public virtual string Id { get; set; }
        public virtual string Description { get; set; }
        public virtual IList<TestItem> Items { get; set; }

        public Test()
        {
            Items = new List<TestItem>();
        }
    }

    public class TestItem
    {
        public virtual string Id { get; set; }
        public virtual Test Test { get; set; }
        public virtual string ItemCode { get; set; }
        public virtual string ItemData { get; set; }
    }

    public class TestMap : ClassMapping<Test>
    {
        public TestMap()
        {
            Id(x => x.Id, m => m.Column("IDTest"));

            Bag(x => x.Items, c =>
            {
                c.Key(k =>
                {
                    k.NotNullable(true);
                    k.Column("IDTest");
                });
                c.Cascade(Cascade.DeleteOrphans);
                c.Lazy(CollectionLazy.NoLazy);
                c.Inverse(true);
            }, r => r.OneToMany(m =>
            {
                m.NotFound(NotFoundMode.Exception);
                m.Class(typeof(TestItem));
            }));
        }
    }

    public class TestItemMap : ClassMapping<TestItem>
    {
        public TestItemMap()
        {
            Id(x => x.Id, m => m.Column("IDTestItem"));

            ManyToOne(x => x.Test, m =>
            {
                m.Column("IDTest");
                m.NotNullable(false);
                m.Lazy(LazyRelation.NoLazy);
            });

            Property(x => x.ItemCode);
            Property(x => x.ItemData);
        }
    }

And this is the code.
If I remove the marked line I get the error.

var session = SessionFactory.OpenSession();

            using (var tr = session.BeginTransaction())
            {
                var test = new Test();
                test.Id = "T01";
                test.Description = "Desc TEST 01";

                session.SaveOrUpdate(test); // If Removed Get INSERT ERROR on TestItem

                var item = new TestItem { Id = "NEW01", ItemCode = "A", Test = test, ItemData = "New T01A" };
                test.Items.Add(item);
                session.SaveOrUpdate(item);

                session.SaveOrUpdate(test);

                tr.Commit();
            }

My question is:

Is this the best practice to persist a “one to many” relation ?

It is possible to use the code below and save all only saving the header Row (test) and automatically cascading all inserts on the child table??

var session = SessionFactory.OpenSession();

            using (var tr = session.BeginTransaction())
            {
                var test = new Test();
                test.Id = "T01";
                test.Description = "Desc TEST 01";

                //session.SaveOrUpdate(test); // If Removed Get INSERT ERROR on TestItem

                var item = new TestItem { Id = "NEW01", ItemCode = "A", Test = test, ItemData = "New T01A" };
                test.Items.Add(item);
                //session.SaveOrUpdate(item);

                session.SaveOrUpdate(test);

                tr.Commit();
            }

I suppose I need to change something on my mapping code but i do not undestand what!!!

Many days of work, googling, stackoverflowing but nothing change the result.

Thank you!!!

Answer 1

Q: Is this the best practice to persist a “one to many” relation ?

A: If you’re talking about a “composition” relationship, the cascading approach can be a good choice.

Q: It is possible to use the code below and save all only saving the header Row (test) and automatically cascading all inserts on the child table??

A: Yes it is possible. But your code should look like this:

public class TestMap : ClassMapping<Test>
{
    public TestMap()
    {
        Id(x => x.Id, m => m.Column("IDTest"));

        Bag(x => x.Items, c =>
        {
            c.Key(k =>
            {
                k.NotNullable(true);
                k.Column("IDTest");
            });
            c.Cascade(Cascade.All | Cascade.DeleteOrphans); //<- My suggestion
            c.Lazy(CollectionLazy.NoLazy);
            c.Inverse(true);
        }, r => r.OneToMany(m =>
        {
            m.NotFound(NotFoundMode.Exception);
            m.Class(typeof(TestItem));
        }));
    }
}