Hinweis zum Ende des Supports: Am 20. Mai 2026 AWS endet der Support für AWS SimSpace Weaver. Nach dem 20. Mai 2026 können Sie nicht mehr auf die SimSpace Weaver Konsole oder SimSpace Weaver die Ressourcen zugreifen. Weitere Informationen finden Sie unter [AWS SimSpace Weaver Ende des Supports](https://docs.aws.amazon.com/simspaceweaver/latest/userguide/simspaceweaver-end-of-support.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Ereignisse der Entität
<a name="working-with_app-sdk_events"></a>

Sie können die folgenden Funktionen im SimSpace Weaver App-SDK verwenden, um alle Eigentums- und Abonnementereignisse abzurufen:
+ `Result<OwnershipChangeList> OwnershipChanges(Transaction& txn) `
+ `Result<SubscriptionChangeList> AllSubscriptionEvents(Transaction& txn) `

Sie können das SimSpace Weaver Demo-Framework verwenden, wenn Sie eine rückrufgesteuerte Verarbeitung von Entitätsereignissen benötigen. Weitere Informationen finden Sie in der folgenden Header-Datei:
+ `sdk-folder/packaging-tools/samples/ext/DemoFramework/include/DemoFramework/EntityEventProcessor.h`

Sie können auch Ihre eigene Entitäts-Eventverarbeitung erstellen.

**Topics**
+ [Iterieren Sie Ereignisse für eigene Entitäten](working-with_app-sdk_events_own.md)
+ [Iterieren Sie Ereignisse für abonnierte Entitäten](working-with_app-sdk_events_sub.md)
+ [Führen Sie Iterationen durch Ereignisse zum Eigentümerwechsel für Entitäten durch](working-with_app-sdk_events_change.md)

# Iterieren Sie Ereignisse für eigene Entitäten
<a name="working-with_app-sdk_events_own"></a>

Wird verwendet`OwnershipChanges()`, um eine Liste von Ereignissen für eigene Entitäten (Entitäten im Eigentumsbereich der App) abzurufen. Die Funktion hat die folgende Signatur:

```
Result<OwnershipChangeList> OwnershipChanges(Transaction& txn)
```

Iterieren Sie dann mit einer Schleife durch die Entitäten, wie im folgenden Beispiel gezeigt.

**Example Beispiel**  

```
WEAVERRUNTIME_TRY(Result<Api::OwnershipChangeList> ownershipChangesResult, Api::OwnershipChanges(transaction));

for (const Api::OwnershipChange& event : ownershipChangeList.changes)
{
    Api::Entity entity = event.entity;
    Api::ChangeListAction action = event.action;

    switch (action)
    {
    case Api::ChangeListAction::None:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Remove:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Add:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Update:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Reject:
        // insert code to handle the event
        break;
    }
}
```

**Ereignistypen**
+ `None`— Die Entität befindet sich in dem Bereich und ihre Positions- und Felddaten wurden nicht geändert.
+ `Remove`— Die Entität wurde aus dem Bereich entfernt.
+ `Add`— Die Entität wurde dem Bereich hinzugefügt.
+ `Update`— Die Entität befindet sich in dem Bereich und wurde geändert.
+ `Reject`— Die App konnte die Entität nicht aus dem Bereich entfernen.

**Anmerkung**  
Im Falle eines `Reject` Ereignisses versucht die App beim nächsten Häkchen erneut, die Übertragung durchzuführen.

# Iterieren Sie Ereignisse für abonnierte Entitäten
<a name="working-with_app-sdk_events_sub"></a>

Wird verwendet`AllSubscriptionEvents()`, um eine Liste von Ereignissen für abonnierte Entitäten (Entitäten im Abonnementbereich der App) abzurufen. Die Funktion hat die folgende Signatur:

```
Result<SubscriptionChangeList> AllSubscriptionEvents(Transaction& txn)
```

Iterieren Sie dann mit einer Schleife durch die Entitäten, wie im folgenden Beispiel gezeigt.

**Example Beispiel**  

```
WEAVERRUNTIME_TRY(Api::SubscriptionChangeList subscriptionChangeList, Api::AllSubscriptionEvents(transaction));

for (const Api::SubscriptionEvent& event : subscriptionChangeList.changes)
{
    Api::Entity entity = event.entity;
    Api::ChangeListAction action = event.action;

    switch (action)
    {
    case Api::ChangeListAction::None:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Remove:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Add:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Update:
        // insert code to handle the event
        break;
    case Api::ChangeListAction::Reject:
        // insert code to handle the event
        break;
    }
}
```

**Ereignistypen**
+ `None`— Die Entität befindet sich in dem Bereich und ihre Positions- und Felddaten wurden nicht geändert.
+ `Remove`— Die Entität wurde aus dem Bereich entfernt.
+ `Add`— Die Entität wurde dem Bereich hinzugefügt.
+ `Update`— Die Entität befindet sich in dem Bereich und wurde geändert.
+ `Reject`— Die App konnte die Entität nicht aus dem Bereich entfernen.

**Anmerkung**  
Im Falle eines `Reject` Ereignisses versucht die App beim nächsten Häkchen erneut, die Übertragung durchzuführen.

# Führen Sie Iterationen durch Ereignisse zum Eigentümerwechsel für Entitäten durch
<a name="working-with_app-sdk_events_change"></a>

Um Ereignisse zu ermitteln, bei denen eine Entität zwischen einem Eigentümerbereich und einem Abonnementbereich wechselt, vergleichen Sie die Änderungen zwischen den aktuellen und früheren Eigentümerschafts- und Abonnementereignissen der Entität.

Sie können mit diesen Ereignissen umgehen, indem Sie Folgendes lesen:
+ `Api::SubscriptionChangeList`
+ `Api::OwnershipEvents`

Anschließend können Sie die Änderungen mit zuvor gespeicherten Daten vergleichen.

Das folgende Beispiel zeigt, wie Sie mit Ereignissen umgehen können, bei denen sich die Eigentümerschaft einer Entität ändert. In diesem Beispiel wird davon ausgegangen, dass bei Entitäten, die zwischen abonnierten Entitäten und eigenen Entitäten (in beide Richtungen) wechseln, das remove/add event occurs first followed by the subscription remove/add Eigentümerereignis im nächsten Tick stattfindet. 

**Example Beispiel**  

```
Result<void> ProcessOwnershipEvents(Transaction& transaction)
{
    using EntityIdsByAction =
        std::unordered_map<Api::ChangeListAction, 
        std::vector<Api::EntityId>>;
    using EntityIdSetByAction =
        std::unordered_map<Api::ChangeListAction, 
        std::unordered_set<Api::EntityId>>;
   
    static EntityIdsByAction m_entityIdsByPreviousOwnershipAction;
    
    EntityIdSetByAction entityIdSetByAction;
   
    /**
     * Enumerate Api::SubscriptionChangeList items 
     * and store Add and Remove events.
     */ 
    WEAVERRUNTIME_TRY(Api::SubscriptionChangeList subscriptionEvents, 
        Api::AllSubscriptionEvents(transaction));
   
    for (const Api::SubscriptionEvent& event : subscriptionEvents.changes)
    {
        const Api::ChangeListAction action = event.action;
    
        switch (action)
        {
        case Api::ChangeListAction::Add:
        case Api::ChangeListAction::Remove:
    
            {
                entityIdSetByAction[action].insert(
                    event.entity.descriptor->id);
                break;
            }
        case Api::ChangeListAction::None:
        case Api::ChangeListAction::Update:
        case Api::ChangeListAction::Reject:
            {
                break;
            }
        }
    }
    
    EntityIdsByAction entityIdsByAction;
    
    /**
     * Enumerate Api::OwnershipChangeList items 
     * and store Add and Remove events.
     */
    
    WEAVERRUNTIME_TRY(Api::OwnershipChangeList ownershipChangeList, 
        Api::OwnershipChanges(transaction));
   
    for (const Api::OwnershipChange& event : ownershipChangeList.changes)
    {
        const Api::ChangeListAction action = event.action;
    
        switch (action)
        {
        case Api::ChangeListAction::Add:
        case Api::ChangeListAction::Remove:
            {
                entityIdsByAction[action].push_back(
                    event.entity.descriptor->id);
                break;
            }
        case Api::ChangeListAction::None:
        case Api::ChangeListAction::Update:
        case Api::ChangeListAction::Reject:
            {
                break;
            }
        }
    
    }
      
    std::vector<Api::EntityId> fromSubscribedToOwnedEntities;
    std::vector<Api::EntityId> fromOwnedToSubscribedEntities;
   
    /**
     * Enumerate the *previous* Api::OwnershipChangeList Remove items
     * and check if they are now in 
     * the *current* Api::SubscriptionChangeList Add items.
     *
     * If true, then that means 
     * OnEntityOwnershipChanged(bool isOwned = false)
     */ 
    for (const Api::EntityId& id : m_entityIdsByPreviousOwnershipAction[
        Api::ChangeListAction::Remove])
    {
        if (entityIdSetBySubscriptionAction[
            Api::ChangeListAction::Add].find(id) !=
                entityIdSetBySubscriptionAction[
                Api::ChangeListAction::Add].end())
        {
            fromOwnedToSubscribedEntities.push_back(id);
        }
    }
    
   
    /**
     * Enumerate the *previous* Api::OwnershipChangeList Add items
     * and check if they are now in 
     * the *current* Api::SubscriptionChangeList Remove items.
     *
     * If true, then that means 
     * OnEntityOwnershipChanged(bool isOwned = true)
     */ 
    for (const Api::EntityId& id : m_entityIdsByPreviousOwnershipAction[
        Api::ChangeListAction::Add])
    {
        if (entityIdSetBySubscriptionAction[
            Api::ChangeListAction::Remove].find(id) !=
            
                entityIdSetBySubscriptionAction[
                Api::ChangeListAction::Remove].end())
        {
            fromSubscribedToOwnedEntities.push_back(id);
        }
    }
    
    m_entityIdsByPreviousOwnershipAction = entityIdsByOwnershipAction;
    
    return Success();
}
```