Exemplarische Vorgehensweise zu Self-Tracking EntitiesSelf-Tracking Entities Walkthrough

Wichtig

Es wird nicht mehr empfohlen, die Vorlage für Entitäten mit Selbstnachverfolgung zu verwenden.We no longer recommend using the self-tracking-entities template. Die Vorlage ist nur für die Unterstützung vorhandener Anwendungen weiterhin verfügbar.It will only continue to be available to support existing applications. Wenn für Ihre Anwendung die Arbeit mit getrennten Diagrammen von Entitäten erforderlich ist, sollten Sie daher Alternativen erwägen, wie z.B. nachverfolgbare Entitäten. Diese Technologie ähnelt den Entitäten mit Selbstnachverfolgung und wird von der Community aktiver entwickelt. Alternativ dazu können Sie auch benutzerdefinierten Code mithilfe von APIs auf niedriger Ebene zur Änderungsnachverfolgung schreiben.If your application requires working with disconnected graphs of entities, consider other alternatives such as Trackable Entities, which is a technology similar to Self-Tracking-Entities that is more actively developed by the community, or writing custom code using the low-level change tracking APIs.

Diese exemplarische Vorgehensweise veranschaulicht das Szenario, in dem ein Windows Communication Foundation (WCF)-Dienst einen Vorgang verfügbar macht, der ein Entitäts Diagramm zurückgibt.This walkthrough demonstrates the scenario in which a Windows Communication Foundation (WCF) service exposes an operation that returns an entity graph. Anschließend bearbeitet eine Client Anwendung dieses Diagramm und übermittelt die Änderungen an einen Dienst Vorgang, der die Updates in einer Datenbank mithilfe Entity Framework überprüft und speichert.Next, a client application manipulates that graph and submits the modifications to a service operation that validates and saves the updates to a database using Entity Framework.

Bevor Sie diese exemplarische Vorgehensweise durcharbeiten, sollten Sie die Seite Entitäten mit selbst Nachverfolgung lesen.Before completing this walkthrough make sure you read the Self-Tracking Entities page.

Diese exemplarische Vorgehensweise umfasst die folgenden Aktionen:This walkthrough completes the following actions:

  • Erstellt eine Datenbank, auf die zugegriffen werden soll.Creates a database to access.
  • Erstellt eine Klassenbibliothek, die das Modell enthält.Creates a class library that contains the model.
  • Tauscht die Vorlage für den Self-Tracking Entity Generator aus.Swaps to the Self-Tracking Entity Generator template.
  • Verschiebt die Entitäts Klassen in ein separates Projekt.Moves the entity classes to a separate project.
  • Erstellt einen WCF-Dienst, der Vorgänge zum Abfragen und Speichern von Entitäten verfügbar macht.Creates a WCF service that exposes operations to query and save entities.
  • Erstellt Client Anwendungen (Konsole und WPF), die den-Dienst nutzen.Creates client applications (Console and WPF) that consume the service.

Wir verwenden Database First in dieser exemplarischen Vorgehensweise, aber dieselben Verfahren gelten auch für Model First.We'll use Database First in this walkthrough but the same techniques apply equally to Model First.

VoraussetzungenPre-Requisites

Um diese exemplarische Vorgehensweise abzuschließen, benötigen Sie eine aktuelle Version von Visual Studio.To complete this walkthrough you will need a recent version of Visual Studio.

Erstellen einer DatenbankCreate a Database

Der Datenbankserver, der mit Visual Studio installiert wird, unterscheidet sich abhängig von der installierten Version von Visual Studio:The database server that is installed with Visual Studio is different depending on the version of Visual Studio you have installed:

  • Wenn Sie Visual Studio 2012 verwenden, erstellen Sie eine localdb-Datenbank.If you are using Visual Studio 2012 then you'll be creating a LocalDB database.
  • Wenn Sie Visual Studio 2010 verwenden, erstellen Sie eine SQL Express-Datenbank.If you are using Visual Studio 2010 you'll be creating a SQL Express database.

Nun generieren wir die Datenbank.Let's go ahead and generate the database.

  • Öffnen Sie Visual Studio.Open Visual Studio
  • Ansicht- > Server-ExplorerView -> Server Explorer
  • Klicken Sie mit der rechten Maustaste auf Datenverbindungen- > Verbindung hinzufügen...Right click on Data Connections -> Add Connection…
  • Wenn Sie über Server-Explorer keine Verbindung mit einer Datenbank hergestellt haben, müssen Sie Microsoft SQL Server als Datenquelle auswählen.If you haven’t connected to a database from Server Explorer before you’ll need to select Microsoft SQL Server as the data source
  • Stellen Sie eine Verbindung mit localdb oder SQL Express her, je nachdem, welche installiert wurde.Connect to either LocalDB or SQL Express, depending on which one you have installed
  • Geben Sie stesample als Datenbanknamen ein.Enter STESample as the database name
  • Wählen Sie OK aus, und Sie werden gefragt, ob Sie eine neue Datenbank erstellen möchten, und wählen Sie Ja aus.Select OK and you will be asked if you want to create a new database, select Yes
  • Die neue Datenbank wird nun in Server-ExplorerThe new database will now appear in Server Explorer
  • Wenn Sie Visual Studio 2012 verwendenIf you are using Visual Studio 2012
    • Klicken Sie im Server-Explorer mit der rechten Maustaste auf die Datenbank, und wählen Sie Neue Abfrage aus.Right-click on the database in Server Explorer and select New Query
    • Kopieren Sie den folgenden SQL-Befehl in die neue Abfrage, klicken Sie mit der rechten Maustaste auf die Abfrage, und wählen Sie Ausführen .Copy the following SQL into the new query, then right-click on the query and select Execute
  • Wenn Sie Visual Studio 2010 verwendenIf you are using Visual Studio 2010
    • Wählen Sie Data- > Transact SQL-Editor- > neue Abfrage Verbindung...Select Data -> Transact SQL Editor -> New Query Connection...
    • Geben Sie ein . \ SQLExpress als Servername, und klicken Sie auf OK .Enter .\SQLEXPRESS as the server name and click OK
    • Wählen Sie in der Dropdown-Datei am oberen Rand des Abfrage-Editors die stesample -Datenbank aus.Select the STESample database from the drop down at the top of the query editor
    • Kopieren Sie das folgende SQL in die neue Abfrage, klicken Sie mit der rechten Maustaste auf die Abfrage, und wählen Sie SQL ausführen aus.Copy the following SQL into the new query, then right-click on the query and select Execute SQL
    CREATE TABLE [dbo].[Blogs] (
        [BlogId] INT IDENTITY (1, 1) NOT NULL,
        [Name] NVARCHAR (200) NULL,
        [Url]  NVARCHAR (200) NULL,
        CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
    );

    CREATE TABLE [dbo].[Posts] (
        [PostId] INT IDENTITY (1, 1) NOT NULL,
        [Title] NVARCHAR (200) NULL,
        [Content] NTEXT NULL,
        [BlogId] INT NOT NULL,
        CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
        CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
    );

    SET IDENTITY_INSERT [dbo].[Blogs] ON
    INSERT INTO [dbo].[Blogs] ([BlogId], [Name], [Url]) VALUES (1, N'ADO.NET Blog', N'blogs.msdn.com/adonet')
    SET IDENTITY_INSERT [dbo].[Blogs] OFF
    INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'Intro to EF', N'Interesting stuff...', 1)
    INSERT INTO [dbo].[Posts] ([Title], [Content], [BlogId]) VALUES (N'What is New', N'More interesting stuff...', 1)

Erstellen des ModellsCreate the Model

Zuerst wird ein Projekt benötigt, in das das Modell eingefügt werden kann.First up, we need a project to put the model in.

  • Datei- > New- > Project...File -> New -> Project...
  • Wählen Sie im linken Bereich **Visual C # ** und dann Klassenbibliothek aus.Select Visual C# from the left pane and then Class Library
  • Geben Sie stesample als Name ein, und klicken Sie auf OK .Enter STESample as the name and click OK

Im EF-Designer erstellen wir nun ein einfaches Modell für den Zugriff auf unsere Datenbank:Now we'll create a simple model in the EF Designer to access our database:

  • Project- > Neues Element hinzufügen...Project -> Add New Item...
  • Wählen Sie im linken Bereich Daten aus, und klicken Sie dann auf ADO.NET Entity Data ModelSelect Data from the left pane and then ADO.NET Entity Data Model
  • Geben Sie als Name bloggingmodel ein, und klicken Sie auf OK .Enter BloggingModel as the name and click OK
  • Wählen Sie aus Datenbank generieren aus , und klicken Sie auf weiterSelect Generate from database and click Next
  • Geben Sie die Verbindungsinformationen für die Datenbank ein, die Sie im vorherigen Abschnitt erstellt haben.Enter the connection information for the database that you created in the previous section
  • Geben Sie bloggingcontext als Namen für die Verbindungs Zeichenfolge ein, und klicken Sie auf weiter .Enter BloggingContext as the name for the connection string and click Next
  • Aktivieren Sie das Kontrollkästchen neben Tabellen und klicken Sie auf Fertig stellen.Check the box next to Tables and click Finish

An ste-Code Generierung austauschenSwap to STE Code Generation

Nun müssen Sie die Standard Codegenerierung und den Austausch in Self-Tracking Entitäten deaktivieren.Now we need to disable the default code generation and swap to Self-Tracking Entities.

Wenn Sie Visual Studio 2012 verwendenIf you are using Visual Studio 2012

  • Erweitern Sie in Projektmappen-Explorer den Eintrag bloggingmodel. edmx , und löschen Sie die BloggingModel.tt und BloggingModel.Context.tt dadurch wird die Standard Codegenerierung deaktiviert .Expand BloggingModel.edmx in Solution Explorer and delete the BloggingModel.tt and BloggingModel.Context.tt This will disable the default code generation
  • Klicken Sie mit der rechten Maustaste auf einen leeren Bereich auf der EF-Designer Oberfläche, und wählen Sie Code Generierungs Element hinzufügen aus.Right-click an empty area on the EF Designer surface and select Add Code Generation Item...
  • Wählen Sie im linken Bereich Online aus, und suchen Sie nach ste Generator .Select Online from the left pane and search for STE Generator
  • Wählen Sie die Vorlage ste Generator # für C aus , geben Sie stetemplate als Namen ein, und klicken Sie auf HinzufügenSelect the STE Generator for C# template, enter STETemplate as the name and click Add
  • Die Dateien STETemplate.tt und STETemplate.Context.tt werden unter der Datei bloggingmodel. edmx hinzugefügt.The STETemplate.tt and STETemplate.Context.tt files are added nested under the BloggingModel.edmx file

Wenn Sie Visual Studio 2010 verwendenIf you are using Visual Studio 2010

  • Klicken Sie mit der rechten Maustaste auf einen leeren Bereich auf der EF-Designer Oberfläche, und wählen Sie Code Generierungs Element hinzufügen aus.Right-click an empty area on the EF Designer surface and select Add Code Generation Item...
  • Wählen Sie im linken Bereich Code aus, und klicken Sie dann auf ADO.net Self-Tracking Entity GeneratorSelect Code from the left pane and then ADO.NET Self-Tracking Entity Generator
  • Geben Sie stetemplate als Name ein, und klicken Sie auf HinzufügenEnter STETemplate as the name and click Add
  • Die Dateien STETemplate.tt und STETemplate.Context.tt werden direkt dem Projekt hinzugefügt.The STETemplate.tt and STETemplate.Context.tt files are added directly to your project

Verschieben von Entitäts Typen in ein separates ProjektMove Entity Types into Separate Project

Um Self-Tracking Entitäten verwenden zu können, benötigt unsere Client Anwendung Zugriff auf die vom Modell generierten Entitäts Klassen.To use Self-Tracking Entities our client application needs access to the entity classes generated from our model. Da wir das gesamte Modell nicht für die Client Anwendung verfügbar machen möchten, verschieben wir die Entitäts Klassen in ein separates Projekt.Because we don't want to expose the whole model to the client application we're going to move the entity classes into a separate project.

Im ersten Schritt wird das Erstellen von Entitäts Klassen im vorhandenen Projekt beendet:The first step is to stop generating entity classes in the existing project:

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf STETemplate.tt , und wählen Sie EigenschaftenRight-click on STETemplate.tt in Solution Explorer and select Properties
  • Löschen Sie im Eigenschaften Fenster TextTemplatingFileGenerator aus der CustomTool -Eigenschaft.In the Properties window clear TextTemplatingFileGenerator from the CustomTool property
  • Erweitern Sie in Projektmappen-Explorer den Eintrag STETemplate.tt , und löschen Sie alle Dateien, die darin gespeichert sindExpand STETemplate.tt in Solution Explorer and delete all files nested under it

Als Nächstes fügen wir ein neues Projekt hinzu und generieren die Entitäts Klassen darin.Next, we are going to add a new project and generate the entity classes in it

  • Datei- > Add- > Project...File -> Add -> Project...

  • Wählen Sie im linken Bereich **Visual C # ** und dann Klassenbibliothek aus.Select Visual C# from the left pane and then Class Library

  • Geben Sie stesample. Entities als Name ein, und klicken Sie auf OK .Enter STESample.Entities as the name and click OK

  • Project- > Vorhandenes Element hinzufügen...Project -> Add Existing Item...

  • Navigieren Sie zum Projektordner " stesample ".Navigate to the STESample project folder

  • Wählen Sie diese Option aus, um **alle Dateien anzuzeigen * . * **Select to view All Files (*.*)

  • Wählen Sie die Datei STETemplate.tt aus.Select the STETemplate.tt file

  • Klicken Sie auf den Dropdown Pfeil neben der Schaltfläche Hinzufügen , und wählen Sie als Link hinzufügen aus.Click on the drop down arrow next to the Add button and select Add As Link

    Verknüpfte Vorlage hinzufügen

Wir stellen auch sicher, dass die Entitäts Klassen im gleichen Namespace wie der Kontext generiert werden.We're also going to make sure the entity classes get generated in the same namespace as the context. Dadurch wird lediglich die Anzahl der using-Anweisungen reduziert, die wir in der gesamten Anwendung hinzufügen müssen.This just reduces the number of using statements we need to add throughout our application.

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf die verknüpfte STETemplate.tt , und wählen Sie EigenschaftenRight-click on the linked STETemplate.tt in Solution Explorer and select Properties
  • Legen Sie im Eigenschaften Fenster benutzerdefinierter Tool Namespace auf stesample fest.In the Properties window set Custom Tool Namespace to STESample

Der von der ste-Vorlage generierte Code benötigt einen Verweis auf " System. Runtime. Serialization ", damit er kompiliert werden kann.The code generated by the STE template will need a reference to System.Runtime.Serialization in order to compile. Diese Bibliothek wird für die WCF DataContract -und DataMember -Attribute benötigt, die für die serialisierbaren Entitäts Typen verwendet werden.This library is needed for the WCF DataContract and DataMember attributes that are used on the serializable entity types.

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt stesample. Entities , und wählen Sie Verweis hinzufügen...Right click on the STESample.Entities project in Solution Explorer and select Add Reference...
    • Aktivieren Sie in Visual Studio 2012 das Kontrollkästchen neben System. Runtime. Serialization , und klicken Sie auf OK .In Visual Studio 2012 - check the box next to System.Runtime.Serialization and click OK
    • Wählen Sie in Visual Studio 2010 die Option System. Runtime. Serialization aus, und klicken Sie auf OK .In Visual Studio 2010 - select System.Runtime.Serialization and click OK

Schließlich benötigt das Projekt mit unserem Kontext darin einen Verweis auf die Entitäts Typen.Finally, the project with our context in it will need a reference to the entity types.

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt stesample , und wählen Sie Verweis hinzufügen aus.Right click on the STESample project in Solution Explorer and select Add Reference...
    • Wählen Sie in Visual Studio 2012 im linken Bereich Projekt Mappe aus, Aktivieren Sie das Kontrollkästchen neben stesample. Entities , und klicken Sie auf OK .In Visual Studio 2012 - select Solution from the left pane, check the box next to STESample.Entities and click OK
    • Wählen Sie in Visual Studio 2010 die Registerkarte Projekte aus, wählen Sie stesample. Entities aus, und klicken Sie auf OK .In Visual Studio 2010 - select the Projects tab, select STESample.Entities and click OK

Hinweis

Eine weitere Möglichkeit zum Verschieben der Entitäts Typen in ein separates Projekt besteht darin, die Vorlagen Datei zu verschieben, anstatt Sie von Ihrem Standard Speicherort zu verknüpfen.Another option for moving the entity types to a separate project is to move the template file, rather than linking it from its default location. Wenn Sie dies tun, müssen Sie die Variable " inputFile " in der Vorlage aktualisieren, um den relativen Pfad zur EDMX-Datei bereitzustellen (in diesem Beispiel: . \ Bloggingmodel. edmx).If you do this, you will need to update the inputFile variable in the template to provide the relative path to the edmx file (in this example that would be ..\BloggingModel.edmx).

Erstellen eines WCF-DienstanbieterCreate a WCF Service

Nun ist es an der Zeit, einen WCF-Dienst hinzuzufügen, um unsere Daten verfügbar zu machen. wir beginnen mit der Erstellung des Projekts.Now it's time to add a WCF Service to expose our data, we'll start by creating the project.

  • Datei- > Add- > Project...File -> Add -> Project...
  • Wählen Sie im linken Bereich **Visual C # ** und dann WCF-Dienst Anwendung aus.Select Visual C# from the left pane and then WCF Service Application
  • Geben Sie stesample. Service als Name ein, und klicken Sie auf OK .Enter STESample.Service as the name and click OK
  • Fügen Sie einen Verweis auf die System. Data. Entity -Assembly hinzu.Add a reference to the System.Data.Entity assembly
  • Hinzufügen eines Verweises auf die Projekte " stesample " und " stesample. Entities "Add a reference to the STESample and STESample.Entities projects

Wir müssen die EF-Verbindungs Zeichenfolge in dieses Projekt kopieren, damit Sie zur Laufzeit gefunden wird.We need to copy the EF connection string to this project so that it is found at runtime.

  • Öffnen Sie die App.Config -Datei für das **stesample **-Projekt, und kopieren Sie das connectionStrings -Element.Open the App.Config file for the **STESample **project and copy the connectionStrings element
  • Fügen Sie das connectionStrings -Element als untergeordnetes Element des Configuration -Elements der Web.Config Datei im stesample. Service -Projekt ein.Paste the connectionStrings element as a child element of the configuration element of the Web.Config file in the STESample.Service project

Nun ist es an der Zeit, den eigentlichen Dienst zu implementieren.Now it's time to implement the actual service.

  • Öffnen Sie IService1.cs , und ersetzen Sie den Inhalt durch den folgenden Code:Open IService1.cs and replace the contents with the following code
    using System.Collections.Generic;
    using System.ServiceModel;

    namespace STESample.Service
    {
        [ServiceContract]
        public interface IService1
        {
            [OperationContract]
            List<Blog> GetBlogs();

            [OperationContract]
            void UpdateBlog(Blog blog);
        }
    }
  • Öffnen Sie Service1. svc , und ersetzen Sie den Inhalt durch den folgenden Code.Open Service1.svc and replace the contents with the following code
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Linq;

    namespace STESample.Service
    {
        public class Service1 : IService1
        {
            /// <summary>
            /// Gets all the Blogs and related Posts.
            /// </summary>
            public List<Blog> GetBlogs()
            {
                using (BloggingContext context = new BloggingContext())
                {
                    return context.Blogs.Include("Posts").ToList();
                }
            }

            /// <summary>
            /// Updates Blog and its related Posts.
            /// </summary>
            public void UpdateBlog(Blog blog)
            {
                using (BloggingContext context = new BloggingContext())
                {
                    try
                    {
                        // TODO: Perform validation on the updated order before applying the changes.

                        // The ApplyChanges method examines the change tracking information
                        // contained in the graph of self-tracking entities to infer the set of operations
                        // that need to be performed to reflect the changes in the database.
                        context.Blogs.ApplyChanges(blog);
                        context.SaveChanges();

                    }
                    catch (UpdateException)
                    {
                        // To avoid propagating exception messages that contain sensitive data to the client tier
                        // calls to ApplyChanges and SaveChanges should be wrapped in exception handling code.
                        throw new InvalidOperationException("Failed to update. Try your request again.");
                    }
                }
            }        
        }
    }

Nutzen des dienstanwendungs aus einer KonsolenanwendungConsume the Service from a Console Application

Wir erstellen eine Konsolenanwendung, die unseren Dienst verwendet.Let's create a console application that uses our service.

  • Datei- > New- > Project...File -> New -> Project...
  • Wählen Sie im linken Bereich **Visual C # ** und dann Konsolenanwendung aus.Select Visual C# from the left pane and then Console Application
  • Geben Sie stesample. consoletest als Name ein, und klicken Sie auf OK .Enter STESample.ConsoleTest as the name and click OK
  • Hinzufügen eines Verweises auf das Projekt " stesample. Entities "Add a reference to the STESample.Entities project

Wir benötigen einen Dienst Verweis auf den WCF-Dienst.We need a service reference to our WCF service

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt stesample. consoletest , und wählen Sie Dienstverweis hinzufügen...Right-click the STESample.ConsoleTest project in Solution Explorer and select Add Service Reference...
  • Klicken Sie auf Ermitteln.Click Discover
  • Geben Sie bloggingservice als Namespace ein, und klicken Sie auf OK .Enter BloggingService as the namespace and click OK

Nun können wir Code schreiben, um den Dienst zu nutzen.Now we can write some code to consume the service.

  • Öffnen Sie Program.cs , und ersetzen Sie den Inhalt durch den folgenden Code.Open Program.cs and replace the contents with the following code.
    using STESample.ConsoleTest.BloggingService;
    using System;
    using System.Linq;

    namespace STESample.ConsoleTest
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Print out the data before we change anything
                Console.WriteLine("Initial Data:");
                DisplayBlogsAndPosts();

                // Add a new Blog and some Posts
                AddBlogAndPost();
                Console.WriteLine("After Adding:");
                DisplayBlogsAndPosts();

                // Modify the Blog and one of its Posts
                UpdateBlogAndPost();
                Console.WriteLine("After Update:");
                DisplayBlogsAndPosts();

                // Delete the Blog and its Posts
                DeleteBlogAndPost();
                Console.WriteLine("After Delete:");
                DisplayBlogsAndPosts();

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }

            static void DisplayBlogsAndPosts()
            {
                using (var service = new Service1Client())
                {
                    // Get all Blogs (and Posts) from the service
                    // and print them to the console
                    var blogs = service.GetBlogs();
                    foreach (var blog in blogs)
                    {
                        Console.WriteLine(blog.Name);
                        foreach (var post in blog.Posts)
                        {
                            Console.WriteLine(" - {0}", post.Title);
                        }
                    }
                }

                Console.WriteLine();
                Console.WriteLine();
            }

            static void AddBlogAndPost()
            {
                using (var service = new Service1Client())
                {
                    // Create a new Blog with a couple of Posts
                    var newBlog = new Blog
                    {
                        Name = "The New Blog",
                        Posts =
                        {
                            new Post { Title = "Welcome to the new blog"},
                            new Post { Title = "What's new on the new blog"}
                        }
                    };

                    // Save the changes using the service
                    service.UpdateBlog(newBlog);
                }
            }

            static void UpdateBlogAndPost()
            {
                using (var service = new Service1Client())
                {
                    // Get all the Blogs
                    var blogs = service.GetBlogs();

                    // Use LINQ to Objects to find The New Blog
                    var blog = blogs.First(b => b.Name == "The New Blog");

                    // Update the Blogs name
                    blog.Name = "The Not-So-New Blog";

                    // Update one of the related posts
                    blog.Posts.First().Content = "Some interesting content...";

                    // Save the changes using the service
                    service.UpdateBlog(blog);
                }
            }

            static void DeleteBlogAndPost()
            {
                using (var service = new Service1Client())
                {
                    // Get all the Blogs
                    var blogs = service.GetBlogs();

                    // Use LINQ to Objects to find The Not-So-New Blog
                    var blog = blogs.First(b => b.Name == "The Not-So-New Blog");

                    // Mark all related Posts for deletion
                    // We need to call ToList because each Post will be removed from the
                    // Posts collection when we call MarkAsDeleted
                    foreach (var post in blog.Posts.ToList())
                    {
                        post.MarkAsDeleted();
                    }

                    // Mark the Blog for deletion
                    blog.MarkAsDeleted();

                    // Save the changes using the service
                    service.UpdateBlog(blog);
                }
            }
        }
    }

Sie können die Anwendung jetzt ausführen, um sie in Aktion zu sehen.You can now run the application to see it in action.

  • Klicken Sie mit der rechten Maustaste auf das Projekt stesample. consoletest in Projektmappen-Explorer und wählen Sie Debuggen > neue Instanz starten aus.Right-click the STESample.ConsoleTest project in Solution Explorer and select Debug -> Start new instance

Die folgende Ausgabe wird angezeigt, wenn die Anwendung ausgeführt wird.You'll see the following output when the application executes.

Initial Data:
ADO.NET Blog
- Intro to EF
- What is New

After Adding:
ADO.NET Blog
- Intro to EF
- What is New
The New Blog
- Welcome to the new blog
- What's new on the new blog

After Update:
ADO.NET Blog
- Intro to EF
- What is New
The Not-So-New Blog
- Welcome to the new blog
- What's new on the new blog

After Delete:
ADO.NET Blog
- Intro to EF
- What is New

Press any key to exit...

Nutzen des dienstanwendungs aus einer WPF-AnwendungConsume the Service from a WPF Application

Erstellen Sie eine WPF-Anwendung, die unseren Dienst verwendet.Let's create a WPF application that uses our service.

  • Datei- > New- > Project...File -> New -> Project...
  • Wählen Sie im linken Bereich **Visual C # ** und dann WPF-Anwendung aus.Select Visual C# from the left pane and then WPF Application
  • Geben Sie stesample. wpftest als Name ein, und klicken Sie auf OK .Enter STESample.WPFTest as the name and click OK
  • Hinzufügen eines Verweises auf das Projekt " stesample. Entities "Add a reference to the STESample.Entities project

Wir benötigen einen Dienst Verweis auf den WCF-Dienst.We need a service reference to our WCF service

  • Klicken Sie in Projektmappen-Explorer mit der rechten Maustaste auf das Projekt stesample. wpftest , und wählen Sie Dienstverweis hinzufügen...Right-click the STESample.WPFTest project in Solution Explorer and select Add Service Reference...
  • Klicken Sie auf Ermitteln.Click Discover
  • Geben Sie bloggingservice als Namespace ein, und klicken Sie auf OK .Enter BloggingService as the namespace and click OK

Nun können wir Code schreiben, um den Dienst zu nutzen.Now we can write some code to consume the service.

  • Öffnen Sie " MainWindow. XAML ", und ersetzen Sie den Inhalt durch den folgenden Code.Open MainWindow.xaml and replace the contents with the following code.
    <Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:STESample="clr-namespace:STESample;assembly=STESample.Entities"
        mc:Ignorable="d" x:Class="STESample.WPFTest.MainWindow"
        Title="MainWindow" Height="350" Width="525" Loaded="Window_Loaded">

        <Window.Resources>
            <CollectionViewSource
                x:Key="blogViewSource"
                d:DesignSource="{d:DesignInstance {x:Type STESample:Blog}, CreateList=True}"/>
            <CollectionViewSource
                x:Key="blogPostsViewSource"
                Source="{Binding Posts, Source={StaticResource blogViewSource}}"/>
        </Window.Resources>

        <Grid DataContext="{StaticResource blogViewSource}">
            <DataGrid AutoGenerateColumns="False" EnableRowVirtualization="True"
                      ItemsSource="{Binding}" Margin="10,10,10,179">
                <DataGrid.Columns>
                    <DataGridTextColumn Binding="{Binding BlogId}" Header="Id" Width="Auto" IsReadOnly="True" />
                    <DataGridTextColumn Binding="{Binding Name}" Header="Name" Width="Auto"/>
                    <DataGridTextColumn Binding="{Binding Url}" Header="Url" Width="Auto"/>
                </DataGrid.Columns>
            </DataGrid>
            <DataGrid AutoGenerateColumns="False" EnableRowVirtualization="True"
                      ItemsSource="{Binding Source={StaticResource blogPostsViewSource}}" Margin="10,145,10,38">
                <DataGrid.Columns>
                    <DataGridTextColumn Binding="{Binding PostId}" Header="Id" Width="Auto"  IsReadOnly="True"/>
                    <DataGridTextColumn Binding="{Binding Title}" Header="Title" Width="Auto"/>
                    <DataGridTextColumn Binding="{Binding Content}" Header="Content" Width="Auto"/>
                </DataGrid.Columns>
            </DataGrid>
            <Button Width="68" Height="23" HorizontalAlignment="Right" VerticalAlignment="Bottom"
                    Margin="0,0,10,10" Click="buttonSave_Click">Save</Button>
        </Grid>
    </Window>
  • Öffnen Sie den Code Behind für MainWindow (MainWindow.XAML.cs), und ersetzen Sie den Inhalt durch den folgenden Code.Open the code behind for MainWindow (MainWindow.xaml.cs) and replace the contents with the following code
    using STESample.WPFTest.BloggingService;
    using System.Collections.Generic;
    using System.Linq;
    using System.Windows;
    using System.Windows.Data;

    namespace STESample.WPFTest
    {
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
            }

            private void Window_Loaded(object sender, RoutedEventArgs e)
            {
                using (var service = new Service1Client())
                {
                    // Find the view source for Blogs and populate it with all Blogs (and related Posts)
                    // from the Service. The default editing functionality of WPF will allow the objects
                    // to be manipulated on the screen.
                    var blogsViewSource = (CollectionViewSource)this.FindResource("blogViewSource");
                    blogsViewSource.Source = service.GetBlogs().ToList();
                }
            }

            private void buttonSave_Click(object sender, RoutedEventArgs e)
            {
                using (var service = new Service1Client())
                {
                    // Get the blogs that are bound to the screen
                    var blogsViewSource = (CollectionViewSource)this.FindResource("blogViewSource");
                    var blogs = (List<Blog>)blogsViewSource.Source;

                    // Save all Blogs and related Posts
                    foreach (var blog in blogs)
                    {
                        service.UpdateBlog(blog);
                    }

                    // Re-query for data to get database-generated keys etc.
                    blogsViewSource.Source = service.GetBlogs().ToList();
                }
            }
        }
    }

Sie können die Anwendung jetzt ausführen, um sie in Aktion zu sehen.You can now run the application to see it in action.

  • Klicken Sie mit der rechten Maustaste auf das Projekt stesample. wpftest in Projektmappen-Explorer und wählen Sie Debuggen > neue Instanz starten aus.Right-click the STESample.WPFTest project in Solution Explorer and select Debug -> Start new instance
  • Sie können die Daten mithilfe des Bildschirms bearbeiten und mithilfe der Schaltfläche " Speichern " über den Dienst speichern.You can manipulate the data using the screen and save it via the service using the Save button

WPF-Hauptfenster