Konzepte für Replikationsverwaltungsobjekte (RMO)

Einführung in die RMO-Programmierung

RMO wurde zum Programmieren aller Aspekte der SQL Server-Replikation entwickelt. Der RMO-Namespace lautet Microsoft.SqlServer.Replication. Er wird durch die Microsoft.SqlServer.Rmo.dll, eine Microsoft .NET Framework-Assembly, implementiert. Die Microsoft.SqlServer.Replication.dll-Assembly, die ebenfalls zum Microsoft.SqlServer.Replication-Namespace gehört, implementiert eine verwaltete Codeschnittstelle zum Programmieren der verschiedenen Replikations-Agents (Snapshot-Agent, Verteilungs-Agent und Merge-Agent). Der Zugriff auf die entsprechenden Klassen kann in RMO erfolgen, um Abonnements zu synchronisieren. Klassen im Microsoft.SqlServer.Replication.BusinessLogicSupport-Namespace, die durch die Microsoft.SqlServer.Replication.BusinessLogicSupport.dll-Assembly implementiert werden, dienen zum Erstellen benutzerdefinierter Geschäftslogik für die Mergereplikation. Diese Assembly ist von RMO unabhängig.

Bereitstellen von Anwendungen auf Grundlage von RMO

RMO hängt von den Replikationskomponenten und den Clientverbindungskomponenten ab, die in allen Versionen von SQL Server mit Ausnahme von SQL Server Compact enthalten sind. Zum Bereitstellen einer Anwendung auf Grundlage von RMO müssen Sie eine Version von SQL Server, die Replikationskomponenten und Clientverbindungskomponenten enthält, auf dem Computer installieren, auf dem die Anwendung ausgeführt wird.

Erste Schritte mit RMO

In diesem Abschnitt wird beschrieben, wie ein einfaches RMO-Projekt mit Microsoft Visual Studio gestartet wird.

So erstellen Sie ein neues Microsoft Visual C#-Projekt

So erstellen Sie ein neues Microsoft Visual Basic .NET-Projekt

Verbinden mit einem Replikationsserver

Bei RMO-Programmierobjekten ist es erforderlich, dass eine Verbindung zu einer Instanz von SQL Server mithilfe einer Instanz der ServerConnection-Klasse erfolgt. Diese Verbindung mit dem Server erfolgt unabhängig von einem RMO-Programmierobjekt. Sie wird anschließend entweder während der Erstellung der Instanz oder durch die Zuweisung zur ConnectionContext-Eigenschaft des Objekts an das RMO-Objekt übergeben. Dadurch können ein RMO-Programmierobjekt und die Instanzen des Verbindungsobjekts getrennt erstellt und verwaltet werden. Zudem kann ein einzelnes Verbindungsobjekt mit mehreren RMO-Programmierobjekten verwendet werden. Für Verbindungen mit einem Replikationsserver gelten die folgenden Regeln:

• Alle Eigenschaften für die Verbindung werden für ein angegebenes ServerConnection-Objekt definiert.

• Jede Verbindung zu einer Instanz von SQL Server muss über ein eigenes ServerConnection-Objekt verfügen.

• Das ServerConnection-Objekt ist der ConnectionContext-Eigenschaft des RMO-Programmierobjekts zugewiesen, das auf dem Server erstellt oder auf das über den Server zugegriffen wird.

• Mit der Connect-Methode wird die Verbindung mit dem Server geöffnet. Diese Methode muss aufgerufen werden, bevor Methoden aufgerufen werden, die auf den Server zugreifen, oder bevor RMO-Programmierobjekte aufgerufen werden, die diese Verbindung verwenden.

• Da sowohl RMO- als auch SQL Server-Verwaltungsobjekte (SMO) die ServerConnection-Klasse für Verbindungen zu SQL Server verwenden, können RMO- und SMO-Objekte die gleiche Verbindung verwenden. Weitere Informationen finden Sie unter Herstellen einer Verbindung zu einer Instanz von SQL Server.

• Sämtliche Authentifizierungsinformationen, die zur Herstellung der Verbindung und zur erfolgreichen Anmeldung beim Server erforderlich sind, sind im ServerConnection-Objekt angegeben.

• Die Windows-Authentifizierung ist als Standard vorgegeben. Um die SQL Server-Authentifizierung verwenden zu können, muss LoginSecure auf false festgelegt sein, und Login und Password müssen auf eine gültige SQL Server-Anmeldung und ein gültiges Kennwort festgelegt sein. Anmeldeinformationen müssen stets sicher aufbewahrt und behandelt werden. Nach Möglichkeit sollte die Eingabe zur Laufzeit erfolgen.

• Für Multithreadanwendungen sollte in jedem Thread ein separates ServerConnection-Objekt verwendet werden.

Rufen Sie die Disconnect-Methode für das ServerConnection-Objekt auf, um aktive, von RMO-Objekten verwendete Serververbindungen zu schließen.

Festlegen von RMO-Eigenschaften

Die Eigenschaften von RMO-Programmierobjekten stellen die Eigenschaften dieser Replikationsobjekte auf dem Server dar. Wenn Sie neue Replikationsobjekte auf dem Server erstellen, werden diese Objekte mithilfe von RMO-Eigenschaften definiert. Für vorhandene Objekte stellen die RMO-Eigenschaften die Eigenschaften des vorhandenen Objekts dar, die nur für nicht schreibgeschützte oder festlegbare Eigenschaften geändert werden können. Eigenschaften können für neue Objekte oder vorhandene Objekte festgelegt werden.

Festlegen von Eigenschaften für neue Replikationsobjekte

Festlegen von Eigenschaften für vorhandene Replikationsobjekte

Für auf dem Server vorhandene Replikationsobjekte unterstützt RMO abhängig vom Objekt die Fähigkeit, einige oder alle Eigenschaften zu ändern. Nur nicht schreibgeschützte oder festlegbare Eigenschaften können geändert werden. Bevor Eigenschaften geändert werden können, muss entweder die Load-Methode oder die LoadProperties-Methode aufgerufen werden, um die aktuellen Eigenschaften vom Server abzurufen. Durch Aufrufen dieser Methoden wird angegeben, dass ein vorhandenes Objekt geändert wird.

Beim Ändern der Objekteigenschaften führt RMO standardmäßig einen Commit für diese Änderungen auf dem Server auf Grundlage des verwendeten Ausführungsmodus von ServerConnection aus. Mit der IsExistingObject-Methode können Sie überprüfen, ob ein Objekt auf dem Server vorhanden ist, bevor Sie versuchen, die entsprechenden Eigenschaften abzurufen oder zu ändern. Weitere Informationen zum Ändern der Eigenschaften eines Replikationsobjekts finden Sie unter Vorgehensweise: Anzeigen und Ändern von Verleger- und Verteilereigenschaften (RMO-Programmierung).

Hinweis
Wenn mehrere RMO-Clients oder mehrere Instanzen eines RMO-Programmierobjekts auf das gleiche Replikationsobjekt auf dem Server zugreifen, kann die Refresh-Methode des RMO-Objekts aufgerufen werden, um Eigenschaften basierend auf dem aktuellen Status des Objekts auf dem Server zu aktualisieren.

Zwischenspeichern von Eigenschaftsänderungen

Wenn die SqlExecutionModes-Eigenschaft auf CaptureSql festgelegt ist, werden alle von RMO generierten Transact-SQL-Anweisungen erfasst, sodass sie manuell mit einer der Ausführungsmethoden in einem einzelnen Batch ausgeführt werden können. Mit RMO können Sie Eigenschaftsänderungen zwischenspeichern und mit der CommitPropertyChanges-Methode des Objekts einen Commit für alle Änderungen gleichzeitig in einem einzelnen Batch durchführen. Um Eigenschaftsänderungen zwischenzuspeichern, muss die CachePropertyChanges-Eigenschaft des Objekts auf true festgelegt werden. Beim Zwischenspeichern von Eigenschaftsänderungen in RMO wird der Zeitpunkt, wann Änderungen an den Server gesendet werden, nach wie vor vom ServerConnection-Objekt gesteuert. Weitere Informationen zum Zwischenspeichern von Eigenschaftsänderungen eines Replikationsobjekts finden Sie unter Vorgehensweise: Anzeigen und Ändern von Verleger- und Verteilereigenschaften (RMO-Programmierung).

Wichtig
Obwohl die ServerConnection-Klasse das Deklarieren von expliziten Transaktionen beim Festlegen von Eigenschaften unterstützt, können diese Transaktionen interne Replikationstransaktionen beeinträchtigen und zu unerwarteten Ergebnissen führen und sollten daher nicht mit RMO verwendet werden.

Beispiel

In diesem Beispiel wird das Zwischenspeichern der Eigenschaftsänderungen veranschaulicht. Änderungen an den Attributen einer Transaktionsveröffentlichung werden zwischengespeichert, bis sie explizit an den Server gesendet werden.

           // Define the server, database, and publication names
            string publisherName = publisherInstance;
            string publicationName = "AdvWorksProductTran";
            string publicationDbName = "AdventureWorks";

            TransPublication publication;

            // Create a connection to the Publisher.
            ServerConnection conn = new ServerConnection(publisherName);

            try
            {
                // Connect to the Publisher.
                conn.Connect();

                // Set the required properties for the publication.
                publication = new TransPublication();
                publication.ConnectionContext = conn;
                publication.Name = publicationName;
                publication.DatabaseName = publicationDbName;

                // Explicitly enable caching of property changes on this object.
                publication.CachePropertyChanges = true;

                // If we can't get the properties for this publication, 
                // throw an application exception.
                if (publication.LoadProperties())
                {
                    // Enable support for push subscriptions and disable support 
                    // for pull subscriptions.
                    if ((publication.Attributes & PublicationAttributes.AllowPull) != 0)
                    {
                        publication.Attributes ^= PublicationAttributes.AllowPull;
                    }
                    if ((publication.Attributes & PublicationAttributes.AllowPush) == 0)
                    {
                        publication.Attributes |= PublicationAttributes.AllowPush;
                    }

                    // Send changes to the server.
                    publication.CommitPropertyChanges();
                }
                else
                {
                    throw new ApplicationException(String.Format(
                        "Settings could not be retrieved for the publication. " +
                        "Ensure that the publication {0} exists on {1}.",
                        publicationName, publisherName));
                }
            }
            catch (Exception ex)
            {
                // Do error handling here.
                throw new ApplicationException(
                    "The publication property could not be changed.", ex);
            }
            finally
            {
                conn.Disconnect();
            }

Siehe auch

Konzepte