Wprowadzenie do podstawowych EF w aplikacji konsoli .NET Core nowej bazy danychGetting Started with EF Core on .NET Core Console App with a New database

W tym przewodniku spowoduje utworzenie aplikacji konsoli .NET Core, który wykonuje dostęp do podstawowych danych względem bazy danych SQLite przy użyciu programu Entity Framework Core.In this walkthrough, you will create a .NET Core console app that performs basic data access against a SQLite database using Entity Framework Core. Migracje użyje do utworzenia bazy danych z modelu.You will use migrations to create the database from your model. Zobacz platformy ASP.NET Core - nową bazę danych dla wersji programu Visual Studio przy użyciu platformy ASP.NET Core MVC.See ASP.NET Core - New database for a Visual Studio version using ASP.NET Core MVC.

Uwaga

.NET Core SDK nie obsługuje już project.json lub programu Visual Studio 2015.The .NET Core SDK no longer supports project.json or Visual Studio 2015. Firma Microsoft zaleca migracji z project.json do csproj.We recommend you migrate from project.json to csproj. Jeśli używasz programu Visual Studio, zaleca się migrowanie do programu Visual Studio 2017.If you are using Visual Studio, we recommend you migrate to Visual Studio 2017.

Porada

Można wyświetlić w tym artykule próbki w witrynie GitHub.You can view this article's sample on GitHub.

Wstępnie wymagane składnikiPrerequisites

Do przeprowadzenia tego instruktażu potrzebne są następujące wymagania wstępne:The following prerequisites are needed to complete this walkthrough:

  • System operacyjny obsługuje .NET Core.An operating system that supports .NET Core.
  • .NET Core SDK 2.0 (mimo że instrukcje może służyć do tworzenia aplikacji z poprzedniej wersji z bardzo kilka zmian).The .NET Core SDK 2.0 (although the instructions can be used to create an application with a previous version with very few modifications).

Tworzenie nowego projektuCreate a new project

  • Utwórz nową ConsoleApp.SQLite folderu projektu i użyj dotnet polecenie, aby umieścić w nim aplikacji .NET Core.Create a new ConsoleApp.SQLite folder for your project and use the dotnet command to populate it with a .NET Core app.
mkdir ConsoleApp.SQLite
cd ConsoleApp.SQLite/
dotnet new console

Zainstaluj program Entity Framework CoreInstall Entity Framework Core

Aby użyć EF podstawowe, należy zainstalować pakiet dla powszechne bazy danych, który ma być docelowa.To use EF Core, install the package for the database provider(s) you want to target. W tym przewodniku zastosowano SQLite.This walkthrough uses SQLite. Lista dostępnych dostawców dostawcy bazy danych.For a list of available providers see Database Providers.

  • Zainstaluj Microsoft.EntityFrameworkCore.Sqlite i Microsoft.EntityFrameworkCore.DesignInstall Microsoft.EntityFrameworkCore.Sqlite and Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design
  • Ręcznie Edytuj ConsoleApp.SQLite.csproj dodać DotNetCliToolReference do Microsoft.EntityFrameworkCore.Tools.DotNet:Manually edit ConsoleApp.SQLite.csproj to add a DotNetCliToolReference to Microsoft.EntityFrameworkCore.Tools.DotNet:

    <ItemGroup>
      <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
    </ItemGroup>
    

    Uwaga: Przyszłej wersji dotnet będzie obsługiwać DotNetCliToolReferences za pośrednictwemdotnet add toolNote: A future version of dotnet will support DotNetCliToolReferences via dotnet add tool

ConsoleApp.SQLite.csprojteraz powinny zawierać następujące:ConsoleApp.SQLite.csproj should now contain the following:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.0.0" />
  </ItemGroup>
</Project>

Uwaga: Numery wersji użyta powyżej były prawidłowe w czasie publikowania.Note: The version numbers used above were correct at the time of publishing.

  • Uruchom dotnet restore do zainstalowania nowych pakietów.Run dotnet restore to install the new packages.

Tworzenie modeluCreate the model

Definiowanie kontekstu i jednostki klasy, które tworzą modelu.Define a context and entity classes that make up your model.

  • Utwórz nową Model.cs pliku z następującą zawartość.Create a new Model.cs file with the following contents.
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

namespace ConsoleApp.SQLite
{
    public class BloggingContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Data Source=blogging.db");
        }
    }

    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }

        public List<Post> Posts { get; set; }
    }

    public class Post
    {
        public int PostId { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }

        public int BlogId { get; set; }
        public Blog Blog { get; set; }
    }
}

Porada: W rzeczywistej aplikacji można będzie umieścić każda klasa w osobnym pliku, a ciąg połączenia w pliku konfiguracji.Tip: In a real application you would put each class in a separate file and put the connection string in a configuration file. Aby zachować samouczka proste, wprowadzamy wszystko w jednym pliku.To keep the tutorial simple, we are putting everything in one file.

Utwórz bazę danychCreate the database

Po utworzeniu modelu, można użyć migracje tworzenia bazy danych.Once you have a model, you can use migrations to create a database.

  • Uruchom dotnet ef migrations add InitialCreate utworzyć szkielet migracji do utworzenia wstępnego zestawu tabel dla modelu.Run dotnet ef migrations add InitialCreate to scaffold a migration and create the initial set of tables for the model.
  • Uruchom dotnet ef database update na zastosowanie nowych migracji w bazie danych.Run dotnet ef database update to apply the new migration to the database. To polecenie tworzy bazy danych przed zastosowaniem migracji.This command creates the database before applying migrations.

Uwaga

Używając ścieżek względnych z SQLite ścieżka będzie względem zestawu głównego aplikacji.When using relative paths with SQLite, the path will be relative to the application's main assembly. W tym przykładzie jest głównym pliku binarnego bin/Debug/netcoreapp2.0/ConsoleApp.SQLite.dll, więc będzie bazy danych SQLite w bin/Debug/netcoreapp2.0/blogging.db.In this sample, the main binary is bin/Debug/netcoreapp2.0/ConsoleApp.SQLite.dll, so the SQLite database will be in bin/Debug/netcoreapp2.0/blogging.db.

Użyj modeluUse your model

  • Otwórz Program.cs i Zastąp zawartość następującym kodem:Open Program.cs and replace the contents with the following code:

    using System;
    
    namespace ConsoleApp.SQLite
    {
        public class Program
        {
            public static void Main()
            {
                using (var db = new BloggingContext())
                {
                    db.Blogs.Add(new Blog { Url = "http://blogs.msdn.com/adonet" });
                    var count = db.SaveChanges();
                    Console.WriteLine("{0} records saved to database", count);
    
                    Console.WriteLine();
                    Console.WriteLine("All blogs in database:");
                    foreach (var blog in db.Blogs)
                    {
                        Console.WriteLine(" - {0}", blog.Url);
                    }
                }
            }
        }
    }
    
  • Testowanie aplikacji:Test the app:

    dotnet run

    Jeden blogu jest zapisywana w bazie danych i szczegółowe informacje o wszystkich blogi są wyświetlane w konsoli.One blog is saved to the database and the details of all blogs are displayed in the console.

    ConsoleApp.SQLite>dotnet run
    1 records saved to database
    
    All blogs in database:
     - http://blogs.msdn.com/adonet
    

Zmiana modelu:Changing the model:

  • Jeśli wprowadzisz zmiany w modelu, możesz użyć dotnet ef migrations add polecenie, aby utworzyć szkielet nowy migracji dokonanie odpowiedniej schematu zmiany w bazie danych.If you make changes to your model, you can use the dotnet ef migrations add command to scaffold a new migration to make the corresponding schema changes to the database. Po zaznaczeniu tej opcji szkieletu kodu (i wszelkie wymagane zmiany wprowadzone), można użyć dotnet ef database update polecenie, aby zastosować zmiany do bazy danych.Once you have checked the scaffolded code (and made any required changes), you can use the dotnet ef database update command to apply the changes to the database.
  • Używa EF __EFMigrationsHistory tabeli w bazie danych, aby śledzić migracji, które zostały już zastosowane do bazy danych.EF uses a __EFMigrationsHistory table in the database to keep track of which migrations have already been applied to the database.
  • SQLite nie obsługuje wszystkich migracji (zmiany schematu) ze względu na ograniczenia w SQLite.SQLite does not support all migrations (schema changes) due to limitations in SQLite. Zobacz ograniczenia SQLite.See SQLite Limitations. W przypadku nowych aplikacji rozważ porzucenie bazy danych i tworzenia nowego zamiast migracje po zmianie modelu.For new development, consider dropping the database and creating a new one rather than using migrations when your model changes.

Dodatkowe zasobyAdditional Resources