Compartir por

Seleccionar columnas mediante FetchXml

  • Artigo

Como se describe en Consultar datos mediante FetchXml, comience su consulta seleccionando una tabla que utilice el elemento de entidad.

Utilice el elemento de atributo para seleccionar las columnas que devolverá con su consulta. Por ejemplo:

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

Esta columna devuelve las columnas AccountClassificationCode, CreatedBy, CreatedOn y Name de las primeras 5000 filas de la Tabla de cuentas. Si necesita más filas que estas, o desea iterar a través de conjuntos de datos más pequeños, aprenda cómo paginar resultados mediante FetchXml.

Para cada atributo que desee devolver, agregue un elemento de atributo y establezca el valor del atributo name en el LogicalName de la columna.

Utilice el elemento de atributo para seleccionar las columnas para la entidad de su consulta y cualquier tabla unida usando el elemento de entidad de vínculo. Aprenda a unir tablas mediante FetchXml.

Importante

Recomendamos encarecidamente devolver todas las columnas de una tabla. Devolver todas las columnas hará que sus aplicaciones se ejecuten más lentamente y puede provocar errores de tiempo de espera. Debe especificar el número mínimo de columnas para recuperar con sus datos. Si no especifica columnas o utiliza el elemento todos los atributos, se devuelven datos de todas las columnas.

Valores con formato

Es posible que los datos escritos devueltos no sean adecuados para mostrarlos en su aplicación. Los valores con formato son valores de cadena devueltos con la solicitud que puede mostrar en su aplicación.

Veamos primero los resultados sin usar valores con formato. Estas funciones utilizan el paquete ConsoleTables NuGet para mostrar la tabla en una aplicación de consola.

Este método SimpleOutput solo tiene acceso a valores en la colección Entity.Attributes.

/// <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();
}

Salida:

 ----------------------------------------------------------------------------------------------
 | 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)|
 ----------------------------------------------------------------------------------------------

Es posible que estos valores no sean los valores fáciles de usar que necesita mostrar en una aplicación.

  • La columna de opción accountclassificationcode devuelve el valor entero.
  • La referencia del SDK a createdby debe utilizar la propiedad EntityReference.Name
  • La API web devuelve la _createdby_value propiedad de búsqueda que tiene el valor GUID para la createdby columna de búsqueda.

Para obtener los valores fáciles de usar que desea, debe tener acceso a valores formateados que pueden ser devueltos por Dataverse.

La forma de obtener esos valores depende de si utiliza SDK para .NET o la API web.

El método de muestra OutputFetchRequest descrito en Código de ejemplo de FetchXml utiliza datos de la colección Entity.FormattedValues, por lo que los resultados de la consulta se ven así:

 --------------------------------------------------------------------------------------------------
 | 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)|
 --------------------------------------------------------------------------------------------------

Este método GetRowValues extrae una lista de valores de cadena para un registro de Entity.FormattedValues cuando están disponibles.

/// <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;
}

Obtenga más información sobre los valores con formato:

Alias de columna

Los alias de columna se utilizan normalmente para operaciones agregadas, pero también funcionan para operaciones de selección simples, por lo que podemos presentarlos aquí.

Utilice el atributo atributo alias para especificar un nombre de columna único para los resultados devueltos.

Cada columna devuelta debe tener un nombre único. De forma predeterminada, los nombres de las columnas devueltas para la tabla de su consulta son los valores de la columna LogicalName. Todos los nombres lógicos de las columnas son únicos para cada tabla, por lo que no puede haber nombres duplicados dentro de ese conjunto.

Cuando usa un elemento de entidad de vínculo para unir tablas, los nombres de columnas predeterminados siguen esta convención de nomenclatura: {Linked table LogicalName}.{Column LogicalName}. Esto evita que se dupliquen los nombres de las columnas. Puede anular esto utilizando un alias único. También puede establecer un valor de alias para el link-entity que representa la tabla unida.

El comportamiento que ve al utilizar alias de columna depende de si está utilizando el SDK para .NET o la API web.

Este método SimpleAliasOutput utiliza alias en lugar de los nombres lógicos de las columnas. Debido a esto, los resultados se devuelven como AliasedValue. Para acceder al valor de tipos complejos como OptionSetValue o EntityReference, tiene que emitir el valor.

Este método utiliza el paquete ConsoleTables NuGet.

/// <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();
}

Salida:

 ----------------------------------------------------------------------------------
 | 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) |
 ----------------------------------------------------------------------------------

Nota

La clase AliasedValue tiene dos propiedades que indican los EntityLogicalName y AttributeLogicalName originales si los necesita.

Pasos siguientes

Más información sobre cómo unir tablas.

Unir tablas

Nota

¿Puede indicarnos sus preferencias de idioma de documentación? Realice una breve encuesta. (tenga en cuenta que esta encuesta está en inglés)

La encuesta durará unos siete minutos. No se recopilan datos personales (declaración de privacidad).