学习011-04 Non-Persistent Objects（非持久性对象）

Non-Persistent Objects（非持久性对象）

A non-persistent class is a type of business class. XAF generates a UI for this class but does not bind it to an application’s database table. You can use this class to display a List or Detail View with temporary data generated in code or loaded from storage. You can also use it to display an empty View (dialog) and process the user’s input.
非持久类是一种业务类。XAF为该类生成UI，但不将其绑定到应用程序的数据库表。您可以使用该类显示带有代码中生成或从存储中加载的临时数据的列表或详细信息视图。您还可以使用它显示空视图（对话框）并处理用户的输入。

Important

• Do not inherit a non-persistent class from an XPO persistent class (including Base Persistent Classes). Otherwise, the SessionMixingException or ObjectDisposedException can occur in your application because the NonPersistentObjectSpace and NonPersistentObjectSpaceProvider are designed to work with a Session.
  不要从XPO持久类（包括基本持久类）继承非持久类。否则，应用程序中可能会发生SessionMixingException或ObjectDisposedException，因为NonPersistentObjectSpace和NonPersistentObjectSpaceProvider设计用于会话。
• Do not use the NonPersistentAttribute to make a class non-persistent. For this purpose, apply the DomainComponentAttribute to a POCO class as shown in the Basic Non-Persistent Class Implementation section.
  不要使用NonPersistentAttribute使类非持久化。为此，请将DomainComponentAttribute应用于POCO类，如基本非持久类实现部分所示。
• The Type permissions list does not include non-persistent object types and everyone can access them. Refer to the Restrict Non-Persistent Types Access section to learn how to include these types in the Type permissions list.
  类型权限列表不包括非持久对象类型，每个人都可以访问它们。请参阅限制非持久类型访问部分以了解如何将这些类型包含在类型权限列表中。

Basic Non-Persistent Class Implementation（基本的非持久类实现）

In the module project, declare a regular class and add the DomainComponentAttribute to implement a non-persistent class. You can inherit your class from the NonPersistentBaseObject, NonPersistentLiteObject, NonPersistentObjectImpl, or NonPersistentEntityObject class. All these classes implement the INotifyPropertyChanged and IXafEntityObject interfaces and support Custom Fields. The NonPersistentBaseObject and NonPersistentLiteObject classes implement the read-only Oid key property of the Guid type. This key is initialized with a random value in a constructor. If you want to use a key property of a different type or a writable property (for example, for serialization), inherit from NonPersistentObjectImpl or NonPersistentEntityObject and implement the key property. The NonPersistentBaseObject and NonPersistentObjectImpl classes implement IObjectSpaceLink.
在模块项目中，声明一个常规类，并添加DomainComponentAttribute来实现一个非持久类。您可以从NonPersistentBaseObject、NonPersistentLiteObject、NonPersistentObjectImpl或NonPersistentEntityObject类继承您的类。所有这些类都实现了INotifyPropertyChanged和IXafEntityObject接口，并支持自定义字段。NonPersistentBaseObject和NonPersistentLiteObject类实现了Guid类型的只读Oid键属性。此键在构造函数中使用随机值进行初始化。如果要使用不同类型的键属性或可写属性（例如，用于序列化），从NonPersistentObjectImpl或NonPersistentEntityObject继承并实现键属性。NonPersistentBaseObject和NonPersistentObjectImpl类实现了IObjectSpaceLink。

The following table lists the base non-persistent classes:
下表列出了基本的非持久类：

Note
You cannot share non-persistent objects that implement IObjectSpaceLink between different Object Spaces. For example, an exception is thrown when you open a Detail View for an object selected in a List View. To address this exception, subscribe to the NonPersistentObjectSpace.ObjectGetting event, create a new object instance, and copy property values from the source object.
您不能在不同的对象空间之间共享实现IObjectSpaceLink的非持久性对象。例如，当您为列表视图中选择的对象打开详细信息视图时，会引发异常。要解决此异常，请订阅NonPersistentObjectSpaceObjectGet事件，创建一个新的对象实例，并从源对象复制属性值。

The following example shows how to implement a non-persistent class:
以下示例显示了如何实现非持久类：

C#
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.DC;
// ...
[DomainComponent]
public class MyNonPersistentObject : NonPersistentBaseObject {
    private String name;
    private String description;
    public override void OnSaving() {
        base.OnSaving();
        // ...
    }
    public String Name {
        get { return name; }
        set { SetPropertyValue(ref name, value); }
    }
    public String Description {
        get { return description; }
        set { SetPropertyValue(ref description, value); }
    }
}

XAF automatically registers the class with this attribute in the Types Info Subsystem and adds it to the Application Model. Rebuild the solution and open the Model Editor to ensure that XAF added the class to the BOModel node and created the corresponding List and Detail Views.
XAF在Types Info子系统中自动注册具有该属性的类并将其添加到应用程序模型中。重建解决方案并打开模型编辑器以确保XAF将类添加到BOModel节点并创建相应的列表和详细信息视图。

XAF can display this MyNonPersistentObject Detail View in a PopupWindowShowAction popup dialog. See the following help topic for details: Add an Action that Displays a Pop-Up Window.
XAF可以在PopupWindowShowAction弹出对话框中显示此MyNonPersistentObject详细信息视图。有关详细信息，请参阅以下帮助主题：添加显示弹出窗口的操作。

You can also use the ActionAttribute to show a non-persistent object’s popup. For this purpose, apply this attribute to a business class method that takes a non-persistent type parameter.
您还可以使用ActionAtcade显示非持久性对象的弹出窗口。为此，将此属性应用于采用非持久性类型参数的业务类方法。

Non-Persistent Object Space（非持久对象空间）

NonPersistentObjectSpace is an Object Space used to manage non-persistent object instances in your application. You can create, read, or update non-persistent object instances from code if the XafApplication object supports this Object Space type.
NonPersistentObjectSpace是一个对象空间，用于管理应用程序中的非持久性对象实例。如果XafApplication对象支持此对象空间类型，您可以从代码中创建、读取或更新非持久性对象实例。

.NET Core Apps

In XAF .NET Core applications (applications with the Application Builder), you need to use the Application Builder’s ObjectSpaceProviders property to register Object Space Providers. Refer to the following help topic for more information on how to do this: Integrate Application Builders into Existing Applications.
在XAF. NET Core应用程序（带有Application Builder的应用程序）中，您需要使用Application Builder的ObjectSpaceProviders属性来注册对象空间提供程序。有关如何执行此操作的更多信息，请参阅以下帮助主题：将Application Builders集成到现有应用程序中。

This technique also improves performance of your application because the application instance is not created in this case.
这种技术还可以提高应用程序的性能，因为在这种情况下不会创建应用程序实例。

If you use another technique (for example, the XafApplication.CreateDefaultObjectSpaceProvider method or the XafApplication.CreateCustomObjectSpaceProvider event mentioned below with Application Builder-based applications), this technique may conflict with IObjectSpaceFactory and IObjectSpaceProviderFactory service usage.
如果您使用其他技术（例如，XafApplication.CreateDefaultObjectSpaceProvider方法或XafApplication.CreateCustomObjectSpaceProvider下面提到的基于Application Builder的应用程序事件），此技术可能与IObjectSpaceFactory和IObjectSpaceProviderFactory服务使用相冲突。

Apps Without the Application Builder（没有应用程序构建器的应用程序）

To support a Non-Persistent Object Space in applications without the Application Builder, add the following code to the overridden CreateDefaultObjectSpaceProvider method in the WinApplication.cs (WinApplication.vb), WebApplication.cs (WebApplication.vb), and/or BlazorApplication.cs file (in addition to the existing XPObjectSpaceProvider or EFObjectSpaceProvider registration).
要在没有Application Builder的应用程序中支持非持久性对象空间，请将以下代码添加到WinApplication. cs（WinApplication.vb）、WebApplication.cs（WebApplication.vb）和/或BlazorApplication.cs文件中覆盖的CreateDefaultObjectSpaceProvider方法中（除了现有的XPObjectSpaceProvider或EFObjectSpaceProvider注册）。

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

Note that the Solution Wizard adds the code above automatically.
请注意，解决方案向导会自动添加上面的代码。

Common Information（共同信息）

XAF uses the first registered Object Space Provider for the following purposes:
XAF将第一个注册的对象空间提供程序用于以下目的：

• To get XafApplication.ObjectSpaceProvider and XafApplication.ConnectionString property values.
  获取XafApplication. ObjectSpaceProvider和XafApplication.ConnectionString属性值。
• To pass this Provider as the CustomCheckCompatibilityEventArgs ObjectSpaceProvider argument.
  将此提供程序作为CustomCheckCompatibilityEventArgsObjectSpaceProvider参数传递。
• To update an application.
  更新应用程序。

Ensure that NonPersistentObjectSpaceProvider is not the first registered Provider in your application.
确保NonPersistentObjectSpaceProvider不是应用程序中的第一个注册提供者。

Important
NonPersistentObjectSpace cannot handle persistent objects. To process these objects, create an additional Object Space for the persistent object type and add it to the NonPersistentObjectSpace.AdditionalObjectSpaces collection. For more information, refer to the following help topic: How to: Show Persistent Objects in a Non-Persistent Object’s View.
NonPersistentObjectSpace无法处理持久对象。要处理这些对象，请为持久对象类型创建一个额外的对象空间，并将其添加到NonPersistentObjectSpaceAdditionalObjectSpaces集合中。有关详细信息，请参阅以下帮助主题：如何：在非持久对象视图中显示持久对象。
Also, note that you may need to refresh and dispose of Object Spaces from this collection and the parent non-persistent Object Space simultaneously. To do this automatically, use the following properties and fields:
另外，请注意，您可能需要同时刷新和处置此集合中的对象空间和父非持久对象空间。要自动执行此操作，请使用以下属性和字段：

• AutoRefreshAdditionalObjectSpaces / AutoRefreshAdditionalObjectSpacesByDefault
• AutoDisposeAdditionalObjectSpaces / AutoDisposeAdditionalObjectSpacesByDefault

Use the CreateObjectSpace(Type) method to create an Object Space and manage non-persistent objects in your code (for example, in the Controller’s code):
使用CreateObjectSpace（Type）方法创建对象空间并管理代码中的非持久对象（例如，在控制器的代码中）：

C#
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.Actions;
// ...
public class ShowDetailViewController : ViewController<ListView> {
    // ...
    void showDetailViewAction_CustomizePopupWindowParams(
        object sender, CustomizePopupWindowParamsEventArgs e) {
        IObjectSpace newObjectSpace = Application.CreateObjectSpace(typeof(NonPersistentObject));
        // ...
    }
}

When you create a NonPersistentObjectSpace instance in a Controller (for example, to show a custom dialog), you can customize it in the Controller’s code.
在Controller中创建NonPersistentObjectSpace实例（例如，显示自定义对话框）时，可以在Controller的代码中对其进行自定义。

Handle the XafApplication.ObjectSpaceCreated event to specify default settings for all NonPersistentObjectSpaces in your application and subscribe to their events. You can do this in a Module after application setup is complete.
处理XafApplication. ObjectSpaceCreated事件以指定应用程序中所有NonPersistentObjectSpaces的默认设置并订阅它们的事件。您可以在应用程序设置完成后在模块中执行此操作。

C#
using System;
using DevExpress.ExpressApp;
//...
public sealed partial class MyModule : ModuleBase {
    //...
    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) {
            // Subscribe to NonPersistentObjectSpace events and customize their properties
        }
    }
}

Note
We do not recommend that you subscribe to the XafApplication.ObjectSpaceCreated event from a View or Window Controller. This may lead to multiple event invocations, because Controllers are created for each Frame. For example, a Window Controller that targets the main window can be instantiated and activated multiple times when you use it in a WinForms application with UIType = TabbedMDI mode or a Web Forms application with EnableMultipleBrowserTabsSupport = true.
我们不建议您从视图或窗口控制器订阅XafApplication. ObjectSpaceCreated事件。这可能会导致多次事件调用，因为每个帧都创建了控制器。例如，当您在具有UIType=TabbedMDI模式的WinForms应用程序或具有EnableMultipleBrowserTabsSupport=true的Web窗体应用程序中使用以主窗口为目标的窗口控制器时，可以多次实例化和激活它。

To supply data to non-persistent objects, handle the following NonPersistentObjectSpace events raised when the Object Space loads non-persistent objects:
要向非持久性对象提供数据，请处理对象空间加载非持久性对象时引发的以下NonPersistentObjectSpace事件：

• NonPersistentObjectSpace.ObjectGetting
• NonPersistentObjectSpace.ObjectsGetting
• NonPersistentObjectSpace.ObjectByKeyGetting

Since these events are raised to request any non-persistent object (declared in custom or built-in Modules), check the object type passed in event parameters before modifying the events’ output parameters.
由于引发这些事件是为了请求任何非持久对象（在自定义或内置模块中声明），因此在修改事件的输出参数之前检查传递在事件参数中的对象类型。

You can use the New, Delete, and Save Actions to manipulate non-persistent objects. The NonPersistentObjectSpace.ModifiedObjects collection contains all modified objects. Newly created and deleted objects are added to this collection automatically. To add an existing object to this collection, use the IObjectSpace.SetModified(Object) method. If an object implements the INotifyPropertyChanged interface, you can set AutoSetModifiedOnObjectChange or AutoSetModifiedOnObjectChangeByDefault to true to add this object to the ModifiedObjects collection automatically when its property is changed.
您可以使用新建、删除和保存操作来操作非持久性对象。NonPersistentObjectSpace。ModifiedObjects集合包含所有修改的对象。新创建和删除的对象会自动添加到此集合中。要将现有对象添加到此集合中，请使用IObjectSpace. SetModified（Object）方法。如果对象实现了INotifyPropertyChanged接口，您可以将AutoSetModifiedOnObjectChange或AutoSetModifiedOnObjectChangeByDefault设置为true，以便在其属性更改时自动将此对象添加到ModifiedObjects集合中。

Key Property（关键属性）

Key properties are required in ASP.NET Web Forms and ASP.NET Core Blazor applications. Use the KeyAttribute to declare a key property.
关键属性在ASP.NET Web窗体和ASP.NET Core Blazor应用程序中是必需的。

The following code snippet demonstrates how to declare a key property in a non-persistent class. The BrowsableAttribute hides this property from the UI.
以下代码片段演示了如何在非持久性类中声明键属性。BrowsableAtual对UI隐藏此属性。

C#
[DomainComponent]
public class NonPersistentObject {
    [Browsable(false)]
    [DevExpress.ExpressApp.Data.Key]
    public int Oid { get; set; }
    // ...
}

Important
Use the Key attribute from the DevExpress.ExpressApp.Data namespace only (not from the System.ComponentModel.DataAnnotations or DevExpress.Xpo namespaces).
仅使用DevExpress.ExpressApp.Data命名空间中的Key属性（不能使用System. ComponentModel.DataAnnoations或DevExpress.Xpo命名空间中的Key属性）。

You can also inherit the non-persistent class from NonPersistentBaseObject or NonPersistentLiteObject that implements the read-only Oid key property of the Guid type. This key is initialized with a random value in a constructor.
您还可以从实现Guid类型的只读Oid键属性的NonPersistentBaseObject或NonPersistentLiteObject继承非持久类。此键在构造函数中使用随机值进行初始化。

You can allow users to open a specific non-persistent object instance from the Navigation:
您可以允许用户从导航中打开特定的非持久对象实例：

1.Add an item to the navigation. Set its IModelNavigationItem.View property to the identifier of the non-persistent object’s DetailView and the IModelNavigationItem.ObjectKey property to an arbitrary integer value.
将项目添加到导航中。将其IModelNavigationItem. View属性设置为非持久对象DetailView的标识符，将IModelNavigationItem.ObjectKey属性设置为任意整数值。

2.Subscribe to the NonPersistentObjectSpace.ObjectByKeyGetting event handler. Find an object instance whose type matches the event’s e.ObjectType parameter and key value coincides with the e.Key parameter. Pass this object to the event’s e.Object parameter.
订阅NonPersistentObjectSpace. ObjectByKeyGet事件处理程序。查找类型与事件的e.ObjectType参数匹配且键值与e.Key参数一致的对象实例。将此对象传递给事件的e.Object参数。

Filter and Sort Non-Persistent Objects（过滤和排序非持久性对象）

You can use the DevExpress.ExpressApp.DynamicCollection to filter and sort a collection of non-persistent objects. Follow the steps below to do this.
您可以使用DevExpress. ExpressApp.DynamicCollection过滤和排序非持久性对象的集合。按照以下步骤执行此操作。

1.Handle the NonPersistentObjectSpace.ObjectsGetting event.
处理NonPersistentObjectSpace对象获取事件。

2.In this event handler, create a new DynamicCollection and subscribe to its FetchObjects event. This event is raised after sort or filter parameters are changed or the collection is reloaded.
在此事件处理程序中，创建一个新的DynamicCollection并订阅其FetchObjects事件。此事件在更改排序或过滤器参数或重新加载集合后引发。

3.Pass a list of non-persistent objects to the Objects event argument. You can filter and sort this list based on event arguments; to do this automatically, set the ShapeData argument to true.
将非持久对象列表传递给Objects事件参数。您可以根据事件参数过滤和排序此列表；要自动执行此操作，请将ShapeData参数设置为true。

4.Pass the DynamicCollection instance to the NonPersistentObjectSpace.ObjectsGetting Objects argument.
将DynamicCollection实例传递给NonPersistentObjectSpace对象获取对象参数。

The following code demonstrates how you can implement it in your application:
以下代码演示了如何在应用程序中实现它：

C#
using System;
using System.Collections.Generic;
using DevExpress.ExpressApp;
// ...
public sealed partial class NonPersistentObjectsDemoModule : ModuleBase {
    private List<Contact> contacts;
    // ...
    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 += ObjectSpace_ObjectsGetting;
        }
    }
    private void ObjectSpace_ObjectsGetting(object sender, ObjectsGettingEventArgs e) {
        if (e.ObjectType == typeof(Contact)) {
            DynamicCollection collection = new DynamicCollection((IObjectSpace)sender, e.ObjectType, e.Criteria, e.Sorting, e.InTransaction);
            collection.FetchObjects += DynamicCollection_FetchObjects;
            e.Objects = collection;
        }
    }
    private void DynamicCollection_FetchObjects(object sender, FetchObjectsEventArgs e) {
        if (e.ObjectType == typeof(Contact)) {
            e.Objects = contacts; // your collection of non-persistent objects.
            e.ShapeData = true; // set to true if the supplied collection is not already filtered and sorted.
        }
    }
}

To see the full example, refer to the following GitHub repository: How to filter and sort Non-Persistent Objects.
要查看完整示例，请参阅以下GitHub存储库：如何过滤和排序非持久性对象。

If users can create new objects in Lookup List Views, cache the collection that the DynamicCollection.FetchObjects event returns. Otherwise, newly added objects disappear from the Lookup List View after it is reopened. The following GitHub repository shows how to do this: How to edit Non-Persistent Objects nested in a Persistent Object.（https://github.com/DevExpress-Examples/XAF_Non-Persistent-Objects-Filtering-Demo）
如果用户可以在查找列表视图中创建新对象，请缓存DynamicCollection. FetchObjects事件返回的集合。否则，新添加的对象会在重新打开查找列表视图后从查找列表视图中消失。以下GitHub存储库显示了如何执行此操作：如何编辑嵌套在持久性对象中的非持久性对象。（https://github.com/DevExpress-Examples/XAF_Non-Persistent-Objects-Filtering-Demo）

INotifyPropertyChanged Support（INotifyPropertyChanged支持）

All of the base non-persistent classes listed above implement INotifyPropertyChanged. To use this interface’s functionality, declare property setters as follows:
上面列出的所有基本非持久类都实现了INotifyPropertyChanged。要使用此接口的功能，请声明属性设置器，如下所示：

C#
using DevExpress.ExpressApp;
using DevExpress.ExpressApp.DC;
// ...
[DomainComponent]
public class MyNonPersistentObject : NonPersistentBaseObject {
    //...
    private String description;
    public String Description {
        get { return description; }
        set { SetPropertyValue(ref description, value); }
    }
}

If you do not use base classes, implement the INotifyPropertyChanged interface in your non-persistent class to use XAF features that track and handle property value changes (for example, Conditional Appearance). Call the OnPropertyChanged method from the property setter to trigger the PropertyChanged event. The Object Space handles this event internally. Then the PropertyChanged event triggers the IObjectSpace.ObjectChanged event.
如果不使用基类，在非持久性类中实现INotifyPropertyChanged接口，以使用跟踪和处理属性值更改的XAF功能（例如，条件外观）。从属性设置器调用OnProperty tyChanged方法来触发属性更改事件。对象空间在内部处理此事件。然后属性更改事件触发IObjectSpace. ObjectChanged事件。

IXafEntityObject and IObjectSpaceLink Support（IXafEntityObject和IObjectSpaceLink支持）

Implement the IXafEntityObject interface to add custom business logic to the non-persistent class code. This interface declares the OnCreated and OnSaved methods that are called when the Object Space creates or saves an object. You can also implement the IObjectSpaceLink interface and use the Object Space that the IObjectSpaceLink.ObjectSpace property returns. This allows you to query other objects in the same and additional Object Spaces.
实现IXafEntityObject接口，将自定义业务逻辑添加到非持久性类代码中。该接口声明对象空间创建或保存对象时调用的OnCreated和OnSaved方法。您还可以实现IObjectSpaceLink接口，并使用IObjectSpaceLink. ObjectSpace属性返回的对象空间。这允许您查询相同和附加对象空间中的其他对象。

C#
using DevExpress.ExpressApp;
// ...
[DomainComponent]
public class MyNonPersistentObject : IXafEntityObject, IObjectSpaceLink{
    // ...
    void IXafEntityObject.OnCreated() {
        // Place the entity initialization code here.
        // You can use Object Space methods, for example, to initialize reference properties:
        // this.Address = objectSpace.CreateObject<Address>();
    }
    void IXafEntityObject.OnLoaded() {
        // Place the code that is executed each time the entity is loaded here. Explicitly call this method in your code if needed.
    }
    void IXafEntityObject.OnSaving() {
        // Place the code that is executed each time the entity is saved here.
    }
    IObjectSpace IObjectSpaceLink.ObjectSpace {
        get { return objectSpace; }
        set { objectSpace = value; }
    }
}

When a non-persistent object contains a reference to one persistent object and another persistent object references this non-persistent object, the IObjectSpaceLink.ObjectSpace property may return an Additional Object Space instead of its owner Object Space. To get the owner Object Space, use the IObjectSpace.Owner property (see the code below):
当一个非持久对象包含对一个持久对象的引用并且另一个持久对象引用这个非持久对象时，IObjectSpaceLink. ObjectSpace属性可能会返回一个附加对象空间而不是其所有者对象空间。要获取所有者对象空间，请使用IObjectSpace.Owner属性（参见下面的代码）：

C#
IObjectSpace ownerObjectSpace = (ObjectSpace.Owner as IObjectSpace) ?? ObjectSpace;

Non-Persistent Object Template（非持久对象模板）

You can use a Visual Studio template to create a non-persistent class. Open the Template Gallery, switch to the XAF category, and choose the XAF Business Object | Non-Persistent Object item. The added class can be used in various complex scenarios listed in this topic.
可以使用Visual Studio模板创建非持久性类。打开模板库，切换到XAF类别，选择XAF业务对象|非持久性对象项。添加的类可用于本主题中列出的各种复杂场景。

This non-persistent class includes the IXafEntityObject, IObjectSpaceLink, and INotifyPropertyChanged interface implementations and an integer type key property.
这个非持久类包括IXafEntityObject、IObjectSpaceLink和INotifyPropertyChanged接口实现以及整数类型键属性。