Apertura di un file SQL CE in fase di esecuzione con Entity Framework 4

Question

mi sto iniziato con Entity Framework 4, e ho una creazione di un'applicazione demo come un esercizio di apprendimento. L'applicazione è un semplice generatore di documentazione, e utilizza un negozio di SQL CE. Ogni progetto di documentazione ha il proprio file di dati SQL CE, e l'utente apre uno di questi file per lavorare su un progetto.

L'EDM è molto semplice. Un progetto di documentazione è composto da un elenco di soggetti, ognuno dei quali ha un titolo, una descrizione, e zero o più note. Così, i miei soggetti sono oggetto, che contiene titolo e il testo proprietà e nota, che ha titolo e il testo proprietà. V'è un'associazione uno-a-molti da soggetto a Nota.

Sto cercando di capire come aprire un file di dati SQL CE. Un file di dati deve corrispondere lo schema del database SQL CE creato da guidata database Create di EF4, e io implementerà un caso nuovo uso del file in altre parti del app per attuare tale requisito. In questo momento, sto solo cercando di ottenere un file di dati esistente aperto in app.

Ho riprodotto il mio codice esistente 'Apri File' di seguito. Ho configurarlo come una classe di servizio statico chiamato File Services . Il codice non funziona abbastanza ancora, ma c'è abbastanza per mostrare quello che sto cercando di fare. Sto cercando di tenere l'ObjectContext aperta per gli aggiornamenti degli oggetti entità, smaltimento quando il file viene chiuso.

Quindi, ecco la mia domanda: Perchè sono sulla strada giusta? Di cosa ho bisogno di cambiare per far funzionare questo codice con EF4? C'è un esempio di come farlo correttamente?

Grazie per il vostro aiuto.

Il mio codice esistente:

public static class FileServices
{
    #region Private Fields

    // Member variables
    private static EntityConnection m_EntityConnection;
    private static ObjectContext m_ObjectContext;

    #endregion

    #region Service Methods

    /// <summary>
    /// Opens an SQL CE database file.
    /// </summary>
    /// <param name="filePath">The path to the SQL CE file to open.</param>
    /// <param name="viewModel">The main window view model.</param>
    public static void OpenSqlCeFile(string filePath, MainWindowViewModel viewModel)
    {  
        // Configure an SQL CE connection string
        var sqlCeConnectionString = string.Format("Data Source={0}", filePath);

        // Configure an EDM connection string
        var builder = new EntityConnectionStringBuilder();
        builder.Metadata = "res://*/EF4Model.csdl|res://*/EF4Model.ssdl|res://*/EF4Model.msl";
        builder.Provider = "System.Data.SqlServerCe";
        builder.ProviderConnectionString = sqlCeConnectionString;
        var entityConnectionString = builder.ToString();

        // Connect to the model
        m_EntityConnection = new EntityConnection(entityConnectionString);
        m_EntityConnection.Open();

        // Create an object context
        m_ObjectContext = new Model1Container();

        // Get all Subject data
        IQueryable<Subject> subjects = from s in Subjects orderby s.Title select s;

        // Set view model data property
        viewModel.Subjects = new ObservableCollection<Subject>(subjects);
    }

    /// <summary>
    /// Closes an SQL CE database file.
    /// </summary>
    public static void CloseSqlCeFile()
    {
        m_EntityConnection.Close();
        m_ObjectContext.Dispose();
    }

    #endregion
}

Answer 1

Ecco la risposta. Ho semplificato il mio codice e corse sul modello più semplice EDM, Personaggi Disney . Modello dispone di due entità, Character e Child, con un 1: * associazione tra Character e Child. I bambini sono i bambini del personaggio - roba abbastanza semplice. Ho scritto la demo come una console app per tenerlo il più semplice possibile.

completo del codice in Program.cs è la seguente:

class Program
{
    static void Main(string[] args)
    {
        /* See http://social.msdn.microsoft.com/Forums/en-US/adodotnetentityframework/thread/8a89a728-6c8d-4734-98cb-11b196ba11fd */

        // Configure an SQL CE connection string 
        var filePath = @"D:\Users\dcveeneman\Documents\Visual Studio 2010\Demos\SqlCeEf4Demo\SqlCeEf4Demo\DisneyChars.sdf";
        var sqlCeConnectionString = string.Format("Data Source={0}", filePath);

        // Create an EDM connection
        var builder = new EntityConnectionStringBuilder();
        builder.Metadata = "res://*/DisneyChars.csdl|res://*/DisneyChars.ssdl|res://*/DisneyChars.msl";
        builder.Provider = "System.Data.SqlServerCe.3.5";
        builder.ProviderConnectionString = sqlCeConnectionString;
        var edmConnectionString = builder.ToString();
        var edmConnection = new EntityConnection(edmConnectionString);

        // Build and query an ObjectContext
        using (var context = new DisneyCharsContainer(edmConnection))
        {
            var chars = context.Characters;
            foreach(var character in chars)
            {
                Console.WriteLine("Character name: {0}", character.Name);
                foreach(var child in character.Children)
                {
                    Console.WriteLine("Child name: {0}", child.Name);
                }
            }
            Console.ReadLine();
        }
    }
}

nella parte superiore del codice è quello di un thread del forum che ho usato per scrivere il codice.

Ecco la procedura dettagliata: In primo luogo, creare una connessione al database. Dal momento che sto usando SQL CE, non ho un costruttore stringa di connessione - la stringa di connessione è semplicemente un percorso, quindi non ho bisogno di uno. Allora io uso un EntityConnectionStringBuilder per costruire una stringa di connessione entità, e poi io uso che per costruire un EntityConnection. Infine, mi passa la connessione al costruttore per la mia ObjectContext. Posso quindi utilizzare il ObjectContext per interrogare l'EDM.

Answer 2

Ricerca / apertura di un database SQL Server CE è, per qualche strana ragione, difficile da fare . Assicurarsi che è possibile effettuare qualsiasi tipo di connessione al DB a tutti prima di tentare di farlo funzionare con l'EF.