DetailViewLayoutBuilders - Introduction

DetailViewLayoutBuilders are a way of defining DetailViews in code. They are a domain specific language (DSL) to build Views in code rather than using the ModelEditor. As always in Xenial.Framework there are several ways to define them and to tell XAF when to consume them. They are an addition to the ModelEditor based approach, because they operate below the differences layer (opens new window).

DetailViewLayoutBuilders are one of the many NonVisual Components of Xenial.Framework designed around best practices and working efficiently in a team, however there are several benefits for smaller teams and projects as well.

Installation

In your platform agnostic module (opens new window) install the Xenial.Framework (opens new window) package.

INFORMATION

By convention the platform agnostic module is usually named <Your Application>.Module. If you're unfamiliar with the Command Line Interface (cli) you can always use the Nuget package manager.

Whilst the Xenial.Framework can of course be used in platform specific modules, for the purposes of this documentation emphasis will be given to its use in the platform agnostic module of your project.

Usage

Xenial.Framework provides both a simple and advanced registration pattern for DetailViewLayoutBuilders as well as one specially optimized for use within ModelBuilders.

All the DetailViewLayoutBuilder examples in this documentation will be based upon the simple 'Person' business object in the code below.

using DevExpress.Persistent.Base;
using DevExpress.Xpo;

namespace MainDemo.Module.BusinessObjects
{
    [Persistent]
    [DefaultClassOptions]
    public class Person : XPObject
    {
        private string firstName;
        private string lastName;
        private string fullName;
        private string phone;
        private byte[] image;
        private string email;
        private Address address1;
        private Address address2;

        public Person(Session session) : base(session) { }

        public override void AfterConstruction()
        {
            base.AfterConstruction();
            Address1 = new Address(Session)
            {
                Person = this,
                Type = "Primary"
            };
            Address2 = new Address(Session)
            {
                Person = this,
                Type = "Secondary"
            };
        }

        [Persistent]
        public string FirstName
        {
            get => firstName;
            set => SetPropertyValue(nameof(FirstName), ref firstName, value);
        }

        [Persistent]
        public string LastName
        {
            get => lastName;
            set => SetPropertyValue(nameof(LastName), ref lastName, value);
        }

        [Persistent]
        public string FullName
        {
            get => fullName;
            set => SetPropertyValue(nameof(FullName), ref fullName, value);
        }

        [Persistent]
        public string Phone
        {
            get => phone;
            set => SetPropertyValue(nameof(Phone), ref phone, value);
        }

        [Persistent]
        public string Email
        {
            get => email;
            set => SetPropertyValue(nameof(Email), ref email, value);
        }

        [Persistent]
        public byte[] Image
        {
            get => image;
            set => SetPropertyValue(nameof(Image), ref image, value);
        }

        [Persistent]
        [ExpandObjectMembers(ExpandObjectMembers.InDetailView)]
        public Address Address1
        {
            get => address1;
            set => SetPropertyValue(nameof(Address1), ref address1, value);
        }

        [Persistent]
        [ExpandObjectMembers(ExpandObjectMembers.InDetailView)]
        public Address Address2
        {
            get => address2;
            set => SetPropertyValue(nameof(Address2), ref address2, value);
        }

        [Association("Person-Addresses")]
        [Aggregated]
        public XPCollection<Address> Addresses
        {
            get
            {
                return GetCollection<Address>(nameof(Addresses));
            }
        }
    }

    [Persistent]
    public class Address : XPObject
    {
        private Person person;
        private string type;
        private string street;
        private string city;
        private string stateProvince;
        private string zipPostal;
        private string country;

        public Address(Session session) : base(session) { }

        [Persistent]
        [Association("Person-Addresses")]
        public Person Person
        {
            get => person;
            set => SetPropertyValue(nameof(Person), ref person, value);
        }

        [Persistent]
        public string Type
        {
            get => type;
            set => SetPropertyValue(nameof(Type), ref type, value);
        }

        [Persistent]
        public string Street
        {
            get => street;
            set => SetPropertyValue(nameof(Street), ref street, value);
        }

        [Persistent]
        public string City
        {
            get => city;
            set => SetPropertyValue(nameof(City), ref city, value);
        }

        [Persistent]
        public string StateProvince
        {
            get => stateProvince;
            set => SetPropertyValue(nameof(StateProvince), ref stateProvince, value);
        }

        [Persistent]
        public string ZipPostal
        {
            get => zipPostal;
            set => SetPropertyValue(nameof(ZipPostal), ref zipPostal, value);
        }

        [Persistent]
        public string Country
        {
            get => country;
            set => SetPropertyValue(nameof(Country), ref country, value);
        }
    }
}

The standard default layout that would be produced by XAF is illustrated below;

The target layout that the code examples of LayoutBuilders in ensuing sections will aim to create is illustrated below;