With the ArcGIS Server REST API, the feature service has the ability to create a copy of itself using CreateReplica. For more information, navigate to http://resources.arcgis.com/en/help/rest/apiref/index.html?featureserver.html. After the edits are made, the feature service can be updated using SynchornizeReplica; refer to http://resources.arcgis.com/en/help/rest/apiref/index.html?featureserver.html.

If you publish the San Francisco parking meters layer that comes with the book and make sure its synchronization is enabled, you could then go to this feature service's directory and perform the following steps to produce a Runtime geodatabase:

Press the Enter key in your browser and the Runtime geodatabase will be downloaded from the server. You can now use this Runtime geodatabase to perform edits on. You may want to rename the output file to something more useful for your app:

It should also be noted that this entire process can be automated using Python or JavaScript.

The second approach is to use the ArcGIS Runtime API. The general process when using the ArcGIS Runtime API is as follows:

In this section, we'll discuss step 1. In the sections that follow, we'll cover steps 2, 3, and 4.

There are several classes involved in generating a Runtime geodatabase using the GenerateGeodatabaseParameters, GenerateGeodatabaseResult, and GeodatabaseSyncTask APIs. Here is an example of using the objects:

var syncTask = new GeodatabaseSyncTask(new Uri(this.URL));

// Get current viewpoints extent from the MapView
var currentViewpoint = this.mapView.GetCurrentViewpoint(ViewpointType.BoundingGeometry);
var viewpointExtent = currentViewpoint.TargetGeometry.Extent;

var options = new GenerateGeodatabaseParameters(new int[] { 0 }, 
    viewpointExtent)
{
    GeodatabasePrefixName = GDB_PREFIX,
    ReturnAttachments = false,
    OutSpatialReference = MyMapView.SpatialReference,
    SyncModel = SyncModel.PerLayer
};

var tcs = new TaskCompletionSource<GeodatabaseStatusInfo>();
Action<GeodatabaseStatusInfo, Exception> 
    completionAction = (info, ex) =>
{
    if (ex != null)
        tcs.SetException(ex);
        tcs.SetResult(info);
};

var generationProgress = new Progress<GeodatabaseStatusInfo>();
generationProgress.ProgressChanged += (sndr, sts) => { ReportStatus(sts.Status.ToString()); };

// Starting GenerateGeodatabase 
var result = await syncTask.GenerateGeodatabaseAsync(options, 
    completionAction,
    TimeSpan.FromSeconds(3), generationProgress, 
    CancellationToken.None);

// Waiting on geodatabase from server
var statusResult = await tcs.Task;

// Downloading Geodatabase…
var gdbPath = await DownloadGeodatabase(statusResult);

// Create local Feature Layers

This code segment creates a GeodatabaseSyncTask API with the feature service's URL, gets the extent of the map, and then sets up the parameters for generating the Runtime geodatabase. In this example, only the first layer is used when specifying the GenerateGeodatabaseParameters API. Also, GenerateGeodatabaseParameters is told to not return attached, and to use a synchronize model called PerLayer. The PerLayer model indicates that each layer will be synced individually. If the synchronization model is set to PerGeodatabase, all layers will be synced once the syncing process starts. A TaskCompletionSource instance is created next, which is called when the download finishes. Next, a Progress object is created with a GeodatabaseStatusInfo object. The GeodatabaseStatusInfo object simply lets you know the progress of the download process. After the Progress object is created, the GenerateGeodatabaseAsync object is started with GenerateGeodatabaseParameter, the TaskCompletionSource instance, the time span in which it is checked, the progress, and CancellationToken of None. Next, the task is awaited using tcs.Task. Finally, when the task is completed, the Runtime geodatabase is downloaded using this method:

private async Task<string> DownloadGeodatabase(GeodatabaseStatusInfo statusResult)
{
    var client = new ArcGISHttpClient();
    var gdbStream = client.GetOrPostAsync(statusResult.ResultUri, null);
    var gdbFolder = System.IO.Path.GetTempPath();
    var gdbPath = System.IO.Path.Combine(gdbFolder, statusResult.GeodatabaseName);

    if (!System.IO.Directory.Exists(gdbFolder))
        System.IO.Directory.CreateDirectory(gdbFolder);

    await Task.Run(async () =>
    {
        using (var stream = System.IO.File.Create(gdbPath))
        {
            await gdbStream.Result.Content.CopyToAsync(stream);
        }
    });

    return gdbPath;
} 

The ArcGISHttpClient class in Esri.ArcGISRuntime.Http is optimized to get data from the ArcGIS Server REST API. Once it is instantiated, you call GetOrPostAsync with the URI of GeodatabaseStatusInfo to the service and it will return an HttpResponseMessage message stream (HttpResponseMessage). With this stream, you can create a geodatabase file and fill it with the content of the stream's contents. As a side note, Esri.ArcGISRuntime.Http allows you to write your own interfaces for interacting with ArcGIS Server.

To create a read-only Runtime geodatabase from ArcGIS Desktop, you will need perform the following steps:

This workflow is easy to execute and provides a simple way to generate a Runtime geodatabase if your users don't need to edit the data.

We will now generate a Runtime geodatabase using a Geoprocessing tool by performing the following steps:

Once again, this will create a read-only Runtime geodatabase.