Freigeben über

Benutzen Sie elastische Tabellen mit Code

  • Artikel

Dieser Artikel beschreibt, wie Sie mit Hilfe von Code Datenvorgänge auf elastischen Tabellen durchführen können.

Arbeiten Sie mit dem Sitzungstoken

Wie in Konsistenzlevel erwähnt, können Sie Konsistenz auf Sitzungsebene erreichen, indem Sie das aktuelle Sitzungstoken mit Ihren Anforderungen übergeben. Wenn Sie das Sitzungstoken nicht einbeziehen, enthalten die Daten, die Sie abrufen, möglicherweise nicht die Datenänderungen, die Sie gerade vorgenommen haben.

Abrufen des Session Token

Das Sitzungstoken ist in der Antwort auf alle Schreibvorgänge verfügbar. Suchen Sie nach dem Wert x-ms-session-token.

Für jede OrganizationResponse, die einen Schreibvorgang durchführt, können Sie den x-ms-session-token-Wert in der Sammlung Results erfassen.

Hinweis

DeleteResponse gibt aktuell nicht den Wert x-ms-session-token zurück. Weitere Informationen finden Sie unter Bekanntes Problem: Kein x-ms-session-token-Wert wird bei Löschvorgängen zurückgegeben.

string sessionToken = response.Results["x-ms-session-token"].ToString();

Senden des Session Token

Auf welche Weise Sie das Sitzungstoken in einem Lesevorgang senden, hängt davon ab, ob Sie das SDK oder die Web-API verwenden.

Wenn Sie einen Vorgang durchführen, der Daten abruft, legen Sie den optionalen Parameter SessionToken auf OrganizationRequest fest.

var request = new RetrieveRequest
{
    Target = new EntityReference("contoso_sensordata", sensordataid),
    ColumnSet = new ColumnSet("contoso_value"),
    ["partitionId"] = deviceId,
    ["SessionToken"] = sessionToken
};

Weitere Informationen zur Verwendung optionaler Parameter.

PartitionId angeben

Wie in Partitionierung und horizontale Skalierung erwähnt, verfügt jede elastische Tabelle über eine Spalte partitionid, die Sie verwenden müssen, wenn Sie eine Partitionierungsstrategie für die Tabelle anwenden wollen. Legen Sie andernfalls keinen Wert für die Spalte partitionid fest.

Wichtig

Wenn Sie sich für die Verwendung einer Partitionierungsstrategie für Ihre elastische Tabelle entscheiden, MÜSSEN alle Vorgänge für diese Tabelle bzw. alle Vorgänge, die sich auf Datensätze in dieser Tabelle beziehen, den partitionid-Spaltenwert zur eindeutigen Identifizierung des Datensatzes angeben. Es tritt kein Fehler auf, wenn partitionid nicht im Suchwert der verweisenden Tabelle angegeben ist, aber die Suche kann den Datensatz nicht finden, wenn Sie ihn verwenden. Sie müssen diese Anforderung mittels Codeüberprüfungen dokumentieren und erzwingen, um sicherzustellen, dass Ihre Daten konsistent sind und partitionid für alle Vorgänge entsprechend verwendet wird.

Nachdem Sie beim Erstellen einer Zeile einen Nicht-Null-Wert für die Spalte partitionid angegeben haben, müssen Sie diesen bei allen anderen Datenvorgängen mit dieser Zeile angeben. Sie können den Wert später nicht ändern.

Wenn Sie bei der Erstellung eines Datensatzes keinen partitionid-Wert festlegen, bleibt der Wert der Spalte partitionid NULL und kann später nicht mehr geändert werden. In diesem Fall können Sie die Datensätze anhand des Primärschlüssels identifizieren, wie Sie es normalerweise bei Standardtabellen tun. Die Angabe eines partitionid-Werts ist nicht erforderlich.

Hinweis

Die Beispiele in diesem Artikel gehen davon aus, dass Sie der Spalte partitionid einen Wert angeben, der nicht Null ist.

Sie können den Wert partitionid auf folgende Weise festlegen, wenn Sie verschiedene Vorgänge mit Daten durchführen.

Verwenden des Alternativschlüssels

Wie in Alternativschlüssel erwähnt, hat jede elastische Tabelle einen Alternativschlüssel mit der Bezeichnung KeyForNoSqlEntityWithPKPartitionId. Dieser alternative Schlüssel kombiniert den Primärschlüssel der Tabelle mit der Spalte partitionid.

Wenn Sie eine Partitionierungsstrategie verwenden, müssen Sie einen Alternativschlüssel angeben, um den partitionid-Wert zu spezifizieren, wenn Sie die Vorgänge Retrieve, Update oder Delete verwenden oder eine Nachschlagespalte für eine andere Tabelle festlegen, die auf einen Datensatz aus einer elastischen Tabelle verweist.

Dieses Beispiel zeigt, wie Sie bei Retrieve-, Update- und Delete-Anforderungen für elastische Tabellen den Alternativschlüssel zur Angabe des partitionid-Werts verwenden können.

var keys = new KeyAttributeCollection() {
    { "contoso_sensordataid", sensordataid },
    { "partitionid", deviceId }
};

var entity = new Entity("contoso_sensordata", keys)

Verwendung des Parameters partitionId

Derzeit können Sie den Wert der Spalte partitionid nur für die Vorgänge Retrieve und Delete mit dem Parameter partitionId angeben. Weitere Informationen finden Sie unter Bekanntes Problem: Der optionale partitionId-Parameter ist nicht für alle Nachrichten verfügbar.

Hinweis

Der partitionId-Parameter funktioniert nicht mit Create-, Update- oder Upsert-Nachrichten und wird ignoriert, wenn er gesendet wird.

request["partitionId"] = "device-001"

Direkte Verwendung der partitionid-Spalte

Für Create-, Upsert- oder Update-Vorgänge können Sie den Wert der Spalte partitionid direkt angeben.

Dieses Beispiel zeigt, wie Sie den Wert der Spalte partitionid in Entity direkt angeben können, wenn Sie einen Create-, Upsert- oder Update-Vorgang ausführen.

var entity = new Entity("contoso_sensordata", sensordataid)
{
    Attributes = {
        { "partitionid", "device-001" }
    }
};

Erstellen Sie einen Datensatz in einer elastischen Tabelle

In diesem Beispiel wird eine Zeile in der Tabelle contoso_SensorData erstellt, wobei partitionid auf deviceid festgelegt ist. Es legt auch die Spalte ttlinseconds fest, um sicherzustellen, dass die Zeile nach einem Tag (86.400 Sekunden) abläuft und automatisch aus Dataverse gelöscht wird.

Dieses Beispiel erfasst auch den x-ms-session-token-Wert, den Sie beim Abrufen des erstellten Datensatzes verwenden können.

/// <summary>
/// Demonstrates creating a record with a partitionid and capturing the session token
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="deviceId">The value used as partitionid for the contoso_sensordata table. </param>
/// <param name="sessionToken">The current session token</param>
/// <returns>The Id of the created record.</returns>
public static Guid CreateExample(
    IOrganizationService service, 
    string deviceId, 
    ref string sessionToken )
{
    var entity = new Entity("contoso_sensordata")
    {
        Attributes =
            {
                { "contoso_deviceid", deviceId },
                { "contoso_sensortype", "Humidity" },
                { "contoso_value", 40 },
                { "contoso_timestamp", DateTime.UtcNow},
                { "partitionid", deviceId },
                { "ttlinseconds", 86400  }  // 86400  seconds in a day
            }
    };

    var request = new CreateRequest { 
        Target = entity
    };

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

    // Capture the session token
    sessionToken = response.Results["x-ms-session-token"].ToString();

    return response.id;
}

Verwenden Sie den zurückgegebenen x-ms-session-token-Wert, um den optionalen Parameter SessionToken festzulegen, wenn Sie den von Ihnen erstellten Datensatz abrufen. Weitere Informationen zum Senden des Sitzungstokens.

Hinweis

Tiefes Einfügen wird derzeit nicht mit elastischen Tabellen unterstützt. Jeder zugehörige Datensatz muss unabhängig erstellt werden. Nur Standardtabellen unterstützen die tiefe Einfügung

Den Primärschlüsselwert festlegen

Wenn Sie keinen Primärschlüsselwert angeben, legt Dataverse einen Primärschlüsselwert für den Datensatz fest, wenn Sie ihn erstellen. Es ist üblich, Dataverse zu erlauben, diesen Wert festzulegen. Bei Bedarf können Sie den Primärschlüsselwert angeben. Bei elastischen Tabellen gibt es keinen Leistungsvorteil, wenn Sie Dataverse erlauben, den Primärschlüsselwert festzulegen.

Elastische Tabellen geben keinen Fehler zurück, wenn Sie einen Datensatz mit einem Primärschlüsselwert erstellen, der nicht eindeutig ist. Durch Festlegen der Primärschlüsselwerte mit elastischen Tabellen können Sie Datensätze erstellen, die dieselben Primärschlüsselwerte und unterschiedliche partitionid-Werte haben. Dieses Muster ist jedoch nicht mit Power Apps kompatibel. Erstellen Sie keine Datensätze mit doppelten Primärschlüsselwerten, wenn Benutzende diese Daten in Canvas- oder modellgesteuerten Apps verwenden müssen.

Aktualisieren eines Datensatzes in einer elastischen Tabelle

Dieses Beispiel aktualisiert die Werte contoso_value und contoso_timestamp einer bestehenden Zeile in der Tabelle contoso_SensorData unter Verwendung des Primärschlüssels contoso_sensordataid und partitionid = 'device-001'.

Wenn Sie eine Partitionierungsstrategie verwenden, sind der Primärschlüssel und die Spalte partitionid erforderlich, um eine vorhandene Zeile der elastischen Tabelle eindeutig zu identifizieren. Der partitionid-Wert einer bestehenden Zeile kann nicht aktualisiert werden und wird nur zur eindeutigen Identifizierung der zu aktualisierenden Zeile verwendet.

In diesem Beispiel wird der Alternativschlüssel KeyForNoSqlEntityWithPKPartitionId verwendet, um den Datensatz sowohl mit dem Primärschlüssel- als auch mit dem partitionid-Wert eindeutig zu identifizieren. Weitere Informationen zu Alternativschlüsseln.

Dieses Beispiel zeigt die Verwendung des Werts partitionid als Alternativschlüssel.

/// <summary>
/// Demonstrates updating elastic table row with partitionid as alternate key.
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="sensordataid">The unique identifier of the contoso_sensordata table.</param>
/// <param name="deviceId">The value used as partitionid for the contoso_sensordata table. </param>
/// <param name="sessionToken">The current session token</param>
public static void UpdateExample(
    IOrganizationService service, 
    Guid sensordataid, 
    string deviceId, 
    ref string sessionToken)
{
    var keys = new KeyAttributeCollection() {
        { "contoso_sensordataid", sensordataid },
        { "partitionid", deviceId }
    };

    var entity = new Entity("contoso_sensordata", keys)
    {
        Attributes = {
            { "contoso_value", 60 },
            { "contoso_timestamp", DateTime.UtcNow }
        }
    };

    var request = new UpdateRequest { 
        Target = entity,
        ["SessionToken"] = sessionToken
    };

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

    // Capture the session token
    sessionToken = response.Results["x-ms-session-token"].ToString();
}

Weitere Informationen über die Verwendung der Entity-Klasse zum Festlegen von Alternativschlüsseln.

Abrufen eines Datensatzes in einer elastischen Tabelle

Wenn der Wert partitionid beim Erstellen eines Datensatzes einer elastischen Tabelle festgelegt wurde, müssen Sie ihn zusammen mit dem Primärschlüsselwert verwenden, um einen Datensatz eindeutig zu identifizieren.

Wenn partitionid nicht festgelegt wurde, können Sie den Datensatz normal abrufen, indem Sie nur den Wert des Primärschlüssels verwenden.

Es gibt zwei verschiedene Möglichkeiten, eine Anforderung zum Abrufen eines Datensatzes mithilfe des Werts partitionid zu erstellen.

In diesem Beispiel wird die RetrieveRequest-Klasse verwendet. Die Target-Eigenschaft ist auf eine EntityReference festgelegt, die mithilfe des Konstruktors erstellt wird, der eine KeyAttributeCollection akzeptiert, um den Alternativschlüssel KeyForNoSqlEntityWithPKPartitionId zu verwenden. Weitere Informationen über die Verwendung der EntityReference-Klasse mit Alternativschlüsseln.

public static void RetrieveExampleAlternateKey(IOrganizationService service, Guid sensorDataId, string deviceId) {

    var keys = new KeyAttributeCollection() {
        { "contoso_sensordataid", sensorDataId },
        { "partitionid", deviceId }
    };

    var entityReference = new EntityReference("contoso_sensordata", keys);

    var request = new RetrieveRequest { 
        ColumnSet = new ColumnSet("contoso_value"),
        Target = entityReference
    };

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

    Console.WriteLine($"contoso_value: {response.Entity.GetAttributeValue<int>("contoso_value")}");
}

Dieses Beispiel verwendet einen optionalen Parameter namens partitionId in der RetrieveRequest-Klasse. Weitere Informationen zur Verwendung optionaler Parameter.

public static void RetrieveExampleOptionalParameter(IOrganizationService service, Guid sensorDataId, string deviceId)
{
    var entityReference = new EntityReference("contoso_sensordata", sensorDataId);

    var request = new RetrieveRequest
    {
        ColumnSet = new ColumnSet("contoso_value"),
        Target = entityReference,
        ["partitionId"] = deviceId
    };

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

    Console.WriteLine($"contoso_value: {response.Entity.GetAttributeValue<int>("contoso_value")}");
}

Abfragen von Zeilen einer elastischen Tabelle

Wenn Sie die Zeilen einer elastischen Tabelle abfragen, erzielen Sie die beste Leistung, wenn Sie Ihre Abfrage auf eine bestimmte Partition beschränken. Andernfalls gibt Ihre Abfrage Daten über alle logischen Partitionen zurück, was nicht so schnell ist.

Hinweis

Wenn Sie diesen Ansatz verwenden, muss der Parameter den Namen partitionId (mit einem Großbuchstaben I) anstelle von partitionid (alles in Kleinbuchstaben) verwenden.

Wenn Sie einen Filter auf diese Weise angeben, müssen Sie die Filterkriterien in Ihrer Abfrage nicht auf die übliche Weise angeben (d. h. mithilfe von partitionid , FetchXML condition QueryExpression ConditionExpression oder Web API). $filter

Die übliche Angabe eines Filters für den Wert partitionid hat nicht die gleichen Leistungsvorteile wie die Angabe über den Parameter partitionId, wie in den folgenden Beispielen gezeigt.

Diese Beispiele rufen die ersten 5.000 Zeilen in der Tabelle contoso_SensorData ab, die zur logischen Partition gehören, wobei partitionid = 'deviceid-001' ist.

public static EntityCollection RetrieveMultipleExample(IOrganizationService service)
{
    var request = new RetrieveMultipleRequest
    {
        Query = new QueryExpression("contoso_sensordata")
        {
            ColumnSet = new ColumnSet("contoso_value")
        },
        ["partitionId"] = "deviceid-001"
    };

    var response = (RetrieveMultipleResponse)service.Execute(request);
    return response.EntityCollection;
}

Elastische Tabellen unterstützen derzeit nicht die Rückgabe zusammenhängender Zeilen bei der Ausführung einer Abfrage. Wenn Sie versuchen, verwandte Zeilen zurückzugeben, wird von Dataverse ein Fehler mit dem Code 0x80048d0b und der folgenden Meldung ausgegeben:

Link entities are not supported.

Elastische Tabellen unterstützen jedoch die Rückgabe zusammengehöriger Zeilen, wenn eine einzelne Zeile abgerufen wird.

Einfügen eines Datensatzes in eine elastische Tabelle (Upsert)

Wichtig

Upsert-Vorgänge mit elastischen Tabellen unterscheiden sich von Upsert-Vorgängen mit Standardtabellen. Bei Upsert-Vorgängen wird erwartet, dass sie den vollständigen Payload enthalten und alle vorhandenen Datensätze überschreiben. Sie rufen keine Create- oder Update-Nachrichten auf. Weitere Informationen zum Upsert für elastische Tabellen.

Bei elastischen Tabellen wird ein Datensatz mit einer bestimmten ID und partitionid erstellt, wenn er noch nicht existiert. Wenn er bereits existiert, wird er ersetzt.

Dieses Beispiel führt einen Upsert für eine Zeile in der Tabelle contoso_SensorData mit dem angegebenen Wert id und partitionid = deviceid-001 aus.

/// <summary>
/// Demonstrates an upsert operation
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="id">The id of the record to update or create.</param>
/// <param name="sessionToken">The current session token</param>
/// <returns>Whether a record was created or not</returns>
public static bool UpsertExample(IOrganizationService service, Guid id, ref string sessionToken)
{
    var entity = new Entity("contoso_sensordata", id)
    {
        Attributes = {
            { "contoso_deviceid", "deviceid-001" },
            { "contoso_sensortype", "Humidity" },
            { "contoso_value", 60 },
            { "contoso_timestamp", DateTime.UtcNow },
            { "partitionid", "deviceid-001" },
            { "ttlinseconds", 86400 }
        }
    };

    var request = new UpsertRequest
    {
        Target = entity,
        ["SessionToken"] = sessionToken
    };

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

    // Capture the session token
    sessionToken = response.Results["x-ms-session-token"].ToString();

    return response.RecordCreated;
}

Löschen eines Datensatzes in einer elastischen Tabelle

Wenn Sie einen Datensatz löschen, der einen angepassten partitionid-Wert verwendet, müssen Sie den partitionid-Wert einschließen.

Dieses Beispiel löscht eine Zeile in der Tabelle contoso_SensorData mit der angegebenen ID und partitionid = 'deviceid-001'.

/// <summary>
/// Demonstrates a delete operation
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="sensordataid">The unique identifier of the contoso_sensordata table.</param>
/// <param name="sessionToken">The current session token</param>
public static void DeleteExample(
    IOrganizationService service, 
    Guid sensordataid, 
    ref string sessionToken)
{
    var request = new DeleteRequest
    {
        Target = new EntityReference("contoso_sensordata", sensordataid),
        ["partitionId"] = "deviceid-001"
    };

    var response = service.Execute(request);
    // Known issue: Value not currently being returned.
    // sessionToken = response.Results["x-ms-session-token"].ToString();
}

Datensätze aus elastischen Tabellen verknüpfen

Wenn sich ein Tabellendatensatz auf einen Datensatz aus einer elastischen Tabelle bezieht, dessen partitionid-Spaltenwert null ist, können Sie einen Datensatz in dieser Tabelle genau wie Standarddatensätze mit einem Datensatz einer elastischen Tabelle verknüpfen. Siehe SDK für .NET oder Web-API.

Wenn ein Tabellendatensatz auf einen Datensatz aus einer elastischen Tabelle verweist, für den der partitionid-Spaltenwert festgelegt ist, müssen Sie den partitionid-Spaltenwert des Datensatzes aus einer elastischen Tabelle einbeziehen, wenn Sie die Nachschlagespalte der verweisenden Tabelle festlegen. Dazu können Sie den Wert als Alternativschlüssel einfügen.

Wie in Spalte „Partitionid-Wert“ in der verweisenden Tabelle beschrieben, wenn eine 1:n-Beziehung erstellt wird und die elastische Tabelle die verwiesene Tabelle ist, wird eine Zeichenfolgenspalte und eine Nachschlagespalte in der verweisenden Tabelle erstellt. In der Zeichenfolgenspalte wird der partitionid-Wert des Datensatzes der verwiesenen elastischen Tabelle gespeichert.

Sie können sowohl die Nachschlage- als auch die Zeichenfolgenspaltenwerte mit ihren jeweiligen Werten festlegen, indem Sie:

  • eine Alternativschlüssel-Referenz verwenden, um nur das Nachschlagen festzulegen
  • die beiden Spaltenwerte zusammen in einer Aktualisierung festlegen

Wie Sie vorgehen, hängt davon ab, ob Sie das SDK für .NET oder die Web-API verwenden.

In diesem Beispiel wird ein Datensatz aus der elastischen Tabelle contoso_SensorData mit der angegebenen ID und partitionid einem vorhandenen Kontodatensatz verknüpft, indem die Nachschlagespalte mit einem Alternativschlüssel festgelegt wird:

/// <summary>
/// Demonstrates associate to elastic table operation.
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="sensordataId">The unique identifier of the contoso_sensordata table.</param>
/// <param name="deviceId">The deviceId. PartitionId of sensor data record.</param>
/// <param name="accountId">The unique identifier of the account record to update.</param>
public static void AssociateAccountAlternateKeyExample(
    IOrganizationService service,
    Guid sensordataId,
    string deviceId,
    Guid accountId)
{
    var keys = new KeyAttributeCollection() {
        { "contoso_sensordataid", sensordataId },
        { "partitionid", deviceId }
    };

    var sensorDataReference = new EntityReference("contoso_sensordata", keys);

    Entity account = new("account", accountId)
    {
        Attributes =
            {
                {"contoso_sensordata", sensorDataReference}
            }
    };

    service.Update(account);
}

In diesem Beispiel wird ebenso vorgegangen, nur dass jetzt beide Spalten zusammen festgelegt werden:

/// <summary>
/// Demonstrates associate to elastic table operation.
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="sensordataId">The unique identifier of the contoso_sensordata table.</param>
/// <param name="deviceId">The deviceId. PartitionId of sensor data record.</param>
/// <param name="deviceId">The unique identifier of the account record to update.</param>
public static void AssociateAccountBothColumnsExample(
    IOrganizationService service,
    Guid sensordataId,
    string deviceId,
    Guid accountId)
{
    Entity account = new("account", accountId) {
        Attributes =
            {
                {"contoso_sensordata", new EntityReference("contoso_sensordata", sensordataId)},
                {"contoso_sensordatapid", deviceId }
            }
    };

    service.Update(account);
}

In letzten Beispiel wird AssociateRequest verwendet, um eine Sammlung von account- Datensätzen demselben contoso_SensorData-Tabellendatensatz in einem Vorgang zuzuordnen.

/// <summary>
/// Demonstrates associating multiple accounts to a contoso_sensordata elastic table record
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="sensordataId">The unique identifier of the contoso_sensordata table.</param>
/// <param name="deviceId">The deviceId. PartitionId of sensor data record.</param>
/// <param name="relatedEntities">A collection of references to account records to associate to the contoso_sensordata elastic table record</param>
public static void AssociateMultipleElasticTableExample(
   IOrganizationService service,
   Guid sensordataId,
   string deviceId,
   EntityReferenceCollection relatedEntities)
{

   // The keys to the elastic table record including the partitionid
   var keys = new KeyAttributeCollection() {
         { "contoso_sensordataid", sensordataId },
         { "partitionid", deviceId }
   };

   AssociateRequest request = new()
   {
         Target = new EntityReference("contoso_sensordata", keys),
         Relationship = new Relationship("contoso_SensorData_contoso_SensorData_Acc"),
         RelatedEntities = relatedEntities
   };

   service.Execute(request);
}

Bulk-Vorgänge mit elastischen Tabellen

Oft müssen Anwendungen in kurzer Zeit eine große Datenmenge in Dataverse erfassen. Dataverse verfügt über eine Gruppe von Nachrichten, die darauf ausgelegt sind, einen hohen Durchsatz zu erzielen. Mit elastischen Tabellen kann der Durchsatz sogar höher sein.

Massenvorgänge werden für die Durchführung mehrerer Schreibvorgänge auf dieselbe Tabelle optimiert, indem ein Batch von Zeilen als Eingabe in einem einzigen Schreibvorgang verwendet wird. Erfahren Sie mehr über Nachrichten für Massenvorgänge (Vorschauversion).

CreateMultiple mit elastischen Tabellen verwenden

Sie können die CreateMultiple Nachricht entweder mit dem SDK für .NET oder der Web-API verwenden.

In diesem Beispiel wird die CreateMultipleRequest-Klasse verwendet, um mehrere Zeilen in der elastischen Tabelle contoso_SensorData zu erstellen.

public static Guid CreateMultiple(IOrganizationService service)
{
    string tableLogicalName = "contoso_sensordata";

    List<Microsoft.Xrm.Sdk.Entity> entityList = new List<Microsoft.Xrm.Sdk.Entity>
    {      
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_deviceId", "deviceid-001" },
                { "contoso_sensortype", "Humidity" },
                { "contoso_value", "40" },
                { "contoso_timestamp", "2023-05-01Z05:00:00"},
                { "partitionid", "deviceid-001" },
                { "ttlinseconds", 86400 }
            }
        },
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_deviceId", "deviceid-002" },
                { "contoso_sensortype", "Humidity" },
                { "contoso_value", "10" },
                { "contoso_timestamp", "2023-05-01Z09:30:00"},
                { "partitionid", "deviceid-002" },
                { "ttlinseconds", 86400 }
            }
        }
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_deviceId", "deviceid-002" },
                { "contoso_sensortype", "Pressure" },
                { "contoso_value", "20" },
                { "contoso_timestamp", "2023-05-01Z07:20:00"},
                { "partitionid", "deviceid-002" },
                { "ttlinseconds", 86400 }
            }
        }
    };

    // Create an EntityCollection populated with the list of entities.
    EntityCollection entities = new(entityList)
    {
        EntityName = tableLogicalName
    };

    // Use CreateMultipleRequest
    CreateMultipleRequest createMultipleRequest = new()
    {
        Targets = entities,
    };
    return service.Execute(request);
}

Verwenden Sie UpdateMultiple mit elastischen Tabellen

Sie können die UpdateMultiple Nachricht entweder mit dem SDK für .NET oder der Web-API verwenden.

In diesem Beispiel wird die UpdateMultipleRequest-Klasse verwendet, um mehrere Zeilen der elastischen Tabelle contoso_SensorData zu aktualisieren. Diese Aktualisierung legt die Spalte contoso_value fest.

public static Guid UpdateMultiple(IOrganizationService service)
{
    string tableLogicalName = "contoso_sensordata";

    List<Microsoft.Xrm.Sdk.Entity> entityList = new List<Microsoft.Xrm.Sdk.Entity>
    {
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_value", "45" },
                { "partitionid", "deviceid-001" }
            }
        },
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_value", "15" },
                { "partitionid", "deviceid-002" }
            }
        }
        new Microsoft.Xrm.Sdk.Entity(tableLogicalName)
        {
            Attributes =
            {
                { "contoso_value", "25" },
                { "partitionid", "deviceid-002" }
            }
        }
    };

    // Create an EntityCollection populated with the list of entities.
    EntityCollection entities = new(entityList)
    {
        EntityName = tableLogicalName
    };

    // Use UpdateMultipleRequest
    UpdateMultipleRequest updateMultipleRequest = new()
    {
        Targets = entities,
    };
    return service.Execute(request);
}

DeleteMultiple mit elastischen Tabellen verwenden

Sie können die DeleteMultiple Nachricht entweder mit dem SDK für .NET oder der Web-API verwenden.

Hinweis

Mit dem SDK müssen Sie die OrganizationRequest-Klasse verwenden, da das SDK derzeit keine DeleteMultipleRequest-Klasse hat. Weitere Informationen zur Verwendung von Nachrichten mit dem SDK für .NET.

Die folgende statische Methode DeleteMultipleExample verwendet die DeleteMultiple-Nachricht mit der OrganizationRequest-Klasse, um mehrere Zeilen aus der elastischen Tabelle contoso_SensorData zu löschen. Der Alternativschlüssel wird verwendet, um den partitionid-Wert einzuschließen, um die 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);
}

Nächste Schritte,

Erfahren Sie, wie Sie mit Code JavaScript Object Notation (JSON)-Daten in JSON-Spalten in elastischen Tabellen erstellen und abfragen können.

JSON-Spalten abfragen

Siehe auch

Elastische Tabellen für Entwickler
Erstellen Sie elastische Tabellen mit Code
Abfrage von JSON-Spalten in elastischen Tabellen
Beispielcode für elastische Tabellen
Massenvorgangsnachrichten (Vorschauversion)