Share via

Crear un servicio de dominio que utilice entidades definidas con POCO

  • Artículo

En este tema se muestra cómo usar WCF RIA Services para crear un servicio de dominio que utiliza POCO (objetos CLR convencionales). El objetivo es mostrar cómo se crea una aplicación de RIA Services muy elemental basada en POCO que explique, en particular, lo que sucede exactamente cuando se utilizan las herramientas de RIA Services (asistentes y cuadros de diálogo) durante los distintos pasos del procedimiento. Los datos proporcionados desde POCO se pueden utilizar para liberar una aplicación de dependencias en bases de datos back-end a efectos de portabilidad o seguridad de datos o con fines de pruebas. RIA Services admite totalmente el código de cliente generado automáticamente, con entidades definidas con POCO como sucede con LINK to SQL o Entity Framework. El servicio de dominio de RIA Services es, de hecho, indiferente con respecto al origen de datos, por lo que esta clase de POCO se puede reemplazar posteriormente por un componente con acceso a los datos de otro origen como una base de datos sin cambiar el propio servicio de dominio.

El procedimiento que se describe aquí requiere la instalación y configuración correctas de varios programas de requisitos previos, como Visual Studio 2010 y Silverlight Developer Runtime y SDK, además de WCF RIA Services. No se requiere el Kit de herramientas de WCF RIA Services. Los temas del nodo Requisitos previos para WCF RIA Services proporcionan instrucciones detalladas para el cumplimiento de cada uno de estos requisitos previos. Siga las instrucciones proporcionadas en ellos en cuanto a los programas necesarios antes de realizar este procedimiento para asegurarse de encontrar el menor número de problemas posibles.

Crear una solución de RIA Services

  1. Cree un nuevo proyecto de RIA Services en Visual Studio 2010 seleccionando Archivo, Nuevo y, a continuación, Proyecto.

    Aparece el cuadro de diálogo Nuevo proyecto.

  2. Seleccione la plantilla Aplicación de Silverlight del grupo Silverlight de las Plantillas instaladas y asigne al nuevo proyecto el nombre RIAServicesPocoExample.

  3. Haga clic en Aceptar.

    Aparece el cuadro de diálogo Nueva aplicación de Silverlight.

  4. Active la casilla Habilitar WCF RIA Services situada cerca de la parte inferior del cuadro de diálogo. La activación de esta casilla crea un vínculo a RIA Services entre el proyecto de cliente y el proyecto de servidor. Para habilitar esta conexión, esta herramienta agrega las referencias siguientes al proyecto de cliente:

    • System.ComponentModel.DataAnnotations

    • System.Runtime.Serialization

    • System.ServiceModel.dll

    • System.ServiceModel.DomainServices.Client

    • System.ServiceModel.DomainServices.Client.Web

    • System.ServiceModel.Web.Extensions

    • System.Windows.Browser

  5. Haga clic en Aceptar para crear la solución.

    La solución contiene dos proyectos: un proyecto de cliente y un proyecto de servidor.

    • RIAServicesPocoExample: proyecto de cliente que contiene el código de Silverlight que se utiliza para crear el nivel de presentación.

    • RIAServicesPocoExample.Web: proyecto de servidor que contiene el código de nivel intermedio.

Crear un servicio de dominio

  1. Haga clic con el botón secundario en el proyecto de servidor, seleccione Agregar y, a continuación, Nuevo elemento.

  2. En la lista de categorías, seleccione Web y, a continuación, seleccione la plantilla Clase de servicio de dominio.

  3. Asigne a la clase el nombre SovereignDomainService.cs (o SovereignDomainService.vb).

  4. Haga clic en Agregar.

    Aparece el cuadro de diálogo Agregar nueva clase de servicio de dominio.

  5. Asegúrese de que esté activada la casilla Habilitar acceso de cliente.

  6. Observe que la única opción disponible en el menú desplegable para las Clases DataContext/ObjectContext disponibles es la entidad de la <clase de servicio de dominio vacía> y que no se puede activar la casilla Generar clases asociadas para metadatos porque no hay contextos de datos disponibles a los que asociar el servicio.

  7. Haga clic en Aceptar.

    Este asistente realiza varias acciones. Genera una clase de SovereignDomainService vacía en un nuevo archivo SovereignDomainService.cs (o SovereignDomainService.vb) con atributos asociados e instrucciones using. También agrega cuatro referencias de ensamblado al proyecto de servicio y elementos de configuración al archivo Web.config.

  8. Para observar este hecho, abra el archivo SovereignDomainService.cs (o SovereignDomainService.vb) si no se ha abierto automáticamente. Observe que el archivo tiene las siguientes características:

    1. Se han agregado las instrucciones using siguientes:

      • using System;

      • using System.Collections.Generic;

      • using System.ComponentModel;

      • using System.ComponentModel.DataAnnotations;

      • using System.Linq;

      • using System.ServiceModel.DomainServices.Hosting;

      • using System.ServiceModel.DomainServices.Server

    2. La clase SovereignDomainService deriva de la clase DomainService, que es una clase base abstracta en el marco de RIA Services . Esta es la clase base para la totalidad del servicio de dominio expuesto en RIA Services .

    3. La clase SovereignDomainService se marca con el atributo EnableClientAccessAttribute para indicar que está visible para el nivel de cliente.

  9. Observe que el asistente ha agregado las referencias siguientes al proyecto de servicio:

    • System.ComponentModel.DataAnnotations

    • System.Runtime.Serialization

    • System.ServiceModel.DomainServices.Hosting

    • System.ServiceModel.DomainServices.Server

  10. Finalmente, abra el archivo Web.config y examine los nuevos elementos agregados por el asistente.

    <configuration>
    <system.webServer>
        <modules runAllManagedModulesForAllRequests="true">
            <add name="DomainServiceModule" preCondition="managedHandler"
                type="System.ServiceModel.DomainServices.Hosting.DomainServiceHttpModule, System.ServiceModel.DomainServices.Hosting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        </modules>
        <validation validateIntegratedModeConfiguration="false" />
    </system.webServer>
    <system.web>
        <httpModules>
            <add name="DomainServiceModule" type="System.ServiceModel.DomainServices.Hosting.DomainServiceHttpModule, System.ServiceModel.DomainServices.Hosting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        </httpModules>
        <compilation debug="true" targetFramework="4.0" />
    </system.web>

    <system.serviceModel>
        <serviceHostingEnvironment aspNetCompatibilityEnabled="true"
            multipleSiteBindingsEnabled="true" />
    </system.serviceModel>
</configuration>

    Exceptuando el elemento de configuración cuyo destino es .NET Framework 4, cada uno de estos elementos se ha agregado mediante el cuadro de diálogo Agregar nueva clase de servicio de dominio. Estos elementos habilitan diversos hospedajes de Internet Information Services (IIS) y opciones de ASP.NET.

    1. El asistente agrega un elemento <modules> en la sección <system.webserver> que el hospedaje de IIS 7 requiere.

    2. El asistente agrega un elemento <add> del elemento <httpModules> en la sección system.web que el hospedaje de IIS 6 requiere.

    3. Los servicios de dominio de RIA Services son servicios de Windows Communication Foundation (WCF) y, cuando se hospedan con ASP.NET, es necesario que lo hagan en el modo de compatibilidad de ASP.NET. Este requisito no se puede establecer en el código y se debe especificar en el archivo Web.config. El modo de compatibilidad de ASP.NET se habilita estableciendo la propiedad aspNetCompatibilityEnabled en true, en el elemento <ServiceHostingEnvironment> de la sección <system.serviceModel>.

Agregar la clase POCO

  1. Este procedimiento describe cómo se indica al marco de RIA Services que se va a utilizar una clase POCO como tipo de entidad. Los tipos de entidad proporcionan estructuras de datos al modelo de datos de la aplicación y se requiere que cada tipo de entidad tenga una clave de entidad única. La estructura de los datos la especifica el conjunto de datos que contiene. La clave de entidad se proporciona reemplazando una propiedad (o un conjunto de propiedades) que debe proporcionar un nombre único para cada objeto entidad que lo distingue de otras entidades del mismo tipo. Esto se especifica normalmente utilizando metadatos de algún tipo. Este procedimiento realiza esta operación mediante la aplicación del atributo [Key] a una propiedad y, de hecho, la aplicación de este atributo es la que indica al marco de RIA Services que las instancias de la clase POCO son objetos entidad.

  2. Abra el archivo SovereignDomainSevice.cs.

  3. En el ámbito del espacio de nombres RIAServicesPocoExample.Web, debajo de la clase SovereignDomainService auxiliar, agregue el código siguiente para la clase Sovereign:

    
public class Sovereign
    {
        [Key]
        public int UniqueId { get; set; }
        public string Name { get; set; }
        public string House { get; set; }
        public string Dominion { get; set; }
        public int ReignStart { get; set; }
        public int ReignEnd { get; set; }
        public string Sobriquet { get; set; }
    }

  4. En este ejemplo, la propiedad UniqueId es la clave de entidad que proporciona un nombre único a cada objeto entidad de tipo Sovereign. El atributo [Key] se define en el ensamblado System.ComponentModel.DataAnnotations, que ya se ha agregado al proyecto de servidor, al igual que la instrucción using para el espacio de nombres correspondiente que lo contiene. La clave de entidad también puede especificarse en un archivo de metadatos o en otros medios, pero esta es una forma cómoda de indicarla directamente en la clase POCO.

  5. Agregue el método FetchSovereigns() a la clase Sovereign que devuelve una lista de instancias de Sovereign.

    
public List<Sovereign> FetchSovereigns()
        {
            List<Sovereign> sovereignList = new List<Sovereign>
            {
            new Sovereign()
                {UniqueId = 1, 
                 Name = "John", 
                 House = "Plantagenet", 
                 Dominion = "Angevin Empire", 
                 ReignStart = 1167, 
                 ReignEnd = 1216, 
                 Sobriquet = "Lackland"
                },
            new Sovereign()
                {UniqueId = 2, 
                 Name = "Charles", 
                 House = "Stuart", 
                 Dominion = "England, Scotland, & Ireland", 
                 ReignStart = 1625, 
                 ReignEnd = 1649, 
                 Sobriquet = "The Martyr"
                },
            new Sovereign()
                {UniqueId = 3, 
                 Name = "William", 
                 House = "Dunkeld", 
                 Dominion = "Scotland", 
                 ReignStart = 1165, 
                 ReignEnd = 1249, 
                 Sobriquet = "The Lion"
                },   
            new Sovereign()
                {UniqueId = 4, 
                 Name = "Elizabeth", 
                 House = "Tudor", 
                 Dominion = "England", 
                 ReignStart = 1555, 
                 ReignEnd = 1609, 
                 Sobriquet = "The Virgin Queen"
                },
            new Sovereign()
                {UniqueId = 5, 
                 Name = "Ivan", 
                 House = "Vasilyevich", 
                 Dominion = "Russia", 
                 ReignStart = 1533, 
                 ReignEnd = 1584, 
                 Sobriquet = "The Terrible"
                },
            new Sovereign()
                {UniqueId = 6, 
                 Name = "Charles", 
                 House = "Valois", 
                 Dominion = "France", 
                 ReignStart = 1380, 
                 ReignEnd = 1422, 
                 Sobriquet = "The Mad"
                }
            };
        return sovereignList;
        }

Definir el servicio de dominio

  1. Este procedimiento describe la forma de crear una consulta en el servicio de dominio que estará accesible desde el cliente para recuperar datos de las entidades definidas con POCO. El marco de RIA Services necesita saber cuáles de sus métodos van a estar disponibles en el cliente como consultas y, para conseguir esto, se utiliza una convención de nomenclatura. El marco de RIA Services reconoce como consultas los nombres de métodos que empiezan con Get y que devuelven una interfaz IEnumerable<EntityType> o una interfaz IQueryable<EntityType>.

    Sugerencia:
    IQueryable deriva de IEnumerable. Use IEnumerable para colecciones en memoria como nuestras entidades definidas con POCO y utilice IQueryable al obtener acceso a un origen de datos remoto o subyacente como una base de datos SQL.

  2. Agregue el método GetSovereign() a la clase SovereignDomainService.

    
        public IEnumerable<Sovereign> GetSovereigns()
        { 
            Sovereign sovereign = new Sovereign();
            return sovereign.FetchSovereigns();
        }

  3. Con esto, se devuelven todas las entidades de soberanos de la colección. Pero, normalmente, solo se desea devolver un subconjunto de las entidades. Para ilustrar esto, modifique esta consulta de modo que solo se devuelvan los soberanos de esta lista que reinaron durante la Edad Media, es decir, en el caso de que sovereign.ReignEnd <= 1500. El código siguiente realiza esta acción:

            public IEnumerable<Sovereign> GetSovereignsByReignEnd(int ReignedBefore)
        {
            Sovereign sovereign = new Sovereign();
            return sovereign.FetchSovereigns().Where<Sovereign>(p => p.ReignEnd <= 1500);
        }

  4. Genere (Ctrl+Mayús+B) la solución para crear el código proxy de cliente generado automáticamente.

  5. En el Explorador de soluciones, seleccione el proyecto de cliente RIAServicesPocoExample, haga clic en el icono Mostrar todos los archivos situado en la parte superior de la ventana y examine el archivo RIAServicesPocoExample.Web.g.cs de la carpeta Generated_Code. Examine el código generado automáticamente de este archivo y tome nota de los elementos siguientes:

    • Se genera una clase WebContext que deriva de la clase WebContextBase y se utiliza para administrar el contexto de aplicación.

    • Se genera una clase Sovereign que deriva de la clase Entity para la entidad expuesta por el servicio de dominio. La clase de entidad Sovereign del proyecto de cliente coincide con la entidad Sovereign en el servidor.

    • Se genera una clase SovereignDomainContext que deriva de la clase DomainContext. Esta clase tiene un método denominado GetSovereignsByReignEndQuery que corresponde al método de consulta creado en el servicio de dominio.

  6. Para obtener más información sobre la generación automática de código, vea el tema Generación de código de cliente. Para obtener información sobre cómo se personaliza la generación de código, vea el tema Personalizar el código generado.

Mostrar el resultado de una consulta en el cliente de Silverlight

  1. Abra MainPage.xaml.

  2. Desde el Cuadro de herramientas situado a la izquierda, arrastre un control DataGrid hasta el interior del elemento Grid en la vista XAML.

    La acción de arrastrar el control DataGrid desde el Cuadro de herramientas hace que se agregue una instrucción using System.Windows.Controls de espacio de nombres al archivo MainPage.xaml.cs y que se agreguen automáticamente al proyecto de cliente referencias a los ensamblados System.Windows.Controls.Data y System.Windows.Controls.Data.Input.

    Precaución:
    Si agrega el control DataGrid sin arrastrarlo desde el Cuadro de herramientas, debe agregar manualmente al proyecto de cliente las referencias a los ensamblados y la instrucción "using" en el archivo de código subyacente.

  3. Cambie el valor de AutoGeneratedColums a True, asigne al elemento DataGrid el nombre SovereignGrid y ajuste los atributos Height y Width como se muestra en el código XAML siguiente.

    
<Grid x:Name="LayoutRoot" Background="White">
     <sdk:DataGrid AutoGenerateColumns="True" 
                   Height="200" 
                   HorizontalAlignment="Left" 
                   Margin="157,86,0,0" 
                   Name="SovereignGrid" 
                   VerticalAlignment="Top"
                   Width="600" />
</Grid>

  4. Abra el archivo MainPage.xaml.cs.

  5. Agregue dos instrucciones Imports (Visual Basic) o using (C#): using RIAServicesPocoExample.Web; y using System.ServiceModel.DomainServices.Client;.

    El espacio de nombres RIAServicesPocoExample.Web es el espacio de nombres que contiene el código generado para el proyecto de cliente en RIAServicesPocoExample.Web.g.cs (o RIAServicesPocoExample.Web.g.vb).

  6. Para crear una instancia del elemento SovereignDomainContext, agregue la línea de código private SovereignDomainContext _sovereignContext = new SovereignDomainContext(); en la clase MainPage.

  7. Recupere las entidades Customer llamando al método GetSovereignsQuery con LoadOperation: LoadOperation<Sovereign> loadOp = this._sovereignContext.Load(this._sovereignContext.GetSovereignsByReignEndQuery(1500));.

  8. Enlace las entidades cargadas al control DataGrid con SovereignGrid.ItemsSource = loadOp.Entities;.

    En resumen, el archivo MainPage.xaml.cs debe contener ahora el código siguiente:

    //Namespaces added
using RIAServicesPocoExample.Web;
using System.ServiceModel.DomainServices.Client;

namespace RIAServicesPocoExample
{
    public partial class MainPage : UserControl

    {
        private SovereignDomainContext _sovereignContext = new SovereignDomainContext();

        public MainPage()
        {

            InitializeComponent();

              LoadOperation<Sovereign> loadOp = this._sovereignContext.Load(this._sovereignContext.GetSovereignsByReignEndQuery(1500));
              SovereignGrid.ItemsSource = loadOp.Entities;
        }
    }
}

  9. Ejecute (F5) la aplicación.

    Debe ver en el explorador una tabla que muestra las propiedades solo de los reyes medievales cuyos reinados finalizaron antes del año 1500 de la era cristiana (en orden alfabético).

Seguridad

Vea también

Tareas

Tutorial: recuperar y mostrar datos de un servicio de dominio

Conceptos

Generación de código de cliente