Freigeben über

Verarbeiten von E-Mails in Batches mithilfe von EWS in Exchange

  • Artikel

Erfahren Sie, wie Sie Batches von E-Mail-Nachrichten in einem einzigen Aufruf erstellen, abrufen, aktualisieren und löschen, indem Sie die verwaltete EWS-API oder EWS in Exchange verwenden.

Sie können die verwaltete EWS-API oder EWS verwenden, um mit Batches von E-Mail-Nachrichten zu arbeiten, um die Anzahl der Aufrufe eines Clients an einen Exchange-Server zu reduzieren. Wenn Sie die verwaltete EWS-API zum Erstellen, Abrufen, Aktualisieren, Löschen und Senden von Nachrichten in Batches verwenden, verwenden Sie ExchangeService-Objektmethoden , während Sie beim Arbeiten mit einzelnen E-Mail-Nachrichten EmailMessage-Objektmethoden verwenden. Wenn Sie EWS verwenden, verwenden Sie dieselben Vorgänge, um sowohl mit einzel- als auch batches von E-Mail-Nachrichten zu arbeiten.

Tabelle 1. Verwaltete EWS-API-Methoden und EWS-Vorgänge für die Arbeit mit Batches von E-Mail-Nachrichten

Gewünschte Aktion Verwenden dieser verwalteten EWS-API-Methode Zu verwendender EWS-Vorgang
Erstellen von E-Mail-Nachrichten in Batches
 ExchangeService.CreateItems
CreateItem
Abrufen von E-Mail-Nachrichten in Batches
 ExchangeService.BindToItems
GetItem
Aktualisieren von E-Mail-Nachrichten in Batches
 ExchangeService.UpdateItems
UpdateItem
Löschen von E-Mail-Nachrichten in Batches
 ExchangeService.DeleteItems
DeleteItem

In diesem Artikel erfahren Sie, wie Sie grundlegende Aufgaben für Batches von E-Mail-Nachrichten mithilfe der verwalteten EWS-API oder EWS ausführen.

Erstellen von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API

Sie können Nachrichten in Batches erstellen, indem Sie die CreateItems-Methode der verwalteten EWS-API verwenden, wie im folgenden Beispiel gezeigt. In diesem Beispiel werden drei EmailMessage-Objekte lokal erstellt, jede Nachricht einer Auflistung hinzugefügt und dann die CreateItems-Methode für die Auflistung von Nachrichten aufgerufen.

In diesem Beispiel wird davon ausgegangen, dass service ein gültiges ExchangeService-Objekt ist und der Benutzer bei einem Exchange-Server authentifiziert wurde.

public static Collection<ItemId> CreateDraftEmailInBatch(ExchangeService service)
{
    // These are unsaved local instances of an EmailMessage object.
    // Despite the required parameter of an ExchangeService object (service), no call
    // to an Exchange server is made when the objects are instantiated.
    // A call to the Exchange server is made when the service.CreateItems() method is called.
    EmailMessage message1 = new EmailMessage(service);
    EmailMessage message2 = new EmailMessage(service);
    EmailMessage message3 = new EmailMessage(service);
    // Set the properties on the first message.
    message1.Subject = "Project priorities";
    message1.Body = "(1) Buy pizza, (2) Eat pizza";
    message1.ToRecipients.Add("sadie@contoso.com");
    // Set the properties on the second message.
    message2.Subject = "Company Soccer Team";
    message2.Body = "Are you interested in joining?";
    message2.ToRecipients.Add("magdalena@contoso.com");
    // Set the properties on the third message.
    message3.Subject = "Code Blast";
    message3.Body = "Are you interested in getting together to finish the methods for the ContosoLive project?";
    message3.ToRecipients.Add("mack@contoso.com");
    // Add the EmailMessage objects to a collection.
    Collection<EmailMessage> messageItems = new Collection<EmailMessage>() { message1, message2, message3 };
    // Create the batch of email messages on the server.
    // This method call results in an CreateItem call to EWS.
    ServiceResponseCollection<ServiceResponse> response = service.CreateItems(messageItems, WellKnownFolderName.Drafts, MessageDisposition.SaveOnly, null);
    // Instantiate a collection of item IDs to populate from the values that are returned by the Exchange server.
    Collection<ItemId> itemIds = new Collection<ItemId>();
    // Collect the item IDs from the created email messages.
    foreach (EmailMessage message in messageItems)
    {
        try
        {
            itemIds.Add(message.Id);
            Console.WriteLine("Email message '{0}' created successfully.", message.Subject);
        }
        catch (Exception ex)
        {
            // Print out the exception and the last eight characters of the item ID.
            Console.WriteLine("Exception while creating message {0}: {1}", message.Id.ToString().Substring(144), ex.Message);
        }
    }
    // Check for success of the CreateItems method call.
    if (response.OverallResult == ServiceResult.Success)
    {
            Console.WriteLine("All locally created messages were successfully saved to the Drafts folder.");
            Console.WriteLine("\r\n");
    }

    // If the method did not return success, print the result message for each email.
    else
    {
        int counter = 1;
        foreach (ServiceResponse resp in response)
        {
            // Print out the result and the last eight characters of the item ID.
            Console.WriteLine("Result (message {0}), id {1}: {2}", counter, itemIds[counter - 1].ToString().Substring(144), resp.Result);
            Console.WriteLine("Error Code: {0}", resp.ErrorCode);
            Console.WriteLine("ErrorMessage: {0}\r\n", resp.ErrorMessage);
            Console.WriteLine("\r\n");
            counter++;
        }
    }
    return itemIds;
}

Beachten Sie, dass im Beispiel nur die Nachrichten im Ordner Entwürfe gespeichert werden. Die Nachrichten werden nicht gesendet. Weitere Informationen zum Senden der Nachrichten finden Sie unter Senden von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API.

Erstellen von E-Mail-Nachrichten in Batches mithilfe von EWS

Sie können E-Mail-Nachrichten in Batches erstellen, indem Sie den EWS-Vorgang CreateItem verwenden, wie im folgenden Codebeispiel gezeigt. Dies ist auch die XML-Anforderung, die die verwaltete EWS-API sendet, wenn Sie die verwaltete EWS-API verwenden, um E-Mail-Nachrichten in Batches zu erstellen.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages"
               xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"
               xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <t:RequestServerVersion Version="Exchange2007_SP1" />
  </soap:Header>
  <soap:Body>
    <m:CreateItem MessageDisposition="SaveOnly">
      <m:SavedItemFolderId>
        <t:DistinguishedFolderId Id="drafts" />
      </m:SavedItemFolderId>
      <m:Items>
        <t:Message>
          <t:Subject>Project priorities</t:Subject>
          <t:Body BodyType="HTML">(1) Buy pizza, (2) Eat pizza</t:Body>
          <t:ToRecipients>
            <t:Mailbox>
              <t:EmailAddress>sadie@contoso.com</t:EmailAddress>
            </t:Mailbox>
          </t:ToRecipients>
        </t:Message>
        <t:Message>
          <t:Subject>Company Soccer Team</t:Subject>
          <t:Body BodyType="HTML">Are you interested in joining?</t:Body>
          <t:ToRecipients>
            <t:Mailbox>
              <t:EmailAddress>magdalena@contoso.com</t:EmailAddress>
            </t:Mailbox>
          </t:ToRecipients>
        </t:Message>
        <t:Message>
          <t:Subject>Code Blast</t:Subject>
          <t:Body BodyType="HTML">Are you interested in getting together to finish the methods for the ContosoLive project?</t:Body>
          <t:ToRecipients>
            <t:Mailbox>
              <t:EmailAddress>mack@contoso.com</t:EmailAddress>
            </t:Mailbox>
          </t:ToRecipients>
        </t:Message>
      </m:Items>
    </m:CreateItem>
  </soap:Body>
</soap:Envelope>

Der Server antwortet auf die CreateItem-Anforderung mit einer CreateItemResponse-Nachricht , die den ResponseCode-WertNoError für jede der neuen Nachrichten enthält, was angibt, dass jede E-Mail erfolgreich erstellt und gespeichert wurde.

Beachten Sie, dass im Beispiel nur die Nachrichten im Ordner Entwürfe gespeichert werden. Die Nachrichten werden nicht gesendet. Weitere Informationen zum Senden der Nachrichten finden Sie unter Senden von E-Mail-Nachrichten in Batches mithilfe von EWS.

Senden von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API

Sie verwenden denselben Code zum Senden von E-Mail-Nachrichten in Batches, den Sie zum Erstellen von E-Mail-Nachrichten in Batches verwenden, mit der Ausnahme, dass einige der Parameter der CreateItems-Methode geändert werden. Verwenden Sie also zum Senden von E-Mail-Nachrichten mithilfe der verwalteten EWS-API den Code, den Sie zum Erstellen von E-Mail-Nachrichten in Batches verwenden, und ersetzen Sie den Aufruf der CreateItems-Methode durch den Aufruf im folgenden Beispiel. In diesem Beispiel werden die Nachrichten im Ordner Gesendete Elemente erstellt, und die Nachrichtendisposition wird in MessageDisposition.SendAndSaveCopy geändert, sodass die Nachricht gesendet und nicht nur lokal gespeichert wird.

// Create and send the batch of email messages on the server.
// This method call results in an CreateItem call to EWS.
ServiceResponseCollection<ServiceResponse> response = service.CreateItems(messageItems, WellKnownFolderName.SentItems, MessageDisposition.SendAndSaveCopy, null);

Senden von E-Mail-Nachrichten in Batches mithilfe von EWS

Sie verwenden denselben Code zum Senden von E-Mail-Nachrichten in Batches, den Sie zum Erstellen von E-Mail-Nachrichten in Batches verwenden, mit der Ausnahme, dass sich einige der Attributwerte für den CreateItem-Vorgang ändern. Wenn Sie also E-Mail-Nachrichten mithilfe von EWS senden möchten, verwenden Sie den Code, den Sie zum Erstellen von E-Mail-Nachrichten in Batches verwenden, und ändern Sie den MessageDisposition-Wert in "SendAndSaveCopy", und ändern Sie distinguishedFolderId in "sentitems", wie im folgenden Codebeispiel gezeigt.

<m:CreateItem MessageDisposition="SendAndSaveCopy">
  <m:SavedItemFolderId>
    <t:DistinguishedFolderId Id="sentitems" />
  </m:SavedItemFolderId>

Der Server antwortet auf die CreateItem-Anforderung mit einer CreateItemResponse-Nachricht , die den ResponseCode-WertNoError für jede der neuen Nachrichten enthält, was angibt, dass jede E-Mail erfolgreich erstellt und gesendet wurde.

Abrufen von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API

Sie können E-Mail-Nachrichten in Batches abrufen, indem Sie die BindToItems-Methode der verwalteten EWS-API verwenden, wie im folgenden Beispiel gezeigt.

In diesem Beispiel wird davon ausgegangen, dass service ein gültiges ExchangeService-Objekt ist und der Benutzer bei einem Exchange-Server authentifiziert wurde.

public static Collection<EmailMessage> BatchGetEmailItems(ExchangeService service, Collection<ItemId> itemIds)
{
    // Create a property set that limits the properties returned by the Bind method to only those that are required.
    PropertySet propSet = new PropertySet(BasePropertySet.IdOnly, EmailMessageSchema.Subject, EmailMessageSchema.ToRecipients);
    // Get the items from the server.
    // This method call results in a GetItem call to EWS.
    ServiceResponseCollection<GetItemResponse> response = service.BindToItems(itemIds, propSet);

    // Instantiate a collection of EmailMessage objects to populate from the values that are returned by the Exchange server.
    Collection<EmailMessage> messageItems = new Collection<EmailMessage>();
    foreach (GetItemResponse getItemResponse in response)
    {
        try
        {
            Item item = getItemResponse.Item;
            EmailMessage message = (EmailMessage)item;
            messageItems.Add(message);
            // Print out confirmation and the last eight characters of the item ID.
            Console.WriteLine("Found item {0}.", message.Id.ToString().Substring(144));
        }
        catch (Exception ex)
        {
           Console.WriteLine("Exception while getting a message: {0}", ex.Message);
        }
    }
    // Check for success of the BindToItems method call.
    if (response.OverallResult == ServiceResult.Success)
    {
        Console.WriteLine("All email messages retrieved successfully.");
        Console.WriteLine("\r\n");
    }
        return messageItems;
}

Abrufen von E-Mail-Nachrichten in Batches mithilfe von EWS

Sie können E-Mail-Nachrichten in Batches abrufen, indem Sie den EWS-Vorgang GetItem und den Code im folgenden Beispiel verwenden. Dies ist auch die XML-Anforderung, die die verwaltete EWS-API sendet, wenn Sie die verwaltete EWS-API verwenden, um E-Mail-Nachrichten in Batches abzurufen.

[!HINWEIS] Die Attribute ItemId und ChangeKey wurden zur besseren Lesbarkeit gekürzt.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages"
               xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"
               xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <t:RequestServerVersion Version="Exchange2007_SP1" />
  </soap:Header>
  <soap:Body>
    <m:GetItem>
      <m:ItemShape>
        <t:BaseShape>IdOnly</t:BaseShape>
        <t:AdditionalProperties>
          <t:FieldURI FieldURI="item:Subject" />
          <t:FieldURI FieldURI="message:ToRecipients" />
        </t:AdditionalProperties>
      </m:ItemShape>
      <m:ItemIds>
        <t:ItemId Id="m4NxAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKB0" />
        <t:ItemId Id="m4NyAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKB1" />
        <t:ItemId Id="m4NzAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKB2" />
      </m:ItemIds>
    </m:GetItem>
  </soap:Body>
</soap:Envelope>

Der Server antwortet auf die GetItem-Anforderung mit einer GetItemResponse-Nachricht , die die Eigenschaften der ersten Klasse für jede der angeforderten Nachrichten enthält.

Aktualisieren von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API

Sie können E-Mail-Nachrichten in Batches abrufen, indem Sie die UpdateItems-Methode der verwalteten EWS-API verwenden, wie im folgenden Beispiel gezeigt.

Eine Liste der beschreibbaren E-Mail-Nachrichteneigenschaften finden Sie unter Email Eigenschaften und Elemente in EWS in Exchange.

Ausführliche Informationen zum Senden eines Nachrichtenentwurfs nach der Aktualisierung finden Sie unter Senden von E-Mail-Nachrichten mithilfe der verwalteten EWS-API.

In diesem Beispiel wird davon ausgegangen, dass service ein gültiges ExchangeService-Objekt ist und der Benutzer bei einem Exchange-Server authentifiziert wurde.

public static Collection<EmailMessage> BatchUpdateEmailItems(ExchangeService service, Collection<EmailMessage> messageItems)
{
    // Update the subject of each message locally.
    foreach (EmailMessage message in messageItems)
    {
        // Update the Subject of the email.
        message.Subject = "Updated subject at " + DateTime.Now;
        // Print out confirmation with the last eight characters of the item ID and the email subject.
        Console.WriteLine("Updated local email message {0} with the subject '{1}'.", message.Id.ToString().Substring(144), message.Subject);
    }
    // Send the item updates to the server.
    // This method call results in an UpdateItem call to EWS.
    ServiceResponseCollection<UpdateItemResponse> response = service.UpdateItems(messageItems, WellKnownFolderName.Drafts, ConflictResolutionMode.AutoResolve, MessageDisposition.SaveOnly, null);
    // Check for success of the UpdateItems method call.
    if (response.OverallResult == ServiceResult.Success)
    {
        Console.WriteLine("All email messages updated successfully.\r\n");
    }
    // If the method did not return success, print the result message for each email.
    else
    {
        Console.WriteLine("All emails were not successfully saved on the server.\r\n");
        int counter = 1;
        foreach (ServiceResponse resp in response)
        {
            Console.WriteLine("Result for (message {0}): {1}", counter, resp.Result);
            Console.WriteLine("Error Code: {0}", resp.ErrorCode);
            Console.WriteLine("ErrorMessage: {0}\r\n", resp.ErrorMessage);
            counter++;
        }
    }
    return messageItems;
}

Aktualisieren von E-Mail-Nachrichten in Batches mithilfe von EWS

Sie können E-Mail-Nachrichten in Batches mithilfe des EWS-Vorgangs GetItem aktualisieren, wie im folgenden Codebeispiel gezeigt. Dies ist auch die XML-Anforderung, die die verwaltete EWS-API sendet, wenn Sie die verwaltete EWS-API verwenden, um E-Mail-Nachrichten in Batches zu aktualisieren.

Eine Liste der beschreibbaren E-Mail-Nachrichtenelemente finden Sie unter Email Eigenschaften und Elemente in EWS in Exchange.

Ausführliche Informationen zum Senden eines Nachrichtenentwurfs nach der Aktualisierung finden Sie unter Senden eines E-Mail-Nachrichtenentwurfs mithilfe von EWS.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages"
               xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"
               xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <t:RequestServerVersion Version="Exchange2007_SP1" />
  </soap:Header>
  <soap:Body>
    <m:UpdateItem MessageDisposition="SaveOnly"
                  ConflictResolution="AutoResolve">
      <m:SavedItemFolderId>
        <t:DistinguishedFolderId Id="drafts" />
      </m:SavedItemFolderId>
      <m:ItemChanges>
        <t:ItemChange>
          <t:ItemId Id="m4OVAAA="
                    ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKCy" />
          <t:Updates>
            <t:SetItemField>
              <t:FieldURI FieldURI="item:Subject" />
              <t:Message>
                <t:Subject>Updated subject at 1/17/2014 2:58:09 PM</t:Subject>
              </t:Message>
            </t:SetItemField>
          </t:Updates>
        </t:ItemChange>
        <t:ItemChange>
          <t:ItemId Id="m4OWAAA="
                    ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKCz" />
          <t:Updates>
            <t:SetItemField>
              <t:FieldURI FieldURI="item:Subject" />
              <t:Message>
                <t:Subject>Updated subject at 1/17/2014 2:58:09 PM</t:Subject>
              </t:Message>
            </t:SetItemField>
          </t:Updates>
        </t:ItemChange>
        <t:ItemChange>
          <t:ItemId Id="m4OXAAA="
                    ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKC0" />
          <t:Updates>
            <t:SetItemField>
              <t:FieldURI FieldURI="item:Subject" />
              <t:Message>
                <t:Subject>Updated subject at 1/17/2014 2:58:09 PM</t:Subject>
              </t:Message>
            </t:SetItemField>
          </t:Updates>
        </t:ItemChange>
      </m:ItemChanges>
    </m:UpdateItem>
  </soap:Body>
</soap:Envelope>

Der Server antwortet auf die UpdateItem-Anforderung mit einer UpdateItemResponse-Nachricht , die den ResponseCode-WertNoError enthält, der angibt, dass jedes der Updates erfolgreich auf dem Server gespeichert wurde. Alle Konflikte werden im ConflictResult-Element gemeldet.

Löschen von E-Mail-Nachrichten in Batches mithilfe der verwalteten EWS-API

Sie können Nachrichten in Batches löschen, indem Sie die DeleteItems-Methode der verwalteten EWS-API verwenden, wie im folgenden Beispiel gezeigt.

In diesem Beispiel wird davon ausgegangen, dass service ein gültiges ExchangeService-Objekt ist und der Benutzer bei einem Exchange-Server authentifiziert wurde.

public static void BatchDeleteEmailItems(ExchangeService service, Collection<ItemId> itemIds)
{
    // Delete the batch of email message objects.
    // This method call results in an DeleteItem call to EWS.
    ServiceResponseCollection<ServiceResponse> response = service.DeleteItems(itemIds, DeleteMode.SoftDelete, null, AffectedTaskOccurrence.AllOccurrences);

    // Check for success of the DeleteItems method call.
    // DeleteItems returns success even if it does not find all the item IDs.
    if (response.OverallResult == ServiceResult.Success)
    {
        Console.WriteLine("Email messages deleted successfully.\r\n");
    }
    // If the method did not return success, print a message.
    else
    {
        Console.WriteLine("Not all email messages deleted successfully.\r\n");
    }
}

Löschen von E-Mail-Nachrichten in Batches mithilfe von EWS

Sie können E-Mail-Nachrichten in Batches löschen, indem Sie den EWS-Vorgang DeleteItem verwenden, wie im folgenden Codebeispiel gezeigt. Dies ist auch die XML-Anforderung, die die verwaltete EWS-API sendet, wenn Sie die verwaltete EWS-API verwenden, um E-Mail-Nachrichten in Batches zu löschen.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages"
               xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"
               xmlns:soap="https://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <t:RequestServerVersion Version="Exchange2007_SP1" />
  </soap:Header>
  <soap:Body>
    <m:DeleteItem DeleteType="SoftDelete"
                  AffectedTaskOccurrences="AllOccurrences">
      <m:ItemIds>
        <t:ItemId Id="m4OkAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKDE" />
        <t:ItemId Id="m4OlAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKDF" />
        <t:ItemId Id="m4OmAAA="
                  ChangeKey="CQAAABYAAAApjGm7TnMWQ5TzjbhziLL0AAF/yKDG" />
      </m:ItemIds>
    </m:DeleteItem>
  </soap:Body>
</soap:Envelope>

Der Server antwortet auf die DeleteItem-Anforderung mit einer DeleteItemResponse-Nachricht , die den ResponseCode-WertNoError für jedes entfernte Element enthält. Beachten Sie, dass der Vorgang auch einen Erfolg zurückgibt, wenn die Element-ID nicht gefunden werden konnte.

Überprüfen, ob ein Batchprozess erfolgreich abgeschlossen wurde

Wenn eine oder mehrere E-Mail-Nachrichten in einer Batchanforderung nicht wie angefordert verarbeitet werden können, wird für jede fehlgeschlagene E-Mail-Nachricht ein Fehler zurückgegeben, und die restlichen E-Mails im Batch werden erwartungsgemäß verarbeitet. Fehler bei der Batchverarbeitung können auftreten, wenn das Element gelöscht wurde und daher nicht gesendet, abgerufen oder aktualisiert werden kann, oder wenn das Element in einen anderen Ordner verschoben wurde und daher über eine neue Element-ID verfügt und nicht mit der gesendeten Element-ID geändert werden kann. Die Informationen in diesem Abschnitt zeigen, wie Fehlerdetails zu Fehlern bei der Batchverarbeitung von E-Mail-Nachrichten abgerufen werden.

Um den Erfolg eines Batchprozesses mithilfe der verwalteten EWS-API zu überprüfen, können Sie überprüfen, ob die OverallResult-Eigenschaft der ServiceResponseCollectiongleich ServiceResult.Success ist. Wenn ja, wurden alle E-Mails erfolgreich verarbeitet. Wenn das OverallResult ungleich ServiceResult.Success ist, wurde mindestens eine der E-Mails nicht erfolgreich verarbeitet. Jedes der in serviceResponseCollection zurückgegebenen Objekte enthält die folgenden Eigenschaften:

Diese Eigenschaften enthalten Informationen dazu, warum die E-Mail-Nachrichten nicht wie angefordert verarbeitet werden konnten. In den Beispielen in diesem Artikel werden ergebnis-, errorCode- und ErrorMessage-Elemente für jede fehlerhafte Nachricht ausgegeben. Sie können diese Ergebnisse verwenden, um das Problem zu untersuchen.

Überprüfen Sie für EWS das ResponseClass-Attribut für jedes verarbeitete Element, um den Erfolg eines Batchprozesses zu überprüfen. Es folgt die grundlegende Struktur von ResponseMessageType, dem Basistyp, von dem alle Antwortnachrichten abgeleitet werden.

<ResponseMessage ResponseClass="Success | Warning | Error">
            <MessageText/>
            <ResponseCode/>
            <DescriptiveLinkKey/>
            <MessageXml/>
</ResponseMessage>

Das ResponseClass-Attribut ist auf Success festgelegt, wenn die E-Mail erfolgreich verarbeitet wurde, oder Auf Fehler , wenn die E-Mail nicht erfolgreich verarbeitet wurde. Bei E-Mail-Nachrichten wird während der Batchverarbeitung keine Warnung angezeigt. Wenn ResponseClassauf Success festgelegt ist, wird auch das darauf folgende ResponseCode-Element immer auf NoError festgelegt. Wenn ResponseClassauf Error festgelegt ist, müssen Sie die Werte der MessageText-, ResponseCode- und MessageXml-Elemente überprüfen, um zu ermitteln, was das Problem verursacht hat. DescriptiveLinkKey wird derzeit nicht verwendet.

Siehe auch