Gerenciando metadados para provedores simples

Artigo
10/17/2009

Um provedor simples exige que você armazene metadados em serviços de armazenamento de metadados, que são implementados em SqlMetadataStore (para código gerenciado) e em ISqlSyncMetadataStore (para código não gerenciado).

O repositório de metadados contém os seguintes tipos de metadados com os quais um provedor ou aplicativo interagirá:

Uma ID de réplica. Identifica a réplica que usa um repositório específico.
Versões e IDs de item. Identificam cada item que foi enumerado a partir de um repositório de itens e a versão atual desse item.
Versões e IDs da unidade de alteração. Opcionalmente, identificam partes de um item que precisam ser rastreadas e a versão atual de cada parte. Por exemplo, um contato em um banco de dados de contatos poderia ser um item e o campo de número de telefone poderia ser uma das unidades de alteração.

Identificando itens no repositório de itens e no repositório de metadados

Para sincronizar um item, o Sync Framework deve poder identificar o item no repositório de itens e mapear essa identidade para uma ID interna no repositório de metadados. Ele também precisa determinar se a versão do item foi alterada desde a última sessão de sincronização. Se a versão tiver sido alterada e a réplica de destino ainda não contiver essa versão de um item, o item deverá ser sincronizado. Se as alterações forem sincronizadas no nível de uma unidade de alteração em vez de um item, o Sync Framework deverá poder identificar a unidade de alteração e sua versão. Uma unidade de alteração representa uma alteração de subitem, como o campo de número de telefone em um item que representa um contato. Este exemplo não usa unidades de alteração.

Especificando o formato de IDs do repositório de metadados

O código a seguir define o construtor para o MyFullEnumerationSimpleSyncProvider e a propriedade IdFormats. Assim, o tempo de execução do Sync Framework pode determinar o formato que o repositório de metadados usa para IDs. Caso não sejam usadas IDs flexíveis, o Sync Framework usará um formato fixo para identificar réplicas, itens e unidades de alteração. Se forem usadas IDs flexíveis, serão usados métodos ISimpleSyncProviderIdGenerator para gerar IDs.

public MyFullEnumerationSimpleSyncProvider(string name, MySimpleDataStore store)
{
    _name = name;
    _store = store;

    // Create a file to store metadata for all items and a file to store 
    // the replica ID.
    _replicaMetadataFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Metadata";
    _replicaIdFile = Environment.CurrentDirectory + "\\" + _name.ToString() + ".Replicaid";

    // Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus
    // an 8-byte prefix.
    _idFormats = new SyncIdFormatGroup();
    _idFormats.ItemIdFormat.IsVariableLength = false;
    _idFormats.ItemIdFormat.Length = 24;
    _idFormats.ReplicaIdFormat.IsVariableLength = false;
    _idFormats.ReplicaIdFormat.Length = 16;

    this.ItemConstraint += new EventHandler<SimpleSyncItemConstraintEventArgs>(OnItemConstraint);
    this.ItemConflicting += new EventHandler<SimpleSyncItemConflictingEventArgs>(OnItemConflicting);
}

public SyncId ReplicaId
{
    get 
    {
        if (_replicaId == null)
        {
            _replicaId = GetReplicaIdFromFile( _replicaIdFile);
        }

        return _replicaId; 
    }
}

public override SyncIdFormatGroup IdFormats
{
    get { return _idFormats; }
}

Public Sub New(ByVal name As String, ByVal store As MySimpleDataStore)
    _name = name
    _store = store

    ' Create a file to store metadata for all items and a file to store 
    ' the replica ID. 
    _replicaMetadataFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Metadata"
    _replicaIdFile = (Environment.CurrentDirectory & "\") + _name.ToString() & ".Replicaid"

    ' Set ReplicaIdFormat to use a GUID as an ID, and ItemIdFormat to use a GUID plus 
    ' an 8-byte prefix. 
    _idFormats = New SyncIdFormatGroup()
    _idFormats.ItemIdFormat.IsVariableLength = False
    _idFormats.ItemIdFormat.Length = 24
    _idFormats.ReplicaIdFormat.IsVariableLength = False
    _idFormats.ReplicaIdFormat.Length = 16

    AddHandler Me.ItemConstraint, AddressOf HandleItemConstraint
    AddHandler Me.ItemConflicting, AddressOf HandleItemConflicting
End Sub
Public ReadOnly Property ReplicaId() As SyncId
    Get
        If _replicaId Is Nothing Then
            _replicaId = GetReplicaIdFromFile(_replicaIdFile)
        End If

        Return _replicaId
    End Get
End Property

Public Overrides ReadOnly Property IdFormats() As SyncIdFormatGroup
    Get
        Return _idFormats
    End Get
End Property

Especificando campos de item e o esquema de metadados

O Sync Framework mapeia dados do repositório de itens ou metadados adicionais criados por você para versões e IDs do repositório de metadados interno usando um objeto ItemMetadataSchema exposto pela propriedade MetadataSchema. Os exemplos de código a seguir fornecem entrada para o objeto ItemMetadataSchema. As constantes no código de exemplo definem um valor inteiro para cada coluna no repositório de itens. Esses valores são usados na criação das definições do campo personalizado e das regras de identidade para o objeto ItemMetadataSchema.

public const uint CUSTOM_FIELD_ID = 1;
public const uint CUSTOM_FIELD_TIMESTAMP = 2;

public override ItemMetadataSchema MetadataSchema
{
    get
    {
        CustomFieldDefinition[] customFields = new CustomFieldDefinition[2];
        customFields[0] = new CustomFieldDefinition(CUSTOM_FIELD_ID, typeof(ulong));
        customFields[1] = new CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, typeof(ulong));

        IdentityRule[] identityRule = new IdentityRule[1];
        identityRule[0] = new IdentityRule(new uint[] { CUSTOM_FIELD_ID });

        return new ItemMetadataSchema(customFields, identityRule);
    }
}

Public Const CUSTOM_FIELD_ID As UInteger = 1
Public Const CUSTOM_FIELD_TIMESTAMP As UInteger = 2
Public Overrides ReadOnly Property MetadataSchema() As ItemMetadataSchema
    Get
        Dim customFields As CustomFieldDefinition() = New CustomFieldDefinition(1) {}
        customFields(0) = New CustomFieldDefinition(CUSTOM_FIELD_ID, GetType(ULong))
        customFields(1) = New CustomFieldDefinition(CUSTOM_FIELD_TIMESTAMP, GetType(ULong))

        Dim identityRule As IdentityRule() = New IdentityRule(0) {}
        identityRule(0) = New IdentityRule(New UInteger() {CUSTOM_FIELD_ID})

        Return New ItemMetadataSchema(customFields, identityRule)
    End Get
End Property

O objeto ItemMetadataSchema expõe três propriedades:

CustomFields

Campos personalizados são campos no repositório de metadados identificados por inteiros. Se um aplicativo exigir um nome amigável para um ou mais campos, ele deve mapear o inteiro para um nome. Os campos personalizados são definidos por dois motivos: para identificar itens e para fornecer informações de versão sobre esses itens. Os campos de versão habilitam o Sync Framework a determinar se um item ou uma unidade de alteração foi alterada. Neste exemplo, os campos de versão contêm os dados reais do repositório de itens; assim, há um campo para cada campo no repositório de itens. Esta correspondência um para um não é necessária, nem é eficiente. Uma solução mais prática seria pegar um hash dos campos de item e armazená-lo em um único campo personalizado.
IdentityRules

A regra de identidade especifica o campo ou os campos personalizados que devem ser usados para identificar um item. Nesse caso, é usado o campo CUSTOM_FIELD_ID (campo 0).
ChangeUnitVersionDefinitions (não usado neste exemplo)

Se forem usadas unidades de alteração, você deve definir campos de versão para as unidades de alteração. Não é necessário que haja um mapeamento um para um entre as unidades de alteração e as informações de versão, ou que os dados reais devam ser armazenados. As unidades de alteração também podem abranger vários campos. Por exemplo, este aplicativo poderia especificar que Zip e Phone são uma unidade de alteração e que Guid é outra unidade de alteração. Para Guid, você pode usar os dados reais e, para a outra unidade de alteração, um hash dos campos Zip e Phone ou algum outro mecanismo para determinar a versão.

Alguns dos métodos que trabalham com dados do repositório de itens, como InsertItem, exigem uma coleção de objetos ItemField que representam cada campo. Os objetos ItemFieldDictionary que são parâmetros para esses métodos têm os mesmos valores de índice que os especificados nos objetos CustomFieldDefinition.

Consulte também

Conceitos

Implementando um provedor personalizado simples
Como criar um provedor simples gerenciado

Partilhar via