Code First in un database esistente
Questa procedura dettagliata fornisce un'introduzione allo sviluppo Code First destinato a un database esistente. Code First consente di definire il modello usando C# o VB.Net classi. Facoltativamente, è possibile eseguire una configurazione aggiuntiva usando attributi per le classi e le proprietà o usando un'API Fluent.
Prerequisiti
Per completare questa procedura dettagliata, è necessario che Visual Studio 2012 o Visual Studio 2013 sia installato.
Sarà necessaria anche la versione 6.1 (o successiva) di Entity Framework Tools per Visual Studio installata. Per informazioni sull'installazione della versione più recente di Entity Framework Tools, vedere Ottenere Entity Framework .
1. Creare un database esistente
In genere, quando si ha come destinazione un database esistente, verrà già creato, ma per questa procedura dettagliata è necessario creare un database per l'accesso.
Procedere e generare il database.
Aprire Visual Studio.
Visualizzazione -> Esplora server
Fare clic con il pulsante destro del mouse su Data Connessione ions -> Aggiungi Connessione ion...
Se non si è connessi a un database da Esplora server prima di dover selezionare Microsoft SQL Server come origine dati
Connessione all'istanza di Local DB e immettere Blogging come nome del database
Selezionare OK e verrà chiesto se si vuole creare un nuovo database, selezionare Sì
Il nuovo database verrà visualizzato in Esplora server, fare clic con il pulsante destro del mouse su di esso e selezionare Nuova query
Copiare il codice SQL seguente nella nuova query, quindi fare clic con il pulsante destro del mouse sulla query e selezionare Esegui
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
);
INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('The Visual Studio Blog', 'http://blogs.msdn.com/visualstudio/')
INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('.NET Framework Blog', 'http://blogs.msdn.com/dotnet/')
2. Creare l'applicazione
Per semplificare le operazioni, verrà compilata un'applicazione console di base che usa Code First per eseguire l'accesso ai dati:
- Aprire Visual Studio.
- File -> Nuovo -> Progetto...
- Selezionare Windows dal menu a sinistra e applicazione console
- Immettere CodeFirstExistingDatabaseSample come nome
- seleziona OK.
3. Modello di reverse engineer
Verrà usato Entity Framework Tools per Visual Studio per generare codice iniziale per eseguire il mapping al database. Questi strumenti generano solo codice che è possibile digitare a mano se si preferisce.
Progetto -> Aggiungi nuovo elemento...
Selezionare Dati dal menu a sinistra e quindi ADO.NET Entity Data Model
Immettere BloggingContext come nome e fare clic su OK
Verrà avviata la Creazione guidata modello di dati di entità
Selezionare Code First dal database e fare clic su Avanti
Selezionare la connessione al database creato nella prima sezione e fare clic su Avanti
Fare clic sulla casella di controllo accanto a Tabelle per importare tutte le tabelle e fare clic su Fine
Una volta completato il processo di reverse engineer, al progetto saranno stati aggiunti alcuni elementi, di seguito verranno esaminati gli elementi aggiunti.
File di configurazione
Al progetto è stato aggiunto un file App.config, che contiene il stringa di connessione al database esistente.
<connectionStrings>
<add
name="BloggingContext"
connectionString="data source=(localdb)\mssqllocaldb;initial catalog=Blogging;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework"
providerName="System.Data.SqlClient" />
</connectionStrings>
Si noteranno anche altre impostazioni nel file di configurazione. Si tratta di impostazioni di Entity Framework predefinite che indicano a Code First dove creare i database. Poiché si esegue il mapping a un database esistente, queste impostazioni verranno ignorate nell'applicazione.
Contesto derivato
Al progetto è stata aggiunta una classe BloggingContext . Il contesto rappresenta una sessione con il database, consentendo di eseguire query e salvare i dati. Il contesto espone un oggetto DbSet<TEntity> per ogni tipo nel modello. Si noterà anche che il costruttore predefinito chiama un costruttore di base usando la sintassi name= . Indica a Code First che il stringa di connessione da usare per questo contesto deve essere caricato dal file di configurazione.
public partial class BloggingContext : DbContext
{
public BloggingContext()
: base("name=BloggingContext")
{
}
public virtual DbSet<Blog> Blogs { get; set; }
public virtual DbSet<Post> Posts { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
}
}
È consigliabile usare sempre la sintassi name= quando si usa un stringa di connessione nel file di configurazione. In questo modo, se il stringa di connessione non è presente, Entity Framework genererà un'eccezione anziché creare un nuovo database per convenzione.
Classi di modello
Infine, al progetto sono state aggiunte anche una classe Blog e Post . Si tratta delle classi di dominio che costituiscono il modello. Verranno visualizzate annotazioni di dati applicate alle classi per specificare la configurazione in cui le convenzioni Code First non sono allineate alla struttura del database esistente. Ad esempio, verrà visualizzata l'annotazione StringLength in Blog.Name e Blog.Url poiché hanno una lunghezza massima di 200 nel database (il valore predefinito Code First consiste nell'usare la lunghezza massima supportata dal provider di database - nvarchar(max) in SQL Server.
public partial class Blog
{
public Blog()
{
Posts = new HashSet<Post>();
}
public int BlogId { get; set; }
[StringLength(200)]
public string Name { get; set; }
[StringLength(200)]
public string Url { get; set; }
public virtual ICollection<Post> Posts { get; set; }
}
4. Lettura e scrittura di dati
Ora che è disponibile un modello, è possibile usarlo per accedere ad alcuni dati. Implementare il metodo Main in Program.cs , come illustrato di seguito. Questo codice crea una nuova istanza del contesto e quindi la usa per inserire un nuovo blog. Usa quindi una query LINQ per recuperare tutti i blog dal database ordinati alfabeticamente in base al titolo.
class Program
{
static void Main(string[] args)
{
using (var db = new BloggingContext())
{
// Create and save a new Blog
Console.Write("Enter a name for a new Blog: ");
var name = Console.ReadLine();
var blog = new Blog { Name = name };
db.Blogs.Add(blog);
db.SaveChanges();
// Display all Blogs from the database
var query = from b in db.Blogs
orderby b.Name
select b;
Console.WriteLine("All blogs in the database:");
foreach (var item in query)
{
Console.WriteLine(item.Name);
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
}
}
È ora possibile eseguire l'applicazione e testarla.
Enter a name for a new Blog: ADO.NET Blog
All blogs in the database:
.NET Framework Blog
ADO.NET Blog
The Visual Studio Blog
Press any key to exit...
Cosa succede se il database cambia?
La procedura guidata Code First to Database è progettata per generare un set di punti di partenza di classi che è quindi possibile modificare e modificare. Se lo schema del database cambia, è possibile modificare manualmente le classi o eseguire un altro reverse engineer per sovrascrivere le classi.
Uso di Migrazioni Code First a un database esistente
Per usare Migrazioni Code First con un database esistente, vedere Migrazioni Code First a un database esistente.
Riepilogo
In questa procedura dettagliata è stato esaminato lo sviluppo Code First usando un database esistente. È stato usato Entity Framework Tools per Visual Studio per eseguire il reverse engineer di un set di classi mappate al database e può essere usato per archiviare e recuperare i dati.
