Domanda sulla progettazione dell'applicazione relativa al salvataggio dei file

L'idea di un libro di cucina è buona. Sembra che la tua applicazione funzionerà più o meno come un documento di word (wrt to file lifecycle).

Crea il tuo oggetto libro di cucina e ne hai uno alla radice relativa della tua applicazione (il modulo radice, immagino, non Program.cs). "currentCookBook" suona bene.

Come potrei controllare se un libro è aperto?

Sai se un utente sta lavorando o meno in un libro di cucina aperto in due modi:

• if (this.currentCookBook == null) {/ * nessun libro di cucina è aperto * /}
• if (this.currentCookBook == CookBook.NullObject) {/ * modello null-object * /}

Come potrei avere l'applicazione per creare il nuovo libro?

Easy peasy:

this.currentCookBook = new CookBook(); // or = CookBook.Empty;

Come potrei avere l'applicazione "Chiudi e dimentica" il libro che è stato chiuso, in modo che l'unico libro aperto sia il nuovo?

Crea un oggetto che è responsabile dell'IO dei libri di cucina.

internal CookBookIO
{
    public static void Save(CookBook cb, string filename) 
    { 
        /* writes cookbook to filename */
    }

    public static CookBook Open(string filename)
    {
        CookBook cb = new CookBook();

        /* read file and populate cb */

        return cb;
    }
}

Apri un libro di cucina in questo modo:

using (OpenFileDialog ofd = new OpenFileDialog() { /* properties */ })
{
    if (ofd.ShowDialog() == DialogResult.Cancel)
        return;

    this.currentCookBook = CookBookIO.Open(ofd.Filename);
}

... e salva (e chiudi) in questo modo:

using (SaveFileDialog sfd = new SaveFileDialog() { /* properties */ })
{
    if (sfd.ShowDialog() == DialogResult.Cancel)
        return;

    CookBookIO.Save(this.currentCookBook, sfd.Filename);
    if (saveAndClose)
    {
        this.currentCookBook = null; 
        // or this.currentCookBook = CookBook.NullObject;
        // or this.currentCookBook = CookBook.Empty; if you want to have it 
        // default to a new, open book upon saveAndClose
    }
}

Di solito questo tipo di cose viene fatto con un piccolo database. Non solo l'uso di un database significa che non devi preoccuparti troppo di tenere traccia degli stati dei file, puoi effettuare ricerche, rilevare ricette duplicate, tutto ciò che devi codificare da solo.

Se vuoi davvero fare tutto da solo, aggiungi una classe BookShelf che è responsabile della conoscenza di tutti i libri di cucina. Chiedi al BookShelf di avere un libro per te (aperto), di mettere via il libro, e il BookShelf gestirà tutti i dettagli di creare, aprire e chiudere.

In seguito, se ti sposti in un database, puoi fare in modo che BookShelf gestisca tutte le operazioni del DB e sei già ben configurato.

Per quanto riguarda il salvataggio, dovresti salvare una ricetta ogni volta che viene apportata una modifica e lasciare la pagina e dare anche un pulsante per consentire all'utente di salvare manualmente (li fa sentire meglio) ogni volta che lo desiderano.