Teilen über

Spalten mithilfe von FetchXml auswählen

  • Artikel

Wie in Daten mithilfe von FetchXml abfragen beschrieben, beginnen Sie Ihre Abfrage, indem Sie eine Tabelle mit dem Entitätselement auswählen.

Verwenden Sie das Attributelement, um die Spalten auszuwählen, die mit Ihrer Abfrage zurückgegeben werden sollen. Zum Beispiel:

<fetch>
  <entity name='account'>
    <attribute name='accountclassificationcode' />
    <attribute name='createdby' />
    <attribute name='createdon' />
    <attribute name='name' />
  </entity>
</fetch>

Diese Abfrage gibt die Spalten AccountClassificationCode, CreatedBy, CreatedOn und Name der ersten 5.000 Zeilen aus der Kontotabelle zurück. Wenn Sie mehr Zeilen als diese benötigen oder kleinere Datensätze durchlaufen möchten, erfahren Sie hier, wie Sie Ergebnisse mithilfe FetchXml auslagern.

Fügen Sie für jedes Attribut, das zurückgegeben werden soll, ein Attributelement hinzu und legen Sie den name-Attributwert auf LogicalName der Spalte fest.

Verwenden Sie das Attributelement, um die Spalten für die Entität Ihrer Abfrage und alle mit dem Link-Entitätselement verknüpften Tabellen auszuwählen. Erfahren Sie, wie Sie Tabellen mithilfe von FetchXml verknüpfen.

Wichtig

Wir raten dringend davon ab, alle Spalten in einer Tabelle zurückzugeben. Durch die Rückgabe aller Spalten werden Ihre Anwendungen langsamer ausgeführt und es kann zu Zeitüberschreitungsfehlern kommen. Sie sollten die Mindestanzahl der Spalten angeben, die mit Ihren Daten abgerufen werden sollen. Wenn Sie keine Spalten angeben oder das all-attributes-Element verwenden, werden Daten für alle Spalten zurückgegeben.

Formatierte Werte

Die zurückgegebenen eingegebenen Daten sind möglicherweise nicht für die Anzeige in Ihrer Anwendung geeignet. Formatierte Werte sind Zeichenfolgenwerte, die mit der Anforderung zurückgegeben werden und die Sie in Ihrer Anwendung anzeigen können.

Schauen wir uns zunächst die Ergebnisse an, ohne formatierte Werte zu verwenden. Diese Funktionen verwenden das ConsoleTables NuGet-Paket, um die Tabelle in einer Konsolenanwendung anzuzeigen.

Diese SimpleOutput-Methode greift nur auf Werte in der Entity.Attributes-Sammlung zu.

/// <summary>
/// Output the entity attribute values
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance</param>
static void SimpleOutput(IOrganizationService service) {

    string fetchXml = @"<fetch>
            <entity name='account'>
                <attribute name='accountclassificationcode' />
                <attribute name='createdby' />
                <attribute name='createdon' />
                <attribute name='name' />
            </entity>
            </fetch>";

    FetchExpression fetchExpression = new(fetchXml);

    //Retrieve the data
    EntityCollection entityCollection = service.RetrieveMultiple(query: fetchExpression);

    var table = new ConsoleTables.ConsoleTable("classificationcode", "createdby", "createdon", "name");

    foreach (var entity in entityCollection.Entities ) {

        var accountclassificationcode = entity.GetAttributeValue<OptionSetValue>("accountclassificationcode").Value;
        var createdby = entity.GetAttributeValue<EntityReference>("createdby").Name;
        var createdon = entity.GetAttributeValue<DateTime>("createdon");
        var name = entity.GetAttributeValue<string>("name");

        table.AddRow(accountclassificationcode, createdby, createdon, name);

    }
    table.Write();
}

Ausgabe:

 ----------------------------------------------------------------------------------------------
 | classificationcode | createdby           | createdon             | name                    |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:08 PM | Fourth Coffee (sample)  |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:10 PM | Litware, Inc. (sample)  |
 ----------------------------------------------------------------------------------------------
 | 1                  | FirstName LastName  | 8/13/2023 10:30:10 PM | Adventure Works (sample)|
 ----------------------------------------------------------------------------------------------

Diese Werte sind möglicherweise nicht die benutzerfreundlichen Werte, die Sie in einer Anwendung anzeigen müssen.

  • Die accountclassificationcode-Auswahlspalte gibt den Integerwert zurück.
  • Der SDK-Verweis auf createdby muss die EntityReference.Name-Eigenschaft verwenden
  • Die Web-API gibt die _createdby_value Lookup-Eigenschaft zurück, die den GUID-Wert für die createdby Lookup-Spalte enthält.

Um die gewünschten benutzerfreundlichen Werte zu erhalten, müssen Sie auf formatierte Werte zugreifen, die von Dataverse zurückgegeben werden können.

Wie Sie diese Werte erhalten, hängt davon ab, ob Sie das SDK für .NET oder die Web-API verwenden.

Die OutputFetchRequest-Beispielmethode, die in FetchXml-Beispielcode beschrieben wird, verwendet Daten aus der Entity.FormattedValues-Sammlung, sodass die Ergebnisse der Abfrage wie folgt aussehen:

 --------------------------------------------------------------------------------------------------
 | accountclassificationcode | createdby           | createdon          | name                    |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Fourth Coffee (sample)  |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Litware, Inc. (sample)  |
 --------------------------------------------------------------------------------------------------
 | Default Value             | FirstName LastName  | 8/13/2023 10:30 PM | Adventure Works (sample)|
 --------------------------------------------------------------------------------------------------

Diese GetRowValues-Methode extrahiert eine Liste von Zeichenfolgenwerten für einen Datensatz aus Entity.FormattedValues, sobald diese verfügbar sind.

/// <summary>
/// Returns the values of a row as strings
/// </summary>
/// <param name="columns">The names of the columns</param>
/// <param name="entity">The entity with the data</param>
/// <returns></returns>
static List<string> GetRowValues(List<string> columns, Entity entity)
{
   List<string> values = new();
   columns.ForEach(column =>
   {
      if (entity.Attributes.ContainsKey(column))
      {
            // Use the formatted value if it available
            if (entity.FormattedValues.ContainsKey(column) &&
            !string.IsNullOrWhiteSpace(entity.FormattedValues[column]))
            {
               values.Add($"{entity.FormattedValues[column]}");
            }
            else
            {
               // When an alias is used, the Aliased value must be converted
               if (entity.Attributes[column] is AliasedValue aliasedValue)
               {
                  // When an EntityReference doesn't have a Name, show the Id
                  if (aliasedValue.Value is EntityReference lookup &&
                  string.IsNullOrWhiteSpace(lookup.Name))
                  {
                        values.Add($"{lookup.Id:B}");
                  }
                  else
                  {
                        values.Add($"{aliasedValue.Value}");
                  }
               }
               else
               {
                  // Use the simple attribute value
                  values.Add($"{entity.Attributes[column]}");
               }
            }
      }
      // Null values are not in the Attributes collection
      else
      {
            values.Add("NULL");
      }

   });
   return values;
}

Weitere Informationen über formatierte Werte:

Spaltenaliasse

Spaltenaliasse werden normalerweise für Aggregatvorgänge verwendet, funktionieren aber auch für einfache Auswahloperationen, sodass wir sie hier vorstellen können.

Verwenden Sie das Attribut Attribut alias, um einen eindeutigen Spaltennamen für die zurückgegebenen Ergebnisse anzugeben.

Jede Spalte gibt einen eindeutigen Namen zurück. Standardmäßig sind die für die Tabelle Ihrer Abfrage zurückgegebenen Spaltennamen die LogicalName-Werte der Spalte. Alle logischen Spaltennamen sind für jede Tabelle eindeutig, daher kann es in diesem Satz keine doppelten Namen geben.

Wenn Sie ein Link-Entitätselement zum Verknüpfen von Tabellen verwenden, folgen die Standardspaltennamen dieser Namenskonvention: {Linked table LogicalName}.{Column LogicalName}. Dies verhindert doppelte Spaltennamen. Sie können dies überschreiben, indem Sie einen eindeutigen Alias verwenden. Sie können auch einen alias-Wert für die link-entity festlegen, der die verknüpfte Tabelle repräsentiert.

Das Verhalten, das Sie sehen, wenn Sie Spaltenaliasse verwenden, hängt davon ab, ob Sie das SDK für .NET oder die Web-API verwenden.

Diese SimpleAliasOutput-Methode verwendet Aliasse anstelle der logischen Namen der Spalten. Aus diesem Grund werden die Ergebnisse als AliasedValue zurückgegeben. Um auf den Wert komplexer Typen wie OptionSetValue oder EntityReference zuzugreifen, müssen Sie den Wert umwandeln.

Diese Methode verwendet das ConsoleTables-NuGet-Paket.

/// <summary>
/// Output the entity attribute values with aliases
/// </summary>
/// <param name="service">The authenticated IOrganizaitonService instance</param>
static void SimpleAliasOutput(IOrganizationService service)
{
    string fetchXml = @"<fetch top='3'>
            <entity name='account'>
              <attribute name='accountclassificationcode' alias='code' />
              <attribute name='createdby' alias='whocreated' />
              <attribute name='createdon' alias='whencreated' />
              <attribute name='name' alias='companyname' />
            </entity>
          </fetch>";

    FetchExpression fetchExpression = new(fetchXml);

    //Retrieve the data
    EntityCollection entityCollection = service.RetrieveMultiple(query: fetchExpression);

    var table = new ConsoleTables.ConsoleTable("code", "whocreated", "whencreated", "companyname");

    foreach (var entity in entityCollection.Entities)
    {

        var code = ((OptionSetValue)entity.GetAttributeValue<AliasedValue>("code").Value).Value;
        var whocreated = ((EntityReference)entity.GetAttributeValue<AliasedValue>("whocreated").Value).Name;
        var whencreated = entity.GetAttributeValue<AliasedValue>("whencreated").Value;
        var companyname = entity.GetAttributeValue<AliasedValue>("companyname").Value;

        table.AddRow(code, whocreated, createdon, companyname);

    }
    table.Write();
}

Ausgabe:

 ----------------------------------------------------------------------------------
 | code | whocreated           | whencreated           | companyname              |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:08 PM | Fourth Coffee (sample)   |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:10 PM | Litware, Inc. (sample)   |
 ----------------------------------------------------------------------------------
 | 1    | FirstName LastName   | 8/13/2023 10:30:10 PM | Adventure Works (sample) |
 ----------------------------------------------------------------------------------

Hinweis

Der AliasedValue-Klasse hat zwei Eigenschaften, die Ihnen den ursprünglichen EntityLogicalName und AttributeLogicalName verraten, wenn Sie sie brauchen.

Nächste Schritte,

Informationen zum Verknüpfen von Tabellen.

Tabellen verbinden

Hinweis

Können Sie uns Ihre Präferenzen für die Dokumentationssprache mitteilen? Nehmen Sie an einer kurzen Umfrage teil. (Beachten Sie, dass diese Umfrage auf Englisch ist.)

Die Umfrage dauert etwa sieben Minuten. Es werden keine personenbezogenen Daten erhoben. (Datenschutzbestimmungen).