Implémentation du service Web Books Authors (exemple d'application EDM)

Le service Web Books Authors présenté à titre d'exemple dans ce groupe de rubriques implémente une application EDM (Modèle de données d'entité) à partir des schémas de la rubrique nommée Schémas du service Web Books Authors (exemple d'application EDM).

L'espace de noms et les classes utilisés par le service Web Books Authors sont générés à partir des entités et des associations conçues en langage CSDL (Conceptual Schema Definition Language). Les tables de base de données qui stockent les données des classes sont décrites par des métadonnées écrites en langage SSDL (Store Schema Definition Language). Les types dans la structure de schéma sont mappés aux métadonnées de stockage en langage MSL (Mapping Specification Language).

Le modèle objet programmable dépend à la fois des schémas et de la spécification de mappage. Comme le modèle objet est généré à partir du schéma conceptuel, la DLL résultante nécessite que le schéma conceptuel, le schéma de stockage et la spécification de mappage soient dans la portée pour qu'une connexion à une entité puisse être établie.

L'établissement de l'objet EntityConnection rend les classes et la source de données disponibles pour le code. Pour plus d'informations sur la création de la bibliothèque de classes, voir Implémentation d'entités (EDM).

Projet de service Web

Le service Web qui utilise le modèle objet Books Authors décrit dans cette section est implémenté comme un projet distinct. Créez un projet basé sur le modèle de service Web ASP.NET. Ajoutez les références à la DLL System.Data.Entity et à la DLL BooksAuthors créée dans le projet EDM Model Object. L'ajout des références crée un dossier Bin qui contient les DLL.

Les schémas doivent être dans la portée de l'exécutable. Ajoutez les schémas à partir du projet de bibliothèque de classes BooksAuthors au dossier App_Data dans le projet de service Web.

Web.config

Un fichier Web.config est nécessaire pour rechercher les schémas, les métadonnées et le serveur de données utilisés par les objets EDM dans le service Web BooksAuthors. Le code XML suivant montre le fichier Web.config du service. La chaîne de connexion identifie le serveur et la base de données utilisés par la spécification de mappage pour établir une connexion entre les classes programmables et la base de données.

<?xml version="1.0"?>
<configuration>

    <configSections/>

    <system.web>
        <authentication mode="Windows"/>
        <identity impersonate ="true"/>
    </system.web>

    <connectionStrings>
        <add name="BooksAuthorsEntities"
         connectionString=
         "metadata=C:\Inetpub\wwwroot\BooksAuthorsWebSrv\App_Data\;
         provider=System.Data.SqlClient; 
         provider connection string='server=serverName; 
         database=BooksAuthors; 
         integrated security=true;
         multipleactiveresultsets=true'" 
         providerName="System.Data.EntityClient"/>
    </connectionStrings>
</configuration>

Remarque
Cette chaîne de connexion affecte la valeur true à plusieurs jeux de résultats actifs, comme cela est requis pour appeler la méthode Load sur des associations lorsqu'un autre lecteur de données est déjà ouvert sur la même connexion.

Lorsque le service s'exécute sur un serveur Web, il doit rechercher le chemin d'accès aux schémas d'un répertoire virtuel. Une façon d'y parvenir consiste à utiliser la méthode Server.MapPath dans le fichier global.asax. Dans le code suivant, la méthode MapPath recherche le chemin d'accès absolu complet. Le chemin d'accès trouvé par la méthode MapPath est utilisé dans la chaîne de connexion obtenue à partir du fichier Web.config.

Les procédures figurent à la suite de la méthode Application_Start dans le fichier global.asax présenté ci-dessous.

  <script >

    void Application_Start(object sender, EventArgs e) 
    {
        String connString = 
          System.Web.Configuration.WebConfigurationManager.
          ConnectionStrings["BooksAuthorsEntities"].ConnectionString;

        connString = connString.Replace(@"C:\Inetpub\wwwroot\BooksAuthorsWebSrv\App_Data\",
         Server.MapPath("~/App_Data"));

        Application.Contents.Add("ConnString", connString);

    }

  </script>

Dans les déclarations Web Method , la chaîne de connexion modifiée est lue à partir de la collection Application.Contents et utilisée pour instancier le contexte de l'objet comme suit : BooksAuthorsEntities db = new BooksAuthorsEntities(Application.Contents["ConnString"] as String).

Code d'application

L'établissement de la connexion d'entité dépend de la chaîne de connexion dans le fichier Web.config et du code dans le constructeur de services Web. Comme la chaîne de connexion est stockée dans le fichier Web.Config, la connexion peut être établie en une seule ligne de code : BooksAuthors db = new BooksAuthors(Application.Contents["ConnString"] as String)). Ce service Web initialise séparément la connexion d'entité dans chaque méthode qu'il fournit. SQL Server utilise le regroupement de connexions pour que cela n'affecte pas les performances.

Les méthodes du service Web dans cette application sont implémentées comme des méthodes publiques qui initialisent et retournent List<T>. Les listes sont converties en texte par les protocoles des services Web et retournées sous forme de données XML.

La première méthode retourne tous les entités Books dans le système. Pour récupérer les données Books, une connexion aux données BooksAuthors est ouverte sur le service Web. Un nouveau List<T> de type Books est initialisé et utilisé pour convertir le Query<T> Books en tableau qui peut être retourné à l'appelant de la méthode. Puis, la connexion est fermée.

    [WebMethod]
    public Books[] GetBooks()
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String))
        {
            List<Books> bookList = new List<Books>(db.Books);
            return bookList.ToArray();
        }
    }

La méthode suivante fonctionne de la même manière pour retourner Authors.

    [WebMethod]
    public Authors[] GetAuthors()
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String)) 
        {
            List<Authors> authorsList = new List<Authors>(db.Authors);
            return authorsList.ToArray();
        }
    }

La méthode suivante utilise une requête paramétrable basée sur le titre d'un livre pour rechercher toutes les entités BooksInfo dans lesquelles la propriété BookTitle correspond au titre fourni. Grâce aux entités BooksInfo, l'association entre les entités Authors et BooksInfo peut être parcourue pour accéder à toutes les entités Authors associées au livre correspondant au titre donné.

Un tableau de type Authors est retourné à l'appelant de la méthode.

    [WebMethod]
    public Authors[] GetAuthorsFromBookTitle(string bookTitle)
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String))
        {
            ObjectParameter param = new ObjectParameter("p", bookTitle);

            List<Authors> authorsList = new List<Authors>();

            foreach (BooksInfo bksInfo in db.BooksInfo.Where(
                "it.BookTitle = @p", param))
            {
                bksInfo.AuthorsReference.Load();
                authorsList.Add(bksInfo.Authors);

            }
            return authorsList.ToArray();
        }
    }

La méthode GetBooksFromAuthorLastName fonctionne comme la méthode précédente pour retourner un tableau de livres à partir d'une requête basée sur le nom d'un auteur.

    [WebMethod]
    public Books[] GetBooksFromAuthorLastName(string authorLastName)
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String))
        {
            ObjectParameter param = new ObjectParameter("p", authorLastName);

            List<Books> booksList = new List<Books>();

            foreach (BooksInfo bksInfo in db.BooksInfo.Where(
                "it.AuthorLastName = @p", param))
            {
                bksInfo.BooksReference.Load();
                booksList.Add(bksInfo.Books);
            }
            return booksList.ToArray();
        }
    }

Ce service Web permet également d'ajouter des entités Books ainsi que l'auteur ou les auteurs du livre ajouté. La connexion d'entité permet d'écrire et de lire des données. La méthode Web suivante crée des entités qui représentent un livre et son auteur, ajoute les entités à l'objet ObjectContext et met à jour la base de données. Elle peut être utilisée autant de fois que nécessaire pour ajouter d'autres auteurs pour le même titre.

    [WebMethod]
    public void AddBook(string title, string authorFirstName,
        string authorLastName, string infoUri, string isbnNumber)
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String))
        {

            BooksInfo newBooksInfo = new BooksInfo();
            newBooksInfo.BookInfoId = Guid.NewGuid();
            newBooksInfo.AuthorLastName = authorLastName;
            newBooksInfo.BookTitle = title;
            if (!infoUri.Equals(""))
                newBooksInfo.InfoLocator = infoUri;

            Books existingBook = null;
            ObjectParameter param = new ObjectParameter("p", title);
            ObjectQuery<Books> queryBook = db.Books.Where(
                "it.Title = @p", param);

            if (queryBook.Exists())
            {
                existingBook = db.Books.Where(
                    "it.Title = @p", param).First();
                newBooksInfo.Books = existingBook;
            }
            else
            {
                Books newBook = new Books();
                newBook.BookId = isbnNumber;
                newBook.Title = title;
                newBooksInfo.Books = newBook;
                db.AddToBooks(newBook);
            }

            Authors existingAuthor = null;
            ObjectParameter aParam = new ObjectParameter(
                "p", authorLastName);
            ObjectParameter aParam2 = new ObjectParameter(
                "q", authorFirstName);
            ObjectParameter[] pars =
                new ObjectParameter[] { aParam, aParam2 };
            ObjectQuery<Authors> queryAuthor = db.Authors.Where(
                "it.LastName = @p AND it.FirstName = @q", pars);

            if (queryAuthor.Exists())
            {
                existingAuthor = db.Authors.Where(
                    "it.LastName = @p AND it.FirstName = @q",
                    pars).First();
                newBooksInfo.Authors = existingAuthor;
            }
            else
            {
                Authors newAuthor = new Authors();
                newAuthor.AuthorId = Guid.NewGuid();
                newAuthor.LastName = authorLastName;
                newAuthor.FirstName = authorFirstName;
                newBooksInfo.Authors = newAuthor;
                db.AddToAuthors(newAuthor);
            }

            db.AddToBooksInfo(newBooksInfo);
            db.SaveChanges();

        }
    }

La dernière méthode dans cet exemple retourne des entités BooksInfo qui comportent le titre du livre, le numéro d'ID du livre, le nom de l'auteur et des informations de localisation.

    [WebMethod]
    public BooksInfo[] GetBooksInfo()
    {
        using (BooksAuthorsEntities db =
            new BooksAuthorsEntities(
                Application.Contents["ConnString"] as String))
        {
            List<BooksInfo> booksInfoList =
                new List<BooksInfo>(db.BooksInfo);

            return booksInfoList.ToArray();
        }
    }

Cette méthode permet d'afficher des données dans les applications clientes présentées dans Client Application for Web Service (Exemple d'application EDM).

Voir aussi

Concepts

Books Authors Web Service (Exemple d'application EDM)
Schémas du service Web Books Authors (exemple d'application EDM)
Client Application for Web Service (Exemple d'application EDM)

Autres ressources

Spécifications EDM
Schémas et spécification de mappage (Entity Framework)