How to persist metadata

C#
using System;
using System.Collections.Generic;
using System.Text;
using DevExpress.Xpo;
using DevExpress.Xpo.Metadata;

namespace PersistentMetadata {
    [NonPersistent]   
    public class MyBaseObject : XPObject {
        public MyBaseObject(Session session, XPClassInfo classInfo) : base(session, classInfo) { }
    }

    public abstract class PersistentTypeInfo : XPObject {
        public PersistentTypeInfo(Session session) : base(session) { }

        string _Name;
        public string Name {
            get { return _Name; }
            set { SetPropertyValue("Name", ref _Name, value); }
        }

        [Association]
        public XPCollection<PersistentAttributeInfo> TypeAttributes { get { return GetCollection<PersistentAttributeInfo>("TypeAttributes"); } }

        protected void CreateAttributes(XPTypeInfo ti) {
            foreach(PersistentAttributeInfo a in TypeAttributes) {
                ti.AddAttribute(a.Create());
            }
        }
    }

    public class PersistentClassInfo : PersistentTypeInfo {
        public static void FillDictionary(XPDictionary dictionary, ICollection<PersistentClassInfo> data) {
            foreach(PersistentClassInfo twc in data) {
                twc.CreateClass(dictionary);
            }
            foreach(PersistentClassInfo twc in data) {
                twc.CreateMembers(dictionary);
            }
        }

        public const string AssemblyName = "";

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

        protected virtual Type GetDefaultBaseClass() {
            return typeof(MyBaseObject);
        }

        public XPClassInfo CreateClass(XPDictionary dictionary) {
            XPClassInfo result = dictionary.QueryClassInfo(AssemblyName, Name);
            if(result == null) {
                XPClassInfo baseClassInfo;
                if(BaseClass != null)
                    baseClassInfo = BaseClass.CreateClass(dictionary);
                else
                    baseClassInfo = dictionary.GetClassInfo(GetDefaultBaseClass());
                result = dictionary.CreateClass(baseClassInfo, Name);
                CreateAttributes(result);
            }
            return result;
        }

        void CreateMembers(XPDictionary dictionary) {
            XPClassInfo ci = dictionary.GetClassInfo(AssemblyName, Name);
            foreach(PersistentMemberInfo mi in OwnMembers) {
                mi.CreateMember(ci);
            }
        }

        PersistentClassInfo _BaseClass;
        public PersistentClassInfo BaseClass {
            get { return _BaseClass; }
            set { SetPropertyValue("BaseClass", ref _BaseClass, value); }
        }

        [Association]
        public XPCollection<PersistentMemberInfo> OwnMembers { get { return GetCollection<PersistentMemberInfo>("OwnMembers"); } }
    }
    public abstract class PersistentMemberInfo : PersistentTypeInfo {
        public PersistentMemberInfo(Session session) : base(session) { }

        internal XPMemberInfo CreateMember(XPClassInfo owner) {
            XPMemberInfo result = owner.FindMember(Name);
            if(result == null)
                result = CreateMemberCore(owner);
            CreateAttributes(result);
            return result;
        }

        protected abstract XPMemberInfo CreateMemberCore(XPClassInfo owner);

        PersistentClassInfo _Owner;
        [Association]
        public PersistentClassInfo Owner {
            get { return _Owner; }
            set { SetPropertyValue("Owner", ref _Owner, value); }
        }
    }

    public class PersistentReferenceMemberInfo : PersistentMemberInfo {
        public PersistentReferenceMemberInfo(Session session) : base(session) { }

        PersistentClassInfo _ReferenceType;
        public PersistentClassInfo ReferenceType {
            get { return _ReferenceType; }
            set { SetPropertyValue("ReferenceType", ref _ReferenceType, value); }
        }

        protected override XPMemberInfo CreateMemberCore(XPClassInfo owner) {
            XPMemberInfo member = owner.CreateMember(Name, ReferenceType.CreateClass(owner.Dictionary));
            return member;
        }
    }

    public class PersistentCollectionMemberInfo : PersistentMemberInfo {
        public PersistentCollectionMemberInfo(Session session) : base(session) { }

        protected override XPMemberInfo CreateMemberCore(XPClassInfo owner) {
            return owner.CreateMember(Name, typeof(XPCollection), true);
        }
    }

    public class PersistentCoreTypeMemberInfo : PersistentMemberInfo {
        public PersistentCoreTypeMemberInfo(Session session) : base(session) { }

        string _TypeName;
        public string TypeName {
            get { return _TypeName; }
            set { SetPropertyValue("TypeName", ref _TypeName, value); }
        }

        protected override XPMemberInfo CreateMemberCore(XPClassInfo owner) {
            return owner.CreateMember(Name, Type.GetType(TypeName, true));
        }
    }

    public abstract class PersistentAttributeInfo : XPObject {
        public PersistentAttributeInfo(Session session) : base(session) { }

        public abstract Attribute Create();
        
        PersistentTypeInfo _Owner;
        [Association]
        public PersistentTypeInfo Owner {
            get { return _Owner; }
            set { SetPropertyValue("Owner", ref _Owner, value); }
        }
    }

    public class PersistentAssociationAttribute : PersistentAttributeInfo {
        public PersistentAssociationAttribute(Session session) : base(session) { }

        string _an;
        public string AssociationName { get { return _an; } set { SetPropertyValue("AssociationName", ref _an, value); } }

        string _ean;
        public string ElementAssemblyName { get { return _ean; } set { SetPropertyValue("ElementAssemblyName", ref _ean, value); } }

        string _etn;
        public string ElementTypeName { get { return _etn; } set { SetPropertyValue("ElementTypeName", ref _etn, value); } }

        public override Attribute Create() {
            return new AssociationAttribute(AssociationName, ElementAssemblyName, ElementTypeName);
        }
    }
}

Visual Basic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports DevExpress.Xpo
Imports DevExpress.Xpo.Metadata

Namespace PersistentMetadata
    <NonPersistent> _
    Public Class MyBaseObject
        Inherits XPObject

        Public Sub New(ByVal session As Session, ByVal classInfo As XPClassInfo)
            MyBase.New(session, classInfo)
        End Sub
    End Class

    Public MustInherit Class PersistentTypeInfo
        Inherits XPObject

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Private _Name As String
        Public Property Name() As String
            Get
                Return _Name
            End Get
            Set(ByVal value As String)
                SetPropertyValue("Name", _Name, value)
            End Set
        End Property

        <Association> _
        Public ReadOnly Property TypeAttributes() As XPCollection(Of PersistentAttributeInfo)
            Get
                Return GetCollection(Of PersistentAttributeInfo)("TypeAttributes")
            End Get
        End Property

        Protected Sub CreateAttributes(ByVal ti As XPTypeInfo)
            For Each a As PersistentAttributeInfo In TypeAttributes
                ti.AddAttribute(a.Create())
            Next a
        End Sub
    End Class

    Public Class PersistentClassInfo
        Inherits PersistentTypeInfo

        Public Shared Sub FillDictionary(ByVal dictionary As XPDictionary, ByVal data As ICollection(Of PersistentClassInfo))
            For Each twc As PersistentClassInfo In data
                twc.CreateClass(dictionary)
            Next twc
            For Each twc As PersistentClassInfo In data
                twc.CreateMembers(dictionary)
            Next twc
        End Sub

        Public Const AssemblyName As String = ""

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Protected Overridable Function GetDefaultBaseClass() As Type
            Return GetType(MyBaseObject)
        End Function

        Public Function CreateClass(ByVal dictionary As XPDictionary) As XPClassInfo
            Dim result As XPClassInfo = dictionary.QueryClassInfo(AssemblyName, Name)
            If result Is Nothing Then
                Dim baseClassInfo As XPClassInfo
                If BaseClass IsNot Nothing Then
                    baseClassInfo = BaseClass.CreateClass(dictionary)
                Else
                    baseClassInfo = dictionary.GetClassInfo(GetDefaultBaseClass())
                End If
                result = dictionary.CreateClass(baseClassInfo, Name)
                CreateAttributes(result)
            End If
            Return result
        End Function

        Private Sub CreateMembers(ByVal dictionary As XPDictionary)
            Dim ci As XPClassInfo = dictionary.GetClassInfo(AssemblyName, Name)
            For Each mi As PersistentMemberInfo In OwnMembers
                mi.CreateMember(ci)
            Next mi
        End Sub

        Private _BaseClass As PersistentClassInfo
        Public Property BaseClass() As PersistentClassInfo
            Get
                Return _BaseClass
            End Get
            Set(ByVal value As PersistentClassInfo)
                SetPropertyValue("BaseClass", _BaseClass, value)
            End Set
        End Property

        <Association> _
        Public ReadOnly Property OwnMembers() As XPCollection(Of PersistentMemberInfo)
            Get
                Return GetCollection(Of PersistentMemberInfo)("OwnMembers")
            End Get
        End Property
    End Class
    Public MustInherit Class PersistentMemberInfo
        Inherits PersistentTypeInfo

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Friend Function CreateMember(ByVal owner As XPClassInfo) As XPMemberInfo
            Dim result As XPMemberInfo = owner.FindMember(Name)
            If result Is Nothing Then
                result = CreateMemberCore(owner)
            End If
            CreateAttributes(result)
            Return result
        End Function

        Protected MustOverride Function CreateMemberCore(ByVal owner As XPClassInfo) As XPMemberInfo

        Private _Owner As PersistentClassInfo
        <Association> _
        Public Property Owner() As PersistentClassInfo
            Get
                Return _Owner
            End Get
            Set(ByVal value As PersistentClassInfo)
                SetPropertyValue("Owner", _Owner, value)
            End Set
        End Property
    End Class

    Public Class PersistentReferenceMemberInfo
        Inherits PersistentMemberInfo

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Private _ReferenceType As PersistentClassInfo
        Public Property ReferenceType() As PersistentClassInfo
            Get
                Return _ReferenceType
            End Get
            Set(ByVal value As PersistentClassInfo)
                SetPropertyValue("ReferenceType", _ReferenceType, value)
            End Set
        End Property

        Protected Overrides Function CreateMemberCore(ByVal owner As XPClassInfo) As XPMemberInfo
            Dim member As XPMemberInfo = owner.CreateMember(Name, ReferenceType.CreateClass(owner.Dictionary))
            Return member
        End Function
    End Class

    Public Class PersistentCollectionMemberInfo
        Inherits PersistentMemberInfo

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Protected Overrides Function CreateMemberCore(ByVal owner As XPClassInfo) As XPMemberInfo
            Return owner.CreateMember(Name, GetType(XPCollection), True)
        End Function
    End Class

    Public Class PersistentCoreTypeMemberInfo
        Inherits PersistentMemberInfo

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Private _TypeName As String
        Public Property TypeName() As String
            Get
                Return _TypeName
            End Get
            Set(ByVal value As String)
                SetPropertyValue("TypeName", _TypeName, value)
            End Set
        End Property

        Protected Overrides Function CreateMemberCore(ByVal owner As XPClassInfo) As XPMemberInfo
            Return owner.CreateMember(Name, Type.GetType(TypeName, True))
        End Function
    End Class

    Public MustInherit Class PersistentAttributeInfo
        Inherits XPObject

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Public MustOverride Function Create() As Attribute

        Private _Owner As PersistentTypeInfo
        <Association> _
        Public Property Owner() As PersistentTypeInfo
            Get
                Return _Owner
            End Get
            Set(ByVal value As PersistentTypeInfo)
                SetPropertyValue("Owner", _Owner, value)
            End Set
        End Property
    End Class

    Public Class PersistentAssociationAttribute
        Inherits PersistentAttributeInfo

        Public Sub New(ByVal session As Session)
            MyBase.New(session)
        End Sub

        Private _an As String
        Public Property AssociationName() As String
            Get
                Return _an
            End Get
            Set(ByVal value As String)
                SetPropertyValue("AssociationName", _an, value)
            End Set
        End Property

        Private _ean As String
        Public Property ElementAssemblyName() As String
            Get
                Return _ean
            End Get
            Set(ByVal value As String)
                SetPropertyValue("ElementAssemblyName", _ean, value)
            End Set
        End Property

        Private _etn As String
        Public Property ElementTypeName() As String
            Get
                Return _etn
            End Get
            Set(ByVal value As String)
                SetPropertyValue("ElementTypeName", _etn, value)
            End Set
        End Property

        Public Overrides Function Create() As Attribute
            Return New AssociationAttribute(AssociationName, ElementAssemblyName, ElementTypeName)
        End Function
    End Class
End Namespace

C#
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using DevExpress.Xpo;
using DevExpress.Xpo.Metadata;
using DevExpress.Xpo.DB;
using System.Collections;

namespace PersistentMetadata {
    class Program {
        static void Main(string[] args) {
            new PersistentMetadataExample().Execute();
        }
    }    

    public class PersistentMetadataExample {
        public void Execute() {
            InitDataLayers();
            CreateMetadata();
            CreateDatabaseAndDefaultData();
            LoadData();
        }

        IDataLayer metadataStorage, dataStorage;

        void InitDataLayers() {
            string metadataFileName = "Metadata.xml";
            string dataFileName = "Data.mdb";

            if(File.Exists(metadataFileName)) File.Delete(metadataFileName);
            if(File.Exists(dataFileName)) File.Delete(dataFileName);

            metadataStorage = XpoDefault.GetDataLayer(InMemoryDataStore.GetConnectionString(metadataFileName), AutoCreateOption.DatabaseAndSchema);
            dataStorage = XpoDefault.GetDataLayer(AccessConnectionProvider.GetConnectionString(dataFileName), AutoCreateOption.DatabaseAndSchema);
        }

        void CreateMetadata() {
            using(UnitOfWork uof = new UnitOfWork(metadataStorage)) {
                PersistentClassInfo classCustomer = new PersistentClassInfo(uof);
                classCustomer.Name = "Customer";

                PersistentCoreTypeMemberInfo propFullName = new PersistentCoreTypeMemberInfo(uof);
                propFullName.Name = "FullName";
                propFullName.TypeName = typeof(string).FullName;
                classCustomer.OwnMembers.Add(propFullName);

                PersistentCollectionMemberInfo propOrders = new PersistentCollectionMemberInfo(uof);
                propOrders.Name = "Orders";
                classCustomer.OwnMembers.Add(propOrders);

                PersistentAssociationAttribute attrCustomerOrders = new PersistentAssociationAttribute(uof);
                attrCustomerOrders.ElementTypeName = "Order";
                propOrders.TypeAttributes.Add(attrCustomerOrders);

                PersistentClassInfo classOrder = new PersistentClassInfo(uof);
                classOrder.Name = "Order";

                PersistentCoreTypeMemberInfo propOrderDate = new PersistentCoreTypeMemberInfo(uof);
                propOrderDate.Name = "OrderDate";
                propOrderDate.TypeName = typeof(DateTime).FullName;
                classOrder.OwnMembers.Add(propOrderDate);

                PersistentReferenceMemberInfo propCustomer = new PersistentReferenceMemberInfo(uof);
                propCustomer.Name = "Customer";
                propCustomer.ReferenceType = classCustomer;
                classOrder.OwnMembers.Add(propCustomer);

                PersistentAssociationAttribute attrOrdersCustomer = new PersistentAssociationAttribute(uof);
                propCustomer.TypeAttributes.Add(attrOrdersCustomer);

                uof.CommitChanges();
            }
        }

        void InitDataDictionary(UnitOfWork dataSession) {
            using(UnitOfWork metadataSession = new UnitOfWork(metadataStorage)) {
                XPCollection<PersistentClassInfo> classes = new XPCollection<PersistentClassInfo>(metadataSession);
                PersistentClassInfo.FillDictionary(dataSession.Dictionary, classes);
            }
        }

        readonly int OrderCount = 1;
        readonly DateTime OrderDate = DateTime.Today;

        void CreateDatabaseAndDefaultData() {
            using(UnitOfWork dataSession = new UnitOfWork(dataStorage)) {
                InitDataDictionary(dataSession);
                dataSession.UpdateSchema(dataSession.GetClassInfo(null, "Customer"), dataSession.GetClassInfo(null, "Order"));

                XPClassInfo classCustomer = dataSession.GetClassInfo("", "Customer");
                XPBaseObject customer = (XPBaseObject)classCustomer.CreateNewObject(dataSession);
                customer.SetMemberValue("FullName", "John Doe");

                for(int i = 0; i < OrderCount; i++) {
                    XPClassInfo classOrder = dataSession.GetClassInfo("", "Order");
                    XPBaseObject order = (XPBaseObject)classOrder.CreateNewObject(dataSession);
                    order.SetMemberValue("OrderDate", OrderDate);
                    order.SetMemberValue("Customer", customer);
                }
                dataSession.CommitChanges();
            }
        }

        void LoadData() {
            using(UnitOfWork dataSession = new UnitOfWork(dataStorage)) {
                InitDataDictionary(dataSession);

                XPClassInfo classCustomer = dataSession.GetClassInfo("", "Customer");
                XPBaseObject customer = (XPBaseObject)dataSession.FindObject(classCustomer, null);
                IList orders = (IList)customer.GetMemberValue("Orders");
            }
        }
    }
}

Visual Basic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.IO
Imports DevExpress.Xpo
Imports DevExpress.Xpo.Metadata
Imports DevExpress.Xpo.DB
Imports System.Collections

Namespace PersistentMetadata
    Friend Class Program
        Shared Sub Main(ByVal args() As String)
            CType(New PersistentMetadataExample(), PersistentMetadataExample).Execute()
        End Sub
    End Class

    Public Class PersistentMetadataExample
        Public Sub Execute()
            InitDataLayers()
            CreateMetadata()
            CreateDatabaseAndDefaultData()
            LoadData()
        End Sub

        Private metadataStorage, dataStorage As IDataLayer

        Private Sub InitDataLayers()
            Dim metadataFileName As String = "Metadata.xml"
            Dim dataFileName As String = "Data.mdb"

            If File.Exists(metadataFileName) Then
                File.Delete(metadataFileName)
            End If
            If File.Exists(dataFileName) Then
                File.Delete(dataFileName)
            End If

            metadataStorage = XpoDefault.GetDataLayer(InMemoryDataStore.GetConnectionString(metadataFileName), AutoCreateOption.DatabaseAndSchema)
            dataStorage = XpoDefault.GetDataLayer(AccessConnectionProvider.GetConnectionString(dataFileName), AutoCreateOption.DatabaseAndSchema)
        End Sub

        Private Sub CreateMetadata()
            Using uof As New UnitOfWork(metadataStorage)
                Dim classCustomer As New PersistentClassInfo(uof)
                classCustomer.Name = "Customer"

                Dim propFullName As New PersistentCoreTypeMemberInfo(uof)
                propFullName.Name = "FullName"
                propFullName.TypeName = GetType(String).FullName
                classCustomer.OwnMembers.Add(propFullName)

                Dim propOrders As New PersistentCollectionMemberInfo(uof)
                propOrders.Name = "Orders"
                classCustomer.OwnMembers.Add(propOrders)

                Dim attrCustomerOrders As New PersistentAssociationAttribute(uof)
                attrCustomerOrders.ElementTypeName = "Order"
                propOrders.TypeAttributes.Add(attrCustomerOrders)

                Dim classOrder As New PersistentClassInfo(uof)
                classOrder.Name = "Order"

                Dim propOrderDate As New PersistentCoreTypeMemberInfo(uof)
                propOrderDate.Name = "OrderDate"
                propOrderDate.TypeName = GetType(Date).FullName
                classOrder.OwnMembers.Add(propOrderDate)

                Dim propCustomer As New PersistentReferenceMemberInfo(uof)
                propCustomer.Name = "Customer"
                propCustomer.ReferenceType = classCustomer
                classOrder.OwnMembers.Add(propCustomer)

                Dim attrOrdersCustomer As New PersistentAssociationAttribute(uof)
                propCustomer.TypeAttributes.Add(attrOrdersCustomer)

                uof.CommitChanges()
            End Using
        End Sub

        Private Sub InitDataDictionary(ByVal dataSession As UnitOfWork)
            Using metadataSession As New UnitOfWork(metadataStorage)
                Dim classes As New XPCollection(Of PersistentClassInfo)(metadataSession)
                PersistentClassInfo.FillDictionary(dataSession.Dictionary, classes)
            End Using
        End Sub

        Private ReadOnly OrderCount As Integer = 1
        Private ReadOnly OrderDate As Date = Date.Today

        Private Sub CreateDatabaseAndDefaultData()
            Using dataSession As New UnitOfWork(dataStorage)
                InitDataDictionary(dataSession)
                dataSession.UpdateSchema(dataSession.GetClassInfo(Nothing, "Customer"), dataSession.GetClassInfo(Nothing, "Order"))

                Dim classCustomer As XPClassInfo = dataSession.GetClassInfo("", "Customer")
                Dim customer As XPBaseObject = CType(classCustomer.CreateNewObject(dataSession), XPBaseObject)
                customer.SetMemberValue("FullName", "John Doe")

                For i As Integer = 0 To OrderCount - 1
                    Dim classOrder As XPClassInfo = dataSession.GetClassInfo("", "Order")
                    Dim order As XPBaseObject = CType(classOrder.CreateNewObject(dataSession), XPBaseObject)
                    order.SetMemberValue("OrderDate", OrderDate)
                    order.SetMemberValue("Customer", customer)
                Next i
                dataSession.CommitChanges()
            End Using
        End Sub

        Private Sub LoadData()
            Using dataSession As New UnitOfWork(dataStorage)
                InitDataDictionary(dataSession)

                Dim classCustomer As XPClassInfo = dataSession.GetClassInfo("", "Customer")
                Dim customer As XPBaseObject = CType(dataSession.FindObject(classCustomer, Nothing), XPBaseObject)
                Dim orders As IList = DirectCast(customer.GetMemberValue("Orders"), IList)
            End Using
        End Sub
    End Class
End Namespace