Gerenciar assinaturas de Flexible Sync- .NET SDK

Adicionar uma assinatura

Você deve ter pelo menos uma assinatura antes de ler ou escrever no Realm. Você deve criar uma ou mais assinaturas iniciais ao configurar o Flexible Sync, em vez de adicionar assinaturas após a inicialização.

var config = new FlexibleSyncConfiguration(app.CurrentUser)
{
    PopulateInitialSubscriptions = (realm) =>
    {
        var myItems = realm.All<Item>().Where(n => n.OwnerId == myUserId);
        realm.Subscriptions.Add(myItems);
    }
};
// The process will complete when all the user's items have been downloaded.
var realm = await Realm.GetInstanceAsync(config);

var query = realm.All<Team>().Where(t => t.Name == "MyTeam");
await query.SubscribeAsync();
// you can also pass a SubscriptionOptions object:
var query2 = realm.All<Team>().Where(t => t.Name == "DevelopmentTeam");
await query2.SubscribeAsync(
    new SubscriptionOptions() { Name = "devTeamSubscription" });

realm.Subscriptions.Update(() =>
{
    // Subscribe to all long running items, and name
    // the subscription "longRunningItems"
    var longRunningTasksQuery = realm.All<Item>()
        .Where(t => t.ProgressMinutes > 120);
    realm.Subscriptions.Add(longRunningTasksQuery,
        new SubscriptionOptions() { Name = "longRunningItems" });
    // Subscribe to all of Ben's Items
    realm.Subscriptions.Add(realm.All<Item>()
        .Where(t => t.Owner == "Ben"));
    // Subscribe to all Teams, name the subscription
    // 'teamsSubscription', and throw an error if
    // this subscription name already exists.
    realm.Subscriptions.Add(realm.All<Team>(),
        new SubscriptionOptions()
        { Name = "teams", UpdateExisting = false });
});

Atualizar assinaturas com uma nova query

Você pode atualizar uma assinatura nomeada com uma nova query. Para atualizar a query de uma assinatura, passe a nova query e uma opção de assinatura com o nome da assinatura que você deseja atualizar para o método SubscriptionSet.Add() . Como adicionar uma nova assinatura, você deve atualizar uma assinatura dentro de um bloco de atualização chamando o método SubscriptionSet.Update() .

No exemplo a seguir, tarefas de longa duração são redefinidas como quaisquer tarefas que levaram mais de 130 minutos:

realm.Subscriptions.Update(() =>
{
    var updatedLongRunningTasksQuery = realm.All<Item>()
        .Where(t => t.Status == "completed" && t.ProgressMinutes > 130);
    realm.Subscriptions.Add(updatedLongRunningTasksQuery,
        new SubscriptionOptions() { Name = "longRunningTasks" });
});

Remover subscrições

Para remover assinaturas do conjunto de assinaturas, você pode:

• Remover uma única assinatura com a query fornecida

• Remover uma única assinatura com o nome fornecido

• Remover uma única assinatura com a assinatura fornecida

• Remover todas as assinaturas de um tipo específico

• Remover todas as assinaturas

Quando você remove uma query de assinatura, o servidor também remove os dados sincronizados do dispositivo cliente.

realm.Subscriptions.Update(() =>
{
    // remove a subscription by it's query
    var query = realm.All<Item>().Where(i => i.Owner == "Ben");
    realm.Subscriptions.Remove(query);
});

realm.Subscriptions.Update(() =>
{
    // remove a named subscription
    var subscriptionName = "longRunningItemsSubscription";
    realm.Subscriptions.Remove(subscriptionName);
});

realm.Subscriptions.Update(() =>
{
    // remove all subscriptions of the "Team" Class Name
    realm.Subscriptions.RemoveAll("Team");
    // Alernatively, remove all subscriptions of the "Team" object type
    realm.Subscriptions.RemoveAll<Team>();
});

realm.Subscriptions.Update(() =>
{
    // remove all subscriptions, including named subscriptions
    realm.Subscriptions.RemoveAll(true);
});

Aguarde as alterações na assinatura para sincronizar

Mutar o conjunto de assinaturas em um bloco de atualização é apenas uma parte da alteração de uma assinatura. Após a alteração da assinatura local, o Realm sincroniza com o servidor para resolver quaisquer atualizações nos dados devido à alteração da assinatura. Isso pode média adicionar ou remover dados do Realm sincronizado.

Use o método SubscriptionSet.WaitForSynchronizationAsync() para aguardar que o servidor reconheça este conjunto de assinaturas. Se o servidor rejeitar a alteração, o SubscriptionSetState será um estado de erro e uma exceção será lançada.

Uma exceção pode ocorrer se:

• Uma query não suportada está inscrita. A assinatura de uma query não suportada pausará a sincronização. Para retomar a sincronização, remova a query não suportada.

• Você está executando uma ação inválida, como adicionar um objeto que não corresponde a uma assinatura. Este Atlas Triggers um reinício do cliente: os dados são apagados do domínio e uma nova cópia dos dados é criada sem nenhuma assinatura no conjunto.

try
{
    await realm.Subscriptions.WaitForSynchronizationAsync();
}
catch (SubscriptionException ex)
{
    // do something in response to the exception or log it
    Console.WriteLine($@"The subscription set's state is Error and synchronization is paused:  {ex.Message}");
}

Estado da assinatura

Use a propriedade SubscriptionSet.state para ler o estado atual do conjunto de assinaturas.

O estado Superseded é um SubscriptionSetState que pode ocorrer quando outro tópico atualiza uma assinatura em uma instância diferente do conjunto de assinatura. Se o estado se tornar Superseded, você deverá obter uma nova instância do conjunto de assinaturas antes de poder atualizá-lo.

Requisitos de inscrição de campos de query indexados

Adicionar um campo de query indexado à sua aplicação pode melhorar o desempenho de queries simples em dados fortemente particionados. Por exemplo, uma aplicação onde as queries mapeiam fortemente os dados para um dispositivo, armazém ou usuário, como user_id == $0, “641374b03725038381d2e1fb”, é uma boa candidata para um campo de query indexado. No entanto, um campo de query indexado tem requisitos específicos para uso em uma inscrição de query:

• O campo de query indexado deve ser usado em todas as inscrições de query. Não pode estar faltando na query.

• O campo de query indexado deve usar uma comparação == ou IN com uma constante pelo menos uma vez na query de inscrição. Por exemplo, user_id == $0, "641374b03725038381d2e1fb" ou store_id IN $0, {1,2,3}.

Opcionalmente, você pode incluir uma comparação AND, desde que o campo consultável indexado seja comparado diretamente com uma constante usando == ou IN pelo menos uma vez. Por exemplo, store_id IN {1,2,3} AND region=="Northeast" ou store_id == 1 AND (active_promotions < 5 OR num_employees < 10).

As consultas inválidas do Flexible Sync em um campo indexado que pode ser consultado incluem consultas em que:

• O campo de consulta indexado não utiliza AND com o resto da consulta. Por exemplo store_id IN {1,2,3} OR region=="Northeast" é inválido porque usa OR em vez de AND. Da mesma forma, store_id == 1 AND active_promotions < 5 OR num_employees < 10 é inválido porque o AND só se aplica ao termo ao lado, não à consulta inteira.

• O campo de consulta indexado não é utilizado em um operador de igualdade. Por exemplo store_id > 2 AND region=="Northeast" é inválido porque utiliza apenas o operador > com o campo de consulta indexado e não tem uma comparação de igualdade.

• A query está totalmente ausente do campo de query indexado. Por exemplo, region=="Northeast ou truepredicate são inválidos porque não contêm o campo de query indexado.

Operadores de consulta não suportados na sincronização flexível

A Flexible Sync tem algumas limitações ao usar operadores RQL. Quando você escreve a assinatura de consulta que determina quais dados sincronizar, o servidor não oferece suporte a esses operadores de consulta. No entanto, você ainda pode usar toda a gama de recursos de RQL para consultar o conjunto de dados sincronizado no aplicativo cliente.

Queries que não diferenciam maiúsculas de minúsculas ([c]) não podem usar índices de forma eficaz. Sendo assim, queries que não diferenciam maiúsculas de minúsculas não são recomendadas, pois podem causar problemas de desempenho.

A sincronização flexível suporta apenas @count para campos de array.

Listar queries

A sincronização flexível oferece suporte às listas de query usando o operador IN .

Você pode consultar uma lista de constantes para ver se ela contém o valor de um campo de consulta:

// Query a constant list for a queryable field value
"priority IN { 1, 2, 3 }"

Se um campo de query tiver um valor de array, você poderá consultar para ver se ele contém um valor constante:

// Query an array-valued queryable field for a constant value
"'comedy' IN genres"

// Invalid Flexible Sync query. Do not do this!
"{'comedy', 'horror', 'suspense'} IN genres"
// Another invalid Flexible Sync query. Do not do this!
"ANY {'comedy', 'horror', 'suspense'} != ANY genres"

Objetos incorporados ou vinculados

A sincronização Flexível não oferece suporte à consulta de propriedades em objetos ou links embarcados. Por exemplo, obj1.field == "foo".

Limite de tamanho da query

O limite de tamanho para qualquer assinatura de query em seu conjunto de assinaturas é de 256 kB. Exceder esse limite resulta em um erro de LimitsExceeded.