Synchronizuj subskrypcję pull

Dotyczy:SQL ServerAzure SQL Managed Instance

Ten temat opisuje, jak zsynchronizować subskrypcję pull w SQL Server za pomocą SQL Server Management Studio, agentów replikacyjnych lub obiektów zarządzania replikacją (RMO).

Korzystanie z programu SQL Server Management Studio

Subskrypcje są synchronizowane przez dystrybucyjny Agent (w celu replikacji migawkowej i transakcyjnej) lub Merge Agent (w celu replikacji scalania). Agenci mogą działać w sposób ciągły, działać na żądanie lub działać zgodnie z harmonogramem. Aby uzyskać więcej informacji na temat określania harmonogramów synchronizacji, zobacz Określanie harmonogramów synchronizacji.

Synchronizuj subskrypcję na żądanie z folderu Lokalne subskrypcje w SQL Server Management Studio.

Aby zsynchronizować subskrypcję pull na żądanie w Management Studio

1. Połącz się z subskrybentem w programie Management Studio, a następnie rozwiń węzeł serwera.

2. Rozwiń folder Replikacja , a następnie rozwiń folder Subskrypcje lokalne .

3. Kliknij prawym przyciskiem myszy subskrypcję, którą chcesz zsynchronizować, a następnie kliknij pozycję Wyświetl stan synchronizacji.

4. W oknie dialogowym Wyświetl stan synchronizacji — <Subskrybent>:<Baza danych subskrypcji> kliknij Start. Po zakończeniu synchronizacji zostanie wyświetlony komunikat Synchronizacja ukończona .

5. Kliknij Zamknij.

Agenci replikacji

Subskrypcje pull mogą być synchronizowane programowo i na żądanie, wywołując odpowiedni plik wykonywalny agenta replikacyjnego z wiersza poleceń. Wywołany plik wykonywalny agenta replikacyjnego będzie zależał od rodzaju publikacji, do której należy subskrypcja pull. Więcej informacji można znaleźć w artykule Agenci replikacji.

Uwaga / Notatka

Agenci replikacji łączą się z lokalnym serwerem, używając danych uwierzytelniających Windows użytkownika, który uruchomił agenta z wiersza poleceń. Te poświadczenia systemu Windows są również używane podczas nawiązywania połączenia ze zdalnymi serwerami przy użyciu zintegrowanego uwierzytelniania systemu Windows.

Aby uruchomić agenta dystrybucyjnego z wiersza poleceń lub z pliku wsadowego

1. Z wiersza poleceń lub w pliku wsadowym uruchom Agenta dystrybucji replikacji, uruchamiając program distrib.exe i podając następujące argumenty wiersza poleceń:

   • -Wydawca

   • -PublisherDB

   • -Dystrybutor

   • = 1

   • -Abonent

   • -SubscriberDB

   • -SubscriberSecurityMode = 1

   • -SubscriptionType = 1

   Jeśli używasz uwierzytelniania programu SQL Server, należy również określić następujące argumenty:

   • -DistributorLogin

   • -HasłoDystrybutora

   • = 0

   • -PublisherLogin

   • -PublisherPassword

   • -PublisherSecurityMode = 0

   • -SubscriberLogin

   • -SubscriberPassword

   • -SubscriberSecurityMode = 0

Aby uruchomić agenta scalania z wiersza poleceń lub z pliku wsadowego

1. Z wiersza poleceń lub w pliku wsadowym uruchom Agenta scalania replikacji, uruchamiając replmerg.exe i określając następujące argumenty wiersza poleceń:

   • -Wydawca

   • -PublisherDB

   • -PublisherSecurityMode = 1

   • -Publikacja

   • -Dystrybutor

   • = 1

   • -Abonent

   • -SubscriberSecurityMode = 1

   • -SubscriberDB

   • -SubscriptionType = 1

   Jeśli używasz uwierzytelniania programu SQL Server, należy również określić następujące argumenty:

   • -DistributorLogin

   • -HasłoDystrybutora

   • -Tryb = Bezpieczeństwa Dystrybutora0

   • -PublisherLogin

   • -PublisherPassword

   • -PublisherSecurityMode = 0

   • -SubscriberLogin

   • -SubscriberPassword

   • -SubscriberSecurityMode = 0

Przykłady (agenci replikacji)

Poniższy przykład uruchamia Agenta dystrybucji w celu zsynchronizowania subskrypcji ściąganej. Wszystkie połączenia są realizowane za pomocą uwierzytelniania Windows.

 -- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks  
SET SubscriptionDB=AdventureWorksReplica   
SET Publication=AdvWorksProductsTran  
  
-- Start the Distribution Agent.  
-- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\100\COM\DISTRIB.EXE" -Subscriber %Subscriber%   
-SubscriberDB %SubscriptionDB% -SubscriberSecurityMode 1 -Publication %Publication%   
-Publisher %Publisher% -PublisherDB %PublicationDB% -Distributor %Publisher%   
-DistributorSecurityMode 1 -Continuous -SubscriptionType 1;  

Poniższy przykład uruchamia Agenta scalania w celu zsynchronizowania subskrypcji typu pull. Wszystkie połączenia są realizowane za pomocą uwierzytelniania Windows.

-- Declare the variables.  
SET Publisher=%instancename%  
SET Subscriber=%instancename%  
SET PublicationDB=AdventureWorks  
SET SubscriptionDB=AdventureWorksReplica   
SET Publication=AdvWorksSalesOrdersMerge  
  
--Start the Merge Agent with concurrent upload and download processes.  
-- The following command must be supplied without line breaks.  
"C:\Program Files\Microsoft SQL Server\100\COM\REPLMERG.EXE" -Publication %Publication%    
-Publisher %Publisher%  -Subscriber  %Subscriber%  -Distributor %Publisher%    
-PublisherDB %PublicationDB%  -SubscriberDB %SubscriptionDB% -PublisherSecurityMode 1    
-OutputVerboseLevel 2  -SubscriberSecurityMode 1  -SubscriptionType 1 -DistributorSecurityMode 1    
-Validate 3  -ParallelUploadDownload 1 ;  

Korzystanie z obiektów zarządzania replikacją (RMO)

Możesz programowo synchronizować subskrypcje pull, korzystając z Obiektów Zarządzania Replikacją (RMO) oraz zarządzanego dostępu do kodu z funkcjami agentów replikacji. Klasy, których używasz do synchronizacji subskrypcji pull, zależą od rodzaju publikacji, do której należy subskrypcja.

Uwaga / Notatka

Jeśli chcesz uruchomić synchronizację, która działa autonomicznie bez wpływu na aplikację, uruchom agenta asynchronicznie. Jednak jeśli chcesz monitorować wynik synchronizacji i otrzymywać odwołania od agenta podczas procesu synchronizacji (na przykład, aby wyświetlić pasek postępu), powinieneś uruchomić agenta synchronicznie. W przypadku subskrybentów programu Microsoft SQL Server 2005 Express należy synchronicznie uruchomić agenta.

Aby zsynchronizować subskrypcję pull z snapshotem lub publikacją transakcyjną

1. Utwórz połączenie z subskrybentem przy użyciu ServerConnection klasy .

2. Utwórz wystąpienie TransPullSubscription klasy i ustaw następujące właściwości:

   • Nazwa bazy danych subskrypcji dla DatabaseName.

   • Nazwa publikacji, do której należy subskrypcja .PublicationName

   • Nazwa bazy danych publikacji dla PublicationDBName.

   • Nazwa Publisher dla PublisherName.

   • Połączenie utworzone w kroku 1 dla elementu ConnectionContext.

3. Wywołaj metodę , LoadProperties aby uzyskać pozostałe właściwości subskrypcji. Jeśli ta metoda zwraca wartość false, sprawdź, czy subskrypcja istnieje.

4. Rozpocznij Distribution Agent u Subskrybenta w jeden z następujących sposobów:

   • Wywołaj metodę SynchronizeWithJob w wystąpieniu TransPullSubscription z kroku 2. Ta metoda asynchronicznie uruchamia agenta dystrybucji, a kontrola natychmiast wraca do aplikacji, podczas gdy zadanie agenta jest wykonywane. Nie można wywołać tej metody dla subskrybentów edycji SQL Server 2005 Express ani jeśli subskrypcja została utworzona z wartością false for CreateSyncAgentByDefault (domyślnie).

   • Pobierz instancję TransSynchronizationAgent klasy z własności SynchronizationAgent i wywołaj metodę Synchronize . Ta metoda uruchamia agenta synchronicznie, a kontrola pozostaje przy uruchomionym zadaniu agenta. Podczas synchronicznego wykonywania można obsłużyć Status zdarzenie podczas działania agenta.

     Uwaga / Notatka

     Jeśli przy tworzeniu subskrypcji pull określiłeś wartość false dla CreateSyncAgentByDefault (domyślną), musisz też podać Distributor, DistributorSecurityMode, a opcjonalnie DistributorLogin , ponieważ DistributorPassword metadane związane z zadaniami agenta dla subskrypcji nie są dostępne w MSsubscription_properties.

Aby zsynchronizować subskrypcję pull z publikacją merge

1. Utwórz połączenie z subskrybentem przy użyciu ServerConnection klasy .

2. Utwórz wystąpienie MergePullSubscription klasy i ustaw następujące właściwości:

   • Nazwa bazy danych subskrypcji dla DatabaseName.

   • Nazwa publikacji, do której należy subskrypcja .PublicationName

   • Nazwa opublikowanej bazy danych dla PublicationDBName.

   • Nazwa Publisher dla PublisherName.

   • Połączenie utworzone w kroku 1 dla elementu ConnectionContext.

3. Wywołaj metodę , LoadProperties aby uzyskać pozostałe właściwości subskrypcji. Jeśli ta metoda zwraca wartość false, sprawdź, czy subskrypcja istnieje.

4. Uruchom agenta scalania u subskrybenta na jeden z następujących sposobów:

   • Wywołaj metodę SynchronizeWithJob w wystąpieniu MergePullSubscription z kroku 2. Ta metoda uruchamia asynchronicznie agenta scalania, a kontrolka natychmiast wraca do aplikacji, gdy zadanie agenta jest uruchomione. Nie można wywołać tej metody dla subskrybentów edycji SQL Server 2005 Express ani jeśli subskrypcja została utworzona z wartością false for CreateSyncAgentByDefault (domyślnie).

   • Pobierz wystąpienie klasy MergeSynchronizationAgent z właściwości SynchronizationAgent i wywołaj metodę Synchronize. Ta metoda uruchamia synchronicznie agenta scalania, a kontrolka pozostaje w uruchomionym zadaniu agenta. Podczas synchronicznego wykonywania można obsłużyć Status zdarzenie podczas działania agenta.

     Uwaga / Notatka

     Jeśli przy tworzeniu subskrypcji pull określiłeś wartość false dla CreateSyncAgentByDefault (domyślną), musisz również podać Distributor, DistributorSecurityMode, PublisherSecurityMode, HostName, SubscriptionType, ExchangeType, a opcjonalnie DistributorLogin, DistributorPassword, PublisherLogina PublisherPassword ponieważ metadane związane z zadaniami agenta dla subskrypcji nie są dostępne w MSsubscription_properties.

Przykłady (RMO)

Ten przykład służy do synchronizowania subskrypcji pull z publikacją transakcyjną, w której agent jest uruchamiany asynchronicznie przy użyciu zadania agenta.

// Define server, publication, and database names.  
String subscriberName = subscriberInstance;  
String publisherName = publisherInstance;  
String publicationName = "AdvWorksProductTran";  
String publicationDbName = "AdventureWorks";  
String subscriptionDbName = "AdventureWorksReplica";  
  
// Create a connection to the Subscriber.  
ServerConnection conn = new ServerConnection(subscriberName);  
  
TransPullSubscription subscription;  
  
try  
{  
    // Connect to the Subscriber.  
    conn.Connect();  
  
    // Define subscription properties.  
    subscription = new TransPullSubscription();  
    subscription.ConnectionContext = conn;  
    subscription.DatabaseName = subscriptionDbName;  
    subscription.PublisherName = publisherName;  
    subscription.PublicationDBName = publicationDbName;  
    subscription.PublicationName = publicationName;  
  
    // If the pull subscription and the job exists, start the agent job.  
    if (subscription.LoadProperties() && subscription.AgentJobId != null)  
    {  
        subscription.SynchronizeWithJob();  
    }  
    else  
    {  
        // Do something here if the subscription does not exist.  
        throw new ApplicationException(String.Format(  
            "A subscription to '{0}' does not exists on {1}",  
            publicationName, subscriberName));  
    }  
}  
catch (Exception ex)  
{  
    // Do appropriate error handling here.  
    throw new ApplicationException("The subscription could not be synchronized.", ex);  
}  
finally  
{  
    conn.Disconnect();  
}  

' Define server, publication, and database names.  
Dim subscriberName As String = subscriberInstance  
Dim publisherName As String = publisherInstance  
Dim publicationName As String = "AdvWorksProductTran"  
Dim publicationDbName As String = "AdventureWorks"  
Dim subscriptionDbName As String = "AdventureWorksReplica"  
  
' Create a connection to the Subscriber.  
Dim conn As ServerConnection = New ServerConnection(subscriberName)  
  
Dim subscription As TransPullSubscription  
  
Try  
    ' Connect to the Subscriber.  
    conn.Connect()  
  
    ' Define subscription properties.  
    subscription = New TransPullSubscription()  
    subscription.ConnectionContext = conn  
    subscription.DatabaseName = subscriptionDbName  
    subscription.PublisherName = publisherName  
    subscription.PublicationDBName = publicationDbName  
    subscription.PublicationName = publicationName  
  
    ' If the pull subscription and the job exists, start the agent job.  
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then  
        subscription.SynchronizeWithJob()  
    Else  
        ' Do something here if the subscription does not exist.  
        Throw New ApplicationException(String.Format( _  
         "A subscription to '{0}' does not exists on {1}", _  
         publicationName, subscriberName))  
    End If  
Catch ex As Exception  
    ' Do appropriate error handling here.  
    Throw New ApplicationException("The subscription could not be synchronized.", ex)  
Finally  
    conn.Disconnect()  
End Try  

Ten przykład synchronizuje subskrypcję typu pull z publikacją transakcyjną, przy czym agent jest uruchamiany synchronicznie.

// Define the server, publication, and database names.  
string subscriberName = subscriberInstance;  
string publisherName = publisherInstance;  
string publicationName = "AdvWorksProductTran";  
string subscriptionDbName = "AdventureWorksReplica";  
string publicationDbName = "AdventureWorks";  
  
// Create a connection to the Subscriber.  
ServerConnection conn = new ServerConnection(subscriberName);  
  
TransPullSubscription subscription;  
  
try  
{  
    // Connect to the Subscriber.  
    conn.Connect();  
  
    // Define the pull subscription.  
    subscription = new TransPullSubscription();  
    subscription.ConnectionContext = conn;  
    subscription.DatabaseName = subscriptionDbName;  
    subscription.PublisherName = publisherName;  
    subscription.PublicationDBName = publicationDbName;  
    subscription.PublicationName = publicationName;  
  
    // If the pull subscription exists, then start the synchronization.  
    if (subscription.LoadProperties())  
    {  
        // Check that we have enough metadata to start the agent.  
        if (subscription.PublisherSecurity != null)  
        {  
            // Synchronously start the Distribution Agent for the subscription.  
            subscription.SynchronizationAgent.Synchronize();  
        }  
        else  
        {  
            throw new ApplicationException("There is insufficient metadata to " +  
                "synchronize the subscription. Recreate the subscription with " +  
                "the agent job or supply the required agent properties at run time.");  
        }  
    }  
    else  
    {  
        // Do something here if the pull subscription does not exist.  
        throw new ApplicationException(String.Format(  
            "A subscription to '{0}' does not exist on {1}",  
            publicationName, subscriberName));  
    }  
}  
catch (Exception ex)  
{  
    // Implement appropriate error handling here.  
    throw new ApplicationException("The subscription could not be " +  
        "synchronized. Verify that the subscription has " +  
        "been defined correctly.", ex);  
}  
finally  
{  
    conn.Disconnect();  
}  

' Define the server, publication, and database names.  
Dim subscriberName As String = subscriberInstance  
Dim publisherName As String = publisherInstance  
Dim publicationName As String = "AdvWorksProductTran"  
Dim subscriptionDbName As String = "AdventureWorksReplica"  
Dim publicationDbName As String = "AdventureWorks"  
  
' Create a connection to the Subscriber.  
Dim conn As ServerConnection = New ServerConnection(subscriberName)  
  
Dim subscription As TransPullSubscription  
  
Try  
    ' Connect to the Subscriber.  
    conn.Connect()  
  
    ' Define the pull subscription.  
    subscription = New TransPullSubscription()  
    subscription.ConnectionContext = conn  
    subscription.DatabaseName = subscriptionDbName  
    subscription.PublisherName = publisherName  
    subscription.PublicationDBName = publicationDbName  
    subscription.PublicationName = publicationName  
  
    ' If the pull subscription exists, then start the synchronization.  
    If subscription.LoadProperties() Then  
        ' Check that we have enough metadata to start the agent.  
        If Not subscription.PublisherSecurity Is Nothing Then  
  
            ' Write agent output to a log file.  
            subscription.SynchronizationAgent.Output = "distagent.log"  
            subscription.SynchronizationAgent.OutputVerboseLevel = 2  
  
            ' Synchronously start the Distribution Agent for the subscription.  
            subscription.SynchronizationAgent.Synchronize()  
        Else  
            Throw New ApplicationException("There is insufficient metadata to " + _  
             "synchronize the subscription. Recreate the subscription with " + _  
             "the agent job or supply the required agent properties at run time.")  
        End If  
    Else  
        ' Do something here if the pull subscription does not exist.  
        Throw New ApplicationException(String.Format( _  
         "A subscription to '{0}' does not exist on {1}", _  
         publicationName, subscriberName))  
    End If  
Catch ex As Exception  
    ' Implement appropriate error handling here.  
    Throw New ApplicationException("The subscription could not be " + _  
     "synchronized. Verify that the subscription has " + _  
     "been defined correctly.", ex)  
Finally  
    conn.Disconnect()  
End Try  

Ten przykład przeprowadza synchronizację subskrypcji typu pull z publikacją scalającą, w której agent jest uruchamiany asynchronicznie za pomocą zadania agenta.

// Define server, publication, and database names.  
String subscriberName = subscriberInstance;  
String publisherName = publisherInstance;  
String publicationName = "AdvWorksSalesOrdersMerge";  
String publicationDbName = "AdventureWorks";  
String subscriptionDbName = "AdventureWorksReplica";  
  
// Create a connection to the Subscriber.  
ServerConnection conn = new ServerConnection(subscriberName);  
  
MergePullSubscription subscription;  
  
try  
{  
    // Connect to the Subscriber.  
    conn.Connect();  
  
    // Define subscription properties.  
    subscription = new MergePullSubscription();  
    subscription.ConnectionContext = conn;  
    subscription.DatabaseName = subscriptionDbName;  
    subscription.PublisherName = publisherName;  
    subscription.PublicationDBName = publicationDbName;  
    subscription.PublicationName = publicationName;  
  
    // If the pull subscription and the job exists, start the agent job.  
    if (subscription.LoadProperties() && subscription.AgentJobId != null)  
    {  
        subscription.SynchronizeWithJob();  
    }  
    else  
    {  
        // Do something here if the subscription does not exist.  
        throw new ApplicationException(String.Format(  
            "A subscription to '{0}' does not exists on {1}",  
            publicationName, subscriberName));  
    }  
}  
catch (Exception ex)  
{  
    // Do appropriate error handling here.  
    throw new ApplicationException("The subscription could not be synchronized.", ex);  
}  
finally  
{  
    conn.Disconnect();  
}  

' Define server, publication, and database names.  
Dim subscriberName As String = subscriberInstance  
Dim publisherName As String = publisherInstance  
Dim publicationName As String = "AdvWorksSalesOrdersMerge"  
Dim publicationDbName As String = "AdventureWorks"  
Dim subscriptionDbName As String = "AdventureWorksReplica"  
  
' Create a connection to the Subscriber.  
Dim conn As ServerConnection = New ServerConnection(subscriberName)  
  
Dim subscription As MergePullSubscription  
  
Try  
    ' Connect to the Subscriber.  
    conn.Connect()  
  
    ' Define subscription properties.  
    subscription = New MergePullSubscription()  
    subscription.ConnectionContext = conn  
    subscription.DatabaseName = subscriptionDbName  
    subscription.PublisherName = publisherName  
    subscription.PublicationDBName = publicationDbName  
    subscription.PublicationName = publicationName  
  
    ' If the pull subscription and the job exists, start the agent job.  
    If subscription.LoadProperties() And Not subscription.AgentJobId Is Nothing Then  
        subscription.SynchronizeWithJob()  
    Else  
        ' Do something here if the subscription does not exist.  
        Throw New ApplicationException(String.Format( _  
         "A subscription to '{0}' does not exists on {1}", _  
         publicationName, subscriberName))  
    End If  
Catch ex As Exception  
    ' Do appropriate error handling here.  
    Throw New ApplicationException("The subscription could not be synchronized.", ex)  
Finally  
    conn.Disconnect()  
End Try  

Ten przykład synchronizuje subskrypcję pull z publikacją scalającą, w której agent jest uruchamiany synchronicznie.

// Define the server, publication, and database names.  
string subscriberName = subscriberInstance;  
string publisherName = publisherInstance;  
string publicationName = "AdvWorksSalesOrdersMerge";  
string subscriptionDbName = "AdventureWorksReplica";  
string publicationDbName = "AdventureWorks";  
  
// Create a connection to the Subscriber.  
ServerConnection conn = new ServerConnection(subscriberName);  
  
MergePullSubscription subscription;  
  
try  
{  
    // Connect to the Subscriber.  
    conn.Connect();  
  
    // Define the pull subscription.  
    subscription = new MergePullSubscription();  
    subscription.ConnectionContext = conn;  
    subscription.DatabaseName = subscriptionDbName;  
    subscription.PublisherName = publisherName;  
    subscription.PublicationDBName = publicationDbName;  
    subscription.PublicationName = publicationName;  
  
    // If the pull subscription exists, then start the synchronization.  
    if (subscription.LoadProperties())  
    {  
        // Check that we have enough metadata to start the agent.  
        if (subscription.PublisherSecurity != null || subscription.DistributorSecurity != null)  
        {  
            // Synchronously start the Merge Agent for the subscription.  
            subscription.SynchronizationAgent.Synchronize();  
        }  
        else  
        {  
            throw new ApplicationException("There is insufficient metadata to " +  
                "synchronize the subscription. Recreate the subscription with " +  
                "the agent job or supply the required agent properties at run time.");  
        }  
    }  
    else  
    {  
        // Do something here if the pull subscription does not exist.  
        throw new ApplicationException(String.Format(  
            "A subscription to '{0}' does not exist on {1}",  
            publicationName, subscriberName));  
    }  
}  
catch (Exception ex)  
{  
    // Implement appropriate error handling here.  
    throw new ApplicationException("The subscription could not be " +  
        "synchronized. Verify that the subscription has " +  
        "been defined correctly.", ex);  
}  
finally  
{  
    conn.Disconnect();  
}  

' Define the server, publication, and database names.  
Dim subscriberName As String = subscriberInstance  
Dim publisherName As String = publisherInstance  
Dim publicationName As String = "AdvWorksSalesOrdersMerge"  
Dim subscriptionDbName As String = "AdventureWorksReplica"  
Dim publicationDbName As String = "AdventureWorks"  
  
' Create a connection to the Subscriber.  
Dim conn As ServerConnection = New ServerConnection(subscriberName)  
  
Dim subscription As MergePullSubscription  
  
Try  
    ' Connect to the Subscriber.  
    conn.Connect()  
  
    ' Define the pull subscription.  
    subscription = New MergePullSubscription()  
    subscription.ConnectionContext = conn  
    subscription.DatabaseName = subscriptionDbName  
    subscription.PublisherName = publisherName  
    subscription.PublicationDBName = publicationDbName  
    subscription.PublicationName = publicationName  
  
    ' If the pull subscription exists, then start the synchronization.  
    If subscription.LoadProperties() Then  
        ' Check that we have enough metadata to start the agent.  
        If Not subscription.PublisherSecurity Is Nothing Or subscription.DistributorSecurity Is Nothing Then  
  
            ' Output agent messages to the console.   
            subscription.SynchronizationAgent.OutputVerboseLevel = 1  
            subscription.SynchronizationAgent.Output = ""  
  
            ' Synchronously start the Merge Agent for the subscription.  
            subscription.SynchronizationAgent.Synchronize()  
        Else  
            Throw New ApplicationException("There is insufficient metadata to " + _  
             "synchronize the subscription. Recreate the subscription with " + _  
             "the agent job or supply the required agent properties at run time.")  
        End If  
    Else  
        ' Do something here if the pull subscription does not exist.  
        Throw New ApplicationException(String.Format( _  
         "A subscription to '{0}' does not exist on {1}", _  
         publicationName, subscriberName))  
    End If  
Catch ex As Exception  
    ' Implement appropriate error handling here.  
    Throw New ApplicationException("The subscription could not be " + _  
     "synchronized. Verify that the subscription has " + _  
     "been defined correctly.", ex)  
Finally  
    conn.Disconnect()  
End Try  

Ten przykład synchronizuje subskrypcję pull z publikacją merge za pomocą synchronizacji web. Subskrypcja została utworzona bez zadania agenta i powiązanych metadanych subskrypcji, więc agent musi zostać uruchomiony synchronicznie i dostarczone są dodatkowe informacje o subskrypcji.

// Define the server, publication, and database names.  
string subscriberName = subscriberInstance;  
string publisherName = publisherInstance;  
string distributorName = distributorInstance;  
string publicationName = "AdvWorksSalesOrdersMerge";  
string subscriptionDbName = "AdventureWorksReplica";  
string publicationDbName = "AdventureWorks";  
string hostname = @"adventure-works\garrett1";  
string webSyncUrl = "https://" + publisherInstance + "/SalesOrders/replisapi.dll";  
  
// Create a connection to the Subscriber.  
ServerConnection conn = new ServerConnection(subscriberName);  
  
MergePullSubscription subscription;  
MergeSynchronizationAgent agent;  
  
try  
{  
    // Connect to the Subscriber.  
    conn.Connect();  
  
    // Define the pull subscription.  
    subscription = new MergePullSubscription();  
    subscription.ConnectionContext = conn;  
    subscription.DatabaseName = subscriptionDbName;  
    subscription.PublisherName = publisherName;  
    subscription.PublicationDBName = publicationDbName;  
    subscription.PublicationName = publicationName;  
  
    // If the pull subscription exists, then start the synchronization.  
    if (subscription.LoadProperties())  
    {  
        // Get the agent for the subscription.  
        agent = subscription.SynchronizationAgent;  
  
        // Check that we have enough metadata to start the agent.  
        if (agent.PublisherSecurityMode == null)  
        {  
            // Set the required properties that could not be returned  
            // from the MSsubscription_properties table.   
            agent.PublisherSecurityMode = SecurityMode.Integrated;  
            agent.DistributorSecurityMode = SecurityMode.Integrated;  
            agent.Distributor = publisherName;  
            agent.HostName = hostname;  
  
            // Set optional Web synchronization properties.  
            agent.UseWebSynchronization = true;  
            agent.InternetUrl = webSyncUrl;  
            agent.InternetSecurityMode = SecurityMode.Standard;  
            agent.InternetLogin = winLogin;  
            agent.InternetPassword = winPassword;  
        }  
        // Enable agent output to the console.  
        agent.OutputVerboseLevel = 1;  
        agent.Output = "";  
  
        // Synchronously start the Merge Agent for the subscription.  
        agent.Synchronize();  
    }  
    else  
    {  
        // Do something here if the pull subscription does not exist.  
        throw new ApplicationException(String.Format(  
            "A subscription to '{0}' does not exist on {1}",  
            publicationName, subscriberName));  
    }  
}  
catch (Exception ex)  
{  
    // Implement appropriate error handling here.  
    throw new ApplicationException("The subscription could not be " +  
        "synchronized. Verify that the subscription has " +  
        "been defined correctly.", ex);  
}  
finally  
{  
    conn.Disconnect();  
}  

' Define the server, publication, and database names.  
Dim subscriberName As String = subscriberInstance  
Dim publisherName As String = publisherInstance  
Dim publicationName As String = "AdvWorksSalesOrdersMerge"  
Dim subscriptionDbName As String = "AdventureWorksReplica"  
Dim publicationDbName As String = "AdventureWorks"  
Dim hostname As String = "adventure-works\garrett1"  
Dim webSyncUrl As String = "https://" + publisherInstance + "/SalesOrders/replisapi.dll"  
  
' Create a connection to the Subscriber.  
Dim conn As ServerConnection = New ServerConnection(subscriberName)  
  
Dim subscription As MergePullSubscription  
Dim agent As MergeSynchronizationAgent  
  
Try  
    ' Connect to the Subscriber.  
    conn.Connect()  
  
    ' Define the pull subscription.  
    subscription = New MergePullSubscription()  
    subscription.ConnectionContext = conn  
    subscription.DatabaseName = subscriptionDbName  
    subscription.PublisherName = publisherName  
    subscription.PublicationDBName = publicationDbName  
    subscription.PublicationName = publicationName  
  
    ' If the pull subscription exists, then start the synchronization.  
    If subscription.LoadProperties() Then  
        ' Get the agent for the subscription.  
        agent = subscription.SynchronizationAgent  
  
        ' Check that we have enough metadata to start the agent.  
        If agent.PublisherSecurityMode = Nothing Then  
            ' Set the required properties that could not be returned  
            ' from the MSsubscription_properties table.   
            agent.PublisherSecurityMode = SecurityMode.Integrated  
            agent.Distributor = publisherInstance  
            agent.DistributorSecurityMode = SecurityMode.Integrated  
            agent.HostName = hostname  
  
            ' Set optional Web synchronization properties.  
            agent.UseWebSynchronization = True  
            agent.InternetUrl = webSyncUrl  
            agent.InternetSecurityMode = SecurityMode.Standard  
            agent.InternetLogin = winLogin  
            agent.InternetPassword = winPassword  
        End If  
  
        ' Enable agent logging to the console.  
        agent.OutputVerboseLevel = 1  
        agent.Output = ""  
  
        ' Synchronously start the Merge Agent for the subscription.  
        agent.Synchronize()  
    Else  
        ' Do something here if the pull subscription does not exist.  
        Throw New ApplicationException(String.Format( _  
         "A subscription to '{0}' does not exist on {1}", _  
         publicationName, subscriberName))  
    End If  
Catch ex As Exception  
    ' Implement appropriate error handling here.  
    Throw New ApplicationException("The subscription could not be " + _  
     "synchronized. Verify that the subscription has " + _  
     "been defined correctly.", ex)  
Finally  
    conn.Disconnect()  
End Try  

Treści powiązane

• Synchronizowanie danych
• Załóż subskrypcję Pull
• Najlepsze rozwiązania dotyczące zabezpieczeń replikacji