Condividi tramite

Gestione dei metadati per provider semplici

  • Articolo

Un provider semplice richiede che i metadati vengano archiviati in servizi di archiviazione dei metadati, con implementazione in SqlMetadataStore (per codice gestito) e in ISqlSyncMetadataStore (per codice non gestito).

L'archivio dei metadati contiene i tipi seguenti di metadati con cui un provider o un'applicazione interagirà:

  • ID replica. Identifica la replica che utilizza un particolare archivio.

  • ID elemento e versioni. Identificano ogni elemento enumerato da un archivio di elementi e la versione corrente di quell'elemento.

  • ID unità di modifica e versioni. Identificano facoltativamente parti di un elemento che deve essere rilevato e la versione corrente di ogni parte. Ad esempio, un contatto in un database di contatti potrebbe essere un elemento e il campo del numero di telefono potrebbe essere una delle unità di modifica.

Identificazione di elementi nell'archivio di elementi e nell'archivio dei metadati

Per sincronizzare un elemento, Sync Framework deve essere in grado di identificare l'elemento nell'archivio di elementi e di eseguire il mapping di tale identità a un ID interno nell'archivio dei metadati. Deve inoltre essere in grado di determinare se la versione dell'elemento è cambiata dall'ultima sessione di sincronizzazione. Se la versione è cambiata e la replica di destinazione non contiene già tale versione dell'elemento, quest'ultimo deve essere sincronizzato. Se le modifiche vengono sincronizzate al livello di un'unità di modifica anziché di un elemento, Sync Framework deve essere in grado di identificare l'unità di modifica e la relativa versione. Un'unità di modifica rappresenta una modifica di un elemento secondario, ad esempio il campo numero di telefono in un elemento che rappresenta un contatto. In questo esempio non vengono utilizzate unità di modifica.

Definizione del formato degli ID dell'archivio dei metadati

Nell'esempio di codice seguente viene definito il costruttore per MyFullEnumerationSimpleSyncProvider e la proprietà IdFormats. In questo modo il runtime di Sync Framework può determinare il formato utilizzato dall'archivio dei metadati per gli ID. Se non vengono utilizzati ID flessibili, in Sync Framework viene utilizzato un formato fisso per identificare repliche, elementi e unità di modifica. Se vengono utilizzati ID flessibili, per generare gli ID vengono utilizzati i metodi ISimpleSyncProviderIdGenerator.

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

Definizione dei campi elemento e dello schema dei metadati

Sync Framework esegue il mapping dei dati dell'archivio di elementi, o di metadati aggiuntivi creati, a versioni e ID dell'archivio dei metadati interni tramite un oggetto ItemMetadataSchema esposto dalla proprietà MetadataSchema. Negli esempi di codice seguenti viene fornito l'input per l'oggetto ItemMetadataSchema. Le costanti nel codice di esempio definiscono un valore integer per ogni colonna nell'archivio di elementi. Questi valori vengono utilizzati nella creazione di definizioni di campi e regole di identità personalizzate per l'oggetto 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

L'oggetto ItemMetadataSchema espone tre proprietà:

  • CustomFields

    I campi personalizzati sono campi dell'archivio dei metadati identificati da valori integer. Se un'applicazione richiede un nome descrittivo per uno o più campi, il valore integer deve essere mappato a un nome. I campi personalizzati vengono definiti per due ragioni: identificare gli elementi e fornire informazioni sulla versione per tali elementi. I campi versione consentono a Sync Framework di determinare se un elemento o un'unità di modifica è cambiata. In questo esempio i campi versione contengono i dati effettivi dell'archivio di elementi, pertanto è presente un campo per ogni campo dell'archivio di elementi. Questa corrispondenza uno-a-uno non è necessaria né efficace. Una soluzione più pratica consiste nell'utilizzare un hash dei campi elemento e archiviarlo in un solo campo personalizzato.

  • IdentityRules

    La regola di identità specifica il campo o i campi personalizzati che devono essere utilizzati per identificare un elemento. In questo caso, viene utilizzato il campo CUSTOM_FIELD_ID (campo 0).

  • ChangeUnitVersionDefinitions (non utilizzata in questo esempio)

    Se vengono utilizzate unità di modifica, è necessario definire campi versione per le unità di modifica. Nessun requisito prevede l'esistenza di un mapping uno-a-uno tra unità di modifica e informazioni sulla versione né impone l'archiviazione dei dati effettivi. Le unità di modifica possono estendersi su più campi. Ad esempio, in questa applicazione potrebbe essere specificato che Zip e Phone sono un'unità di modifica e che Guid è un'altra unità di modifica. Per Guid, è possibile utilizzare i dati effettivi e per l'altra unità di modifica un hash dei campi Zip e Phone o un altro meccanismo per determinare la versione.

Alcuni dei metodi applicabili ai dati dell'archivio di elementi, ad esempio InsertItem, richiedono una raccolta di oggetti ItemField che rappresentano ciascun campo. Gli oggetti ItemFieldDictionary che sono parametri di questi metodi dispongono degli stessi valori di indice di quelli specificati negli oggetti CustomFieldDefinition.

Vedere anche

Concetti

Implementazione di un provider personalizzato semplice
Procedura: creare un provider semplice gestito