Abrufen und Erkennen von Änderungen bei Metadaten

  • Artikel

Die Klassen im Microsoft.Xrm.Sdk.Metadata.Query-Namespace und die RetrieveMetadataChangesResponse- und RetrieveMetadataChangesRequest-Klassen erlauben Ihnen, effiziente Metadatenabfragen aufzubauen und Änderungen an den Metadaten, die im Laufe der Zeit auftreten, zu erfassen.

Alle Codebeispiele, auf die in diesem Dokument aus verwiesen wird, werden gefunden in Beispiel: Abfragen von Metadaten und Ermitteln von Änderungen.

Der technische Artikel Abfragemetadaten mit JavaScript stellt eine JavaScript-Bibliothek für die Verwendung der Objekte und Nachrichten in clientseitigem Code bereit.

Strategien für die Verwendung von Metadaten

Mithilfe von Metadaten können Sie Anwendungen erstellen, die sich anpassen, während das Dynamics 365 Customer Engagement (on-premises)-Datenmodell sich ändert. Metadaten sind für die folgenden Typen von Anwendungen wichtig:

  • UI für-Client-Anwendungen

  • Integrationstools, die Dynamics 365 Customer Engagement (on-premises) Daten externen Systemen zuordnen müssen

  • Entwicklungstools

    Bei Verwenden der Klassen im Microsoft.Xrm.Sdk.Metadata.Query-Namespace können Sie Entwürfe implementieren, die irgendwo zwischen einer Abfrage mit geringem Umfang und einem permanenten Metadatencache liegen.

Einfache Abfrage

Ein Beispiel für eine einfache Abfrage ist es, wenn Sie eine benutzerdefinierte Webressourcen-Benutzeroberfläche haben, die ein Auswahlsteuerelement bereitstellt, um die aktuellen Optionen in einem Dynamics 365 Customer Engagement Optionssatzattribut (Auswahllistenattribut) anzuzeigen. Sie möchten diese Optionen nicht hartcodiert festlegen, da Sie diesen Code aktualisieren müssten, wenn die verfügbaren Optionen jemals geändert werden. Stattdessen können Sie eine Abfrage erstellen, um nur diese Optionswerte und Beschriftungen aus den Metadaten abzurufen.

Sie müssen diese Daten nicht zwischenspeichern, da Sie die Microsoft.Xrm.Sdk.Metadata.Query-Klassen verwenden können, um diese Daten direkt aus dem Dynamics 365 Customer Engagement Anwendungscache abzurufen.

Dauerhafter Metadatencache

Wenn Sie eine Anwendung haben, die arbeiten können muss, während sie vom Dynamics 365 Server getrennt ist, oder die durch eine beschränkte Netzwerk-Bandbreite zwischen dem Client und dem Server leicht beeinträchtigt wird, wie etwa eine mobile Anwendung, müssen Sie einen dauerhaften Metadatencache implementieren.

Mit einem dauerhaften Metadatencache muss Ihre Anwendung alle notwendigen Metadaten abfragen, wenn sie zum ersten Mal eine Verbindung herstellen. Anschließend speichern Sie diese Daten in der Anwendung. Das nächste Mal, wenn die Anwendung eine Verbindung mit dem Server herstellt, können Sie einfach Unterschied abfragen, was sehr viel weniger zu übertragende Daten bedeuten sollte, und dann die Änderungen mit den Metadatencache zusammenführen, wenn die Anwendung geladen wird.

Wie häufig Sie nach Metadatenänderungen abfragen sollten, hängt von der erwarteten Volatillität der Metadaten für die Anwendung ab, und wie lange die Anwendung weiterhin ausgeführt wird. Es ist kein Ereignis verfügbar, das Sie verwenden können, um zu ermitteln, wann Metadatenänderungen eintreten. Es gibt eine Begrenzung für die Anzahl der Tage, die Metadatenänderungen gespeichert werden, und eine Anforderungen von Änderungen, die jenseits dieser Beschränkung auftritt, erfordert eine vollständige Reinitialisierung des Metadatencache. Weitere Informationen finden Sie unter Ablauf gelöschter Metadaten.

Sind keine Änderungen vorhanden, sollte die Abfrage schnell reagieren, und es sind keine Daten vorhanden, die zurückzugeben sind. Falls jedoch Änderungen vorhanden sind, insbesondere wenn es gelöschte Metadatenelemente gibt, die aus dem Cache entfernt werden müssen, können Sie damit rechnen, dass die Anforderung einige Zeit in Anspruch nehmen kann. Weitere Informationen: Leistung beim Abrufen gelöschter Metadaten

Rufen Sie nur die Metadaten ab, die Sie benötigen.

Metadaten werden häufig abgerufen oder synchronisiert, wenn eine Anwendung gestartet wird und sich auf die Zeit auswirken kann, die die Anwendung zum Laden benötigt. Dies gilt besonders für mobile Anwendungen, die zum ersten Mal Metadaten abrufen. Nur die Metadaten abzurufen, die Sie benötigen, ist sehr wichtig, um eine Anwendung zu erstellen, die gute Leistung bringt.

Die EntityQueryExpression-Klasse bietet eine Struktur, die mit der QueryExpression-Klasse konsistent ist, die Sie verwenden, um komplexe Abfragen zu erstellen, um Entitätsdaten abzurufen. Im Gegensatz zu den Klassen RetrieveAllEntitiesRequest, RetrieveEntityRequest, RetrieveAttributeRequest oder RetrieveRelationshipRequest enthält die Klasse RetrieveMetadataChangesRequest einen Query-Parameter, der eine EntityQueryExpression-Instanz akzeptiert, mit der Sie zusätzlich zu den gewünschten Eigenschaften spezifische Kriterien für die zurückzugebenden Daten angeben können. Sie können RetrieveMetadataChangesRequest verwenden, um den ganzen Satz von Metadaten zurückzugeben, die Sie erhalten, wenn Sie RetrieveAllEntitiesRequest verwenden, oder nur eine Beschriftung für ein bestimmtes Attribut.

Angeben der Filterkriterien

Die Eigenschaft EntityQueryExpression. Criteria akzeptiert eine MetadataFilterExpression, die eine Sammlung von MetadataConditionExpression Objekten enthält, die es zulassen, Bedingungen für die Filterung von Entitätseigenschaften auf der Grundlage ihres Wertes zu definieren. Diese Anforderungen verwenden einen MetadataConditionOperator, der folgende Operatoren zulässt:

Im folgenden Beispiel wird ein MetadataFilterExpression angezeigt, der einen Satz von nicht sich überschneiden Entitäten im Besitz des Benutzers zurückgibt, die nicht in einer Liste von Entitäten enthalten sind, die ausgeschlossen sind:




     // An array SchemaName values for non-intersect, user-owned entities that should not be returned.
     String[] excludedEntities = {
"WorkflowLog",
"Template",
"CustomerOpportunityRole",
"Import",
"UserQueryVisualization",
"UserEntityInstanceData",
"ImportLog",
"RecurrenceRule",
"QuoteClose",
"UserForm",
"SharePointDocumentLocation",
"Queue",
"DuplicateRule",
"OpportunityClose",
"Workflow",
"RecurringAppointmentMaster",
"CustomerRelationship",
"Annotation",
"SharePointSite",
"ImportData",
"ImportFile",
"OrderClose",
"Contract",
"BulkOperation",
"CampaignResponse",
"Connection",
"Report",
"CampaignActivity",
"UserEntityUISettings",
"IncidentResolution",
"GoalRollupQuery",
"MailMergeTemplate",
"Campaign",
"PostFollow",
"ImportMap",
"Goal",
"AsyncOperation",
"ProcessSession",
"UserQuery",
"ActivityPointer",
"List",
"ServiceAppointment"};

     //A filter expression to limit entities returned to non-intersect, user-owned entities not found in the list of excluded entities.
     MetadataFilterExpression EntityFilter = new MetadataFilterExpression(LogicalOperator.And);
     EntityFilter.Conditions.Add(new MetadataConditionExpression("IsIntersect", MetadataConditionOperator.Equals, false));
     EntityFilter.Conditions.Add(new MetadataConditionExpression("OwnershipType", MetadataConditionOperator.Equals, OwnershipTypes.UserOwned));
     EntityFilter.Conditions.Add(new MetadataConditionExpression("SchemaName", MetadataConditionOperator.NotIn, excludedEntities));
     MetadataConditionExpression isVisibileInMobileTrue = new MetadataConditionExpression("IsVisibleInMobile", MetadataConditionOperator.Equals, true);
     EntityFilter.Conditions.Add(isVisibileInMobileTrue);

Erstellen der Eigenschaften, die Sie wünschen

Die Properties-Eigenschaft akzeptiert einen MetadataPropertiesExpression. Sie können MetadataPropertiesExpression. AllProperties auf true festlegen, wenn Sie alle Eigenschaften zurückgeben möchten, oder Sie können eine Sammlung von Strings an die MetadataPropertiesExpression. PropertyNames übergeben, um festzulegen, welche Eigenschaften Sie in die Ergebnisse aufnehmen möchten.

Die zurückgegebenen stark typisierten Objekte enthalten alle Eigenschaften, aber nur die, die Sie benötigen, enthalten Daten. Alle anderen Eigenschaften sind Null, mit den folgenden wenigen Ausnahmen: jedes Metadatenelement enthält die MetadataId ,LogicalName und HasChanged-Werte, wenn sie für dieses Element vorhanden sind. Sie müssen sie nicht in den Properties angeben, die Sie benötigen.

Wenn Sie nicht verwalteten Code verwenden, und das responseXML analysieren, das von derXMLHttpRequest zurückgegeben wurde, erhalten Sie Elemente für jede Eigenschaft, aber nur die, die Sie benötigen, enthalten Daten. Das folgende XML zeigt die Kontaktentitätsmetadaten-XML, die zurückgegeben wird, wenn IsVisibleInMobile die einzige angeforderte Eigenschaft ist.

<a:EntityMetadata>  
 <c:MetadataId>608861bc-50a4-4c5f-a02c-21fe1943e2cf</c:MetadataId>  
 <c:HasChanged i:nil="true"/>  
 <c:ActivityTypeMask i:nil="true"/>  
 <c:Attributes i:nil="true"/>  
 <c:AutoRouteToOwnerQueue i:nil="true"/>  
 <c:CanBeInManyToMany i:nil="true"/>  
 <c:CanBePrimaryEntityInRelationship i:nil="true"/>  
 <c:CanBeRelatedEntityInRelationship i:nil="true"/>  
 <c:CanCreateAttributes i:nil="true"/>  
 <c:CanCreateCharts i:nil="true"/>  
 <c:CanCreateForms i:nil="true"/>  
 <c:CanCreateViews i:nil="true"/>  
 <c:CanModifyAdditionalSettings i:nil="true"/>  
 <c:CanTriggerWorkflow i:nil="true"/>  
 <c:Description i:nil="true"/>  
 <c:DisplayCollectionName i:nil="true"/>  
 <c:DisplayName i:nil="true"/>  
 <c:IconLargeName i:nil="true"/>  
 <c:IconMediumName i:nil="true"/>  
 <c:IconSmallName i:nil="true"/>  
 <c:IsActivity i:nil="true"/>  
 <c:IsActivityParty i:nil="true"/>  
 <c:IsAuditEnabled i:nil="true"/>  
 <c:IsAvailableOffline i:nil="true"/>  
 <c:IsChildEntity i:nil="true"/>  
 <c:IsConnectionsEnabled i:nil="true"/>  
 <c:IsCustomEntity i:nil="true"/>  
 <c:IsCustomizable i:nil="true"/>  
 <c:IsDocumentManagementEnabled i:nil="true"/>  
 <c:IsDuplicateDetectionEnabled i:nil="true"/>  
 <c:IsEnabledForCharts i:nil="true"/>  
 <c:IsImportable i:nil="true"/>  
 <c:IsIntersect i:nil="true"/>  
 <c:IsMailMergeEnabled i:nil="true"/>  
 <c:IsManaged i:nil="true"/>  
 <c:IsMappable i:nil="true"/>  
 <c:IsReadingPaneEnabled i:nil="true"/>  
 <c:IsRenameable i:nil="true"/>  
 <c:IsValidForAdvancedFind i:nil="true"/>  
 <c:IsValidForQueue i:nil="true"/>  
 <c:IsVisibleInMobile>  
  <a:CanBeChanged>false</a:CanBeChanged>  
  <a:ManagedPropertyLogicalName>canmodifymobilevisibility</a:ManagedPropertyLogicalName>  
  <a:Value>false</a:Value>  
 </c:IsVisibleInMobile>  
 <c:LogicalName>contact</c:LogicalName>  
 <c:ManyToManyRelationships i:nil="true"/>  
 <c:ManyToOneRelationships i:nil="true"/>  
 <c:ObjectTypeCode i:nil="true"/>  
 <c:OneToManyRelationships i:nil="true"/>  
 <c:OwnershipType i:nil="true"/>  
 <c:PrimaryIdAttribute i:nil="true"/>  
 <c:PrimaryNameAttribute i:nil="true"/>  
 <c:Privileges i:nil="true"/>  
 <c:RecurrenceBaseEntityLogicalName i:nil="true"/>  
 <c:ReportViewName i:nil="true"/>  
 <c:SchemaName i:nil="true"/>  
</a:EntityMetadata>

In einer zukünftigen Version wird möglicherweise mehr Effizienz erreicht, indem Elementen mit leeren Werten für Eigenschaften , die nicht angefordert wurden, nicht zurückgegeben werden. Wenn Sie Code schreiben, um diese XML zu analysieren, sollten Sie erwarten, dass die XML-Datei, die für dieselbe Abfrage zurückgegeben wurde, zu der folgenden XML-Datei reduziert werden könnte.

<a:EntityMetadata>  
 <c:MetadataId>608861bc-50a4-4c5f-a02c-21fe1943e2cf</c:MetadataId>  
 <c:IsVisibleInMobile>  
  <a:CanBeChanged>false</a:CanBeChanged>  
  <a:ManagedPropertyLogicalName>canmodifymobilevisibility</a:ManagedPropertyLogicalName>  
  <a:Value>false</a:Value>  
 </c:IsVisibleInMobile>  
 <c:LogicalName>contact</c:LogicalName>  
</a:EntityMetadata>

Metadaten werden in einer Baumstruktur zurückgegeben, wie sie die RetrieveAllEntitiesRequest verwendet. Um auf ein ein bestimmtes Attribut oder eine Beziehung zuzugreifen, müssen Sie eine Abfrage erstellen, die die Entität zurückgibt, von der sie ein Teil ist. Wenn Sie Daten über ein bestimmtes Attribut abrufen möchten, müssen Sie die Eigenschaft EntityMetadata. Attributes in Ihre EntityQueryExpression. Properties aufnehmen. Damit die Beziehungen zwischen den Entitäten zurückgegeben werden können, müssen Sie eine oder mehrere der folgenden EntityMetadata-Eigenschaften angeben: ManyToManyRelationships, ManyToOneRelationships, oder OneToManyRelationships.

Das folgende Bespiel wird die Attributes-Eigenschaft für die angeforderte Entitäten zurückgeben:



//A properties expression to limit the properties to be included with entities
MetadataPropertiesExpression EntityProperties = new MetadataPropertiesExpression()
{
 AllProperties = false
};
EntityProperties.PropertyNames.AddRange(new string[] { "Attributes" });

Attribut-Metadaten abrufen

Die Eigenschaft EntityQueryExpression.AttributeQuery akzeptiert eine AttributeQueryExpression, die Criteria und Properties für die Attribute definiert, die für die Entitäten zurückgegeben werden sollen, die mit den EntityQueryExpressionCriteria und Properties übereinstimmen.

In der folgenden Tabelle werden AttributeMetadata-Eigenschaften aufgeführt, die nicht in einer MetadataFilterExpression verwendet werden können.

Das folgende Bespiel beschränkt die zurückgegebenen Attribute nur auf solche, die ein OptionSet haben und nur die OptionSet- und AttributeType-Eigenschaften für diese Attribute zurückgegeben:



//A condition expresson to return optionset attributes
MetadataConditionExpression[] optionsetAttributeTypes = new MetadataConditionExpression[] { 
new MetadataConditionExpression("AttributeType", MetadataConditionOperator.Equals, AttributeTypeCode.Picklist),
new MetadataConditionExpression("AttributeType", MetadataConditionOperator.Equals, AttributeTypeCode.State),
new MetadataConditionExpression("AttributeType", MetadataConditionOperator.Equals, AttributeTypeCode.Status),
new MetadataConditionExpression("AttributeType", MetadataConditionOperator.Equals, AttributeTypeCode.Boolean)
};

//A filter expression to apply the optionsetAttributeTypes condition expression
MetadataFilterExpression AttributeFilter = new MetadataFilterExpression(LogicalOperator.Or);
AttributeFilter.Conditions.AddRange(optionsetAttributeTypes);

//A Properties expression to limit the properties to be included with attributes
MetadataPropertiesExpression AttributeProperties = new MetadataPropertiesExpression() { AllProperties = false };
AttributeProperties.PropertyNames.Add("OptionSet");
AttributeProperties.PropertyNames.Add("AttributeType");

Beziehungsmetadaten abrufen

Die Eigenschaft EntityQueryExpression.RelationshipQuery akzeptiert eine RelationshipQueryExpression, um die Entitätsbeziehung Criteria und Properties anzugeben, die Sie für die Entitäten wünschen, die mit den EntityQueryExpressionCriteria und Properties übereinstimmen.

Verwenden Sie die Eigenschaft RelationshipType in den Kriterien, um anzugeben, dass Sie ManyToMany-Beziehungen oder OneToMany-Beziehungen zurückgeben möchten.

In der folgenden Tabelle werden Beziehungsmetadateneigenschaften aufgeführt, die in einer MetadataFilterExpression nicht verwendet werden können.

Abrufen von Beschriftungen

Schließlich akzeptiert die Eigenschaft EntityQueryExpression.LabelQuery eine LabelQueryExpression, mit der Sie einen oder mehrere ganzzahlige LCID Werte angeben können, um zu bestimmen, welche lokalisierten Labels zurückgegeben werden sollen. Gültige Gebietsschema-ID-Werte finden Sie unter Gebietsschema-ID-Diagramm (LCID). Wenn eine Organisation viele Sprachpakete installiert hat, werden die Beschriftungen für alle Sprachen zurückgegeben, es sei denn, Sie legen eine LabelQuery fest.

Das folgende Bespiel definiert eine LabelQueryExpression, die Beschriftungen auf solche beschränkt, die die bevorzugte Sprache des Benutzers darstellen.



private Guid _userId;
private int _languageCode;




_userId = ((WhoAmIResponse)_service.Execute(new WhoAmIRequest())).UserId;
_languageCode = RetrieveUserUILanguageCode(_userId);




protected int RetrieveUserUILanguageCode(Guid userId)
{
 QueryExpression userSettingsQuery = new QueryExpression("usersettings");
 userSettingsQuery.ColumnSet.AddColumns("uilanguageid", "systemuserid");
 userSettingsQuery.Criteria.AddCondition("systemuserid", ConditionOperator.Equal, userId);
 EntityCollection userSettings = _service.RetrieveMultiple(userSettingsQuery);
 if (userSettings.Entities.Count > 0)
 {
  return (int)userSettings.Entities[0]["uilanguageid"];
 }
 return 0;
}





//A label query expression to limit the labels returned to only those for the user's preferred language
LabelQueryExpression labelQuery = new LabelQueryExpression();
labelQuery.FilterLanguages.Add(_languageCode);

Abrufen von neuen oder geänderten Metadaten

Die Klasse RetrieveMetadataChangesResponse gibt eine stark typisierte EntityMetadataCollection zurück, die die nachgefragten Daten enthält. Die Klasse RetrieveMetadataChangesResponse liefert auch einen ServerVersionStamp-Wert, den Sie in späteren Anfragen an die Eigenschaft RetrieveMetadataChangesRequest.ClientVersionStamp übergeben können. Wenn ein Wert für die ClientVersionStamp-Eigenschaft eingeschlossen wird, werden nur Daten zurückgegeben, die der EntityQueryExpression entsprechen, und die sich geändert haben, seit der ClientVersionStamp abgerufen wurde. Die einzige Ausnahme ist, wenn Ihr EntityQueryExpression.Properties auch EntityMetadata.Privileges enthält. Rechte werden immer zurückgegeben, unabhängig vom ClientVersionStamp. Dadurch kann die Anwendung bestimmen, ob wichtige Änderungen eingetreten sind, seit Sie zuletzt die Metadaten abgerufen haben. Sie können dann neue oder geänderte Metadaten im dauerhaften Metadatencache zusammenführen, sodass die Anwendung in der Lage ist, Leistungsprobleme durch das Herunterladen von Metadaten zu vermeiden, die möglicherweise nicht erforderlich sind.

Die Eigenschaft HasChanged bietet eine Möglichkeit, festzustellen, welche untergeordneten Elemente in einem Metadatenelement sich geändert haben. Da alle Metadaten im Rahmen des Metadatenelements zurückgegeben werden, wenn die Beschriftung eines OptionMetadata sich geändert hat, werden die enthaltende EntityMetadata, AttributeMetadata und OptionSetMetadata-Eigenschaft zurückgegeben. Die Eigenschaft HasChanged ist jedoch falsch für solche, die Metadatenelemente enthalten. Nur die Eigenschaft OptionMetadata.HasChanged wird wahr sein.

Das folgende Beispiel enthält eine anfängliche Abfrage durch Definieren einer EntityQueryExpression und Durchführen einer Abfrage, bei der ClientVersionStamp auf Null gesetzt ist.



//An entity query expression to combine the filter expressions and property expressions for the query.
EntityQueryExpression entityQueryExpression = new EntityQueryExpression()
{

 Criteria = EntityFilter,
 Properties = EntityProperties,
 AttributeQuery = new AttributeQueryExpression()
 {
  Criteria = AttributeFilter,
  Properties = AttributeProperties
 },
 LabelQuery = labelQuery

};

//Retrieve the metadata for the query without a ClientVersionStamp
RetrieveMetadataChangesResponse initialRequest = getMetadataChanges(entityQueryExpression, null, DeletedMetadataFilters.OptionSet);




protected RetrieveMetadataChangesResponse getMetadataChanges(
 EntityQueryExpression entityQueryExpression,
 String clientVersionStamp,
 DeletedMetadataFilters deletedMetadataFilter)
{
 RetrieveMetadataChangesRequest retrieveMetadataChangesRequest = new RetrieveMetadataChangesRequest()
 {
  Query = entityQueryExpression,
  ClientVersionStamp = clientVersionStamp,
  DeletedMetadataFilters = deletedMetadataFilter
 };

 return (RetrieveMetadataChangesResponse)_service.Execute(retrieveMetadataChangesRequest);

}

Abrufen von Informationen zu gelöschten Metadaten

Die Eigenschaft RetrieveMetadataChangesResponse.DeletedMetadata gibt eine DeletedMetadataCollection zurück, wenn die Eigenschaften ClientVersionStamp und DeletedMetadataFilters auf der RetrieveMetadataChangesRequest festgelegt sind. Die DeletedMetadataCollection enthält die MetadataId-Werte aller EntityMetadata-, AttributeMetadata- oder RelationshipMetadataBase-Objekte, die innerhalb eines Zeitlimits aus dem System gelöscht worden sind. Weitere Informationen finden Sie unter Ablauf gelöschter Metadaten.

Verwenden Sie die Aufzählung DeletedMetadataFilters mit der Aufzählung RetrieveMetadataChangesRequest.DeletedMetadataFilters, um die Informationen auf die Arten von Metadaten zu beschränken, an denen Sie interessiert sind. Die DeletedMetadataFilters-Aufzählung bietet folgende Optionen:

Ablauf gelöschter Metadaten

Metadatenelemente, der gelöscht wurden, werden für einen beschränkten Zeitraum nachverfolgt, der durch den Organization.ExpireSubscriptionsInDays-Wert angegeben wird. Der Standardwert ist 90 Tage. Wenn der Wert RetrieveMetadataChangesRequest.ClientVersionStamp darauf hinweist, dass die letzte Metadatenabfrage vor dem Ablaufdatum lag, löst der Dienst einen ExpiredVersionStamp-Fehler (0x80044352) aus. Wenn Sie Daten abrufen, um einen bestehenden Metadaten-Zwischenspeicher zu aktualisieren, sollten Sie immer versuchen, diesen Fehler abzufangen und darauf vorbereitet sein, Ihren Metadaten-Zwischenspeicher mit den Ergebnissen einer zweiten Anfrage ohne ClientVersionStamp neu zu initialisieren. Der Fehler wird ExpiredVersionStamp wird auch ausgegeben, wenn Änderungen auf dem Server, wie Änderungen am ExpireSubscriptionsInDays-Wert, sich auf die exakte Nachverfolgung der gelöschte Metadaten auswirken.

Das folgenden Beispiel übergibt einen ClientVersionStamp und fängt den ExpiredVersionStamp ab. Wenn der Fehler abgefangen wird, wird der Cache reintialisert, indem eine neue Abfrage mit dem ClientVersionStamp-Set auf null eingereicht wird.



protected String updateOptionLabelList(EntityQueryExpression entityQueryExpression, String clientVersionStamp)
{
 //Retrieve metadata changes and add them to the cache
 RetrieveMetadataChangesResponse updateResponse;
 try
 {
  updateResponse = getMetadataChanges(entityQueryExpression, clientVersionStamp, DeletedMetadataFilters.OptionSet);
  addOptionLabelsToCache(updateResponse.EntityMetadata, true);
  removeOptionLabelsFromCache(updateResponse.DeletedMetadata, true);

 }
 catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
 {
  // Check for ErrorCodes.ExpiredVersionStamp (0x80044352)
  // Will occur when the timestamp exceeds the Organization.ExpireSubscriptionsInDays value, which is 90 by default.
  if (ex.Detail.ErrorCode == unchecked((int)0x80044352))
  {
   //reinitialize cache
   _optionLabelList.Clear();

   updateResponse = getMetadataChanges(entityQueryExpression, null, DeletedMetadataFilters.OptionSet);
   //Add them to the cache and display the changes
   addOptionLabelsToCache(updateResponse.EntityMetadata, true);

  }
  else
  {
   throw ex;
  }

 }
 return updateResponse.ServerVersionStamp;
}

Leistung beim Abrufen gelöschter Metadaten

Wenn ein Metadatenelement gelöscht wird, wird es in der Datenbank gespeichert, und nicht im Dynamics 365 Customer Engagement Metadatencache. Obwohl die gelöschte Metadaten nur auf die MetadataId und den Typ des Metadatenelements beschränkt sind, ist der Zugriff auf die Datenbank ein Vorgang, der mehr Serverressourcen erfordert als nur die Abfrage nach Änderungen.

Siehe auch

Schreiben von Anwendungen und Servererweiterungen
Offline-Nutzung der Dynamics 365 Customer Engagement-Dienste
Beispiel: Metadaten abfragen und Änderungen erkennen
Erweitern des Metadatenmodells für Dynamics 365 Customer Engagement
Anpassen von Entitätsmetadaten
Anpassen von Entitätsattributmetadaten
Anpassen von Entitätsbeziehungsmetadaten
Abfragemetadaten mit JavaScript