Code duplication reduction exercise

[henda79]

I'm looking to implement a better way to define offline tables on the client.

In my current project I have around 50 tables and implementing these would mean I need to define each one

store.DefineTable<MyModel1>();

then I need to get a reference to each one using

_table = _client.GetOfflineTable<MyModel1>();

it just seems like there could be an easier way. So I'm looking for ideas...

[adrianhall]

Nope - no easier way. You need to define the tables prior to usage, then call InitializeOfflineStoreAsync, then get each one. I only get them when I need to use them - even at the method level - the sync context is constant,

[adrianhall]

That being said - what does you ideal situation look like? What code would you want to write?

[henda79]

Yes, I see that they need defined then the Initialize call made before they can be accessed. Initially I was hoping when each table was defined it would also return that table.

Currently I have a generic class and extension methods which encapsulate the CRUD methods of the Datasync methods.

So far, I'm not really sure how this can be improved, it's just when I started to refactor, it just didn't feel right.

[adrianhall]

No reason you can't do something like:

var options = new MyOptions
{
  endpoint = "https://my-endpoint.azure-api.net",
  authorizer = new GenericAuthorizationProvider(GetAuthorizationToken),
  models = new Type[]
  {
    typeof(MyType1),
    typeof(MyType2),
    ...
  }
}
var serviceClient = new MyServiceClient(options);
await serviceClient.InitializeAsync();

Then, in service client initializer, you can use:

var offlineStore = new OfflineSQLiteStore(options.connectionString);
foreach (var model in options.models) 
{
  var json = GetJsonModel(model);
  offlineStore.DefineTable(model.Name.ToLowerInvariant(), json);
}
var client = new DatasyncClient(options.endpoint, options.authorizer);
await client.InitializeOfflineStoreAsync();
foreach (var model in options.models)
{
  tables[model] = client.GetOfflineTable(model);
}

However, we'd have to add an extension method to client to have GetOfflineTable(Type model), which maybe isn't a bad idea anyhow.

Also, however, it's not actually saving you that much code. You still need to understand the types up front and you still need to define the structure of the database up front.

Possibility (when I rewrite the client for v6) is to have a GetOfflineClientAsync<Tmodel>(tablename, remotetable) - or something similar - if tablename isn't in the SQLite store, then create the database table before using it. Or even better, GetOfflineClient() and then it tracks the initialization state and only initializes on first access (pull, push, etc.)

So then your code would be

var options = new DatasyncOptions
{
  OfflineStore = new OfflineSQLiteStore(connectionString)
};
var client = new DatasyncClient(endpoint, options);
await client.InitializeOfflineStoreAsync();
var table = client.GetOfflineTable<TModel>();

Then later:

// Offline store gets updated with details of TModel here
table.PullItemsAsync();

Thoughts?

[henda79]

Yes, I've been working on this today and as you say whatever method you come up (I had thought about something similar to yours) it would not save much code, so for now I just define them all then call InitializeOfflineStoreAsync(), then use my generic methods and extensions to use the generic version of GetOfflineTable, so far so good.

I like your idea for version 6, but if you're dropping support .NET Standard 2.1 I wont be able to enjoy it, as I'm sticking with Xamarin until MAUI is a bit more mature.

I also had a question about transactions, but I'll post another Q&A