Save Objects to Database

• May 12, 2023
• 8 minutes to read

Common business tasks require additional logic before you store changes in a database. For example, you may need to get objects that are about to be saved and write additional information to them or save objects in a custom way.

In a Controller

Useful API

Members	Description
Methods:
IObjectSpace.CommitChanges	Saves all the changes made to the persistent objects belonging to the current Object Space to the database.
IObjectSpace.IsObjectToSave	Indicates whether the specified object has been added, deleted or modified, but not committed in the transaction currently in progress.
IObjectSpace.GetObjectsToSave	Returns a collection of persistent objects that will be saved when the current transaction is committed, including objects that will be saved in the parent transaction(s), optionally.
IObjectSpace.RemoveFromModifiedObjects	Removes the specified object from the list of objects to be committed.
Properties:
IObjectSpace.IsCommitting	Indicates whether the Object Space is currently committing the changes made to its object(s).
IObjectSpace.ModifiedObjects	Returns a collection of objects that have been created, modified or deleted after they were retrieved or committed.
Events:
IObjectSpace.Committing	Occurs before persistent objects are saved to the database.
IObjectSpace.Committed	Occurs after persistent object changes are stored in the database.
IObjectSpace.CustomCommitChanges	Replaces the default commit logic with a custom one.
IObjectSpace.ObjectSaving	Occurs before saving changes made to a specified persistent object to the database.
IObjectSpace.ObjectSaved	Occurs after saving changes made to a specified persistent object to the database.

XAF saves changes in a View in the following situations:

• The Save, Save and New, or Save and Close Action is executed.
• In a popup window, the Accept Action is executed and the DialogController.SaveOnAccept property is true.

In XAF WinForms applications, you can control if XAF automatically saves or rolls back changes when you change the current object or close a View. The ModificationsController.ModificationsHandlingMode property specifies this behavior.

Persist Changes in Code

To save changes in your code, call the IObjectSpace.CommitChanges method.

C#

using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Actions;

public class MyViewController : ObjectViewController<DetailView, Department> {
    public MyViewController() {
        var action = new SimpleAction(this, "Change Title and Save changes", DevExpress.Persistent.Base.PredefinedCategory.Save);
        action.Execute += Action_Execute;
    }
    private void Action_Execute(object sender, SimpleActionExecuteEventArgs e) {
        Department department = (Department)View.CurrentObject;
        department.Title = "New Title";
        this.ObjectSpace.CommitChanges();
    }
}

VB.NET

Imports DevExpress.ExpressApp
Imports DevExpress.ExpressApp.Actions

Public Class MyViewController
    Inherits ObjectViewController(Of DetailView, Department)
    Public Sub New()
        Dim action = New SimpleAction(Me, "Change Title and Save changes", DevExpress.Persistent.Base.PredefinedCategory.Save)
        AddHandler action.Execute, AddressOf Action_Execute
    End Sub
    Private Sub Action_Execute(ByVal sender As Object, ByVal e As SimpleActionExecuteEventArgs)
        Dim department As Department = CType(View.CurrentObject, Department)
        department.Title = "New Title"
        Me.ObjectSpace.CommitChanges()
    End Sub
End Class

Obtain Modified Objects

To write additional information to an object before saving it to a database, do this in the IObjectSpace.Committing event handler. The following code illustrates this. An Employee business object has the Notes property that stores audit information on a number of other objects that were changed in the current transaction.

C#

using DevExpress.ExpressApp;
using System.Collections;

public class MyViewController : ObjectViewController<DetailView, Employee> {
    protected override void OnActivated() {
        base.OnActivated();
        ObjectSpace.Committing += ObjectSpace_Committing;
    }
    void ObjectSpace_Committing(object sender, System.ComponentModel.CancelEventArgs e) {
        ICollection collection = ObjectSpace.GetObjectsToSave(false);
        Employee owner = (Employee)View.CurrentObject;
        owner.Notes = string.Format("{0};{1} objects changed", owner.Notes, collection.Count);
    }
}

VB.NET

Imports DevExpress.ExpressApp

Public Class MyViewController
    Inherits ObjectViewController(Of DetailView, Employee)
    Protected Overrides Sub OnActivated()
        MyBase.OnActivated()
        AddHandler ObjectSpace.Committing, AddressOf ObjectSpace_Committing
    End Sub
    Private Sub ObjectSpace_Committing(ByVal sender As Object, ByVal e As CancelEventArgs)
        Dim collection = ObjectSpace.GetObjectsToSave(False)
        Dim owner = CType(View.CurrentObject, Employee)
        owner.Notes = String.Format("{0};{1} objects changed", owner.Notes, collection.Count)
    End Sub
End Class

Process Saving Objects

It’s also possible to save changes in a custom way in the IObjectSpace.CustomCommitChanges event handler. To prevent the default logic to persist objects, handle the IObjectSpace.Committing event and call the IObjectSpace.RemoveFromModifiedObjects method to remove an object from being committed in the event handler.

The following code shows how to manually save child collection changes made in the parent Detail View:

C#

using DevExpress.ExpressApp;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using YourSolutionName.Module.BusinessObjects;

namespace YourSolutionName.Module.Controllers {
    public class MyViewController : ObjectViewController<DetailView, Parent> {
        List<Child> detailObjectsCache = new List<Child>();
        protected override void OnActivated() {
            base.OnActivated();
            ObjectSpace.CustomCommitChanges += ObjectSpace_CustomCommitChanges;
            ObjectSpace.Committing += ObjectSpace_Committing;
            ObjectSpace.Committed += ObjectSpace_Committed;
            ObjectSpace.Reloaded += ObjectSpace_Reloaded;
        }
        protected override void OnDeactivated() {
            ObjectSpace.CustomCommitChanges -= ObjectSpace_CustomCommitChanges;
            ObjectSpace.Committing -= ObjectSpace_Committing;
            ObjectSpace.Committed -= ObjectSpace_Committed;
            ObjectSpace.Reloaded -= ObjectSpace_Reloaded;
            base.OnDeactivated();
        }
        void ObjectSpace_Reloaded(object sender, EventArgs e) {
            detailObjectsCache.Clear();
        }
        void ObjectSpace_Committed(object sender, EventArgs e) {
            detailObjectsCache.Clear();
        }
        void ObjectSpace_Committing(object sender, CancelEventArgs e) {
            IObjectSpace os = (IObjectSpace)sender;
            for (int i = os.ModifiedObjects.Count - 1; i >= 0; i--) {
                object item = os.ModifiedObjects[i];
                if (typeof(Child).IsAssignableFrom(item.GetType())) {
                    detailObjectsCache.Add(item as Child);
                    os.RemoveFromModifiedObjects(item);
                }
            }
        }
        void ObjectSpace_CustomCommitChanges(object sender, HandledEventArgs e) {
            // Implement custom logic to save Detail objects here. 
            foreach (Child detailObject in detailObjectsCache) {
                //...  
            }
        }
    }
}

VB.NET

Imports DevExpress.ExpressApp
Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports YourSolutionName.Module.BusinessObjects

Namespace YourSolutionName.Module.Controllers
    Public Class MyViewController
        Inherits ObjectViewController(Of DetailView, Parent)

        Private detailObjectsCache As List(Of Child) = New List(Of Child)()

        Protected Overrides Sub OnActivated()
            MyBase.OnActivated()
            AddHandler ObjectSpace.CustomCommitChanges, AddressOf ObjectSpace_CustomCommitChanges
            AddHandler ObjectSpace.Committing, AddressOf ObjectSpace_Committing
            AddHandler ObjectSpace.Committed, AddressOf ObjectSpace_Committed
            AddHandler ObjectSpace.Reloaded, AddressOf ObjectSpace_Reloaded
        End Sub

        Protected Overrides Sub OnDeactivated()
            RemoveHandler ObjectSpace.CustomCommitChanges, AddressOf ObjectSpace_CustomCommitChanges
            RemoveHandler ObjectSpace.Committing, AddressOf ObjectSpace_Committing
            RemoveHandler ObjectSpace.Committed, AddressOf ObjectSpace_Committed
            RemoveHandler ObjectSpace.Reloaded, AddressOf ObjectSpace_Reloaded
            MyBase.OnDeactivated()
        End Sub

        Private Sub ObjectSpace_Reloaded(ByVal sender As Object, ByVal e As EventArgs)
            detailObjectsCache.Clear()
        End Sub

        Private Sub ObjectSpace_Committed(ByVal sender As Object, ByVal e As EventArgs)
            detailObjectsCache.Clear()
        End Sub

        Private Sub ObjectSpace_Committing(ByVal sender As Object, ByVal e As CancelEventArgs)
            Dim os As IObjectSpace = CType(sender, IObjectSpace)

            For i As Integer = os.ModifiedObjects.Count - 1 To 0
                Dim item As Object = os.ModifiedObjects(i)

                If GetType(Child).IsAssignableFrom(item.[GetType]()) Then
                    detailObjectsCache.Add(TryCast(item, Child))
                    os.RemoveFromModifiedObjects(item)
                End If
            Next
        End Sub

        Private Sub ObjectSpace_CustomCommitChanges(ByVal sender As Object, ByVal e As HandledEventArgs)
            ' Implement custom logic to save Detail objects here.  
            For Each detailObject As Child In detailObjectsCache
            Next
        End Sub
    End Class
End Namespace

Note

We recommend that you handle these events only for root Views. Nested Views use their parent View’s Object Space. As a result, the events are handled several times. You can specify the controller scope as described at Define the Scope of Controllers and Actions. Alternatively, you can check properties like View.IsRoot and IObjectSpace.Owner in event handlers to determine for what View a handler is invoked.

In a Data Model (in an XPO Business Class)

In XPO business objects, override the OnSaving method of a business class to perform additional logic when you save data. A common task is to generate an auto-incremented number or a sequence. Find a sample for how to implement this at XAF - How to generate a sequential number for a persistent object within a database transaction with Entity Framework Core.

Be aware of the following specifics when you implement custom logic with Integrated Mode or Middle Tier Security:

• The OnSaving and OnDeleting methods of a business class can be called multiple times because Integrated Mode and Middle Tier Security use more than one Session/DbContext object. If you implement custom logic in these methods, check whether a new value is already assigned to a property. This helps you avoid incorrect results. The following article describes how to do this with XPO: XPO Best Practices.

• Detail Views do not display changes made to an object within a transaction (for example, an auto-generated sequential number for an XPO business object) even if you saved this object in a View. These changes are made on the server only and are not automatically passed to the client application. To show these changes, reload the object. If you want to reload the object on each Save operation, override the business class’s OnSaved method. The following example demonstrates how to override this method to reload an object on the client:

  C#

  using DevExpress.Persistent.BaseImpl;
  // ...
  public class DemoObject : BaseObject {
      // ...
      protected override void OnSaved() {
          base.OnSaved();
          // 0 is the default value
          if (Number == 0) {
              Session.Reload(this);
          }
      }
  }
  

  VB.NET

  Imports DevExpress.Persistent.BaseImpl
  ' ...
  Public Class DemoObject
      Inherits BaseObject
      ' ...
      Protected Overrides Sub OnSaved()
          MyBase.OnSaved()
          ' 0 is the default value
          If Number = 0 Then
              Session.Reload(Me)
          End If
      End Sub
  End Class
  

• The Session.DataLayer property is null in the secured Session. Instead of DataLayer, we recommend that you use the View.ObjectSpace property to query and change data from the database. This technique is also recommended for non-secure applications.

  If this recommendation does not apply to your scenario, use the Session.ObjectLayer property instead of DataLayer.

  You can also execute different code on the server and client depending on the DataLayer and ObjectLayer property values. The following example demonstrates how to do it:

  C#

  using DevExpress.ExpressApp.Security.ClientServer;
  using DevExpress.Persistent.BaseImpl;
  // ...
  public class DemoObject : BaseObject {
      // ...
      protected override void OnSaving() { 
          if(Session.DataLayer != null && !(Session.ObjectLayer is SecuredSessionObjectLayer)) { 
              // Server-side code
          } 
          else {  
              // Client-side code 
          } 
          base.OnSaving(); 
      }
  }
  

  VB.NET

  Imports DevExpress.ExpressApp.Security.ClientServer
  Imports DevExpress.Persistent.BaseImpl
  ' ...
  Public Class DemoObject
      Inherits BaseObject
      ' ...
      Protected Overrides Sub OnSaving()
          If Session.DataLayer IsNot Nothing AndAlso 
          Not (TypeOf Session.ObjectLayer Is SecuredSessionObjectLayer) Then
              ' Server-side code 
          Else
              ' Client-side code
          End If
          MyBase.OnSaving()
      End Sub
  End Class