Nachrichten für Massenvorgänge verwenden

  • Artikel

Um die beste Leistung zu erzielen, wenn Sie Vorgänge über mehrere Zeilen einer Microsoft Dataverse-Tabelle ausführen, verwenden Sie eine der folgenden Nachrichten für Massenoperationen:

  • 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 (Vorschauversion): Nur für elastische Tabellen. Löscht mehrere Datensätze desselben Typs in einer einzigen Anfrage.

Hinweis

Anleitungen zu Optionen beim Durchführen von Massenvorgängen, beispielsweise wann diese APIs im Vergleich zu Batch-APIs wie ExecuteMultiple verwendet werden sollten, finden Sie unter Leistung für Massenvorgänge optimieren.

Beispiele

Im folgenden Beispielcode wird gezeigt, wie die Meldung für Massenvorgänge verwendet wird: 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 bei der Aktualisierung einzelner Datensätze müssen die Daten, die Sie mit UpdateMultiple senden, nur die Werte enthalten, die Sie ändern. Lernen Sie, wie Sie Datensätze mit SDK für .NET und Datensätze mit der Web-API aktualisieren.

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-Ziele“

Mehrere Datensätze mit demselben Primärschlüssel oder denselben Alternativschlüssel-Werten in der Nutzlast werden mit UpdateMultiple nicht unterstützt. 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. Alle nachfolgenden Datensätze mit denselben Schlüsselwerten in der Nutzlast werden ignoriert. Dieses Verhalten unterscheidet sich von UpsertMultiple.

UpsertMultiple

Verwenden Sie Upsert, um Daten mit externen Quellen zu integrieren, wenn Sie nicht wissen, ob die Tabelle in Dataverse existiert oder nicht. Upsert-Vorgänge sind häufig auf alternative Schlüssel angewiesen, um Datensätze zu identifizieren. UpsertMultipleverwenden, um Upsert Massenvorgänge auszuführen.

Verwendet die UpsertMultipleRequest Klasse.

Dieses Statik UpsertMultipleExample Methode hängt von einer samples_bankaccount Tabelle ab. Diese hat eine Zeichenfolgenspalte mit dem Namen samples_accountname, die als Alternativschlüssel konfiguriert ist. 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

Innerhalb Beispiel: SDK für .NET verwenden Sie Massenvorgänge, suchen nach UpsertMultiple-Projekt

Verfügbarkeit

UpsertMultiple ist für Tabellen verfügbar, die CreateMultiple und UpdateMultiple unterstützen. Hierzu zählen alle elastischen Tabellen. Die in Verfügbarkeit mit Standardtabellen gefundenen Anforderungen 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, unterstützt auch UpsertMultiple.

Doppelte Datensätze im Parameter „UpsertMultiple-Ziele“

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

Standard- und elastische Tabellenverwendung

Sowohl Standardtabellen als auch elastische Tabellen profitieren von einem deutlichen Leistungsvorteil, wenn Sie Nachrichten für Massenvorgänge verwenden, aber Sie müssen sie unterschiedlich einsetzen. 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. Wir empfehlen, jeweils 100 - 1.000 Datensätze zu versenden. Wir empfehlen, jeweils 100 Datensätze zu versenden.
Bei Fehlerverhalten 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. Verfügbar mit der SDK OrganizationRequest Klasse. Die Web-API DeleteMultiple Aktion ist privat, aber Sie können sie jetzt verwenden. Sie wird bald veröffentlicht werden.

Die Verwendung von Standardtabellen und elastischen Tabellen unterscheidet sich, da Standardtabellen Azure SQL verwenden und Transaktionen unterstützen. Elastische Tabellen verwenden Azure Cosmos DB, das keine Transaktionen unterstützt, aber große Datenmengen mit hohem Durchsatz und geringer Latenz verarbeiten kann. 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 lässt auch zu, dass alle Plug-in-Schritte, die für den Massenvorgang registriert sind, effizienter sind. Jedes Mal, wenn ein Plug-In für eine einzelne Operation aufgerufen wird, sind einige Millisekunden erforderlich, um die Plug-In-Klasse aufzurufen, die die Logik enthält. Wenn ein Plug-In für eine Massenvorgangsnachricht registriert wird, 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 gibt Ihnen einen Anreiz, in jeder Anfrage die größtmögliche Anzahl an Datensätzen zu senden. Mit zunehmender Anzahl der Datensätze steigt jedoch auch der Umfang der Anfrage, sodass die Verarbeitung länger dauert. Eventuell werden Sie auf Nachrichtengröße und Zeitlimits stoßen. 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. Vielleicht müssen Sie experimentieren, um die beste Zahl zu finden. Im Allgemeinen gehen wir davon aus, dass 100 - 1.000 Datensätze pro Anfrage ein angemessener Ausgangspunkt sind, wenn die Größe der Datensatzdaten gering ist und keine Plug-Ins vorhanden sind. Die Arten von Fehlern, auf die Sie stoßen können, können normalerweise behoben werden, indem bei jeder Anfrage weniger Datensätze gesendet werden. Wir empfehlen Ihnen, 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. Wir empfehlen Ihnen, 100 Vorgänge pro Anfrage zu senden und Anfragen parallel zu senden, um einen maximalen Durchsatz zu erreichen.

Bei 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, führt zu einem Rollback des gesamten Vorgangs. Sie sollten Massenvorgänge auf Standardtabellen nur dann verwenden, wenn Sie ein hohes Maß an Vertrauen haben, dass alle Vorgänge erfolgreich sein werden. Vielleicht möchten Sie die SDK ExecuteMultipleRequest Klasse oder die Web-API $batch verwenden, um einen Fallback der Vorgänge zuzulassen, wenn der Massenvorgang fehlschlägt. 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.

Zum Fehlerverhalten bei elastischen Tabellen

Mit elastischen Tabellen kann ein Massenvorgang teilweise erfolgreich sein. 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 Massenvorgangsnachrichten hängt davon ab, ob Sie Standard- oder elastische Tabellen verwenden. Alle elastischen Tabellen unterstützen die CreateMultiple, UpdateMultiple, UpsertMultiple und DeleteMultiple Nachrichten.

Siehe auch:

Verfügbarkeit mit Standardtabellen

Sie können die Nachrichten CreateMultiple und UpdateMultiple für Massenvorgänge mit angepassten Standardtabellen und vielen allgemeinen Standardtabellen verwenden, aber nicht mit allen. Sie sollten testen, 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 der Nachrichten für Massenvorgänge verfügt über 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 an die Nachrichten für Massenvorgänge ist, dass Organisationen nicht verpflichtet sind, angepasste Logik an zwei Stellen zu pflegen. Um die gleiche angepasste Logik zu haben und sie an einer Stelle zu verwalten, haben wir die Pipelines für die Verarbeitung dieser Nachrichten zusammengelegt. Was bedeutet das?

  • Wenn eine Nachricht für einen Massenvorgang verwendet wird, tritt das entsprechende Ereignis Create und Update für jede Entität im Parameter Targets 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 eine Nachricht für einen einzelnen Vorgang verwendet wird, tritt das entsprechende Ereignis für den Massenvorgang mit einer EntityCollection auf, die eine einzelne Entity-Instanz 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 muss weiterhin angewendet werden, wenn Clientanwendungen die Massenvorgangsnachrichten verwenden. Für Tabellen, die mit umfangreichen Massenvorgängen verwendet werden, empfehlen wir Ihnen, die synchrone Logik von Ereignissen mit einzelnen Nachrichten auf Ereignisse mit Massenvorgängen zu verlagern. Wenn Sie neue Logik einführen, verwenden Sie anstelle der einzelnen Vorgangsereignisse die Massenvorgangsereignisse.

Achtung

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 wir Ihre Absicht nicht kennen können.

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, wenn Sie Nachrichten für Massenvorgänge verwenden.

Nachrichtengröße und Zeitlimits

Bei Standardtabellen gibt es einen Leistungsanreiz, mehr Datensätze mit jeder Anfrage zu senden. Die Anzahl der Datensätze, die Sie senden können, ist jedoch durch die Größe der Nutzlast und die für die Verarbeitung des Vorgangs erforderliche Zeit begrenzt.

Grenzwerte für die Nachrichtengröße

Wenn Sie ein Plug-in für eine beliebige Nachricht registriert haben, kann der Fehler „Nachrichtengröße beim Senden von Kontext an Sandbox überschritten“ auftreten, wenn die Gesamtgröße der Anfrage 116,85 MB überschreitet. Bei Nachrichten für Massenvorgänge stoßen Sie eher an diese Grenze, wenn Sie größere Payloads versenden.

Dieser Fehler tritt nicht auf, wenn für das Ereignis kein Plug-In registriert ist. Um den Fehler zu vermeiden, deaktivieren Sie alle Plugins oder senden Sie Ihre Anfrage mit dem optionalen Parameter BypassCustomPluginExecution.

Zeitlimits

Wenn Sie den Dataverse ServiceClient verwenden, kann dieser Fehler auftreten:

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 mit ServiceClient festgelegte Standard-Timeout beträgt 4 Minuten, was für jeden synchronen Vorgang lang ist. Sie können diesen Wert mit der statischen Eigenschaft ServiceClient.MaxConnectionTimeout ändern. Der Standard-Timeout mithilfe von CrmServiceClient beträgt 2 Minuten.

Hinweis

Bevor Sie die Zeitgrenzwerte erhöhen, sollten Sie erwägen, die Anzahl der Datensätze zu reduzieren, die im Targets-Parameter übergeben werden.

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

Derzeit unterstützen wir die Verwendung von Massenvorgangsmeldungen im Plug-In-Code nicht. Weitere Informationen: Verwenden Sie keine Batchanforderungstypen in Plug-Ins und Workflowaktivitäten.

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 bei der Verwendung von Massenvorgängen Fehler auftreten, lesen Sie bitte 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, verwenden Sie die Schaltfläche unten auf der Seite, um Feedback für diese Seite senden und anzeigen. Sie benötigen ein GitHub-Konto, um Feedback zu senden.

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

Wir haben nicht vor, das Verhalten der Nachrichten Retrieve und RetrieveMultiple zu ändern. Es handelt sich dabei seit vielen Jahren um getrennte Nachrichten, und die Entwickler mussten die Logik für diese Funktionen immer separat pflegen. Der Versuch, die Pipeline der Nachrichten für sie zusammenzuführen, wäre höchst problematisch. Außerdem raten wir davon ab, eine angepasste Logik für diese Nachrichten anzuwenden, da diese Auswirkungen auf die Leistung haben kann.

Wie werden API-Grenzwerte angewendet?

Es gibt zwei Arten von API-Grenzen. Die Massenvorgangsmeldungen bieten keine Möglichkeit, beide Typen zu umgehen.

Grenzwerte für den Serviceschutz

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 fällt für diesen Grenzwert an. Erfahren Sie mehr über Anfragelimits und Zuweisungen.

Siehe auch

Verwenden Sie UpsertMultiple (Vorschauversion)
Verwenden Sie DeleteMultiple (Vorschauversion)
Elastische Tabelle
Plug-Ins für „CreateMultiple“ und „UpdateMultiple“ schreiben
Beispiel: SDK für .Net Massenvorgänge 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