Share via

Ejemplo: proveedor de tablas virtuales personalizadas con operaciones CRUD

  • Artículo

Este ejemplo muestra cómo implementar un proveedor de datos personalizado para crear una tabla virtual que admita operaciones de creación, recuperación, actualización y eliminación. Para cada una de estas operaciones, implementa un complemento genérico, las registra con la herramienta de registro de complementos y habilita las fuentes de datos de la tabla virtual para crear la tabla virtual.

Para obtener más información sobre los proveedores de datos y el desarrollo de complementos, consulte Proveedores de datos personalizados

Detalles del origen de datos:

En este tutorial, configurará una tabla simple en un servidor SQL externo para crear una tabla virtual. El nombre de la tabla que se usa en este ejemplo es VETicket.

Nota

Actualice su código de complemento, si desea cambiar el nombre de la tabla o las columnas.

Nombre de columna Tipo de datos Finalidad
TicketID Identificador único, clave principal Clave principal de la tabla.
Gravedad Integer Valor de gravedad del ticket.
Nombre String Descripción del ticket.

Hay cuatro pasos para permitir que un proveedor de datos personalizado cree una tabla virtual.

Paso 1: implementación de complementos CRUD y registro del ensamblaje

Paso 2: crear un proveedor de datos y agregar complementos al proveedor

Paso 3: crear una tabla virtual en un entorno de Dataverse

Paso 4: crear, actualizar, ver y eliminar registros usando una tabla virtual

Paso 1: implementación de complementos CRUD y registro del ensamblaje

  1. Cree su proyecto de complemento e instale los siguientes paquetes NuGet. La solución en este ejemplo se llama StubProvider.

    Ensamblado Dirección URL
    Microsoft.CrmSdk.CoreAssemblies https://www.nuget.org/packages/Microsoft.CrmSdk.CoreAssemblies
    Microsoft.CrmSdk.Data https://www.nuget.org/packages/Microsoft.CrmSdk.Data
    Microsoft.CrmSdk.Deployment https://www.nuget.org/packages/Microsoft.CrmSdk.Deployment
    Microsoft.CrmSdk.Workflow https://www.nuget.org/packages/Microsoft.CrmSdk.Workflow
    Microsoft.CrmSdk.XrmTooling.CoreAssembly https://www.nuget.org/packages/Microsoft.CrmSdk.XrmTooling.CoreAssembly
    Microsoft.IdentityModel.Clients.ActiveDirectory https://www.nuget.org/packages/Microsoft.IdentityModel.Clients.ActiveDirectory
    Microsoft.Rest.ClientRuntime https://www.nuget.org/packages/Microsoft.Rest.ClientRuntime
    Newtonsoft.Json https://www.nuget.org/packages/Newtonsoft.Json/13.0.1-beta2

  2. Agregue los siguientes archivos de seis clases a su solución. Agregue las instrucciones using siguientes en cada uno de los archivos de clase

    using System; 
using System.Collections.Generic; 
using System.Data.SqlClient; 
using System.Linq; using System.Text; 
using System.Threading.Tasks; 
using Microsoft.Xrm.Sdk; 
using Microsoft.Xrm.Sdk.Extensions; 
using Microsoft.Xrm.Sdk.Data.Exceptions; 
using Newtonsoft.Json;

    Nota

    En cada uno de estos archivos de clase, actualice el nombre de la tabla para que coincida con el nombre de la tabla de origen que ha configurado. El ejemplo usa VETicket como nombre de la tabla de origen.

    Nombre del archivo de clase Finalidad
    Connection.cs Esta clase contiene código para crear y administrar la conexión al origen de datos SQL externo. Incluye parámetros de cadena de conexión específicos de la base de datos externa e información de autenticación basada en SQL necesaria para establecer la conexión. Reemplace los valores correspondientes a su: servidor de base de datos, ID de usuario, contraseña y nombre de la tabla en la que creará una tabla virtual Dataverse.
    CreatePlugin.cs Esta clase contiene código que maneja la operación de creación de la tabla virtual.
    UpdatePlugin.cs Esta clase contiene código que maneja la operación de actualización de registros en la tabla virtual.
    RetrievePlugin.cs Esta clase contiene código que recupera un registro específico de la tabla virtual.
    RetrieveMultiplePlugin.cs Esta clase contiene código para obtener varios registros de la tabla virtual.
    DeletePlugin.cs Esta clase contiene código que le permite eliminar un registro en la tabla virtual.

    Código para Connection.cs

     public static class Connection
{
   public static SqlConnection GetConnection()
   {
       try
       {
           //sample database to connect to 
           SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
           builder.DataSource = "Enter name or network address of the SQL Server";
           builder.UserID = "Enter User Name";
           builder.Password = "Enter password";
           builder.InitialCatalog = "Enter database details";
           SqlConnection connection = new SqlConnection(builder.ConnectionString);
           return connection;
       }
       catch (SqlException e)
       {
           Console.WriteLine(e.ToString());
           throw;
       }
   }
}

    Código para CreatePlugin.cs

    public class CreatePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = serviceProvider.Get<IPluginExecutionContext>();
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
        {
            Entity entity = (Entity)context.InputParameters["Target"];
            Guid id = Guid.NewGuid();
            //change the table name below to the source table name you have created 
            string cmdString = "INSERT INTO VETicket (TicketID,Name,Severity) VALUES (@TicketID, @Name, @Severity)";
            SqlConnection connection = Connection.GetConnection();
            using (SqlCommand command = connection.CreateCommand())
            {
                command.CommandText = cmdString;
                command.Parameters.AddWithValue("@TicketID", id);
                command.Parameters.AddWithValue("@Name", entity["new_name"]);
                command.Parameters.AddWithValue("@Severity", entity["new_severity"]);
                connection.Open();
                try
                {
                    var numRecords = command.ExecuteNonQuery();
                    Console.WriteLine("inserted {0} records", numRecords);
                }
                finally
                {
                    connection.Close();
                }
                // other codes. 
            }
            context.OutputParameters["id"] = id;
        }
    }
}

    Código para UpdatePlugin.cs

    public class UpdatePlugin: IPlugin {
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = serviceProvider.Get<IPluginExecutionContext>();
        Guid id = Guid.Empty;
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
        {
            Entity entity = (Entity)context.InputParameters["Target"];
            //change the table name below to the source table name you have created  
            string cmdString = "UPDATE VETicket SET {0} WHERE TicketID=@TicketID";
            SqlConnection connection = Connection.GetConnection();
            using (SqlCommand command = connection.CreateCommand())
            {
                command.Parameters.AddWithValue("@TicketID", entity["new_ticketid"]);
                List<string> setList = new List<string>();
                if (entity.Attributes.Contains("new_name"))
                {
                    command.Parameters.AddWithValue("@Name", entity["new_name"]);
                    setList.Add("Name=@Name");
                }
                if (entity.Attributes.Contains("new_severity"))
                {
                    command.Parameters.AddWithValue("@Severity", entity["new_severity"]);
                    setList.Add("Severity=@Severity");
                }
                command.CommandText = string.Format(cmdString, string.Join(",", setList)); connection.Open();
                try
                {
                    var numRecords = command.ExecuteNonQuery();
                    Console.WriteLine("updated {0} records", numRecords);
                }
                finally
                {
                    connection.Close();
                }
                // other codes. 
            }
        }
    }
}

    Código para RetrievePlugin.cs

    public class RetrievePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = serviceProvider.Get<IPluginExecutionContext>();
        Guid id = Guid.Empty;
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is EntityReference)
        {
            EntityReference entityRef = (EntityReference)context.InputParameters["Target"];
            Entity e = new Entity("new_ticket");
            //change the table name below to the source table name you have created  
            string cmdString = "SELECT TicketID, Severity, Name FROM VETicket WHERE TicketID=@TicketID";
            SqlConnection connection = Connection.GetConnection();
            using (SqlCommand command = connection.CreateCommand())
            {
                command.CommandText = cmdString;
                command.Parameters.AddWithValue("@TicketID", entityRef.Id);
                connection.Open();
                try
                {
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        if (reader.Read())
                        {
                            e.Attributes.Add("new_ticketid", reader.GetGuid(0));
                            e.Attributes.Add("new_severity", reader.GetInt32(1));
                            e.Attributes.Add("new_name", reader.GetString(2));
                        }
                    }
                }
                finally
                {
                    connection.Close();
                }
                // other codes. 
            }
            context.OutputParameters["BusinessEntity"] = e;
        }
    }
}

    Código para RetrieveMultiplePlugin.cs

    public class RetrieveMultiplePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = serviceProvider.Get<IPluginExecutionContext>();
        EntityCollection collection = new EntityCollection();
        //change the table name below to the source table name you have created  
        string cmdString = "SELECT TicketID, Severity, Name FROM VETicket";
        SqlConnection connection = Connection.GetConnection();
        using (SqlCommand command = connection.CreateCommand())
        {
            command.CommandText = cmdString;
            connection.Open();
            try
            {
                using (SqlDataReader reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        Entity e = new Entity("new_ticket");
                        e.Attributes.Add("new_ticketid", reader.GetGuid(0));
                        e.Attributes.Add("new_severity", reader.GetInt32(1));
                        e.Attributes.Add("new_name", reader.GetString(2));
                        collection.Entities.Add(e);
                    }
                }
            }
            finally
            {
                connection.Close();
            }
            context.OutputParameters["BusinessEntityCollection"] = collection;
        }
    }
}

    Código para DeletePlugin.cs

    public class DeletePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = serviceProvider.Get<IPluginExecutionContext>();
        //comment 
        Guid id = Guid.Empty;
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is EntityReference)
        {
            EntityReference entityRef = (EntityReference)context.InputParameters["Target"];
            id = entityRef.Id;
            //change the table name below to the source table name you have created 
            string cmdString = "DELETE VETicket WHERE TicketID=@TicketID";
            SqlConnection connection = Connection.GetConnection();
            using (SqlCommand command = connection.CreateCommand())
            {
                command.CommandText = cmdString; command.Parameters.AddWithValue("@TicketID", id);
                connection.Open();
                try
                {
                    var numRecords = command.ExecuteNonQuery();
                    Console.WriteLine("deleted {0} records", numRecords);
                }
                finally
                {
                    connection.Close();
                }
                // other codes. 
            }
        }
    }
}

  3. Compile y cree la solución. Ahora tendrá un archivo de ensamblaje (.dll) que puede usar para registrarse en su entorno de Dataverse. Encontrará este archivo en el directorio carpeta de soluciones/bin/Debug.

    DLL de ensamblado.

  4. Registre el ensamblado usando la herramienta de registro de complementos. Puede obtener el último paquete de herramientas de registro de complementos en NuGet.

  5. Abra la herramienta de registro de complementos. Debe tener privilegios de administración del sistema para registrar el ensamblado. Seleccione CREAR NUEVA CONEXIÓN para conectarse al entorno de Dataverse. Seleccione la lista desplegable Registrar y luego seleccione Registrar nuevo ensamblado.

    Registrar nuevo paso.

  6. Seleccione el archivo de ensamblaje y registre los complementos. Asegúrese de haber seleccionado todos los complementos (Crear, Actualizar, Eliminar, Recuperar y Recuperar varios complementos).

    registrar nuevo ensamblado.

Paso 2: crear un proveedor de datos y agregar complementos al proveedor

  1. Seleccione la lista desplegable Registrar y luego seleccione Registrar nuevo proveedor de datos.

  2. En el cuadro de diálogo Registrar nuevo proveedor de datos, introduzca los siguientes detalles:

    1. Introduzca Nombre del proveedor de datos.

    2. En la opción Soluciones, seleccione una solución existente o cree una nueva solución en el menú desplegable. Si desea crear una nueva solución, seleccione la opción Nueva solución del menú desplegable. En el cuadro de diálogo Crear nueva solución, introduzca los detalles requeridos y seleccione Guardar.

    3. En la opción Tabla (entidad) de origen de datos, seleccione Crear nuevo origen de datos. Introduzca los detalles. Asegúrese de que origen de datos sea parte de la solución que creó o seleccionó.

      Nota

      La tabla origen de datos de Dataverse contiene los datos de configuración de un registro origen de datos que se pasará a los complementos del proveedor.

    4. Asigne cada uno de los complementos registrados a sus respectivas operaciones.

    5. Registre el nuevo proveedor de datos.

      Registrar proveedor de datos.

  3. En la herramienta de registro de complementos, verá el nuevo registro origen de datos y el proveedor de datos asociado. Al seleccionar el origen de datos, se mostrarán los detalles que incluyen los complementos y su GUID registrado.

    Proveedor de datos registrado.

Paso 3: crear una tabla virtual en un entorno de Dataverse

  1. Cree una nueva tabla virtual origen de datos navegando a Configuración > Administración > Fuentes de datos de tablas (entidades) virtuales.

  2. Seleccione Nuevo y luego seleccione el proveedor de datos que creó en el paso anterior del menú desplegable.

  3. Ingrese un nombre para el origen de datos y seleccione Guardar y cerrar.

  4. Ahora está listo para crear la tabla virtual que representa el origen de datos externo. Para ello, vaya a Configuración > Personalizar el sistema.

  5. En el panel de navegación izquierdo del explorador de soluciones, seleccione Tablas (entidades) y seleccione Nuevo desde el panel principal.

  6. Escriba los siguientes datos:

    Columna Descripción
    Origen de datos Seleccione el origen de datos que ha creado en el paso anterior.
    Nombre Nombre de tabla virtual.
    Nombre plural Se rellenará el valor automáticamente en función del nombre para mostrar.
    Nombre Esto también se creará automáticamente en función del valor que ingrese para nombre.
    Nombre externo El nombre de la tabla de origen.
    Nombre de colecciones externo Puede utilizar el mismo valor de la columna de nombre en plural.

  7. Seleccione Guardar y cerrar.

    Crear registro nuevo.

  8. En el panel de navegación izquierdo, seleccione y amplíe la tabla virtual que creó.

  9. Seleccione Campos para actualizar y crear nuevas columnas que representen la fuente externa.

  10. Seleccione la columna Clave primaria de la tabla virtual y seleccione Editar.

  11. Actualice la columna Nombre externo para que coincida con el nombre de la columna en su origen de datos externo. En este ejemplo, el nombre de la columna externa es Identificación de entradas.

    Crear nueva tabla.

  12. Seleccione Guardar y cerrar.

  13. Seleccione el campo Nombre de la tabla virtual y seleccione Editar.

  14. Actualice el campo Nombre externo para que coincida con el nombre de campo del origen de datos externo. En este ejemplo, el nombre de la columna externa es Nombre.

    Crear un campo de nombre nuevo.

  15. Seleccione Guardar y cerrar.

  16. Seleccione Nuevo para crear una nueva columna en la tabla virtual. Esta columna representará la columna de gravedad en el origen de datos externo.

  17. Escriba la siguiente información para las nuevas columnas:

    Nombre de columna valor
    Nombre Gravedad
    Nombre new_severity
    Nombre externo Gravedad
    Requisito de campo Necesario para la empresa
    Tipo de datos Número entero

    Crear un campo de gravedad nuevo.

  18. Seleccione Guardar y cerrar.

Paso 4: crear, actualizar, ver y eliminar registros usando una tabla virtual

Cree una aplicación basada en modelo y agregue la tabla virtual al mapa del sitio. Luego seleccione el formulario principal de la tabla virtual y la vista de campo Avanzado. Publica la aplicación. Más información: Creación de su primera aplicación controlada por modelos desde cero

Crear aplicaciones basadas en modelos.

Los usuarios de la aplicación pueden realizar operaciones de lectura, creación, actualización y eliminación utilizando la tabla virtual como cualquier otra tabla en Microsoft Dataverse.

Consultar también

Introducción a las tablas virtuales
Consideraciones de API para tablas virtuales
Proveedores de datos de tablas virtuales personalizadas
Tutorial de tablas virtuales con el proveedor de datos OData v4