Ordinamento dei metodi

0

Questo è il tipo di domanda che si potrebbe ottenere in un esame, ma ora capita di essere nella parola reale. :-) Apprezzerei qualche consiglio riguardo alla struttura dati / algoritmo che può essere usato per risolvere il seguente scenario.

Un po 'di background:

Ho un programma di controllo che legge il codice sorgente C # da un database, crea file sorgente C # e poi compila i file in una DLL. Quindi utilizza questa dll per eseguire calcoli su altri dati ottenuti dal database e scrive i risultati dei calcoli sul database.

Chiamiamo il programma di controllo, il motore e i file sorgente, i modelli. Il motore compila i modelli in una classe parziale TemplateCalculations in modo che ogni modello corrisponda a un metodo di quella classe. I modelli contengono codice che modificherà gli elementi. Gli elementi sono gli oggetti su cui verranno eseguiti i calcoli.

Ma ora, il problema attuale: Attualmente, il motore utilizza una lista nel database per vedere quale dovrebbe essere l'ordine in cui i modelli devono essere eseguiti. Il motore crea una classe Controller che gestisce le chiamate ai metodi nell'ordine corretto. I modelli contengono molte chiamate SetValue (elementName, elementValue) e GetValue (elementName). Ovviamente, non dovrebbe cercare di ottenere il valore dell'elemento, prima che abbia già impostato il valore.

Sfortunatamente, questa lista nel database che contiene la sequenza dei modelli viene a volte incasinata da una persona ignorante, e quindi i calcoli non vengono eseguiti correttamente.

Le chiamate SetValue e GetValue per un particolare elemento potrebbero o potrebbero non essere nello stesso file Template (o metodo di TemplateCalculations una volta che è stato compilato).

Supponiamo di avere qualcosa di simile al seguente:

Template A: Engine.SetValue(“Element2”, Engine.GetValue(“Element1”))
Template B: Engine.SetValue(“Element1”,1)

quindi la soluzione attuale avrebbe la lista nel database specifica che il Template B deve essere eseguito prima del Template A.

Inoltre, il datastructure sottostante per gli elementi e i valori durante l'esecuzione dei calcoli è un dizionario.

Ho i file sorgente disponibili nel motore, così come la DLL che esegue effettivamente l'esecuzione del calcolo. Cioè, prima avvio il motore e poi il motore controlla i calcoli. Ci può essere più di un SetValue per un particolare elemento.

Quindi, la domanda è: in che modo il motore sarà in grado di capire l'ordine dei modelli in modo che l'elenco non sia più necessario? Cioè, come posso determinare un ordine per i file modello, in modo che GetValue di un elemento non venga mai chiamato prima di un SetValue per esso?

Una soluzione più semplice sarebbe quella di determinare prima che l'ordine sia errato e di individuare quale elemento (su quale riga di codice) sta causando il problema. La soluzione più avanzata sarebbe quella di eliminare completamente l'elenco e lasciare che il motore determini l'ordine ottimale.

Penso vagamente che una specie di implementazione di un albero possa fare il trucco, ma è molto vaga. : -)

Fammi sapere se hai bisogno di ulteriori spiegazioni. Qualsiasi suggerimento sarebbe benvenuto.

    
posta Igavshne 07.11.2014 - 07:41
fonte

1 risposta

1

Se puoi avere più incarichi (chiamate SetValue) su un elemento, allora è semplicemente impossibile generare automaticamente l' ordine corretto di esecuzione dei modelli, per la semplice ragione che ci sono più ordini possibili che sono ugualmente validi.

Supponendo che tu abbia

Template A: Engine.SetValue(“Element2”, Engine.GetValue(“Element1”))
Template B: Engine.SetValue(“Element1”,1)
Template C: Engine.SetValue(“Element1”,2)

Senza ripetere un modello, ci sono 4 ordini ugualmente validi e senza conoscere l'intento dei calcoli, è impossibile stabilire quale sia l'ordine corretto. Se i modelli possono essere richiamati ripetutamente, il numero di possibilità aumenta solo.

Se ti viene dato un ordine o esegui i modelli, allora è possibile determinare se quell'ordine è valido (come in, tutti gli Elementi sono stati assegnati prima di essere usati). Questo è il tipo di analisi che i compilatori fanno per determinare se una variabile è stata inizializzata prima del suo primo utilizzo.

Se il tempo di esecuzione non ha molta importanza (ad esempio, se i calcoli vengono eseguiti automaticamente di notte e comunque non si vedranno i risultati fino al mattino successivo) e una corsa parziale non può danneggiare nulla, la soluzione più semplice è verificare in GetValue che l'elemento sia stato inserito nel dizionario con un valore e generare un'eccezione che annulla tutti i calcoli se non lo è.

Se è necessario eseguire la verifica in anticipo, esistono essenzialmente due opzioni:

  1. Si analizza il codice sorgente e si cammina l'albero di analisi nell'ordine in cui verranno eseguiti i modelli. Per ogni chiamata SetValue si registra quale elemento viene assegnato e per ogni chiamata GetValue si verifica che l'elemento di riferimento sia stato assegnato. Questo può essere ottenuto semplicemente mantenendo una tabella di ricerca di elementi assegnati / esistenti.
  2. Si implementa una modalità 'a secco', in cui si eseguono i modelli, ma si impedisce che tutte le modifiche visibili dall'esterno vengano propagate / commesse. Se tutte queste modifiche vengono apportate tramite chiamate al motore, questa potrebbe essere la soluzione più semplice.
risposta data 07.11.2014 - 08:32
fonte

Leggi altre domande sui tag