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);
}
}
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>
/// 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 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);
}
}
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;
}
