Freigeben über

Nachrichten für Massenvorgänge verwenden

Um die beste Leistung beim Ausführen von Vorgängen in mehreren Zeilen einer Microsoft Dataverse-Tabelle zu erzielen, verwenden Sie eine der folgenden Massenvorgangsmeldungen:

  • CreateMultiple: Erzeugt mehrere Datensätze desselben Typs in einer einzigen Anfrage.
  • UpdateMultiple: Aktualisiert mehrere Datensätze desselben Typs in einer einzigen Anfrage.
  • UpsertMultiple: Erstellt oder aktualisiert mehrere Datensätze desselben Typs in einer einzigen Anforderung.
  • DeleteMultiple: Nur für elastische Tabellen. Löscht mehrere Datensätze desselben Typs in einer einzigen Anfrage.

Anmerkung

Weitere Informationen zu den Optionen bei der Durchführung von Massenvorgängen, wie z. B. wann diese APIs im Vergleich zu Batch-APIs genutzt werden sollen, finden Sie unter Optimieren der Leistung für Massenvorgänge.

Beispiele

Die folgenden Beispielcodes zeigen, wie die Meldungen für Massenvorgänge verwendet werden. Sie können die Beispiele von github.com/microsoft/PowerApps-Samples herunterladen:

CreateMultiple

Erstellt mehrere Datensätze desselben Typs in einer einzigen Anfrage.

Verwendet die Klasse CreateMultipleRequest.

/// <summary>
/// Demonstrates the use of the CreateMultiple Message
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance.</param>
/// <param name="recordsToCreate">A list of records of the same table to create.</param>
/// <returns>The Guid values of the records created.</returns>
static Guid[] CreateMultipleExample(IOrganizationService service,
    List<Entity> recordsToCreate)
{

    // Create an EntityCollection populated with the list of entities.
    EntityCollection entities = new(recordsToCreate)
    {
        // All the records must be for the same table.
        EntityName = recordsToCreate[0].LogicalName
    };

    // Instantiate CreateMultipleRequest
    CreateMultipleRequest createMultipleRequest = new()
    {
        Targets = entities,
    };

    // Send the request
    CreateMultipleResponse createMultipleResponse =
                (CreateMultipleResponse)service.Execute(createMultipleRequest);

    // Return the Ids of the records created.
    return createMultipleResponse.Ids;
}

UpdateMultiple

Aktualisiert mehrere Datensätze desselben Typs in einer einzigen Anfrage.

Genau wie beim Aktualisieren einzelner Datensätze müssen die Daten, die Sie mit UpdateMultiple senden, nur die Werte enthalten, die Sie ändern. Weitere Informationen finden Sie unter Aktualisieren von Datensätzen mit SDK für .NET und Aktualisieren von Datensätzen mit der Web-API.

Verwendet die Klasse UpdateMultipleRequest.

/// <summary>
/// Demonstrates the use of the UpdateMultiple message.
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance.</param>
/// <param name="recordsToUpdate">A list of records to create.</param>
static void UpdateMultipleExample(IOrganizationService service, List<Entity> recordsToUpdate) {
    // Create an EntityCollection populated with the list of entities.
    EntityCollection entities = new(recordsToUpdate)
    {
        // All the records must be for the same table.
        EntityName = recordsToUpdate[0].LogicalName
    };

    // Use UpdateMultipleRequest
    UpdateMultipleRequest updateMultipleRequest = new()
    {
        Targets = entities,
    };

    service.Execute(updateMultipleRequest);
}

Doppelte Datensätze im Parameter „UpdateMultiple Targets“

UpdateMultiple unterstützt nicht mehrere Datensätze mit demselben Primärschlüssel oder alternativen Schlüsselwerten in der Nutzlast. Wenn mehr als ein Datensatz im Parameter Targets durch einen primären oder Alternativschlüssel eindeutig identifiziert wird, wird der Vorgang nur für den ersten Datensatz ausgeführt. Der Vorgang ignoriert alle nachfolgenden Datensätze mit denselben Schlüsselwerten in der Nutzlast. Dieses Verhalten unterscheidet sich von UpsertMultiple.

UpsertMultiple

Wird Upsert verwendet, um Daten in externe Quellen zu integrieren, wenn Sie nicht wissen, ob die Tabelle in Dataverse vorhanden ist. Upsert-Vorgänge sind häufig auf alternative Schlüssel angewiesen, um Datensätze zu identifizieren. Verwenden Sie UpsertMultiple, um Upsert Massenoperationen auszuführen.

Verwendet die UpsertMultipleRequest Klasse.

Diese statische UpsertMultipleExample Methode hängt von einer samples_bankaccount Tabelle ab, die eine String-Spalte mit dem Namen samples_accountname als Alternativschlüssel konfiguriert hat. Es gibt auch eine Zeichenfolgenspalte mit dem Namen samples_description. Dieser Code verwendet den Entitätskonstruktor, der den Schlüsselnamen und den Schlüsselwert festlegt, um den Alternativschlüssel-Wert anzugeben.

/// <summary>
/// Demonstrates using UpsertMultiple with alternate key values
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance</param>
static void UpsertMultipleExample(IOrganizationService service)
{
    var tableLogicalName = "samples_bankaccount";
    // samples_accountname string column is configued as an alternate key
    // for the samples_bankaccount table
    var altKeyColumnLogicalName = "samples_accountname";

    // Create one record to update with upsert
    service.Create(new Entity(tableLogicalName)
    {
        Attributes =
        {
            {altKeyColumnLogicalName, "Record For Update"},
            {"samples_description","A record to update using Upsert" }
        }
    });

    // Using the Entity constructor to specify alternate key
    Entity toUpdate = new(
            entityName: tableLogicalName,
            keyName: altKeyColumnLogicalName,
            // Same alternate key value as created record.
            keyValue: "Record For Update");
    toUpdate["samples_description"] = "Updated using Upsert";

    Entity toCreate = new(
        entityName: tableLogicalName,
        keyName: altKeyColumnLogicalName,
        keyValue: "Record For Create");
    toCreate["samples_description"] = "A record to create using Upsert";

    // Add the records to a collection
    EntityCollection records = new()
    {
        EntityName = tableLogicalName,
        Entities = { toUpdate, toCreate }
    };

    // Send the request
    UpsertMultipleRequest request = new()
    {
        Targets = records
    };

    var response = (UpsertMultipleResponse)service.Execute(request);

    // Process the responses:
    foreach (UpsertResponse item in response.Results)
    {
        Console.WriteLine($"Record {(item.RecordCreated ? "Created" : "Updated")}");
    }
}

Ausgabe:

Record Updated
Record Created

Ob in diesem Beispiel ein Datensatz erstellt oder aktualisiert wird, hängt davon ab, ob Datensätze mit dem passenden sample_keyattribute-Wert vorhanden sind. Es werden keine Daten zurückgegeben, um anzugeben, ob ein Datensatz erstellt oder aktualisiert wurde.

SDK-Beispiele

Suchen Sie im Beispiel: SDK für .NET Massenvorgänge verwenden; nach dem UpsertMultiple-Projekt.

Verfügbarkeit

UpsertMultiple ist für Tabellen verfügbar, die CreateMultiple und UpdateMultiple unterstützen. Diese Unterstützung umfasst alle elastischen Tabellen. Die Abfragen, die in "Verfügbarkeit" mit Standardtabellen gefunden wurden, geben keine Ergebnisse für UpsertMultiple zurück, aber Sie können sie verwenden, um zu erkennen, ob eine Tabelle sowohl CreateMultiple als auch UpdateMultiple unterstützt.

Diese Abfragen geben keine Ergebnisse für die UpsertMultiple Nachricht zurück. Eine Tabelle, die sowohl CreateMultiple als auch UpdateMultiple unterstützt und UpsertMultiple unterstützt.

Doppelte Datensätze im Parameter „UpsertMultiple Targets“

UpsertMultiple unterstützt nicht mehrere Datensätze mit demselben Primärschlüssel oder alternativen Schlüsselwerten in der Nutzlast. Wenn mehr als ein Datensatz im Targets-Parameter durch einen Primär- oder Alternativschlüssel eindeutig identifiziert wird, gibt UpsertMultiple einen Fehler zurück. Dieses Verhalten unterscheidet sich von UpdateMultiple.

DeleteMultiple

Löschen Sie mehrere Datenzeilen in elastischen Tabellen mit einer einzigen Anfrage.

Verwenden Sie die OrganizationRequest-Klasse , da das SDK für .NET keine Klasse besitzt DeleteMultipleRequest . Weitere Informationen finden Sie unter Verwenden von Nachrichten mit dem SDK für .NET.

Die folgende DeleteMultipleExample statische Methode verwendet die DeleteMultiple Nachricht mit der OrganizationRequest-Klasse , um mehrere Zeilen aus der contoso_SensorData elastischen Tabelle zu löschen, indem der alternative Schlüssel verwendet wird, um die partitionid Zeilen eindeutig zu identifizieren.

public static void DeleteMultipleExample(IOrganizationService service)
{
    string tableLogicalName = "contoso_sensordata";

    List<EntityReference> entityReferences = new() {
        {
            new EntityReference(logicalName: tableLogicalName,
               keyAttributeCollection: new KeyAttributeCollection
               {
                  { "contoso_sensordataid", "3f56361a-b210-4a74-8708-3c664038fa41" },
                  { "partitionid", "deviceid-001" }
               })
        },
        { new EntityReference(logicalName: tableLogicalName,
               keyAttributeCollection: new KeyAttributeCollection
               {
                  { "contoso_sensordataid", "e682715b-1bba-415e-b2bc-de9327308423" },
                  { "partitionid", "deviceid-002" }
               })
        }
    };

    OrganizationRequest request = new(requestName:"DeleteMultiple")
    {
        Parameters = {
            {"Targets", new EntityReferenceCollection(entityReferences)}
        }
    };

    service.Execute(request);
}

Mehrfachverfügbarkeit löschen

DeleteMultiple wird nur für elastische Tabellen unterstützt. Elastische Tabellen unterstützen kein Tabellenbeziehungs-Kaskadenverhalten, was zu unvorhersehbaren Ausführungszeiten für Löschvorgänge führen kann. Wenn Sie DeleteMultiple für eine Standardtabelle verwenden, erhalten Sie die Fehlermeldung: DeleteMultiple has not yet been implemented.

DeleteMultiple Beispiele

Beispielcode finden Sie auf GitHub unter github.com/microsoft/PowerApps -Beispielcode:

Standard- und elastische Tabellenverwendung

Sowohl Standardtabellen als auch elastische Tabellen erhalten eine erhebliche Leistungssteigerung, wenn Sie Massenvorgangsnachrichten verwenden, aber Sie müssen sie anders verwenden. In der folgenden Tabelle sind die Unterschiede zusammengefasst.

Differenz Standard Elastisch
Anzahl der Datensätze Vorgänge sind mit einer größeren Anzahl von Datensätzen effizienter. Es gibt keine Begrenzung für die Anzahl der Datensätze, aber es gibt Grenzen für die Größe der Nachricht und die Zeit. Senden Sie jeweils 100 bis 1.000 Datensätze. Senden Sie jeweils 100 Datensätze.
Im Fehlerfall Bei einem Fehler werden alle Vorgänge zurückgesetzt. Teilerfolg ist möglich.
Verfügbarkeit Nicht alle Standardtabellen unterstützen diese Nachrichten. Die Nachrichten sind für alle elastischen Tabellen verfügbar.
DeleteMultiple Nicht verfügbar. Verwenden Sie stattdessen das SDK BulkDeleteRequest-Klasse oder die Web-API BulkDelete-Aktion. Lernen Sie, wie Sie Daten in großen Mengen löschen können. Die SDK DeleteMultipleRequest-Klasse oder die Web-API DeleteMultiple-Aktion verwenden

Die Verwendung von Standardtabellen und elastischen Tabellen unterscheidet sich, da Standardtabellen Azure SQL verwenden und Transaktionen unterstützen. Elastic-Tabellen verwenden Azure Cosmos DB, das keine Transaktionen unterstützt, aber große Datenmengen bei hohem Durchsatz und niedriger Latenz verarbeitet. Die folgenden Abschnitte enthalten weitere Details. Erfahren Sie mehr über Bulk-Vorgänge auf elastischen Tabellen.

Anzahl der Datensätze

Die Anzahl der Datensätze, die Sie in jede Anforderung einbeziehen sollten, hängt davon ab, ob Sie Standard- oder elastische Tabellen verwenden.

Tipp

Sowohl Standard- als auch elastische Tabellen haben einen höheren Durchsatz, wenn Sie Massenvorgang-Nachrichten parallel versenden.

Anzahl der Datensätze mit Standardtabellen

Bulk-Vorgänge an Standardtabellen sind so optimiert, dass sie in einer einzigen Transaktion für mehrere Zeilen durchgeführt werden können. Die Vorgänge werden effizienter und die Leistung nimmt insgesamt zu, wenn die Anzahl der Vorgänge pro Anfrage steigt. Diese Optimierung macht auch alle Plug-In-Schritte, die für den Massenvorgang registriert sind, effizienter. Jedes Mal, wenn ein Plug-In für einen einzelnen Vorgang aufgerufen wird, erfordert der Prozess einige Millisekunden, um die Plug-In-Klasse mit der Logik aufzurufen. Wenn Sie ein Plug-In für eine Massenvorgangsnachricht registrieren, wird die Klasse einmal aufgerufen und kann alle Vorgänge effizienter verarbeiten. Lernen Sie, wie man Plug-Ins für CreateMultiple und UpdateMultiple schreibt.

Dieser Leistungsvorteil empfiehlt Ihnen, die größte Anzahl von Datensätzen zu senden, die Sie in jeder Anforderung verwenden können. Mit zunehmender Anzahl der Datensätze steigt jedoch auch der Umfang der Anfrage, sodass die Verarbeitung länger dauert. Schließlich treten Nachrichtengrößen und Zeitlimits auf. Wenn Sie diese Grenzwerte erreichen, schlägt der gesamte Vorgang fehl. Es gibt keine Begrenzung für die Anzahl der Datensätze, die Sie senden können. Möglicherweise müssen Sie experimentieren, um die beste Zahl zu finden. Im Allgemeinen ist 100 bis 1.000 Datensätze pro Anforderung ein angemessener Ausgangspunkt, wenn die Größe der Datensatzdaten klein ist und keine Plug-Ins vorhanden sind. Die Arten von Fehlern, die möglicherweise auftreten, können in der Regel behoben werden, indem weniger Datensätze mit jeder Anforderung gesendet werden. Schließen Sie die Möglichkeit ein, die Anzahl der gesendeten Entitäten zu konfigurieren, damit Sie sich anpassen können, indem Sie weniger senden.

Anzahl der Datensätze mit elastischen Tabellen

Da es bei elastischen Tabellen keine Transaktion gibt, bringt es keinen Leistungsvorteil, wenn Sie versuchen, eine große Anzahl von Datensätzen pro Anfrage zu senden. Senden Sie 100 Vorgänge pro Anforderung und senden Sie Anforderungen parallel, um den maximalen Durchsatz zu erzielen.

Zum Fehlerverhalten

Das Verhalten bei Fehlern hängt davon ab, ob Sie Standard- oder elastische Tabellen verwenden.

Zum Fehlerverhalten bei Standardtabellen

Jeder Fehler, der bei einem Massenvorgang mit einer Standardtabelle auftritt, bewirkt, dass der gesamte Vorgang zurückgesetzt wird. Verwenden Sie Massenvorgänge nur für Standardtabellen, wenn Sie ein hohes Maß an Vertrauen haben, dass alle Vorgänge erfolgreich ausgeführt werden. Wenn der Massenvorgang fehlschlägt, empfiehlt es sich, die SDK ExecuteMultipleRequest-Klasse oder Web-API $batchzu verwenden, um den Rollback für die Gruppe von Vorgängen zuzulassen. Wenn die Erfolgsquote bei Ihren ersten Versuchen niedrig ist, führt diese Strategie zu einer schlechteren Leistung. Verwenden Sie diese Fallback-Strategie nur, wenn Sie erwarten, dass die meisten Vorgänge erfolgreich sind.

Bei Fehlerverhalten mit elastischen Tabellen

Bei elastischen Tabellen kann eine Massenoperation teilweise erfolgreich ausgeführt werden. Anhand der Fehlerdetails können Sie feststellen, welche Datensätze fehlgeschlagen sind.

Wenn Sie das SDK verwenden, um einen Massenvorgang für eine elastische Tabelle durchzuführen, wird bei einem Fehler eine FaultException vom Typ OrganizationServiceFault ausgelöst. Verwenden Sie den folgenden Code, um den Status der einzelnen Datensätze abzurufen.

if (ex.Detail.ErrorDetails.TryGetValue("Plugin.BulkApiErrorDetails", out object errorDetails))
{
    List<BulkApiErrorDetail> bulkApiErrorDetails = JsonConvert.DeserializeObject<List<BulkApiErrorDetail>>(errorDetails.ToString());
}

public class BulkApiErrorDetail
{
    public int RequestIndex { get; set; }
    public string Id { get; set; }
    public int StatusCode { get; set; }
}

Verfügbarkeit

Die Verfügbarkeit von Nachrichten für Massenoperationen hängt davon ab, ob Sie Standard- oder elastische Tabellen verwenden. Alle elastischen Tabellen unterstützen die CreateMultiple, UpdateMultiple, UpsertMultiple und DeleteMultiple Nachrichten.

Verfügbarkeit mit Standardtabellen

Sie können die Nachrichten CreateMultiple und UpdateMultiple für Massenvorgänge mit benutzerdefinierten und vielen allgemeinen Standardtabellen verwenden, jedoch nicht mit allen. Testen Sie, ob einzelne Standardtabellen diese Nachrichten unterstützen. Die folgenden Beispiele zeigen Ihnen, wie Sie das tun können.

Verwenden Sie diese statische Methode, um zu erkennen, ob eine bestimmte Tabelle CreateMultiple oder UpdateMultiple unterstützt.

/// <summary>
/// Detect whether a specified message is supported for the specified table.
/// </summary>
/// <param name="service">The IOrganizationService instance.</param>
/// <param name="entityLogicalName">The logical name of the table.</param>
/// <param name="messageName">The name of the message.</param>
/// <returns></returns>
public static bool IsMessageAvailable(
    IOrganizationService service,
    string entityLogicalName,
    string messageName)
{
    QueryExpression query = new("sdkmessagefilter")
    {
        ColumnSet = new ColumnSet("sdkmessagefilterid"),
        Criteria = new FilterExpression(LogicalOperator.And)
        {
            Conditions = {
            new ConditionExpression(
                attributeName:"primaryobjecttypecode",
                conditionOperator: ConditionOperator.Equal,
                value: entityLogicalName)
            }
        },
        LinkEntities = {
            new LinkEntity(
                linkFromEntityName:"sdkmessagefilter",
                linkToEntityName:"sdkmessage",
                linkFromAttributeName:"sdkmessageid",
                linkToAttributeName:"sdkmessageid",
                joinOperator: JoinOperator.Inner)
            {
                    LinkCriteria = new FilterExpression(LogicalOperator.And){
                    Conditions = {
                        new ConditionExpression(
                            attributeName:"name",
                            conditionOperator: ConditionOperator.Equal,
                            value: messageName)
                        }
                    }
            }
        }
    };

    EntityCollection entityCollection = service.RetrieveMultiple(query);

    return entityCollection.Entities.Count.Equals(1);
}

Nachrichten-Pipelines zusammengeführt

Jede Massenvorgangsnachricht hat eine entsprechende Nachricht, die auf einzelne Zeilen wirkt: Create, Update und Delete. Diese Nachrichten gibt es schon seit langem und viele Unternehmen haben eine angepasste Logik, die von den Ereignissen abhängt, die bei der Verwendung dieser Nachrichten auftreten.

Eine wichtige Anforderung der Massenvorgangsnachrichten besteht darin, dass Organisationen keine benutzerdefinierte Logik an zwei Stellen verwalten sollten. Um dieselbe benutzerdefinierte Logik zu haben und an einer zentralen Stelle zu verwalten, führt Dataverse die Nachrichtenverarbeitungspipelinen für diese Nachrichten zusammen. Was bedeutet diese Zusammenführung?

  • Wenn Sie eine Massenvorgangsnachricht verwenden, tritt das jeweilige Create Ereignis Update für jede Entitätsinstanz im Targets Parameter auf. Alle Plug-ins oder andere Handler für die entsprechenden individuellen Ereignisse funktionieren weiterhin wie bisher. Sie müssen keine neuen Plug-Ins schreiben, um die Ereignisse zu verwalten, die durch diese Nachrichten ausgelöst werden.

  • Wenn Sie eine einzelne Vorgangsmeldung verwenden, tritt das entsprechende Massenoperationsevent mit einer EntityCollection auf, die eine einzelneEntitätsinstanz enthält, die im Parameter Targets übergeben wird. Sie können jede Logik, die auf Ereignisse für einzelne Vorgänge reagiert, in die effizienteren Massenvorgangsereignisse verschieben und die Logik wird sowohl für einzelne als auch für mehrere Vorgänge angewendet.

Vor der Einführung von Nachrichten für Massenvorgänge bezog sich die gesamte angepasste Logik auf die Nachrichten für einzelne Vorgänge. Diese Logik wird weiterhin angewendet, wenn Clientanwendungen die Massenvorgangsmeldungen verwenden. Verschieben Sie bei Tabellen, die mit Massenvorgängen mit hohem Volumen verwendet werden, jede synchrone Logik von einzelnen Nachrichtenereignissen in Massenvorgangsereignisse. Wenn Sie neue Logik einführen, verwenden Sie anstelle der einzelnen Vorgangsereignisse die Massenvorgangsereignisse.

Vorsicht

Auf diese Weise kann die doppelte Logik sowohl auf einzelne als auch auf mehrere Versionen von Ereignissen angewendet werden. Dataverse versucht nicht, dies zu verhindern, da sie Ihre Absicht nicht kennen kann.

Es liegt in Ihrer Verantwortung, dafür zu sorgen, dass dieselbe Logik, die für die Einzelversion von Ereignissen angewendet wird, auf die Mehrfachversion des Ereignisses übertragen und aus der Einzelversion des Ereignisses entfernt wird. Andernfalls wird die Logik zweimal angewendet.

Lernen Sie, wie man Plug-Ins für CreateMultiple und UpdateMultiple schreibt.

Einschränkungen

Beachten Sie die folgenden Einschränkungen bei der Verwendung von Nachrichten für Sammeloperationen.

Nachrichtengröße und Zeitlimits

Bei Standardtabellen erhalten Sie eine bessere Leistung, wenn Sie mit jeder Anforderung mehr Datensätze senden. Die Größe der Nutzlast und die Zeit, die zum Verarbeiten des Vorgangs benötigt wird, beschränken jedoch die Anzahl der Datensätze, die Sie senden können.

Grenzwerte für die Nachrichtengröße

Wenn Sie ein Plug-In für eine Nachricht registrieren, tritt möglicherweise der Fehler "Beim Senden von Kontext an Sandbox überschrittene Nachrichtengröße" auf, wenn die Gesamtgröße der Anforderung 116,85 MB überschreitet. Wenn Sie Massenvorgangsnachrichten verwenden, können Sie diesen Grenzwert einfacher erreichen, da Sie größere Nutzlasten senden.

Dieser Fehler tritt nicht auf, wenn Sie kein Plug-In für das Ereignis registrieren. Um den Fehler zu vermeiden, deaktivieren Sie Plug-Ins, oder senden Sie Ihre Anforderung mithilfe des BypassCustomPluginExecution optionalen Parameters.

Zeitlimits

Wenn Sie den Dataverse ServiceClient verwenden, tritt möglicherweise dieser Fehler auf:

The request channel timed out attempting to send after 00:04:00. 
Increase the timeout value passed to the call to Request or increase the SendTimeout value on the Binding. 
The time allotted to this operation may have been a portion of a longer timeout.

Das standardmäßige Timeout, das mithilfe von ServiceClient festgelegt wird, beträgt vier Minuten, was für jeden synchronen Vorgang lang ist. Sie können diesen Wert mithilfe der statischen ServiceClient.MaxConnectionTimeout-Eigenschaft ändern. Das Standardtimeout mithilfe von CrmServiceClient beträgt zwei Minuten.

Anmerkung

Bevor Sie die Zeitlimits erhöhen, sollten Sie die Anzahl der Datensätze verringern, die Sie an den Targets Parameter übergeben.

Nicht unterstützt für die Verwendung in Plug-ins

Derzeit unterstützt Dataverse die Verwendung von Massenvorgangsmeldungen im Plug-In-Code nicht. Weitere Informationen finden Sie unter "Verwenden von Batchanforderungstypen in Plug-Ins und Workflowaktivitäten nicht".

Allerdings sollten Sie Plug-Ins für die CreateMultiple- und UpdateMultiple-Nachrichten schreiben, wie in Plug-Ins für „CreateMultiple“ und „UpdateMultiple“ schreiben beschrieben.

Problembehandlung häufiger Fehler

Wenn beim Verwenden von Massenvorgängen Fehler auftreten, lesen Sie die folgenden Artikel:

Häufig gestellte Fragen (FAQ)

Wenn Sie in diesem Artikel keine Antwort auf Ihre Fragen zur Verwendung von Nachrichten für Massenvorgänge finden, nutzen Sie die Schaltfläche unten auf der Seite, um Feedback zu dieser Seite zu übermitteln und anzuzeigen. Sie benötigen ein GitHub-Konto, um Feedback zu senden.

Werden die Logiken „Retrieve“ und „RetrieveMultiple“ zusammengeführt?

Microsoft plant nicht, das Verhalten von Retrieve- und RetrieveMultiple-Nachrichten zu ändern. Diese Nachrichten sind seit vielen Jahren separate Nachrichten, und Entwickler müssen die Logik für sie immer separat verwalten. Der Versuch, die Pipeline der Nachrichten für sie zusammenzuführen, wäre höchst problematisch. Vermeiden Sie außerdem das Anwenden von benutzerdefinierter Logik für diese Nachrichten aufgrund der Auswirkungen, die sie auf die Leistung haben können.

Wie werden API-Grenzwerte angewendet?

Es gelten zwei Arten von API-Grenzwerten. Die Meldungen für Massenoperationen bieten keine Möglichkeit, einen der beiden Typen zu umgehen.

Grenzwerte für den Dienstschutz

Wie in API-Grenzwerte für den Serviceschutz beschrieben haben Grenzwerte drei Facetten. Zwei dieser Einschränkungen werden in einem gleitenden Fünf-Minuten-Fenster ausgewertet und gelten für die Verwendung dieser Nachrichten.

  • Anzahl der Anfragen: Jede Nachricht über einen Massenvorgang zählt als einzelne Anfrage, sodass das Limit von 6.000 Anfragen pro Benutzer, pro Server, während des Fünf-Minuten-Fensters erreicht wird. Da bei diesen Anforderungen einzelne Vorgänge gruppiert werden, ist die Wahrscheinlichkeit, dass dieser Grenzwert erreicht wird, geringer.
  • Ausführungszeit: Da jede Anforderung einer Nachricht für einen Massenvorgang in der Regel länger dauert, ist es wahrscheinlicher, dass Sie, wenn Sie Anfragen parallel senden, das Ausführungszeitlimit von 20 Minuten pro Benutzer und Server während des Fünf-Minuten-Fensters erreichen.

Grenzwerte für Power Platform-Anforderungen (API-Berechtigung)

Diese Grenzwerte basieren auf Datenänderungen: Create, Update und Delete Vorgänge. Jedes im Targets-Parameter einer Massenoperationsanforderung enthaltene Element wird auf dieses Limit angerechnet. Erfahren Sie mehr über Anfragelimits und Zuweisungen.

Siehe auch

Elastische Tabelle
Plug-Ins für „CreateMultiple“ und „UpdateMultiple“ schreiben
Beispiel: SDK für .NET Massenoperationen nutzen
Beispiel: Web API für Massenvorgänge nutzen
Beispiel: „CreateMultiple“- und „UpdateMultiple“-Plug-Ins
Nachrichten mit dem SDK für .NET verwenden
Leistung für Massenvorgänge optimieren

  • Last updated on