本主題描述如何使用 Managed 語言來追蹤用於 Sync Framework 同步處理社群的篩選，以及如何列舉篩選變更批次。
本主題假設您對於 C# 和 Microsoft .NET Framework 概念有基本的了解。
本主題的範例將重點放在下列 Sync Framework 類別和成員：
了解篩選追蹤
建議您讓同步處理社群中的所有複寫都追蹤該社群所使用的篩選。當篩選複寫從篩選追蹤複寫收到篩選變更列舉時，就會保持較小的篩選複寫知識。當篩選複寫從沒有追蹤篩選的複寫收到篩選變更列舉時，知識的大小成長比例將與所傳送的變更數目成正比。
篩選追蹤提供者會實作 IFilterTrackingProvider 介面。Sync Framework 會使用此介面來協調由來源複寫與目的地複寫所追蹤之篩選的交涉。
來源提供者會在同步處理期間針對每個相互追蹤的篩選傳送篩選中繼資料。篩選追蹤提供者通常也會實作 ISupportFilteredSync 介面，而且能夠列舉任何追蹤篩選所篩選的變更。
目的地提供者會實作 IFilterTrackingNotifyingChangeApplierTarget 介面，讓變更套用者用來取得並更新追蹤篩選的篩選機碼對應和篩選被遺忘知識。此外，目的地提供者也會更新傳送至 SaveItemChange 或 SaveChangeWithChangeUnits 方法之項目和變更單位的篩選變更中繼資料。
組建需求
.NET Framework 2.0 或更新版本。
範例
本主題的範例程式碼將示範如何實作傳送篩選變更中繼資料的篩選追蹤提供者，可在做為來源提供者時列舉篩選變更批次，而在做為目的地提供者時套用篩選變更中繼資料。這個範例中的複寫是一個文字檔，這個檔案會將連絡人資訊儲存為以逗號分隔的值清單。要同步處理的項目是這個檔案中所包含的連絡人。篩選是一個字串，只有當系統在連絡人的地址欄位中找到篩選字串時，才會導致加入連絡人。
交涉追蹤篩選
為了交涉追蹤篩選，Sync Framework 會針對目的地提供者呼叫 SpecifyTrackedFilters。這則範例會列舉目的地複寫所追蹤的篩選清單、傳送每個篩選至來源提供者，並且只有當來源提供也追蹤篩選時，才會將篩選加入至相互追蹤篩選的清單。
public void SpecifyTrackedFilters(RequestTrackedFilterCallback filterTrackingRequestCallback)
{
foreach (AddressFilter filter in _ContactStore.TrackedFilters)
{
if (filterTrackingRequestCallback(filter))
{
// Add the filter to the list of mutually tracked filters only when the
// source provider also tracks the filter.
_filterKeyMap.AddFilter(filter);
}
}
}
Sync Framework 會針對目的地提供者所列舉的每個篩選，呼叫來源提供者的 TryAddTrackedFilter 方法。這則範例會檢查來源複寫是否追蹤指定的篩選，而且如果是，就會將它加入至相互追蹤篩選的清單。
public bool TryAddTrackedFilter(ISyncFilter filter)
{
bool isTracked = false;
foreach (AddressFilter addressFilter in _ContactStore.TrackedFilters)
{
// Add the filter to the list of mutually tracked filters only when it
// is identical to one of the filters of this replica.
if (addressFilter.IsIdentical(filter))
{
_filterKeyMap.AddFilter(addressFilter);
isTracked = true;
break;
}
}
return isTracked;
}
交涉用於同步處理的篩選
當目的地複寫是篩選複寫時，它通常會要求來源提供者用來列舉變更的篩選。來源提供者會透過 TryAddFilter 方法接收此要求。這則範例會檢查要求的篩選是否為相互追蹤篩選，而且如果是，就會儲存它以便在列舉變更時使用。
public bool TryAddFilter(object filter, FilteringType filteringType)
{
_filterForSync = null;
// The filter must be tracked by both replicas.
for (int filterKey = 0; filterKey < _filterKeyMap.Count; filterKey++)
{
if (_filterKeyMap[filterKey].IsIdentical((ISyncFilter)filter))
{
_filterForSync = (AddressFilter)_filterKeyMap[filterKey];
_filteringType = filteringType;
break;
}
}
return (null != _filterForSync);
}
傳送篩選中繼資料和篩選變更
當來源提供者傳送變更批次時，它就會傳送篩選中繼資料。這則範例可以傳送篩選變更批次或未篩選變更批次，端視篩選是否用於同步處理而定。當項目以相對於追蹤篩選的方式變更時，變更批次所包含的每個變更都會附加篩選變更中繼資料。此外，系統也會傳送每個追蹤篩選的篩選被遺忘知識。當篩選用於同步處理時，如果某個項目位於篩選中，就會傳送此項目，而且已經移出篩選的項目則標示為準刪除項目。
public override ChangeBatch GetChangeBatch(uint batchSize, SyncKnowledge destinationKnowledge, out object changeDataRetriever)
{
// Return this object as the IChangeDataRetriever object that is called to retrieve item data.
changeDataRetriever = this;
// The metadata storage service does not support filter tracking, so enumerate changes manually.
ChangeBatch changeBatch;
if (null == _filterForSync)
{
// No filter was specified for synchronization, so produce an unfiltered change batch.
changeBatch = new ChangeBatch(IdFormats, destinationKnowledge, _ContactStore.ContactReplicaMetadata.GetForgottenKnowledge());
}
else
{
// A filter was specified for synchronization, so produce a filtered change batch.
CustomFilterInfo filterInfo = new CustomFilterInfo(IdFormats, _filterForSync);
changeBatch = new ChangeBatch(IdFormats, destinationKnowledge, _filterForSync.FilterForgottenKnowledge, filterInfo);
}
// If the destination replica tracks filters that are tracked by the source replica,
// set the filter key map of the change batch.
if (0 < FilterKeyMap.Count)
{
// Add the filter key map to the change batch before any groups are started.
changeBatch.FilterKeyMap = FilterKeyMap;
}
// Get all the items from the metadata store.
IEnumerable<ItemMetadata> allItems = _ContactStore.ContactReplicaMetadata.GetAllItems(true);
// Convert the destination knowledge for use with local versions.
SyncKnowledge mappedDestKnowledge = _ContactStore.ContactReplicaMetadata.GetKnowledge().MapRemoteKnowledgeToLocal(destinationKnowledge);
// Build the list of items in the change batch.
List<ItemChange> itemChanges = new List<ItemChange>((int)batchSize);
uint cItemsInBatch = 0;
SyncId replicaId = _ContactStore.ContactReplicaMetadata.ReplicaId;
foreach (ItemMetadata itemMeta in allItems)
{
// Process all items if this is an unfiltered enumeration.
// Otherwise, only process an item that has been in the filter. An item has been in the filter if
// it is currently in the filter or if its move version in relation to the filter is a value
// other than (0,0).
if (null == _filterForSync || _ContactStore.HasBeenInFilter(itemMeta, _filterForSync))
{
// If a change is not contained in the destination knowledge, add it to the change batch.
if (!mappedDestKnowledge.Contains(replicaId, itemMeta.GlobalId, itemMeta.ChangeVersion))
{
ChangeKind kind;
if (itemMeta.IsDeleted)
{
kind = ChangeKind.Deleted;
}
// An item that has been in the filter but is not currently in the filter has
// recently moved out, so it must be marked as a ghost.
else if (null != _filterForSync
&& !_filterForSync.IsInFilter(_ContactStore.ContactList[itemMeta.GlobalId]))
{
kind = ChangeKind.Ghost;
}
else
{
kind = ChangeKind.Update;
}
ItemChange itemChange = new ItemChange(IdFormats, _ContactStore.ContactReplicaMetadata.ReplicaId,
itemMeta.GlobalId, kind, itemMeta.CreationVersion, itemMeta.ChangeVersion);
// Pass along any filter information for filters tracked by both the source and destination replicas.
_ContactStore.AddFilterChanges(_filterKeyMap, itemMeta, mappedDestKnowledge, itemChange);
// Add the item to the change list. Include ghosts only if the destination requested ghosts.
if (kind != ChangeKind.Ghost || (kind == ChangeKind.Ghost && FilteringType.CurrentItemsAndVersionsForMovedOutItems == _filteringType))
{
itemChanges.Add(itemChange);
}
cItemsInBatch++;
}
}
if (batchSize <= cItemsInBatch)
{
break;
}
}
// Add the list of items to the change batch object.
if (0 < itemChanges.Count)
{
changeBatch.BeginOrderedGroup(itemChanges[0].ItemId);
// Set the filter forgotten knowledge for each filter that the destination has requested.
for (int iFilter = 0; iFilter < FilterKeyMap.Count; iFilter++)
{
AddressFilter addressFilter = (AddressFilter)FilterKeyMap[iFilter];
changeBatch.SetFilterForgottenKnowledge((uint)iFilter, addressFilter.FilterForgottenKnowledge);
}
changeBatch.AddChanges(itemChanges);
// End the group of changes in the change batch. Pass the current source knowledge.
changeBatch.EndOrderedGroup(itemChanges[itemChanges.Count - 1].ItemId, _ContactStore.ContactReplicaMetadata.GetKnowledge());
// If all items were enumerated before the batch was filled, then this is the last batch.
if (cItemsInBatch < batchSize)
{
changeBatch.SetLastBatch();
}
}
else
{
throw new InvalidOperationException("GetChangeBatch called but there are no new changes to enumerate.");
}
return changeBatch;
}
系統會檢查每個相互追蹤篩選的篩選變更中繼資料。當變更的移動版本沒有包含在目的地知識中時，篩選變更中繼資料就會加入至變更。
public void AddFilterChanges(FilterKeyMap filterKeyMap, ItemMetadata itemMeta, SyncKnowledge destKnowledge,
ItemChange itemChange)
{
for (int filterKey = 0; filterKey < filterKeyMap.Count; filterKey++)
{
// Find the filter in the list of all filters tracked by this replica.
int iFilter = 0;
for (; iFilter < _trackedFilters.Count; iFilter++)
{
if (filterKeyMap[filterKey].IsIdentical(_trackedFilters[iFilter]))
{
break;
}
}
// Get the filter information for the item and add it to the ItemChange object.
SyncVersion moveVersion = GetMoveVersion(itemMeta, iFilter);
// Only return a filter change if the destination knowledge does not contain the version of the
// last move that occurred in relation to the specified filter.
FilterChange filterChange = null;
if (!destKnowledge.Contains(ContactReplicaMetadata.ReplicaId, itemMeta.GlobalId, moveVersion))
{
filterChange = new FilterChange(GetIsInFilter(itemMeta, iFilter), moveVersion);
itemChange.AddFilterChange((uint)filterKey, filterChange);
}
}
}
套用篩選中繼資料
使用變更套用者來套用變更，而且它會呼叫目的地提供者的 SaveItemChange 方法。建立或更新某個項目時，這則範例會建立或更新連絡人存放區中的資料、更新同步處理中繼資料，並且更新篩選追蹤中繼資料。系統會針對目的地提供者所追蹤的所有篩選更新篩選追蹤中繼資料，而不只是相互追蹤篩選的篩選追蹤中繼資料而已。當來源提供者傳送了篩選中繼資料時，就會使用此篩選中繼資料，否則變更會與每個追蹤篩選相比較並且設定適當篩選變更中繼資料。
public void UpdateContactFromSync(ItemChange itemChange, string changeData, FilterKeyMap providerFilterKeyMap)
{
if (!_ContactList.ContainsKey(itemChange.ItemId))
{
// The item does not exist, so create a new contact and add it to the contact and metadata store.
Contact contact = new Contact();
ItemMetadata itemMeta = _ContactReplicaMetadata.CreateItemMetadata(itemChange.ItemId,
itemChange.CreationVersion);
InitializeFilterTrackingFields(itemMeta);
_ContactList.Add(itemMeta.GlobalId, contact);
_ContactItemMetaList.Add(itemMeta.GlobalId, itemMeta);
}
_ContactList[itemChange.ItemId].FromString(changeData);
// Update the metadata for the item.
UpdateContactMetadataInternal(itemChange.ItemId, itemChange.ChangeVersion, itemChange, providerFilterKeyMap);
}
private void UpdateContactMetadataInternal(SyncId itemId, SyncVersion version, ItemChange itemChange, FilterKeyMap providerFilterKeyMap)
{
ItemMetadata itemMeta = _ContactItemMetaList[itemId];
// Set the value of all index fields in the metadata store.
itemMeta.SetCustomField(FirstNameField, _ContactList[itemId].FirstName);
itemMeta.SetCustomField(LastNameField, _ContactList[itemId].LastName);
itemMeta.SetCustomField(PhoneNumberField, _ContactList[itemId].PhoneNumber);
// Update the version metadata for the change unit.
itemMeta.ChangeVersion = version;
// Update the filter tracking metadata both for filter change metadata sent from the source provider and for
// any other filters tracked by this replica.
for (int iFilter = 0; iFilter < _trackedFilters.Count; iFilter++)
{
// Get filter change metadata from the source provider for this change, if it exists.
FilterChange filterChange = GetFilterChange(itemChange, iFilter, providerFilterKeyMap);
// If filter change metadata is present, use it to update the item metadata.
if (null != filterChange)
{
SetIsInFilter(itemMeta, iFilter, filterChange.IsMoveIn);
SetMoveVersion(itemMeta, iFilter, filterChange.MoveVersion);
}
// Otherwise, update the item metadata for other tracked filters.
else
{
UpdateFilterTrackingMetadata(itemMeta, iFilter, version);
}
}
}
// An item has been created or has changed, so update the filter tracking metadata for the item.
void UpdateFilterTrackingMetadata(ItemMetadata itemMeta, int iFilter, SyncVersion moveVersion)
{
// Determine whether the item is in the filter.
Contact contact = _ContactList[itemMeta.GlobalId];
bool isInFilter = _trackedFilters[iFilter].IsInFilter(contact);
// Determine whether the item was in the filter.
bool wasInFilter = GetIsInFilter(itemMeta, iFilter);
// If the filter membership has changed, update the filter tracking metadata.
if (isInFilter != wasInFilter)
{
SetIsInFilter(itemMeta, iFilter, isInFilter);
SetMoveVersion(itemMeta, iFilter, moveVersion);
}
}
此外，變更套用者也會呼叫目的地提供者之 IFilterTrackingNotifyingChangeApplierTarget 介面的方法來取得並儲存篩選追蹤中繼資料。這則範例會傳回要求的物件並儲存指定的中繼資料。
private FilterKeyMap _filterKeyMap;
public FilterKeyMap FilterKeyMap
{
get
{
return _filterKeyMap;
}
}
public ForgottenKnowledge GetFilterForgottenKnowledge(uint filterIndex)
{
if (filterIndex < _filterKeyMap.Count)
{
return ((AddressFilter)_filterKeyMap[(int)filterIndex]).FilterForgottenKnowledge;
}
else
{
throw new ArgumentOutOfRangeException("GetFilterForgottenKnowledge received and out-of-range index.");
}
}
public void SaveKnowledgeWithFilterForgottenKnowledge(SyncKnowledge syncKnowledge, ForgottenKnowledge forgottenKnowledge, ForgottenKnowledge[] filterForgottenKnowledge)
{
// First update the list of filter forgotten knowledge objects.
for (int iFilter = 0; iFilter < filterForgottenKnowledge.Length; iFilter++)
{
((AddressFilter)_filterKeyMap[iFilter]).FilterForgottenKnowledge = filterForgottenKnowledge[iFilter];
}
// Update the list of filters that are stored in the custom replica metadata.
AddressFilter.StoreFiltersInReplicaMetadata(_ContactStore.ContactReplicaMetadata, _ContactStore.TrackedFilters);
// Store the remaining knowledge objects.
StoreKnowledgeForScope(syncKnowledge, forgottenKnowledge);
}
儲存篩選中繼資料
複寫所追蹤的篩選必須連同每個追蹤篩選的篩選被遺忘知識一起儲存在複寫中。這則範例會使用中繼資料儲存服務來儲存中繼資料。由於中繼資料儲存服務不支援自訂篩選，所以追蹤篩選會序列化成位元組資料流並且儲存在中繼資料存放區的自訂複寫中繼資料欄位中。
class AddressFilter : ISyncFilter, ISyncFilterDeserializer
{
// For deserialization.
public AddressFilter()
{
_filter = null;
}
// A filter is a string that is compared against the Address field of a contact.
public AddressFilter(string filter)
{
_filter = filter;
}
public string Filter
{
get
{
return _filter;
}
}
// A contact is in the filter when the filter string is contained in the Address field of the contact.
public bool IsInFilter(Contact contact)
{
return contact.Address.Contains(_filter);
}
private string _filter;
public ForgottenKnowledge FilterForgottenKnowledge
{
get
{
return _filterForgottenKnowledge;
}
set
{
_filterForgottenKnowledge = value;
}
}
private ForgottenKnowledge _filterForgottenKnowledge;
#region ISyncFilter Members
// Two filters are identical when their filter strings are equal.
public bool IsIdentical(ISyncFilter otherFilter)
{
return _filter.Equals(((AddressFilter)otherFilter).Filter);
}
public byte[] Serialize()
{
MemoryStream memStream = new MemoryStream();
BinaryWriter biWriter = new BinaryWriter(memStream, Encoding.Unicode);
SerializeToBinaryWriter(biWriter);
return memStream.GetBuffer();
}
private void SerializeToBinaryWriter(BinaryWriter biWriter)
{
bool hasFilterForgottenKnowledge = (null != _filterForgottenKnowledge);
biWriter.Write(hasFilterForgottenKnowledge);
biWriter.Write(_filter);
if (null != _filterForgottenKnowledge)
{
byte[] serializedForgottenKnowledge = _filterForgottenKnowledge.Serialize();
biWriter.Write(serializedForgottenKnowledge.Length);
biWriter.Write(serializedForgottenKnowledge);
}
}
#endregion
#region ISyncFilterDeserializer Members
public ISyncFilter Deserialize(byte[] data)
{
MemoryStream memStream = new MemoryStream(data, 0, data.Length, false, true);
BinaryReader biReader = new BinaryReader(memStream, Encoding.Unicode);
DeserializeFromBinaryReader(biReader, memStream);
return this;
}
private void DeserializeFromBinaryReader(BinaryReader biReader, MemoryStream memStream)
{
bool hasFilterForgottenKnowledge = biReader.ReadBoolean();
_filter = biReader.ReadString();
if (hasFilterForgottenKnowledge)
{
int cbForgottenKnowledge = biReader.ReadInt32();
byte[] rawBuffer = biReader.ReadBytes(cbForgottenKnowledge);
_filterForgottenKnowledge = ForgottenKnowledge.Deserialize(ContactStore.ContactIdFormatGroup,
rawBuffer);
}
}
#endregion
// This implementation uses the metadata storage service to store metadata.
// The metadata storage service does not support custom filters, so store the filters
// that are tracked by a replica in the custom replica metadata field
// of the metadata store.
public static void StoreFiltersInReplicaMetadata(ReplicaMetadata repMeta, List<AddressFilter> filters)
{
MemoryStream memStream = new MemoryStream();
BinaryWriter biWriter = new BinaryWriter(memStream, Encoding.Unicode);
biWriter.Write(filters.Count);
foreach (AddressFilter filter in filters)
{
filter.SerializeToBinaryWriter(biWriter);
}
repMeta.CustomReplicaMetadata = memStream.GetBuffer();
}
public static List<AddressFilter> ReadFiltersFromReplicaMetadata(ReplicaMetadata repMeta)
{
MemoryStream memStream = new MemoryStream(repMeta.CustomReplicaMetadata, 0, repMeta.CustomReplicaMetadata.Length, false, true);
BinaryReader biReader = new BinaryReader(memStream, Encoding.Unicode);
int cFilters = biReader.ReadInt32();
List<AddressFilter> filters = new List<AddressFilter>(cFilters);
AddressFilter newFilter;
for (int iFilter = 0; iFilter < cFilters; iFilter++)
{
newFilter = new AddressFilter();
newFilter.DeserializeFromBinaryReader(biReader, memStream);
filters.Add(newFilter);
}
return filters;
}
public override string ToString()
{
return _filter;
}
}
每個項目都會追蹤它是否位於篩選內，以及導致項目移入或移出篩選的變更版本。這則範例會將項目的篩選追蹤中繼資料儲存成中繼資料存放區內的自訂項目欄位。
// Allocate space for the filter tracking metadata for each tracked filter.
private void InitializeFilterTrackingFields(ItemMetadata itemMeta)
{
if (0 < _trackedFilters.Count)
{
byte[] newIsInFilterBytes = new byte[_trackedFilters.Count];
byte[] newMoveVersionBytes = new byte[_trackedFilters.Count * (sizeof(uint) + sizeof(ulong))];
itemMeta.SetCustomField(IsInFiltersField, newIsInFilterBytes);
itemMeta.SetCustomField(MoveVersionsField, newMoveVersionBytes);
}
}
// Gets a value that indicates whether the specified item is in the specified filter,
// according to the filter tracking metadata.
private bool GetIsInFilter(ItemMetadata itemMeta, int iFilter)
{
byte[] isInFilterList = itemMeta.GetBytesField(IsInFiltersField);
return (1 == isInFilterList[iFilter]);
}
// Sets a value that indicates whether the specified item is in the specified filter.
private void SetIsInFilter(ItemMetadata itemMeta, int iFilter, bool isInFilter)
{
byte[] isInFilterList = itemMeta.GetBytesField(IsInFiltersField);
isInFilterList[iFilter] = (byte)(isInFilter ? 1 : 0);
itemMeta.SetCustomField(IsInFiltersField, isInFilterList);
}
// Gets the version of the change that caused the specified item to move in relation
// to the specified filter.
private SyncVersion GetMoveVersion(ItemMetadata itemMeta, int iFilter)
{
// Get the raw bytes for the move version list.
byte[] moveVersionBytes = itemMeta.GetBytesField(MoveVersionsField);
// Read the SyncVersion elements from the specified location in the byte array.
MemoryStream memStream = new MemoryStream(moveVersionBytes);
memStream.Seek(iFilter * (sizeof(uint) + sizeof(ulong)), SeekOrigin.Begin);
BinaryReader biReader = new BinaryReader(memStream, Encoding.Unicode);
uint replicaKey = biReader.ReadUInt32();
ulong tickCount = biReader.ReadUInt64();
SyncVersion moveVersion = new SyncVersion(replicaKey, tickCount);
return moveVersion;
}
// Sets the version of the change that caused the specified item to move in relation
// to the specified filter.
private void SetMoveVersion(ItemMetadata itemMeta, int iFilter, SyncVersion moveVersion)
{
// Get the raw bytes for the move version list.
byte[] moveVersionBytes = itemMeta.GetBytesField(MoveVersionsField);
// Write the SyncVersion elements to the specified location in the byte array.
MemoryStream memStream = new MemoryStream(moveVersionBytes);
memStream.Seek(iFilter * (sizeof(uint) + sizeof(ulong)), SeekOrigin.Begin);
BinaryWriter biWriter = new BinaryWriter(memStream, Encoding.Unicode);
biWriter.Write(moveVersion.ReplicaKey);
biWriter.Write(moveVersion.TickCount);
itemMeta.SetCustomField(MoveVersionsField, moveVersionBytes);
}
// Set up fields used to track a new filter.
public bool StartTrackingFilter(AddressFilter filter)
{
bool filterIsNew = true;
foreach (AddressFilter addressFilter in _trackedFilters)
{
if (addressFilter.IsIdentical(filter))
{
filterIsNew = false;
break;
}
}
if (filterIsNew)
{
// Initialize the filter forgotten knowledge to the current knowledge of the replica.
filter.FilterForgottenKnowledge = new ForgottenKnowledge(ContactStore.ContactIdFormatGroup,
ContactReplicaMetadata.GetKnowledge());
_trackedFilters.Add(filter);
// Allocate new space for and initialize filter tracking metadata for all active items.
byte[] newIsInFilterBytes = new byte[_trackedFilters.Count];
byte[] newMoveVersionBytes = new byte[_trackedFilters.Count * (sizeof(uint) + sizeof(ulong))];
int iFilter = _trackedFilters.Count - 1;
foreach (ItemMetadata itemMeta in _ContactItemMetaList.Values)
{
// Get current filter tracking metadata, copy it to the new byte arrays, and store it.
byte[] isInFilterBytes = itemMeta.GetBytesField(IsInFiltersField);
byte[] moveVersionBytes = itemMeta.GetBytesField(MoveVersionsField);
if (null != isInFilterBytes)
{
isInFilterBytes.CopyTo(newIsInFilterBytes, 0);
}
if (null != moveVersionBytes)
{
moveVersionBytes.CopyTo(newMoveVersionBytes, 0);
}
itemMeta.SetCustomField(IsInFiltersField, newIsInFilterBytes);
itemMeta.SetCustomField(MoveVersionsField, newMoveVersionBytes);
// Initialize filter tracking metadata.
bool isInFilter = filter.IsInFilter(_ContactList[itemMeta.GlobalId]);
SetIsInFilter(itemMeta, iFilter, isInFilter);
if (isInFilter)
{
// If the item is in the filter, set the move version to the change version for the item.
// Otherwise, leave the move version as (0,0).
SetMoveVersion(itemMeta, iFilter, itemMeta.ChangeVersion);
}
}
// Update the list of filters that are stored in the custom replica metadata.
AddressFilter.StoreFiltersInReplicaMetadata(ContactReplicaMetadata, TrackedFilters);
}
return filterIsNew;
}
// Gets the list of address filters that are tracked by this replica.
public List<AddressFilter> TrackedFilters
{
get
{
return _trackedFilters;
}
}
private List<AddressFilter> _trackedFilters;
後續的步驟
接著，您可能會想要將篩選交涉新增至提供者，讓它能夠與目的地提供者通訊，以便確立要用於變更列舉的篩選。如需如何交涉篩選的詳細資訊，請參閱 HOW TO：交涉篩選。
此外，當您的提供者是目的地提供者時，可能也會想要讓它代表篩選複寫。如需如何實作篩選提供者的詳細資訊，請參閱 HOW TO：篩選複寫。