How to: Perform CRUD Operations with Non-Persistent Objects

• Jan 11, 2024
• 7 minutes to read

This topic describes how to implement the create, read, update, and delete operations for non-persistent objects. This example uses ValueManager to access the storage of non-persistent objects.

1. Implement the following non-persistent class:

   C#

   using System;
   using System.ComponentModel;
   using DevExpress.ExpressApp.Data;
   using DevExpress.ExpressApp.DC;
   using DevExpress.Persistent.Base;
   // ...
   [DomainComponent, DefaultClassOptions]
   public class NonPersistentClass : INotifyPropertyChanged {
       private Int32 id;
       private String name;
       protected void RaisePropertyChanged(String propertyName) {
           if (PropertyChanged != null) {
               PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
           }
       }
       public NonPersistentClass(Int32 id, String name)
           : base() {
           this.id = id;
           this.name = name;
       }
       public NonPersistentClass()
           : this(0, "") {
       }
   
       [Key, Browsable(false)]
       public Int32 ID {
           get { return id; }
           set { id = value; }
       }
       public String Name {
           get { return name; }
           set {
               if (name != value) {
                   name = value;
                   RaisePropertyChanged(nameof(Name));
               }
           }
       }
       public event PropertyChangedEventHandler PropertyChanged;
   }
   

   VB.NET

   Imports DevExpress.ExpressApp.Data
   Imports DevExpress.ExpressApp.DC
   Imports DevExpress.Persistent.Base
   Imports System.ComponentModel
   ' ...
   <DomainComponent, DefaultClassOptions>
   Public Class NonPersistentClass
       Implements INotifyPropertyChanged
   
       Private _id As Int32
       Private _name As String
       Protected Sub RaisePropertyChanged(ByVal propertyName As String)
           RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
       End Sub
       Public Sub New(ByVal id As Int32, ByVal name As String)
           MyBase.New()
           Me._id = id
           Me._name = name
       End Sub
       Public Sub New()
           Me.New(0, "")
       End Sub
       <Browsable(False)>
       <Key>
       Public Property ID() As Int32
           Get
               Return _id
           End Get
           Set(ByVal value As Int32)
               _id = value
           End Set
       End Property
       Public Property Name() As String
           Get
               Return _name
           End Get
           Set(ByVal value As String)
               If _name <> value Then
                   _name = value
                   RaisePropertyChanged(NameOf(Name))
               End If
           End Set
       End Property
       Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
   End Class
   

2. Open the WinApplication.cs (WinApplication.vb), WebApplication.cs (WebApplication.vb), and/or BlazorApplication.cs file in a C#/VB Editor. Ensure that the NonPersistentObjectSpaceProvider is registered in the overridden CreateDefaultObjectSpaceProvider method (in addition to the existing XPObjectSpaceProvider or EFObjectSpaceProvider). The Solution Wizard adds this code automatically. Note that this code may be missing if you created your project in an older XAF version.

   C#

   protected override void CreateDefaultObjectSpaceProvider(CreateCustomObjectSpaceProviderEventArgs args) {
       // ...
       args.ObjectSpaceProviders.Add(new NonPersistentObjectSpaceProvider(TypesInfo, null));
   }
   

   VB.NET

   Protected Overrides Sub CreateDefaultObjectSpaceProvider(ByVal args As CreateCustomObjectSpaceProviderEventArgs)
       ' ...
       args.ObjectSpaceProviders.Add(New NonPersistentObjectSpaceProvider(TypesInfo, Nothing))
   End Sub
   

3. In a module project, access the NonPersistentObjectSpace and handle its events listed below.

   • NonPersistentObjectSpace.ObjectsGetting and NonPersistentObjectSpace.ObjectByKeyGetting - to provide objects that the UI requests;
   • BaseObjectSpace.Committing - to store a result of the Create and Delete operations in memory;

   The following code shows how to do this:

   C#

   using System;
   using System.Collections.Generic;
   using System.ComponentModel;
   using DevExpress.ExpressApp;
   using DevExpress.Persistent.Base;
   // ...
   public sealed partial class MyModule : ModuleBase {
       private static Dictionary<int, NonPersistentClass> ObjectsCache {
           get {
               var manager = ValueManager.GetValueManager<Dictionary<int, NonPersistentClass>>("NP");
               Dictionary<int, NonPersistentClass> objectsCache = (manager.CanManageValue) ? manager.Value : null;
               if(objectsCache == null) {
                   objectsCache = new Dictionary<int, NonPersistentClass>();
                   objectsCache.Add(0, new NonPersistentClass(0, "A"));
                   objectsCache.Add(1, new NonPersistentClass(1, "B"));
                   objectsCache.Add(2, new NonPersistentClass(2, "C"));
                   objectsCache.Add(3, new NonPersistentClass(3, "D"));
                   objectsCache.Add(4, new NonPersistentClass(4, "E"));
                   if(manager.CanManageValue) {
                       manager.Value = objectsCache;
                   }
               }
               return objectsCache;
           }
       }
       //...
       public override void Setup(XafApplication application) {
           base.Setup(application);
           application.SetupComplete += Application_SetupComplete;
       }
       private void Application_SetupComplete(object sender, EventArgs e) {
           Application.ObjectSpaceCreated += Application_ObjectSpaceCreated;
       }
       private void Application_ObjectSpaceCreated(object sender, ObjectSpaceCreatedEventArgs e) {
           NonPersistentObjectSpace nonPersistentObjectSpace = e.ObjectSpace as NonPersistentObjectSpace;
           if(nonPersistentObjectSpace != null) {
               nonPersistentObjectSpace.ObjectsGetting += NonPersistentObjectSpace_ObjectsGetting;
               nonPersistentObjectSpace.ObjectByKeyGetting += NonPersistentObjectSpace_ObjectByKeyGetting;
               nonPersistentObjectSpace.Committing += NonPersistentObjectSpace_Committing;
           }
       }
       private void NonPersistentObjectSpace_ObjectsGetting(Object sender, ObjectsGettingEventArgs e) {
           if(e.ObjectType == typeof(NonPersistentClass)) {
               IObjectSpace objectSpace = (IObjectSpace)sender;
               BindingList<NonPersistentClass> objects = new BindingList<NonPersistentClass>();
               objects.AllowNew = true;
               objects.AllowEdit = true;
               objects.AllowRemove = true;
               foreach(NonPersistentClass obj in ObjectsCache.Values) {
                   objects.Add(objectSpace.GetObject<NonPersistentClass>(obj));
               }
               e.Objects = objects;
           }
       }
       private void NonPersistentObjectSpace_ObjectByKeyGetting(object sender, ObjectByKeyGettingEventArgs e) {
           IObjectSpace objectSpace = (IObjectSpace)sender;
           if(e.ObjectType == typeof(NonPersistentClass)) {
               NonPersistentClass obj;
               if(ObjectsCache.TryGetValue((int)e.Key, out obj)) {
                   e.Object = objectSpace.GetObject(obj);
               }
           }
       }
       private void NonPersistentObjectSpace_Committing(Object sender, CancelEventArgs e) {
           IObjectSpace objectSpace = (IObjectSpace)sender;
           foreach(Object obj in objectSpace.ModifiedObjects) {
               NonPersistentClass myobj = obj as NonPersistentClass;
               if(obj != null) {
                   if(objectSpace.IsNewObject(obj)) {
                       int key = ObjectsCache.Count;
                       myobj.ID = key;
                       ObjectsCache.Add(key, myobj);
                   }
                   else if(objectSpace.IsDeletedObject(obj)) {
                       ObjectsCache.Remove(myobj.ID);
                   }
               }
           }
       }
   }
   

   VB.NET

   Imports System
   Imports System.Collections.Generic
   Imports System.ComponentModel
   Imports DevExpress.ExpressApp
   Imports DevExpress.Persistent.Base
   ' ...
   Public NotInheritable Partial Class MyModule
       Inherits ModuleBase
   
       Private Shared ReadOnly Property ObjectsCache() As Dictionary(Of Integer, NonPersistentClass)
           Get
               Dim manager As IValueManager(Of Dictionary(Of Integer, NonPersistentClass)) = 
                   ValueManager.GetValueManager(Of Dictionary(Of Integer, NonPersistentClass))("NP")
               Dim _objectsCache As Dictionary(Of Integer, NonPersistentClass) = If(manager.CanManageValue, manager.Value, Nothing)
               If _objectsCache Is Nothing Then
                   _objectsCache = New Dictionary(Of Integer, NonPersistentClass)()
                   _objectsCache.Add(0, New NonPersistentClass(0, "A"))
                   _objectsCache.Add(1, New NonPersistentClass(1, "B"))
                   _objectsCache.Add(2, New NonPersistentClass(2, "C"))
                   _objectsCache.Add(3, New NonPersistentClass(3, "D"))
                   _objectsCache.Add(4, New NonPersistentClass(4, "E"))
                   If manager.CanManageValue Then
                       manager.Value = _objectsCache
                   End If
               End If
               Return _objectsCache
           End Get
       End Property
       '...
       Public Overrides Sub Setup(ByVal application As XafApplication)
           MyBase.Setup(application)
           AddHandler application.SetupComplete, AddressOf Application_SetupComplete
       End Sub
       Private Sub Application_SetupComplete(ByVal sender As Object, ByVal e As EventArgs)
           AddHandler Application.ObjectSpaceCreated, AddressOf Application_ObjectSpaceCreated
       End Sub
       Private Sub Application_ObjectSpaceCreated(ByVal sender As Object, ByVal e As ObjectSpaceCreatedEventArgs)
           Dim nonPersistentObjectSpace As NonPersistentObjectSpace = TryCast(e.ObjectSpace, NonPersistentObjectSpace)
           If nonPersistentObjectSpace IsNot Nothing Then
               AddHandler nonPersistentObjectSpace.ObjectsGetting, AddressOf NonPersistentObjectSpace_ObjectsGetting
               AddHandler nonPersistentObjectSpace.ObjectByKeyGetting, AddressOf NonPersistentObjectSpace_ObjectByKeyGetting
               AddHandler nonPersistentObjectSpace.Committing, AddressOf NonPersistentObjectSpace_Committing
           End If
       End Sub
       Private Sub NonPersistentObjectSpace_ObjectsGetting(ByVal sender As Object, ByVal e As ObjectsGettingEventArgs)
           If e.ObjectType Is GetType(NonPersistentClass) Then
               Dim objectSpace As IObjectSpace = DirectCast(sender, IObjectSpace)
               Dim objects As New BindingList(Of NonPersistentClass)()
               objects.AllowNew = True
               objects.AllowEdit = True
               objects.AllowRemove = True
               For Each obj As NonPersistentClass In ObjectsCache.Values
                   objects.Add(objectSpace.GetObject(Of NonPersistentClass)(obj))
               Next obj
               e.Objects = objects
           End If
       End Sub
       Private Sub NonPersistentObjectSpace_ObjectByKeyGetting(ByVal sender As Object, ByVal e As ObjectByKeyGettingEventArgs)
           Dim objectSpace As IObjectSpace = DirectCast(sender, IObjectSpace)
           If e.ObjectType Is GetType(NonPersistentClass) Then
               Dim obj As NonPersistentClass = Nothing
               If ObjectsCache.TryGetValue(CInt(Math.Truncate(e.Key)), obj) Then
                   e.Object = objectSpace.GetObject(obj)
               End If
           End If
       End Sub
       Private Sub NonPersistentObjectSpace_Committing(ByVal sender As Object, ByVal e As CancelEventArgs)
           Dim objectSpace As IObjectSpace = DirectCast(sender, IObjectSpace)
           For Each obj As Object In objectSpace.ModifiedObjects
               Dim myobj As NonPersistentClass = TryCast(obj, NonPersistentClass)
               If obj IsNot Nothing Then
                   If objectSpace.IsNewObject(obj) Then
                       Dim key As Integer = ObjectsCache.Count
                       myobj.ID = key
                       ObjectsCache.Add(key, myobj)
                   ElseIf objectSpace.IsDeletedObject(obj) Then
                       ObjectsCache.Remove(myobj.ID)
                   End If
               End If
           Next obj
       End Sub
   End Class
   

   Tip

   Refer to the following GitHub repository to see the extended example: How to implement CRUD operations for Non-Persistent Objects stored remotely.

Important Notes

1. A non-persistent Object Space does not track changes of original objects and does not add changed objects to the ModifiedObjects collection. You can use the IObjectSpace.SetModified(Object) method to add changed objects to this collection explicitly. If a non-persistent object implements the INotifyPropertyChanged interface, you can set AutoSetModifiedOnObjectChange / AutoSetModifiedOnObjectChangeByDefault to true to automatically add the changed object to the ModifiedObjects collection when PropertyChanged is raised.

2. If a non-persistent object implements IObjectSpaceLink and its ObjectSpace property value doesn’t match the Object Space that manipulates the object, the following exception is thrown: ‘An error with the number 1021 has occurred. Error message: The object that was edited belongs to a different ObjectSpace. This error can occur if you manipulate your objects via an ObjectSpace to which these objects do not belong.’

   We recommend that you do not share non-persistent objects when they implement IObjectSpaceLink or have linked persistent objects because of the following limitations.

   • You can use a shared (static) storage for non-persistent objects only if a single NonPersistentObjectSpace works with these objects at any time. Non-persistent objects that implement IObjectSpaceLink cannot belong to multiple Object Spaces simultaneously. When you change the IObjectSpaceLink.ObjectSpace property to a different Object Space, dispose of the previously used Object Space. Otherwise, object changes can trigger events in multiple Views and cause conflicts or unexpected behavior.
   • You cannot share persistent objects between Object Spaces.

   Instead of sharing non-persistent objects, create new instances in each NonPersistentObjectSpace. If you want to preserve data from all instances of a non-persistent object, store this data separately. See the example in the FeatureCenter.Module\NonPersistentObjects\Controllers.cs file (the NonPersistentObjectSpaceExtender class) in the Feature Center demo that is installed in the %PUBLIC%\Documents\DevExpress Demos 23.2\Components\XAF\FeatureCenter.NETFramework.XPO folder.

   For more information, refer to the following Breaking Change description: Core - Error 1021 may occur if a non-persistent object implements IObjectSpaceLink and shared between different Object Spaces.