Freigeben über


Gewusst wie: Speichern und Wiederherstellen eines Änderungstokens

Letzte Änderung: Dienstag, 28. Juli 2009

Gilt für: SharePoint Foundation 2010

Wenn das Änderungsprotokoll von der Anwendung regelmäßig abgefragt wird, können Sie das letzte Änderungstoken am Ende der Ausführung beibehalten und zu einem späteren Zeitpunkt das beibehaltene Token rekonstruieren, um es als Startpunkt für die nächste Ausführung zu verwenden. Rufen Sie zum Speichern eines Änderungstokens zunächst die SPChangeToken.ToString()-Methode auf, um eine Zeichenfolgendarstellung des Tokens abzurufen. Speichern Sie dann das Ergebnis in einem dauerhaften Speicher. Rufen Sie zum Wiederherstellen des Tokens die Zeichenfolge aus dem Speicher ab, und übergeben Sie es an den SPChangeToken.SPChangeToken(String)-Konstruktor.

VorsichtVorsicht

Änderungstoken sind spezifisch für eine Liste, Website, Websitesammlung oder Inhaltsdatenbank. Das SPChangeToken-Objekt eines Objekts kann nicht in der GetChanges-Methode eines anderen Objekts verwendet werden. Zu dieser Regel gibt es nur eine Ausnahme: Ein SPChangeToken-Objekt aus einem SPContentDatabase-Objekt kann in der GetChanges-Methode für ein beliebiges Objekt verwendet werden, das in dieser Inhaltsdatenbank enthalten ist.

Beispiel

Beim folgenden Beispiel handelt es sich um eine Konsolenanwendung, die das Änderungsprotokoll nach Änderungen im Inhaltsdatenbankbereich abfragt.

Bei der ersten Ausführung der Anwendung werden alle Änderungen abgerufen, die vom Anfang des Protokolls bis zum aktuellen Ende aufgezeichnet wurden. Diese Abfrage wird ausgeführt, indem zunächst die ChangeTokenStart-Eigenschaft eines SPChangeQuery-Objekts auf einen NULL-Wert festgelegt wird und dann das SPQuery-Objekt an die GetChanges-Methode übergeben wird. Nachdem alle Änderungen verarbeitet wurden, wird das letzte Änderungstoken vom letzten Batch mit Änderungen vom Programm serialisiert, indem die ToString()-Methode aufgerufen wird. Das Ergebnis wird dann in einer Datei auf dem Datenträger gespeichert.

Bei nachfolgenden Ausführungen wird das gespeicherte Änderungstoken vom Programm deserialisiert und zum Festlegen der ChangeTokenStart-Eigenschaft verwendet, wodurch der Startpunkt für die Abfrage des Änderungsprotokolls definiert wird. Die ChangeTokenEnd-Eigenschaft bleibt auf den standardmäßigen NULL-Wert festgelegt, wodurch signalisiert wird, dass die Abfrage bis zum Ende des Protokolls fortgesetzt werden soll.

Die wichtigsten Aufgaben werden in der GetStartingToken-Funktion erledigt. Hier wird der SPChangeToken-Konstruktor aufgerufen.

using System;
using System.IO;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;

namespace Test
{
   class ConsoleApp
   {
      private const string DATA_FILE_PATH = "ChangeToken.dat";

      static void Main(string[] args)
      {
         using (SPSite site = new SPSite("https://localhost"))
         {
            SPChangeQuery query = new SPChangeQuery(true, true);
            query.ChangeTokenStart = GetStartingToken();

            while (true)
            {
               // Get a batch of changes.
               SPChangeCollection changes = site.ContentDatabase.GetChanges(query);

               // Process them.
               foreach (SPChange change in changes)
               {
                  Console.WriteLine("Date: {0}  Type of object: {1}  Type of change: {2}",
                     change.Time.ToShortDateString(), change.GetType().ToString(), change.ChangeType);
               }

               // Starting point for next batch.
               query.ChangeTokenStart = changes.LastChangeToken;

               // If this is the last batch, exit.
               if (changes.Count < query.FetchLimit)
                  break;
            }
            // Serialize the last token as a starting point for the next run.
            SaveLastToken(query.ChangeTokenStart);
         }

         Console.Write("\nPress ENTER to continue...");
         Console.ReadLine();
      }

      static SPChangeToken GetStartingToken()
      {
         // Passing a null token to GetChanges fetches 
         // changes from the start of the log.
         SPChangeToken token = null;

         // If we have a token from the last run, use it.
         if (File.Exists(DATA_FILE_PATH))
         {
            using (FileStream fs = File.OpenRead(DATA_FILE_PATH))
            {
               BinaryReader br = new BinaryReader(fs);
               try
               {
                  string str = br.ReadString();
                  // Construct a change token from serialized string.
                  token = new SPChangeToken(str);
               }
               catch (EndOfStreamException e)
               {
                  // No serialized string, so do nothing.
               }
               finally
               {
                  br.Close();
               }
            }
         }
         return token;
      }

      static void SaveLastToken(SPChangeToken token)
      {
         using (FileStream fs = File.Create(DATA_FILE_PATH))
         {
            // Serialize the token.
            BinaryWriter bw = new BinaryWriter(fs);
            string s = token.ToString();
            bw.Write(s);

            // Flush and close.
            bw.Flush();
            bw.Close();
         }
      }
   }
}
Imports System
Imports System.IO
Imports Microsoft.SharePoint
Imports Microsoft.SharePoint.Administration

Module ConsoleApp

   Private Const DATA_FILE_PATH As String = "ChangeToken.dat"

   Sub Main()
      Using site As SPSite = New SPSite("https://localhost")

         Dim query As New SPChangeQuery(True, True)
         query.ChangeTokenStart = GetStartingToken()

         While (True)
            ' Get a batch of changes.
            Dim changes As SPChangeCollection = site.ContentDatabase.GetChanges(query)

            ' Process them.
            For Each change As SPChange In changes
               Console.WriteLine("Date: {0}  Type of object: {1}  Type of change: {2}", _
                     change.Time.ToShortDateString(), change.GetType().ToString(), change.ChangeType)
            Next

            ' This is the starting point for next batch.
            query.ChangeTokenStart = changes.LastChangeToken

            ' If this is the last batch, exit.
            If changes.Count < query.FetchLimit Then
               Exit While
            End If

         End While

         ' Serialize the last token as a starting point for the next run.
         SaveLastToken(query.ChangeTokenStart)
      End Using

      Console.Write(vbCrLf + "Press ENTER to continue...")
      Console.ReadLine()

   End Sub

   Function GetStartingToken() As SPChangeToken
      ' Passing a null token to GetChanges fetches 
      ' changes from the start of the log.
      Dim token As SPChangeToken = Nothing

      ' If we have a token from the last run, use it.
      If File.Exists(DATA_FILE_PATH) Then
         Using fs As FileStream = File.OpenRead(DATA_FILE_PATH)
            Dim br As BinaryReader = New BinaryReader(fs)
            Try
               Dim str As String = br.ReadString()
               ' Construct a change token from serialized string.
               token = New SPChangeToken(str)
            Catch e As EndOfStreamException
               ' No serialized string, so do nothing.
            Finally
               br.Close()
            End Try
         End Using
      End If

      Return token
   End Function

   Sub SaveLastToken(ByRef token As SPChangeToken)
      Using fs As FileStream = File.Create(DATA_FILE_PATH)
         ' Serialize the token.
         Dim bw As BinaryWriter = New BinaryWriter(fs)
         Dim s As String = token.ToString()
         bw.Write(s)
         ' Flush and close.
         bw.Flush()
         bw.Close()
      End Using
   End Sub

End Module

Siehe auch

Referenz

SPChangeToken

SPChangeTokenCollection