Procedura: creare un servizio del dominio che utilizza entità definite da POCO

  • Articolo

In questo argomento viene illustrato come utilizzare WCF RIA Services per creare un servizio del dominio che utilizza oggetti POCO (Plain Old CLR Objects). L'obiettivo è quello di indicare come si costruisce un'applicazione RIA Services molto elementare basata su POCO che spiega, in particolare, quello che si verifica esattamente quando gli strumenti (procedure guidate e finestre di dialogo) RIA Services vengono utilizzati durante i vari passaggi nella procedura. I dati serviti da POCO possono essere utilizzati per liberare un'applicazione dalle dipendenze nei database di back-end per scopi di sicurezza dei dati o portabilità oppure per scopi di test. Il codice client generato automaticamente è totalmente supportato da RIA Services con le entità definite da POCO e con Linq to SQL o Entity Framework. Il servizio del dominio RIA Services è infatti agnostico rispetto all'origine dati, pertanto questa classe POCO può essere sostituita in un secondo momento da un componente che esegue l'accesso ai dati da un'altra origine, ad esempio un database, senza modificare il servizio del dominio stesso.

Per l'esecuzione della procedura descritta in questo documento, è necessario che siano installati e configurati correttamente alcuni programmi prerequisiti quali Visual Studio 2010 e Silverlight Developer Runtime e SDK, oltre a WCF RIA Services. WCF RIA Services Toolkit non è richiesto. Le istruzioni dettagliate per soddisfare tali prerequisiti vengono fornite negli argomenti all'interno del nodo Prerequisiti per WCF RIA Services. Seguire le istruzioni fornite per i programmi richiesti prima di continuare con questa procedura in modo da evitare il maggior numero di problemi possibile.

Creare una soluzione Servizi RIA

  1. Creare un nuovo progetto RIA Services in Visual Studio 2010 selezionando File, Nuovo e Progetto.

    Viene visualizzata la finestra di dialogo Nuovo progetto.

  2. Selezionare il modello Applicazione Silverlight dal gruppo Silverlight di Modelli installati e denominare il nuovo progetto RIAServicesPocoExample.

  3. Fare clic su OK.

    Viene visualizzata la finestra di dialogo Nuova applicazione Silverlight.

  4. Selezionare la casella di controllo Abilita servizi RIA WCF nella parte inferiore della finestra di dialogo. Se si seleziona questa casella viene creato un collegamento RIA Services tra il progetto client e il progetto server. Per abilitare questa connessione vengono aggiunti i riferimenti seguenti al progetto client:

    • 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. Fare clic su OK per creare la soluzione.

    La soluzione contiene due progetti: un progetto client e un progetto server.

    • RIAServicesPocoExample: il progetto client che contiene il codice Silverlight che si utilizza per creare il livello di presentazione.

    • RIAServicesPocoExample.Web: il progetto server che contiene il codice di livello intermedio.

Creare un servizio del dominio

  1. Fare clic con il pulsante destro del mouse sul progetto server, scegliere Aggiungi, quindi Nuovo elemento.

  2. Nell'elenco delle categorie, scegliere Web, quindi selezionare il modello Classe di servizio del dominio.

  3. Assegnare alla classe il nome SovereignDomainService.cs (o SovereignDomainService.vb).

  4. Fare clic su Aggiungi.

    Viene visualizzata la finestra di dialogo Aggiungi una nuova classe di servizio del dominio.

  5. Verificare che sia selezionata la casella Abilita l'accesso client.

  6. Notare che l'unica opzione disponibile nel menu a discesa Classi DataContext/ObjectContext disponibili è l'entità <Classe di servizio del dominio vuota> e non è possibile selezionare la casella di controllo Genera classi associate per i metadati perché non sono disponibili contesti di dati a cui associare il servizio.

  7. Fare clic su OK.

    Con questa procedura guidata si possono eseguire diverse operazioni. È possibile generare una classe SovereignDomainService vuota in un nuovo file SovereignDomainService.cs (o SovereignDomainService.vb) con attributi e istruzioni using associati. Inoltre, è possibile aggiungere quattro riferimenti all'assembly agli elementi di configurazione e progetto del servizio nel file Web.config.

  8. A tale scopo, aprire il file SovereignDomainService.cs (o SovereignDomainService.vb) se è non è già stato aperto automaticamente. Notare le seguenti caratteristiche del file:

    1. Sono state aggiunte le istruzioni using:

      • 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 classe SovereignDomainService deriva dalla classe DomainService, classe di base astratta nel framework RIA Services . Si tratta della classe di base per tutto il servizio del dominio esposto in RIA Services .

    3. La classe SovereignDomainService è contrassegnata dall'attributo EnableClientAccessAttribute per indicare che è visibile a livello client.

  9. Notare che sono stati aggiunti dalla procedura guidata i riferimenti seguenti al progetto di servizio:

    • System.ComponentModel.DataAnnotations

    • System.Runtime.Serialization

    • System.ServiceModel.DomainServices.Hosting

    • System.ServiceModel.DomainServices.Server

  10. Infine aprire il file Web.config ed esaminare i nuovi elementi aggiunti dalla procedura guidata.

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

    Ad eccezione dell'elemento di configurazione destinato a .NET Framework 4.0, ciascuno di questi elementi è stato aggiunto tramite la finestra di dialogo Aggiungi una nuova classe di servizio del dominio. Gli elementi abilitano diverse opzioni ASP.NET e di hosting di Internet Information Server (IIS).

    1. Viene aggiunto l'elemento <modules> nella sezione <system.webserver> richiesta dall'hosting di IIS 7.

    2. Viene aggiunto un elemento <add> dell'elemento <httpModules> nella sezione system.web richiesta dall'hosting di IIS 6.

    3. I servizi del dominio di RIA Services sono servizi Windows Communication Foundation (WCF) che se ospitati con ASP.NET devono essere ospitati nella modalità di compatibilità ASP.NET. Questo requisito non può essere impostato nel codice e deve essere specificato nel file Web.config. La modalità di compatibilità ASP.NET viene abilitata impostando la proprietà aspNetCompatibilityEnabled su true nell'elemento <ServiceHostingEnvironment> della sezione <system.serviceModel>.

Aggiungere la classe POCO

  1. In questa procedura viene descritto come si indica al framework RIA Services che una classe POCO deve essere utilizzata come tipo di entità. I tipi di entità forniscono le strutture di dati al modello di dati dell'applicazione e ogni tipo di entità deve avere una chiave di entità univoca. La struttura dei dati viene specificata dal set di proprietà che contiene. La chiave di entità è fornita deputando una proprietà o un set di proprietà che deve fornire per ogni oggetto entità un nome univoco che lo distingue dalle altre entità dello stesso tipo. In genere ciò si specifica utilizzando i metadati di una certa varietà. Questa operazione viene eseguita applicando l'attributo [Key] a una proprietà ed è di fatto l'applicazione di questo attributo che indica al framework RIA Services che le istanze della classe POCO sono oggetti entità.

  2. Aprire il file SovereignDomainSevice.cs.

  3. Nell'ambito dello spazio dei nomi RIAServicesPocoExample.Web, sotto la classe SovereignDomainService generata automaticamente, aggiungere il codice seguente per la classe 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. In questo esempio la proprietà UniqueId è la chiave di entità che fornisce un nome univoco per ogni oggetto entità di tipo Sovereign. L'attributo [Key] è definito nell'assembly System.ComponentModel.DataAnnotations che è già stato aggiunto al progetto server come l'istruzione using per lo spazio dei nomi corrispondente che lo contiene. La chiave di entità può anche essere specificata in un file di metadati o in altre modalità, ma questo è un modo conveniente per indicarla direttamente nella classe POCO.

  5. Aggiungere il metodo FetchSovereigns() alla classe Sovereign che restituisce un elenco di istanze di 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;
        }

Definire il servizio del dominio

  1. In questa procedura viene descritto come si crea una query nel servizio del dominio che sarà accessibile dal client per recuperare i dati dalle entità definite da POCO. È necessario che il framework RIA Services sappia quali metodi devono essere resi disponibili sul client come query ed è necessario utilizzare a tale scopo una convenzione di denominazione. I nomi dei metodi che iniziano con Get e che restituiscono un elemento IEnumerable<EntityType> o un elemento IQueryable<EntityType> sono riconosciuti dal framework RIA Services come query.

    TipSuggerimento:
    IQueryable deriva da IEnumerable. Utilizzare IEnumerable per le raccolte in memoria, ad esempio le entità definite da POCO e utilizzare IQueryable quando si accede a un'origine dati sottostante o remota, come un database SQL.

  2. Aggiungere il metodo GetSovereign() alla classe SovereignDomainService.

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

  3. Vengono restituite tutte le entità sovrano della raccolta. In genere, tuttavia, si desidera venga restituito solo un sottoinsieme delle entità. A tale scopo, modificare la query in modo che vengano restituiti da questo elenco solo i sovrani che hanno regnato durante il Medio Evo, ossia sovereign.ReignEnd <= 1500. Il codice riportato di seguito effettua questa operazione:

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

  4. Compilare (CTRL+MAIUSC+B) la soluzione per creare il codice del proxy client generato automaticamente.

  5. In Esplora soluzioni selezionare il progetto client RIAServicesPocoExample, fare clic sull'icona Mostra tutti i file nella parte superiore della finestra ed esaminare il file RIAServicesPocoExample.Web.g.cs nella cartella Generated_Code. Esaminare il codice generato automaticamente in questo file e prendere nota degli elementi seguenti:

    • Una classe WebContext che deriva dalla classe WebContextBase viene generata e utilizzata per gestire il contesto dell'applicazione.

    • Una classe Sovereign che deriva dalla classe Entity viene generata per l'entità esposta dal servizio del dominio. La classe dell'entità Sovereign nel progetto client corrisponde all'entità Sovereign nel server.

    • Viene generata una classe SovereignDomainContext che deriva dalla classe DomainContext. Questa classe dispone di un metodo denominato GetSovereignsByReignEndQuery che corrisponde al metodo di query creato nel servizio del dominio.

  6. Per ulteriori informazioni sulla generazione automatica del codice, vedere l'argomento Generazione del codice client. Per ulteriori informazioni sulla personalizzazione della generazione automatica, vedere gli argomenti Personalizzazione del codice generato.

Visualizzare il risultato della query nel client Silverlight

  1. Aprire MainPage.xaml.

  2. Dalla casella degli strumenti sulla sinistra, trascinare un controllo DataGrid nell'elemento Grid nella visualizzazione XAML.

    Il trascinamento del controllo DataGrid dalla casella degli strumenti provoca l'aggiunta al file MainPage.xaml.cs di un'istruzione using System.Windows.Controls dello spazio dei nomi e l'aggiunta automatica al progetto client dei riferimenti agli assembly System.Windows.Controls.Data e System.Windows.Controls.Data.Input.

    CautionAttenzione:
    Se si aggiunge DataGrid senza trascinarlo dalla casella degli strumenti, è necessario aggiungere manualmente al progetto client i riferimenti agli assembly e al file code-behind l'istruzione using.

  3. Impostare il valore di AutoGeneratedColums su True, assegnare il nome SovereignGrid all'elemento DataGrid e modificare i valori di Height e Width come indicato nel seguente codice XAML.

    
<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. Aprire il file MainPage.xaml.cs.

  5. Aggiungere due istruzioni using (C#) o Imports (Visual Basic): using RIAServicesPocoExample.Web; e using System.ServiceModel.DomainServices.Client;.

    Lo spazio dei nomi RIAServicesPocoExample.Web è quello contenente il codice generato per il progetto client in RIAServicesPocoExample.Web.g.cs (o RIAServicesPocoExample.Web.g.vb).

  6. Per creare un'istanza di SovereignDomainContext, aggiungere la riga di codice private SovereignDomainContext _sovereignContext = new SovereignDomainContext(); nella classe MainPage.

  7. Recuperare le entità del cliente chiamando il metodo GetSovereignsQuery con LoadOperation: LoadOperation<Sovereign> loadOp = this._sovereignContext.Load(this._sovereignContext.GetSovereignsByReignEndQuery(1500));.

  8. Associare le entità caricate a DataGrid con SovereignGrid.ItemsSource = loadOp.Entities;.

    Per riassumere, il file MainPage.xaml.cs a questo punto contiene il codice seguente:

    //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. Eseguire (F5) l'applicazione.

    Viene visualizzata la tabella nel browser indicando in ordine alfabetico solo le proprietà dei sovrani del Medio Evo il cui regno è terminato prima dell'era volgare del 1500).

Sicurezza

Vedere anche

Attività

Procedura dettagliata: recupero e visualizzazione di dati da un servizio del dominio

Concetti

Generazione del codice client