public static ReplicationProperties GetProperties(string connectionString, string publicationLabel) { string[] vals = publicationLabel.Split(':'); string publisher = vals[0]; string publicationDatabase = vals[1]; string publication = vals[2]; using (SqlCeReplication repl = new SqlCeReplication()) { repl.SubscriberConnectionString = connectionString; repl.Publisher = publisher; repl.Publication = publication; repl.PublisherDatabase = publicationDatabase; repl.LoadProperties(); var props = new ReplicationProperties(); props.InternetLogin = repl.InternetLogin; props.InternetPassword = repl.InternetPassword; props.InternetUrl = repl.InternetUrl; props.Publication = repl.Publication; props.Publisher = repl.Publisher; props.PublisherDatabase = repl.PublisherDatabase; props.PublisherLogin = repl.PublisherLogin; props.PublisherPassword = repl.PublisherPassword; if (repl.PublisherSecurityMode == SecurityType.NTAuthentication) { props.UseNT = true; } props.Subscriber = repl.Subscriber; props.SubscriberConnectionString = repl.SubscriberConnectionString; props.HostName = repl.HostName; return(props); } }
private void mitemSynchronize_Click(object sender, System.EventArgs e) { SqlCeReplication replNW = new SqlCeReplication(); try { replNW.ExchangeType = ExchangeType.BiDirectional; replNW.InternetUrl = strURL; replNW.InternetLogin = ""; replNW.InternetPassword = ""; replNW.Publisher = "SNOWDEN"; replNW.PublisherDatabase = "Northwind"; replNW.Publication = "EmployeeOrderInfo"; replNW.PublisherSecurityMode = SecurityType.DBAuthentication; replNW.PublisherLogin = "******"; replNW.PublisherPassword = "******"; replNW.Subscriber = "YaoDurant"; replNW.SubscriberConnectionString = strConnLocal; replNW.Synchronize(); } catch (SqlCeException exSQL) { HandleSQLException(exSQL); } finally { replNW.Dispose(); } }
public SqlCeReplicationHelper(string connectionString, string url, string publisher, string publicationDatabase, string publication, string subscriber, string hostName, bool useNT, string internetUsername, string internetPassword, string publisherUsername, string publisherPassword, bool isNew) #endif { this.repl = new SqlCeReplication(); repl.SubscriberConnectionString = connectionString; if (isNew) { repl.AddSubscription(AddOption.ExistingDatabase); } if (useNT) { repl.PublisherSecurityMode = SecurityType.NTAuthentication; } else { repl.PublisherSecurityMode = SecurityType.DBAuthentication; } repl.Publisher = publisher; repl.PublisherLogin = publisherUsername; repl.PublisherPassword = publisherPassword; repl.PublisherDatabase = publicationDatabase; repl.Publication = publication; repl.InternetUrl = url; repl.InternetLogin = internetUsername; repl.InternetPassword = internetPassword; repl.Subscriber = subscriber; repl.HostName = hostName; }
/// <summary> /// Download data for the subscription from the server, and don't return until the download /// finishes. /// </summary> /// <param name="subscription"> /// The subscription for which you want to download data from the server. /// </param> public void Synchronize(Subscription subscription) { Guard.ArgumentNotNull(subscription, "subscription"); if (!Subscriptions.Contains(subscription)) { throw new ArgumentException(Properties.Resources.NoSuchSubscription); } SubscriptionCredentials credentials = subscriptionCredentials.FindCredentials(subscription); SqlCeReplication replication = GetSyncReplication(subscription); if (credentials != null) { credentials.ApplyCredentials(replication); } try { replication.Synchronize(); } finally { replication.Dispose(); ReloadSubscriptions(); } }
/// <summary> /// Removes a subscription from the local database. /// </summary> /// <param name="subscription"></param> public void Drop(Subscription subscription) { Guard.ArgumentNotNull(subscription, "subscription"); lock (subscriptions) { if (!Subscriptions.Contains(subscription)) { throw new ArgumentException(Properties.Resources.NoSuchSubscription); } // // The subscription information isn't saved in the replication tables until the // subscription is synchronized. // if (subscription.HasBeenSynchronized) { SqlCeReplication replication = new SqlCeReplication(); replication.SubscriberConnectionString = refDatabase.ConnectionString; replication.Publication = subscription.Publication; replication.Publisher = subscription.Publisher; replication.PublisherDatabase = subscription.PublisherDatabase; replication.DropSubscription(DropOption.LeaveDatabase); } string sql = @"DELETE FROM SubscriptionInfo WHERE SubscriptionInfoID=" + infoDatabase.BuildParameterName("ID"); DbParameter idParameter = infoDatabase.CreateParameter("@ID", subscription.SubscriptionInfoId); infoDatabase.ExecuteNonQuery(sql, idParameter); subscriptions.Remove(subscription); } }
private void SyncCompletedCallback(IAsyncResult ar) { try { SqlCeReplication repl = (SqlCeReplication)ar.AsyncState; repl.EndSynchronize(ar); repl.SaveProperties(); string result = "Successfully completed sync" + Environment.NewLine; result += string.Format("Number of changes downloaded: {0}{1}", repl.PublisherChanges.ToString(), Environment.NewLine); result += string.Format("Number of changes uploaded: {0}{1}", repl.SubscriberChanges.ToString(), Environment.NewLine); result += string.Format("Number of conflicts at Publisher: {0}{1}", repl.PublisherConflicts.ToString(), Environment.NewLine); #if V40 SyncArgs4 args = new SyncArgs4(result, null); #else SyncArgs args = new SyncArgs(result, null); #endif Completed(this, args); } catch (SqlCeException e) { #if V40 SyncArgs4 args = new SyncArgs4("Errors occured during sync", e); #else SyncArgs args = new SyncArgs("Errors occured during sync", e); #endif Completed(this, args); } }
/// <summary> /// Override this method if you need to apply more credentials than the basic set, or if you /// need to use NTAuthentication instead of SQL Server authentication. /// </summary> /// <remarks> /// This method is called by the <see cref="SubscriptionManager"/> class just before it starts as /// synchronization (either synchronous or asynchronous). The default implementaion sets the /// SQL server authentication to use <see cref="SecurityType.DBAuthentication"/> and it sets /// the PublisherLogin and PublisherPassword values using the values stored in this instance. /// </remarks> /// <param name="repl"> /// The SqlCeReplication instance that the <see cref="SubscriptionManager"/> class has prepared and will use /// after this method call returns to perform a synchronization. /// </param> public virtual void ApplyCredentials(SqlCeReplication replication) { Guard.ArgumentNotNull(replication, "replication"); replication.PublisherSecurityMode = PublisherSecurityMode; replication.PublisherLogin = PublisherLogin; replication.PublisherPassword = PublisherPassword; }
public string GetFullConnectionString(string connectionString) { using (SqlCeReplication repl = new SqlCeReplication()) { repl.SubscriberConnectionString = connectionString; return repl.SubscriberConnectionString; } }
public string GetFullConnectionString(string connectionString) { using (SqlCeReplication repl = new SqlCeReplication()) { repl.SubscriberConnectionString = connectionString; return(repl.SubscriberConnectionString); } }
private SqlCeReplication GetSyncReplication(Subscription subscription) { SqlCeReplication replication = new SqlCeReplication(); replication.ConnectionManager = true; replication.SubscriberConnectionString = refDatabase.ConnectionString; replication.Publication = subscription.Publication; replication.Publisher = subscription.Publisher; replication.PublisherDatabase = subscription.PublisherDatabase; replication.Subscriber = subscription.Subscriber ?? String.Empty; replication.InternetUrl = subscription.InternetUrl ?? String.Empty; replication.HostName = subscription.Filter ?? String.Empty; // // Simply setting some of these values, even if we're not changing the // value, causes other values in the same group to become required. As // a result, we have to make sure we don't set null, etc. // replication.CompressionLevel = subscription.CompressionLevel; if (subscription.Distributor != null) { replication.Distributor = subscription.Distributor; } if (subscription.DistributorAddress != null) { replication.DistributorAddress = subscription.DistributorAddress; } if (replication.DistributorNetwork != subscription.DistributorNetwork) { replication.DistributorNetwork = subscription.DistributorNetwork; } replication.ExchangeType = subscription.ExchangeType; if (subscription.InternetProxyServer != null) { replication.InternetProxyServer = subscription.InternetProxyServer; } replication.LoginTimeout = subscription.LoginTimeout; if (subscription.ProfileName != null) { replication.ProfileName = subscription.ProfileName; } if (subscription.PublisherAddress != null) { replication.PublisherAddress = subscription.PublisherAddress; } replication.PublisherNetwork = subscription.PublisherNetwork; replication.QueryTimeout = subscription.QueryTimeout; replication.SnapshotTransferType = (SnapshotTransferType)subscription.SnapshotTransferType; replication.Validate = subscription.Validate; if (!subscription.HasBeenSynchronized) { replication.AddSubscription(AddOption.ExistingDatabase); } return(replication); }
internal void EndSync() { try { replication.EndSynchronize(asyncResult); } finally { asyncResult = null; replication.Dispose(); replication = null; } }
private void btnSinkroniziraj_Click(object sender, EventArgs e) { lblPoruka.Text = String.Empty; lblPoruka.ForeColor = SystemColors.ControlText; txtServer.Text = txtServer.Text.Trim(); if (txtServer.Text == String.Empty) { MessageBox.Show("Naziv servera je obavezan."); return; } SqlCeReplication r = new SqlCeReplication(); r.InternetUrl = "http://" + txtServer.Text + "/merge-replication-novapp/sqlcesa35.dll"; r.InternetLogin = String.Empty; r.InternetPassword = String.Empty; r.Publisher = txtServer.Text; r.PublisherDatabase = "NovaPP"; r.Publication = "NovaPP"; r.PublisherSecurityMode = SecurityType.DBAuthentication; r.PublisherLogin = "******"; r.PublisherPassword = "******"; r.SubscriberConnectionString = Program.ConnString; r.Subscriber = "DlanovnikPP"; r.ExchangeType = ExchangeType.BiDirectional; try { if (File.Exists(Program.PathToLocalDB)) { r.ReinitializeSubscription(true); } else { r.AddSubscription(AddOption.CreateDatabase); } r.Synchronize(); lblPoruka.Text = "Sinkronizacija podataka je uspješno provedena."; } catch (Exception ex) { lblPoruka.Text = ex.Message; lblPoruka.ForeColor = Color.Red; } finally { r.Dispose(); } }
/// <summary> /// Initiate a synchronization with the Web Agent based on the settings in app.config /// </summary> /// <param name="connection">A SqlCeConnection that point to the local database. Preferably closed.</param> /// <param name="hostName">The parameter used to filter the Publication (not required)</param> /// <param name="additionalId">Additional identification</param> /// <param name="additionalInfo">Additional information</param> /// <param name="option">ReinitializeOption</param> public void Synchronize(SqlCeConnection connection, string hostName, int additionalId, string additionalInfo, ReinitializeOption option) { _hostName = hostName; _additionalId = additionalId; _additionalInfo = additionalInfo; _connection = connection; CreateDatabaseIfNotExists(connection); if (connection.State == ConnectionState.Open) { connection.Close(); } var props = GetProperties(); var repl = new SqlCeReplication(); repl.Subscriber = hostName; repl.SubscriberConnectionString = GetSubscriberConnectionString(connection); if (!string.IsNullOrWhiteSpace(hostName)) { repl.HostName = hostName; repl.Subscriber = hostName; } if (!string.IsNullOrWhiteSpace(props.Subscriber)) { repl.Subscriber = props.Subscriber; } repl.PostSyncCleanup = 2; SetProperties(props, repl); InsertSyncLog(connection, hostName, additionalId, "Attempt", additionalInfo); if (option == ReinitializeOption.ReinitializeNoUpload) { repl.ReinitializeSubscription(false); } if (option == ReinitializeOption.ReinitializeUploadSubscriberChanges) { repl.ReinitializeSubscription(true); } repl.BeginSynchronize( SyncCompletedCallback, OnStartTableUploadCallback, OnStartTableDownloadCallback, OnSynchronizationCallback, repl); }
/// <summary> /// Adds a new subscription to the database. Call <see cref="BeginSync"/> to /// download the subscription from the server. /// </summary> /// <remarks> /// The subscription information is initially stored in the SubscriptionInfo /// table only in the local database. It will also appear in system tables /// managed by SQL Server Mobile after the first synchronization. Use /// <see cref="BeginSync"/> or <see cref="Synchronize"/> to synchronize /// the data. /// </remarks> /// <param name="sub"></param> /// <exception cref="ArgumentException"> /// A subscription with the same publisher information already exists. /// </exception> public void Add(SubscriptionParameters subscription) { Guard.ArgumentNotNull(subscription, "subscription"); SqlCeReplication replication = new SqlCeReplication(); replication.Publication = subscription.Publication; replication.Publisher = subscription.Publisher; replication.PublisherDatabase = subscription.PublisherDatabase; replication.InternetUrl = subscription.InternetUrl; replication.Subscriber = subscription.Subscriber; replication.HostName = subscription.Filter; Add(replication); replication.Dispose(); }
public void CanAddSubscriptionWithReplicationInstance() { SqlSubscriptionManager subMgr = CreateSubscriptionManager(); SqlCeReplication repl = new SqlCeReplication(); repl.Publication = "PubCustomers"; repl.Publisher = "MOBGUISQL01"; repl.PublisherDatabase = "AdventureWorksMobileStaging"; repl.InternetUrl = "http://mobguisql01/PublicationCustomers/sqlcesa30.dll"; repl.Subscriber = "Test"; repl.HostName = "DE"; subMgr.Add(repl); Assert.AreEqual(1, subMgr.Subscriptions.Count); Assert.AreEqual("Test", subMgr.Subscriptions[0].Subscriber); }
public static void DropPublication(string connectionString, string publicationLabel) { string[] vals = publicationLabel.Split(':'); string publisher = vals[0]; string publicationDatabase = vals[1]; string publication = vals[2]; using (SqlCeReplication repl = new SqlCeReplication()) { repl.SubscriberConnectionString = connectionString; repl.Publisher = publisher; repl.Publication = publication; repl.PublisherDatabase = publicationDatabase; repl.LoadProperties(); repl.DropSubscription(DropOption.LeaveDatabase); } }
private static void SetProperties(ReplicationProperties props, SqlCeReplication repl) { if (props.UseNT) { repl.PublisherSecurityMode = SecurityType.NTAuthentication; } else { repl.PublisherSecurityMode = SecurityType.DBAuthentication; } if (props.UseProxy) { repl.InternetProxyLogin = props.InternetProxyLogin; repl.InternetProxyPassword = props.InternetProxyPassword; repl.InternetProxyServer = props.InternetProxyServer; } repl.Publisher = props.Publisher; repl.PublisherLogin = props.PublisherLogin; repl.PublisherPassword = props.PublisherPassword; repl.PublisherDatabase = props.PublisherDatabase; repl.Publication = props.Publication; repl.InternetUrl = props.InternetUrl; repl.InternetLogin = props.InternetLogin; repl.InternetPassword = props.InternetPassword; if (props.CompressionLevel != 1) { repl.CompressionLevel = props.CompressionLevel; } if (props.ConnectionRetryTimeout != 120) { repl.ConnectionRetryTimeout = props.ConnectionRetryTimeout; } if (props.ConnectTimeout > 0) { repl.ConnectTimeout = props.ConnectTimeout; } if (props.ReceiveTimeout != 60000) { repl.ReceiveTimeout = props.ReceiveTimeout; } if (props.SendTimeout > 0) { repl.SendTimeout = props.SendTimeout; } }
/// <summary> /// Begin downloading data for the subscription and return control immediately. /// </summary> /// <remarks> /// <para> /// Before you call this method, you can register to receive events from the <paramref name="subscription"/> /// object. This will allow you to monitor the progress of the synchronization. /// </para> /// <para> /// Once the synchronization completes, you must call <see cref="EndSync"/>. /// </para> /// </remarks> /// <param name="subscription"> /// The subscription you want to synchronize. /// </param> public void BeginSynchronize(Subscription subscription) { Guard.ArgumentNotNull(subscription, "subscription"); if (!Subscriptions.Contains(subscription)) { throw new ArgumentException(Properties.Resources.NoSuchSubscription); } SubscriptionCredentials credentials = subscriptionCredentials.FindCredentials(subscription); SqlCeReplication replication = GetSyncReplication(subscription); if (credentials != null) { credentials.ApplyCredentials(replication); } subscription.BeginSync(replication); }
private void SynchronizeSqlDatabase() { //specify the location of the local device database string strDataPath = "\\My Documents\\IssueTracker.sdf"; //create the data replication object SqlCeReplication replication = new SqlCeReplication(); try { //define the source of the replication data replication.Publisher = "server_name"; replication.PublisherDatabase = "IssueTracker"; //database name replication.Publication = "IssueTrackerPublication"; //define the login credentials replication.PublisherLogin = "******"; replication.PublisherPassword = ""; //define the subscriber-side connection string replication.SubscriberConnectionString = "Provider=Microsoft.SQLServer.OLEDB.CE.2.0;" + "Data Source=" + strDataPath; replication.Subscriber = "iPAQ Mobile Device"; //define the location of the IIS replication service agent replication.InternetUrl = "http://jkanalakis/sqlce/ssceca20.dll"; //define the replication mode and begin the process replication.ExchangeType = ExchangeType.BiDirectional; replication.Synchronize(); } catch (SqlCeException x) { MessageBox.Show(x.Message); } catch (Exception x) { MessageBox.Show(x.Message); } return; }
private void SyncCompletedCallback(IAsyncResult ar) { SqlCeReplication repl = (SqlCeReplication)ar.AsyncState; try { repl.EndSynchronize(ar); repl.SaveProperties(); var result = "Successfully completed sync" + Environment.NewLine; result += string.Format("Number of changes downloaded: {0}{1}", repl.PublisherChanges.ToString(), Environment.NewLine); result += string.Format("Number of changes uploaded: {0}{1}", repl.SubscriberChanges.ToString(), Environment.NewLine); result += string.Format("Number of conflicts at Publisher: {0}{1}", repl.PublisherConflicts.ToString(), Environment.NewLine); var args = new SyncArgs(result, null, 100, SyncStatus.SyncComplete, null); Completed?.Invoke(this, args); InsertSyncLog(_connection, _hostName, _additionalId, "Success", _additionalInfo); } catch (SqlCeException e) { InsertSyncLog(_connection, _hostName, _additionalId, "Error", _additionalInfo + Environment.NewLine + ShowErrors(e)); SyncArgs args; if (e.NativeError == 29006) { args = new SyncArgs("Publication may have expired, or the snapshot is invalid", new PublicationMayHaveExpiredException("Publication may have expired, or the snapshot is invalid", e), 100, SyncStatus.SyncFailed, null); } else { args = new SyncArgs("Errors occured during sync", e, 100, SyncStatus.SyncFailed, null); } Completed?.Invoke(this, args); } finally { if (repl != null) { repl.Dispose(); } if (_connection != null) { _connection.Close(); _connection.Dispose(); } } }
private void button1_Click(object sender, EventArgs e) { SqlCeReplication sqlCeRep = new SqlCeReplication(); string cesource = @"E:\My Project\MVC Project\Solutions\YTech.IM.JSM\app\YTech.IM.JSM.Web\DB_IM_JSM.sdf"; using (sqlCeRep) { sqlCeRep.InternetUrl = "http://localhost:81/Sync/sqlcesa35.dll"; sqlCeRep.Publisher = "yahu"; sqlCeRep.PublisherSecurityMode = SecurityType.DBAuthentication; sqlCeRep.PublisherLogin = "******"; //sqlCeRep.PublisherPassword = "******"; sqlCeRep.PublisherDatabase = "DB_IM_JSM"; sqlCeRep.Publication = "JSMPub"; sqlCeRep.Subscriber = "Rully"; sqlCeRep.SubscriberConnectionString = "Data Source=" + cesource; try { if (!System.IO.File.Exists(cesource)) { sqlCeRep.AddSubscription(AddOption.CreateDatabase); } sqlCeRep.Synchronize(); lblInfo.Text = "Synchronized."; } catch (SqlCeException sqlex) { lblInfo.Text = sqlex.Message; } catch (Exception ex) { lblInfo.Text = ex.Message; } } }
public void ExtendedPropsArePutIntoReplicationObject() { SqlSubscriptionManager subMgr = CreateSubscriptionManager(); SqlCeReplication repl = new SqlCeReplication(); repl.Publication = "PubCustomers"; repl.Publisher = "MOBGUISQL01"; repl.PublisherDatabase = "AdventureWorksMobileStaging"; repl.InternetUrl = "http://mobguisql01/PublicationCustomers/sqlcesa30.dll"; repl.Subscriber = "Test"; repl.HostName = "DE"; repl.Distributor = "junk"; SubscriptionCredentialsMock.FoundJunkDistributor = false; subMgr.Add(repl); try { subMgr.Synchronize(subMgr.Subscriptions[0]); } catch {} Assert.IsTrue(SubscriptionCredentialsMock.FoundJunkDistributor); }
/// <summary> /// Adds a new subscription to the database. Call <see cref="BeginSync"/> to /// download the subscription from the server. /// </summary> /// <remarks> /// <para> /// The subscription information is initially stored in the SubscriptionInfo /// table only in the local database. It will also appear in system tables /// managed by SQL Server Mobile after the first synchronization. Use /// <see cref="BeginSync"/> or <see cref="Synchronize"/> to synchronize /// the data. /// </para> /// <para> /// Note: You should use the <paramref name="sub"/> parameter only as a carrier of /// data. In other words, do not call any methods on this instance--let this class /// handle all the method calls. /// </para> /// </remarks> /// <param name="sub"></param> /// <exception cref="ArgumentException"> /// A subscription with the same publisher information already exists. /// </exception> public void Add(SqlCeReplication subscription) { Guard.ArgumentNotNull(subscription, "subscription"); Subscription target = new Subscription(); target.Publication = subscription.Publication; target.Publisher = subscription.Publisher; target.PublisherDatabase = subscription.PublisherDatabase; if (Subscriptions.Find(target) >= 0) { throw new ArgumentException(Properties.Resources.SubscriptionExists); } string sql = @"INSERT SubscriptionInfo ( Publication, Publisher, PublisherDatabase, InternetUrl, Subscriber, HostName, CompressionLevel, ConnectionRetryTimeout, Distributor, DistributorAddress, DistributorNetwork, ExchangeType, InternetProxyServer, LoginTimeout, ProfileName, PublisherAddress, PublisherNetwork, QueryTimeout, SnapshotTransferType, Validate) VALUES( @Publication, @Publisher, @PublisherDatabase, @InternetUrl, @Subscriber, @HostName, @CompressionLevel, @ConnectionRetryTimeout, @Distributor, @DistributorAddress, @DistributorNetwork, @ExchangeType, @InternetProxyServer, @LoginTimeout, @ProfileName, @PublisherAddress, @PublisherNetwork, @QueryTimeout, @SnapshotTransferType, @Validate)" ; DbParameter[] parameters = new DbParameter[] { infoDatabase.CreateParameter("@Publication", DbType.String, 4000, subscription.Publication), infoDatabase.CreateParameter("@Publisher", DbType.String, 4000, subscription.Publisher), infoDatabase.CreateParameter("@PublisherDatabase", DbType.String, 4000, subscription.PublisherDatabase), infoDatabase.CreateParameter("@InternetUrl", DbType.String, 4000, subscription.InternetUrl), infoDatabase.CreateParameter("@Subscriber", DbType.String, 4000, subscription.Subscriber), infoDatabase.CreateParameter("@HostName", DbType.String, 4000, subscription.HostName), infoDatabase.CreateParameter("@CompressionLevel", DbType.Int16, 4000, subscription.CompressionLevel), infoDatabase.CreateParameter("@ConnectionRetryTimeout", DbType.Int16, 0, subscription.ConnectionRetryTimeout), infoDatabase.CreateParameter("@Distributor", DbType.String, 4000, subscription.Distributor ?? String.Empty), infoDatabase.CreateParameter("@DistributorAddress", DbType.String, 4000, subscription.DistributorAddress ?? String.Empty), infoDatabase.CreateParameter("@DistributorNetwork", DbType.Int32, 0, (int)subscription.DistributorNetwork), infoDatabase.CreateParameter("@ExchangeType", DbType.Int32, 0, subscription.ExchangeType), infoDatabase.CreateParameter("@InternetProxyServer", DbType.String, 4000, subscription.InternetProxyServer ?? String.Empty), infoDatabase.CreateParameter("@LoginTimeout", DbType.Int16, 0, subscription.LoginTimeout), infoDatabase.CreateParameter("@ProfileName", DbType.String, 4000, subscription.ProfileName ?? String.Empty), infoDatabase.CreateParameter("@PublisherAddress", DbType.String, 4000, subscription.PublisherAddress ?? String.Empty), infoDatabase.CreateParameter("@PublisherNetwork", DbType.Int32, 0, (int)subscription.PublisherNetwork), infoDatabase.CreateParameter("@QueryTimeout", DbType.Int16, 0, subscription.QueryTimeout), infoDatabase.CreateParameter("@SnapshotTransferType", DbType.Int32, 0, subscription.SnapshotTransferType), infoDatabase.CreateParameter("@Validate", DbType.Int32, 0, subscription.Validate) }; infoDatabase.ExecuteNonQuery(sql, parameters); ReloadSubscriptions(); }
private bool SynchronizeSubscription(string subsriptionName, bool reinitializeSubscription, string registryKey, Label label) { bool result = false; Cursor.Current = Cursors.WaitCursor; SqlCeReplication repl = null; try { PerformanceSampling.StartSample(0, "Synchronization time"); repl = new SqlCeReplication(); repl.Publisher = (string)Setting.LocalSetting.GetValue("Server", "WIN2003"); repl.InternetUrl = string.Format("http://{0}/ADA/sqlcesa30.dll", repl.Publisher); this.textBoxStatus.Text += "Synchronizing " + subsriptionName + " data with " + repl.Publisher + " ...\r\n"; this.textBoxStatus.Update(); repl.PublisherDatabase = @"ADA"; repl.PublisherSecurityMode = SecurityType.DBAuthentication; repl.PublisherLogin = @"ada"; repl.PublisherPassword = @"p@ssw0rd"; repl.Publication = subsriptionName; repl.Subscriber = subsriptionName; repl.SubscriberConnectionString = ("Data Source =" + (_databaseFilePath) + (";Password ="******"\"\";")); repl.HostName = _deviceID; if (!File.Exists(_databaseFilePath)) { repl.AddSubscription(AddOption.CreateDatabase); } if (reinitializeSubscription) { repl.ReinitializeSubscription(false); } repl.Synchronize(); PerformanceSampling.StopSample(0); DateTime now = System.DateTime.Now; label.Text = now.ToShortDateString() + " " + now.ToShortTimeString(); label.Update(); this.Setting.LocalSetting.SetValue(registryKey, now); this.textBoxStatus.Text += "Successful!\r\n" + PerformanceSampling.GetSampleDurationText(0) + "\r\n"; result = true; } catch (SqlCeException sqlex) { this.textBoxStatus.Text += "Failed! Error messages:\r\n"; foreach (SqlCeError sqlError in sqlex.Errors) { this.textBoxStatus.Text += sqlError.Message + "\r\n"; } } catch (Exception ex) { this.textBoxStatus.Text += "Failed! Error messages:\r\n" + ex.Message + "\r\n"; } finally { if (repl != null) { repl.Dispose(); } } Cursor.Current = Cursors.Default; return(result); }
public static ReplicationProperties GetProperties(string connectionString, string publicationLabel) #endif { string[] vals = publicationLabel.Split(':'); string publisher = vals[0]; string publicationDatabase = vals[1]; string publication = vals[2]; using (SqlCeReplication repl = new SqlCeReplication()) { repl.SubscriberConnectionString = connectionString; repl.Publisher = publisher; repl.Publication = publication; repl.PublisherDatabase = publicationDatabase; repl.LoadProperties(); #if V40 var props = new ReplicationProperties4(); #else var props = new ReplicationProperties(); #endif props.InternetLogin = repl.InternetLogin; props.InternetPassword = repl.InternetPassword; props.InternetUrl = repl.InternetUrl; props.Publication = repl.Publication; props.Publisher = repl.Publisher; props.PublisherDatabase = repl.PublisherDatabase; props.PublisherLogin = repl.PublisherLogin; props.PublisherPassword = repl.PublisherPassword; if (repl.PublisherSecurityMode == SecurityType.NTAuthentication) props.UseNT = true; props.Subscriber = repl.Subscriber; props.SubscriberConnectionString = repl.SubscriberConnectionString; props.HostName = repl.HostName; return props; } }
public override void ApplyCredentials(SqlCeReplication repl) { base.ApplyCredentials(repl); FoundJunkDistributor = (repl.Distributor == "junk"); }
internal void BeginSync(SqlCeReplication replication) { this.replication = replication; asyncResult = replication.BeginSynchronize(OnSyncCompletion, OnStartTableUpload, OnStartTableDownload, OnSynchronization, null); }
internal void CancelSync() { replication.CancelSynchronize(); replication.Dispose(); replication = null; }