Dove memorizzare i dati front-end per "calcolatrice oggetto"

Recentemente ho completato una libreria linguistica che funge da filtro gigante per gli articoli alimentari e scorre un po 'come questo :Products -> Recipes -> MenuItems -> Meals e infine, dopo l'invio, crea un Order .

Ho anche completato una struttura di database che memorizza tutte le informazioni pertinenti per ogni classe, e sembra adattarsi alle mie esigenze.

Il problema che sto avendo è quello di collegare i due. Ho immaginato che tutte le informazioni fossero locali per ogni istanza del prodotto, dove esiste un utente di back-end che modifica e manipola i dati e più utenti front-end che selezionano il loro Meal (s) per creare un Order . Idealmente, tutti gli utenti front-end avrebbero tutte queste informazioni memorizzate localmente all'interno della libreria e aggiornerebbero la libreria all'avvio da un database.

Come devo archiviare i dati in modo che possa caricarli nella libreria ogni volta che l'utente apre l'applicazione? Imballa un database a bordo e carico e popola ogni volta?

L'unico metodo che attualmente posso immaginare, anche se ho solo 500 possibili oggetti Product , richiederebbe di foreach l'elenco per ogni Product che devo associare a Recipe e quindi e così via ogni volta che rilancio il programma, che sembra un carico molto dispendioso.

Ecco un flusso generale della mia architettura:

Prodotti:

public class Product : IPortionable
{
    public Product(string n, uint pNumber = 0)
    {
        name = n;
        productNumber = pNumber;
    }


    public string name { get; set; }
    public uint productNumber { get; set; }
}

Ricette:

public Recipe(string n, decimal yieldAmt, Volume.Unit unit)
    {
        name = n;
        yield = new Volume(yieldAmt, unit);
        yield.ConvertUnit();
    }
    /// <summary>
    /// Creates a new ingredient object
    /// </summary>
    /// <param name="n">Name</param>
    /// <param name="yieldAmt">Recipe Yield</param>
    /// <param name="unit">Unit of Yield</param>
    public Recipe(string n, decimal yieldAmt, Weight.Unit unit)
    {
        name = n;
        yield = new Weight(yieldAmt, unit);
    }

    public Recipe(Recipe r)
    {
        name = r.name;
        yield = r.yield;
        ingredients = r.ingredients;
    }

    public string name { get; set; }
    public IMeasure yield;

    public Dictionary<IPortionable, IMeasure> ingredients = new Dictionary<IPortionable,IMeasure>();

MenuItems:

public abstract class MenuItem : IScalable
{
    public static string title = null;

    public string name { get; set; }
    public decimal maxPortionSize { get; set; }
    public decimal minPortionSize { get; set; }

    public Dictionary<IPortionable, IMeasure> ingredients = new Dictionary<IPortionable, IMeasure>();

e Pasto:

public class Meal
{
    public Meal(int guests)
    {
        guestCount = guests;
    }

    public int guestCount { get; private set; }

    //TODO: Make a new MainCourse class that holds pasta and Entree
    public Dictionary<string, int> counts = new Dictionary<string, int>(){
       {MainCourse.title, 0},
       {Side.title , 0},
       {Appetizer.title, 0}
    };

    public List<MenuItem> items = new List<MenuItem>();

Il Database memorizza e collega ciascuno di questi nomi di base e somma gli ID di utilizzo ( RecipeID, ProductID and MenuItemID )