In N-Tier setup, the server sync provider runs one the server node, while the sync agent and client provider reside on the client. Since the agent is located on the client, the client application runs the show. This is the typical setup, however, there is no technical reason not to locate the agent on the server and implement some sort of a server driven push sync. Although, this is not what the framework is optimized for.

Two steps are need to turn our 2-tier application developed in 'demo II' to n-tier application:

Step 1: Expose ServerSyncProvider Interface as Web Service

This is really simple step. The ServerSyncProvider interface has only four methods, again only four methods. That's is not a sheer luck! To expose those four method as web methods, we need a simple wrapper as shown in the code below:

public class Service : System.Web.Services.WebService
{
     private DbServerSyncProvider _serverProvider;

public Service ()
{
    /// Same code as in demo II Sychronize button code
}

///  Access server sync parameters
[WebMethod]
public SyncServerInfo GetServerInfo()
{
    return _serverProvider.GetServerInfo();
} 

/// Access table schema in DataSet form   
[WebMethod]
public SyncSchema GetSchema(Collection<string> tableNames)
{
    return _serverProvider.GetSchema(tableNames);
} 

/// Enumerate group changes   
[WebMethod]
public SyncContext GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession)
{
    return _serverProvider.GetChanges(groupMetadata, syncSession);       
}

/// Apply group changes
[WebMethod]
public SyncContext ApplyChanges(SyncGroupMetadata groupMetadata, DataSet dataSet, SyncSession   syncSession)
{               
    return _serverProvider.ApplyChanges(groupMetadata, dataSet, syncSession);
}   

}

Our simple wrapper just relay the calls to the ServerSyncProvider instance. Take a look at service.cs file for the code of the constructor to this type. You will find it familiar since it is the same code for the sync adapters we had in the previous demo. With this, the server side is ready to serve clients. Let's switch gears to client side.

Step 2: Expose the Web Service Proxy as ServerSyncProvider Interface

On the client, you know what to do. Reference the web service we just created in the client project. I will call the web reference, SyncWebService:

In its raw form, the web reference inherits from SoapHttpClientProtocol. The SyncAgent expects a ServerSyncProvider instance. Yes, we need another wrapper class to relay the same four methods to the web service proxy. If you are interested in seeing yet another wrapper class, check out the ServerSyncProviderProxy.cs for the code.

The rest is detail at this point. Just pass the proxy type to the sync agent and you are done. 

Compiling the client project will generate few errors due to type sharing issues. The steps to install the web service below should help you resolve these issues.

That was easy, wasn't it? ready for another demo?

Install OfflineAppDemo Application Steps:

Version 1.2 [C#] : Download Now