Sincronizacion de Datos para Mobile Con ADO - NET Sync Services

Sincronización de bases de datos con
ADO.net Sync Services en VS 2008
Preparado para
Mobile .Net Users Group
Preparado por:
Joaquin Raya Barberis
joaquin.raya@gmail.com
ADO.NET Sync Services con VS 2008
INDICE
1. Introducción ......................................................................................................................... 4
2. Sincronización de bases de datos con ADO.net Sync Services en VS 2008 ................ 5

2.1. Prerrequisitos ................................................................................................................ 5
2.2. Paso 1: Preparar la BD ................................................................................................. 6
2.3. Paso 2: Preparar la estructura de proyectos ................................................................. 7
2.4. Paso 3: Iniciar el diseñador de sincronización ............................................................ 12
2.5. Paso 4: Generar el servicio web ................................................................................. 18
2.6. Paso 5: Configurar el cliente del dispositivo ............................................................... 24
2.7. Paso 6: Código de pruebas ......................................................................................... 30
2.8. Paso 7: Gestión de conflictos ...................................................................................... 35
3. Epilogo: ............................................................................................................................... 36
www.mobilenug.com Pág. 2 de 36
Condiciones de uso y distribución:

Puedes utilizar, imprimir, copiar, y mejorar este documento siempre que su uso sea sin ánimo de lucro.
El contenido de este documento está basado en la documentación oficial del producto explicado en él, y
en las pruebas y trabajos realizados por el autor sobre el mismo.
En el caso de distribución de los contenidos en este documento debes notificárselo al autor del mismo.
Si observas algún dato incorrecto, se te ocurre alguna mejora, o tienes alguna proposición sobre el
mismo no dudes en ponerte en contacto con el autor, el te lo agradecerá y pasaras a formar parte como
de este mismo artículo como colaborador.
Para ponerte en contacto puedes escribir a “consulta@mobilenug. es”
1. Introducción
Microsoft Sync Framwork es la respuesta de Microsoft a los escenarios ocasionalmente
conectados. MSF 1.0 es la primera versión de un marco de desarrollo que permite el
desarrollo de cualquier tipo de solución que requiera de algún tipo de sincronización
en escenarios off-line de cualquier tipo de origen de datos sobre cualquier protocolo o
tipo de red y exponerlos como servicios WCF. Se distribuye con SQL Server 2008
debido a su afinidad en contextos de sincronización de datos y con Visual Studio 2008
.NET SP1.
2. Sincronización de bases de datos con ADO.net

Sync Services en VS 2008
En este documento se muestra el procedimiento a seguir para sincronizar tablas con
Microsoft ADO.net Sync Services. Para acelerar este proceso abusaremos de todos los
diseñadores, wizards y sistemas automatizados de los que nos provee Microsoft. El
código de la aplicación de pruebas es totalmente trivial, se deja como tarea para el
usuario introducir escenarios más complejos.
Para una visión general del Sync Framework, proveedores de sincronización,

arquitectura y etc, consultar MSDN en:
http://msdn.microsoft.com/en-us/sync/default.aspx
2.1. Prerrequisitos
- VS 2008 SP1
- SQL Server, u otro servidor de BD con conectores para ADO.net y sobre la que
podamos hacer todo tipo de modificaciones
- Microsoft Synchronization Services for ADO.NET v1 SP1 (Devices)
- Microsoft SQL Server Compact 3.5 Service Pack 1 for Windows Mobile
2.2. Paso 1: Preparar la BD
Para este tutorial usaremos la BD Northwind, de los samples de MS SQL Server 2000. Si
no están instalados, los debes descargar de la MSDN en:
http://www.microsoft.com/Downloads/details.aspx?FamilyID=06616212-0356-46a0-
8da2-eebc53a68034&displaylang=en
Para instalar Northwind, ejecutamos instnwnd.sql, de la carpeta SQL Server 2000

Sample Databases.
2.3. Paso 2: Preparar la estructura de proyectos
- Creamos un proyecto Windows de tipo Class Library, con nombre

ServerSyncLibrary. Antes de aceptar, cambiamos el nombre de la solución a
NorthwindMobile. Borra la clase Class1 que te añade por defecto.
- Creamos un proyecto Smart Device de nombre ClientSyncLibrary.

Seleccionamos como plataforma de destino Windows Mobile 6 Professional, y
tipo de proyecto Class Library. También aquí borramos la clase Class1 que
añade por defecto.
- Creamos un proyecto Web de tipo ASP.Net Web Service Application y lo

llamamos WSServerProvider. Tambien borramos el Service1 que nos crea por
defecto
- Por último, creamos un proyecto Smart Device llamado MobileClient, con

plataforma de destino Windows Mobile 6 Professional y de tipo
DeviceApplication
Debería quedar la siguiente distribución de proyectos:
2.4. Paso 3: Iniciar el diseñador de sincronización
Hacéis clic derecho en ServerSyncLibrary, y seleccionáis Add -> New Item.

Seleccionaréis un objeto Local Database Cache, al que le daréis como nombre
NorthWindDataCache
Esto debería iniciar el siguiente diseñador de sincronización y añadir al proyecto un

archivo NorthWindDataCache.sync. Para volver al diseñador, solo hay que hacer doble
clic en este archivo
En Server Connection, haced click en New y configurad una connexión a NorthWind.

Cuando lo hagáis, Client connection se rellenará con un valor por defecto (un Nuevo
archivo .sdf).
Haced clic en el botón Advanced, y allí cambiad el proyecto cliente a ClientSyncLibrary
Después, seleccionad el botón Add para seleccionar las tablas que participarán en la
sincronización, en este caso solamente Customers. Dejad todos los valores por
defecto, esto hará que el diseñador modifique el esquema de la base de datos
añadiendo las tablas, columnas y triggers que necesita para operar.
Finalmente, haced clic en OK para iniciar la generación. En el cuadro de diálogo de

generación de scripts SQL dejad ambas checkboxes activadas para que los scripts se
guarden en la solución y se lancen contra la BD de desarrollo.
En la pantalla de configuración de datasource seleccionamos la única tabla que vamos

a sincronizar y le damos a Finalizar.
Os deberían quedar los siguientes archivos y referencias en las soluciones:
2.5. Paso 4: Generar el servicio web
Hacemos clic en el proyecto WSServerProvider y añadimos una referencia a

ServerSyncLibrary, Microsoft.Synchronization.Data y
Microsoft.Synchronization.Data.Server
Añadimos un nuevo servicio web SyncService.asmx
En el código, implementamos la interfaz

ServerSyncLibrary.INorthWindDataCacheSyncContract, y le añadimos a cada uno de los
métodos de la interfaz el atributo WebMethod
[WebMethod]
public Microsoft.Synchronization.Data.SyncContext
ApplyChanges(Microsoft.Synchronization.Data.SyncGroupMetadata groupMetadata,
System.Data.DataSet dataSet, Microsoft.Synchronization.Data.SyncSession syncSession)
{
throw new NotImplementedException();
}
[WebMethod]
GetChanges(Microsoft.Synchronization.Data.SyncGroupMetadata groupMetadata,
Microsoft.Synchronization.Data.SyncSession syncSession)
{
}
[WebMethod]
public Microsoft.Synchronization.Data.SyncSchema
GetSchema(System.Collections.ObjectModel.Collection<string> tableNames,
{
}
[WebMethod]
public Microsoft.Synchronization.Data.SyncServerInfo
GetServerInfo(Microsoft.Synchronization.Data.SyncSession syncSession)
{
}
El servicio web actúa como Façade sobre el proveedor de sincronización de servidor,

por lo que cada uno de estos métodos deberá redirigir las peticiones a un objeto. Esto
se presta para usar el WS como Chain of Responsability o Decorator para añadir
funcionalidades de cifrado, compresión, log o una gestión de conflictos mejorada.
El código quedará así:
[WebMethod]
ApplyChanges(Microsoft.Synchronization.Data.SyncGroupMetadata groupMetadata,
System.Data.DataSet dataSet, Microsoft.Synchronization.Data.SyncSession syncSession)
{
ServerSyncLibrary.NorthWindDataCacheServerSyncProvider ServerProvider = new
ServerSyncLibrary.NorthWindDataCacheServerSyncProvider();
return ServerProvider.ApplyChanges(groupMetadata, dataSet, syncSession);

}
[WebMethod]
GetChanges(Microsoft.Synchronization.Data.SyncGroupMetadata groupMetadata,
{
return ServerProvider.GetChanges(groupMetadata, syncSession);

}
[WebMethod]
public Microsoft.Synchronization.Data.SyncSchema
GetSchema(System.Collections.ObjectModel.Collection<string> tableNames,
{
return ServerProvider.GetSchema(tableNames, syncSession);

}
[WebMethod]
public Microsoft.Synchronization.Data.SyncServerInfo
GetServerInfo(Microsoft.Synchronization.Data.SyncSession syncSession)
{
return ServerProvider.GetServerInfo(syncSession);
}
Ahora vamos a configurar el WS para que se instale sobre el IIS local, para que el
cliente PDA pueda verlo. Vamos a Propiedades del proyecto, y seleccionamos la
pestaña Web. Aquí en Servers seleccionamos “Use local IIS Web Server”
Hacemos clic en Create Virtual Directory, y comprobamos que al introducir la URL en

un navegador nos lleva a la página de prueba de servicios
2.6. Paso 5: Configurar el cliente del dispositivo
Hacemos clic en el proyecto MobileClient y añadimos una referencia a

ClientSyncLibrary, Microsoft.Synchronization.Data y
Microsoft.Synchronization.Data.SqlServerCe
Ahora hacemos clic en el proyecto y añadimos una referencia web al servicio

WSServerProvider/SyncService. La referencia se llamará WSServerProvider.
NOTA: Es importante sustituir localhost por la IP de la máquina, para que el dispositivo

pueda localizar la máquina
Este proceso generará una clase Proxy para el servicio web. El problema es que genera
clases nuevas incluso para clases que ya tenemos definidas en nuestro proyecto, así
que hay que limpiar el código generado. Para esto, hacemos clic en el icono de
“Mostrar archivos ocultos del explorador de soluciones y desplegamos la
referencia web hasta ver el archivo Reference.cs
En Reference.cs debemos añadir una directiva using para

Microsoft.Synchronization.Data, y eliminar todas las definiciones de clases y
enumerados que encontremos, salvo la clase Proxy del webservice, que en nuestro
caso se llama SyncService
La directiva using:
using Microsoft.Synchronization.Data;
Y el código completo de la clase:
//--------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.3053
//
// Changes to this file may cause incorrect behavior and will be
// lost if
// the code is regenerated.
// </auto-generated>
//--------------------------------------------------------------------
//
// This source code was auto-generated by

Microsoft.CompactFramework.Design.Data, Version 2.0.50727.3053.
//
namespace MobileClient.WSServerProvider {
using System.Diagnostics;
using System.Web.Services;
using System.ComponentModel;
using System.Web.Services.Protocols;
using System;
using System.Xml.Serialization;
using System.Data;
using Microsoft.Synchronization.Data;
/// <remarks/>
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Web.Services.WebServiceBindingAttribute(Name="SyncServiceSoap"
, Namespace="http://tempuri.org/")]
public partial class SyncService :
System.Web.Services.Protocols.SoapHttpClientProtocol {
/// <remarks/>
public SyncService() {
this.Url =
"http://10.49.66.41/WSServerProvider/SyncService.asmx";
}
/// <remarks/>
[System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://tem
puri.org/ApplyChanges", RequestNamespace="http://tempuri.org/",
ResponseNamespace="http://tempuri.org/",
Use=System.Web.Services.Description.SoapBindingUse.Literal,
ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Wrappe
d)]
public SyncContext ApplyChanges(SyncGroupMetadata
groupMetadata, System.Data.DataSet dataSet, SyncSession syncSession) {
object[] results = this.Invoke("ApplyChanges", new
object[] {
groupMetadata,
dataSet,
syncSession});
return ((SyncContext)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginApplyChanges(SyncGroupMetadata
groupMetadata, System.Data.DataSet dataSet, SyncSession syncSession,
System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("ApplyChanges", new object[] {
groupMetadata,
dataSet,
syncSession}, callback, asyncState);
}
/// <remarks/>
public SyncContext EndApplyChanges(System.IAsyncResult

asyncResult) {
object[] results = this.EndInvoke(asyncResult);
}
/// <remarks/>
puri.org/GetChanges", RequestNamespace="http://tempuri.org/",
d)]
public SyncContext GetChanges(SyncGroupMetadata groupMetadata,
SyncSession syncSession) {
object[] results = this.Invoke("GetChanges", new object[]
{
groupMetadata,
syncSession});
}
/// <remarks/>
public System.IAsyncResult BeginGetChanges(SyncGroupMetadata
groupMetadata, SyncSession syncSession, System.AsyncCallback callback,
object asyncState) {
return this.BeginInvoke("GetChanges", new object[] {
groupMetadata,
}
/// <remarks/>
public SyncContext EndGetChanges(System.IAsyncResult
asyncResult) {
}
/// <remarks/>
puri.org/GetSchema", RequestNamespace="http://tempuri.org/",
d)]
public SyncSchema GetSchema(string[] tableNames, SyncSession
syncSession) {
object[] results = this.Invoke("GetSchema", new object[] {
tableNames,
syncSession});
return ((SyncSchema)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginGetSchema(string[] tableNames,

SyncSession syncSession, System.AsyncCallback callback, object
asyncState) {
return this.BeginInvoke("GetSchema", new object[] {
tableNames,
}
/// <remarks/>
public SyncSchema EndGetSchema(System.IAsyncResult
asyncResult) {
return ((SyncSchema)(results[0]));
}
/// <remarks/>
puri.org/GetServerInfo", RequestNamespace="http://tempuri.org/",
d)]
public SyncServerInfo GetServerInfo(SyncSession syncSession) {
object[] results = this.Invoke("GetServerInfo", new
object[] {
syncSession});
return ((SyncServerInfo)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginGetServerInfo(SyncSession
syncSession, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("GetServerInfo", new object[] {
}
/// <remarks/>
public SyncServerInfo EndGetServerInfo(System.IAsyncResult
asyncResult) {
return ((SyncServerInfo)(results[0]));
}
}
}
Debemos repetir este proceso cada vez que se actualice la definición del WS, pero eso no
debería ser muy frecuente.
Compilamos, y ya tenemos el cliente configurado. Pasamos al siguiente paso para añadir

código al formulario y hacer pruebas
2.7. Paso 6: Código de pruebas
En el proyecto MobileClient, abrimos el formulario Form1 y añadimos un control

datagrid, donde mostraremos los datos de la BD
En la Toolbox, en el tab ClientSyncLibrary Components encontramos los componentes

NorthwindDataSet y CustomersTableAdapter. Los seleccionamos, arrastramos y
soltamos sobre el diseñador
Al intentar añadir el NorthwindDataSet, nos saldrá la ventana Add Dataset. En la

combo seleccionamos Referenced datasets -> ClientSyncLibrary.NorthwindDataSet
Ahora añadimos un componente BindingSource al diseñador, como DataSource

seleccionamos northwindDataSet1, y como DataMember seleccionamos la tabla
Customers
Y finalmente ponemos bindingSource1 como DataSource de la DataGrid
Ahora añadimos cinco botones: Insert, Update, Delete, Sync y Load. Los tres primeros
harán operaciones de ejemplo y las guardarán en la BD, con el siguiente código:
private void button1_Click(object sender, EventArgs e)

{
this.northwindDataSet1.Customers.AddCustomersRow("AAAAA", "TestCompany", "TestContact",
"TestTitle", "TestAddress", "TestCity", "TestRegion", "", "", "", "", DateTime.Now, DateTime.Now);
this.customersTableAdapter1.Update(this.northwindDataSet1);
}

{
ClientSyncLibrary.NorthwindDataSet.CustomersDataTable dt = this.northwindDataSet1.Customers;
dt[0].CompanyName = "UPD";
}

{
ClientSyncLibrary.NorthwindDataSet.CustomersDataTable dt = this.northwindDataSet1.Customers;
dt[0].Delete();
}
El botón Load se ocupará de cargar la grid con los datos de la BD, con el siguiente código:

{
this.customersTableAdapter1.Fill(this.northwindDataSet1.Customers);
bindingSource1.ResetBindings(false);
}
Y por último, el más importante: el botón Sync, que iniciará la sincronización con el
servidor con el siguiente código:

{
Cursor.Current = Cursors.WaitCursor;
ClientSyncLibrary.NorthWindDataCacheClientSyncProvider ClientProvider = new

ClientSyncLibrary.NorthWindDataCacheClientSyncProvider();
Microsoft.Synchronization.Data.ServerSyncProviderProxy ServerProvider = new
Microsoft.Synchronization.Data.ServerSyncProviderProxy(new WSServerProvider.SyncService());
ClientSyncLibrary.NorthWindDataCacheSyncAgent Agent = new
ClientSyncLibrary.NorthWindDataCacheSyncAgent();
Agent.LocalProvider = ClientProvider;
Agent.RemoteProvider = ServerProvider;
Agent.Customers.SyncDirection = Microsoft.Synchronization.Data.SyncDirection.Bidirectional;
Microsoft.Synchronization.Data.SyncStatistics s;
s = Agent.Synchronize();
if (s.UploadChangesFailed > 0)
{
MessageBox.Show("Han habido fallos en la sincronización de subida");
}
Cursor.Current = Cursors.Default;
}
Ahora compilamos y ejecutamos. Para probar, primero debemos presionar el botón

Sync, para que cree y descargue la BD local, y después presionar Load para ver los
datos en la grid. Una vez probemos un poco, es probable que surja algún conflicto de
datos, entonces pasamos al siguiente paso: gestión de conflictos
2.8. Paso 7: Gestión de conflictos
Ya tenemos una aplicación que sincroniza. Por defecto, en caso de conflicto de datos
entre el cliente y el servidor, gana el servidor, y si es entre clientes gana el último en
enviar. Pero es probable que queramos modificar esta situación por defecto, para
hacer que gane siempre el cliente, o quizás para tomar la decisión en base a una lógica
de negocio (ej. las actualizaciones del jefe ganan a las del subordinado, o viceversa)
La gestión de conflictos siempre se lleva en el lado del servidor. Si se quiere que el

cliente decida sobre los conflictos, debemos implementar una solución especial (ej.
una tabla de conflictos que se descargue al usuario y lógica de cliente que permita
repetir las operaciones)
Para hacer esto debemos modificar el comportamiento de la clase

NorthWindDataCacheServerSyncProvider. Por suerte, el generador de código la
declara como clase parcial, por lo que no necesitamos modificar el código
autogenerado y repetir el proceso cada vez que reconfiguremos el proceso de
sincronización. Así que vamos al proyecto ServerSyncLibrary, y añadimos una nueva
clase NorthWindDataCacheServerSyncProvider.Custom.cs. Modificamos la declaración
de clase por defecto con este código:
public partial class NorthWindDataCacheServerSyncProvider
Y añadimos el siguiente código para registrar un manejador para el evento

ApplyChangeFailed:
partial void OnInitialized()

{
this.ApplyChangeFailed += new
EventHandler<Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs>(NorthWindDataCacheServ
erSyncProvider_ApplyChangeFailed);
}
void NorthWindDataCacheServerSyncProvider_ApplyChangeFailed(object sender,

Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs e)
{
e.Action = Microsoft.Synchronization.Data.ApplyAction.RetryWithForceWrite;
}
El código de ejemplo fuerza a que en caso de conflicto el último cambio en llegar gane,
pero con los datos que devuelve ApplyChangeFailedEventArgs podemos implementar
lógica de cualquier tipo.
3. Epilogo:
Con esta “pequeña” guía Joaquin nos muestra lo sencillo que es trabajar con ADO.NET
Sync Services para Mobile y la potencia que podemos desplegar gracias a esta
tecnológia.
Sync Framework nos aporta un proveedor especifico para la sincronización de carpetas

archivos gracias a File Sync Services, también nos da un proveedor para la
sincronización SSE que nos facilita la actualización de RSS y Atm, además con Sync
Services para ADO.NET contamos con un SDK completo para la creación de
proveedores de datos personalizados específicos, asi como de un control total para la
resolución de conflictos a través de la implementación de la lógica de negocio con la
que trabajemos.
Desde MobileNug le damos las gracias a Joaquin por esta valiosa aportación.
Podréis encontrar una solución de ejemplo en:
http://www.mobilenug.com/descargas/Descarga%20de%20soluciones/HOWTO-
SyncFrameworkMobile.rar
Saludos
Jose Antonio Gallego

Sincronizacion de Datos para Mobile Con ADO - NET Sync Services

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Sincronizacion de Datos para Mobile Con ADO - NET Sync Services

Загружено:

Авторское право:

Доступные форматы

Sincronización de bases de datos con

ADO.net Sync Services en VS 2008

2. Sincronización de bases de datos con ADO.net Sync Services en VS 2008 ................ 5

Condiciones de uso y distribución:

Para ponerte en contacto puedes escribir a “consulta@mobilenug. es”

2. Sincronización de bases de datos con ADO.net

Para una visión general del Sync Framework, proveedores de sincronización,

2.2. Paso 1: Preparar la BD

Para instalar Northwind, ejecutamos instnwnd.sql, de la carpeta SQL Server 2000

2.3. Paso 2: Preparar la estructura de proyectos

- Creamos un proyecto Windows de tipo Class Library, con nombre

- Creamos un proyecto Smart Device de nombre ClientSyncLibrary.

- Creamos un proyecto Web de tipo ASP.Net Web Service Application y lo

- Por último, creamos un proyecto Smart Device llamado MobileClient, con

Debería quedar la siguiente distribución de proyectos:

2.4. Paso 3: Iniciar el diseñador de sincronización

Hacéis clic derecho en ServerSyncLibrary, y seleccionáis Add -> New Item.

Esto debería iniciar el siguiente diseñador de sincronización y añadir al proyecto un

En Server Connection, haced click en New y configurad una connexión a NorthWind.

Haced clic en el botón Advanced, y allí cambiad el proyecto cliente a ClientSyncLibrary

Finalmente, haced clic en OK para iniciar la generación. En el cuadro de diálogo de

En la pantalla de configuración de datasource seleccionamos la única tabla que vamos

Os deberían quedar los siguientes archivos y referencias en las soluciones:

2.5. Paso 4: Generar el servicio web

Hacemos clic en el proyecto WSServerProvider y añadimos una referencia a

Añadimos un nuevo servicio web SyncService.asmx

En el código, implementamos la interfaz

El servicio web actúa como Façade sobre el proveedor de sincronización de servidor,

El código quedará así:

return ServerProvider.ApplyChanges(groupMetadata, dataSet, syncSession);

return ServerProvider.GetChanges(groupMetadata, syncSession);

return ServerProvider.GetSchema(tableNames, syncSession);

Hacemos clic en Create Virtual Directory, y comprobamos que al introducir la URL en

2.6. Paso 5: Configurar el cliente del dispositivo

Hacemos clic en el proyecto MobileClient y añadimos una referencia a

Ahora hacemos clic en el proyecto y añadimos una referencia web al servicio

NOTA: Es importante sustituir localhost por la IP de la máquina, para que el dispositivo

En Reference.cs debemos añadir una directiva using para

Y el código completo de la clase:

// This source code was auto-generated by

public SyncContext EndApplyChanges(System.IAsyncResult

public System.IAsyncResult BeginGetSchema(string[] tableNames,

Compilamos, y ya tenemos el cliente configurado. Pasamos al siguiente paso para añadir

2.7. Paso 6: Código de pruebas

En el proyecto MobileClient, abrimos el formulario Form1 y añadimos un control

En la Toolbox, en el tab ClientSyncLibrary Components encontramos los componentes

Al intentar añadir el NorthwindDataSet, nos saldrá la ventana Add Dataset. En la

Ahora añadimos un componente BindingSource al diseñador, como DataSource

Y finalmente ponemos bindingSource1 como DataSource de la DataGrid

private void button1_Click(object sender, EventArgs e)

private void button2_Click(object sender, EventArgs e)

private void button3_Click(object sender, EventArgs e)

private void button5_Click(object sender, EventArgs e)

private void button4_Click(object sender, EventArgs e)

ClientSyncLibrary.NorthWindDataCacheClientSyncProvider ClientProvider = new

Ahora compilamos y ejecutamos. Para probar, primero debemos presionar el botón

2.8. Paso 7: Gestión de conflictos

La gestión de conflictos siempre se lleva en el lado del servidor. Si se quiere que el

Para hacer esto debemos modificar el comportamiento de la clase

public partial class NorthWindDataCacheServerSyncProvider

Y añadimos el siguiente código para registrar un manejador para el evento

partial void OnInitialized()

void NorthWindDataCacheServerSyncProvider_ApplyChangeFailed(object sender,