Domanda
Ho alcune classi definite dall'utente pubbliche con relazioni tra i membri e anche diversi metodi con firme specifiche e generiche.
Vorrei poter archiviare e manipolare il flusso di controllo personalizzato su queste classi (più le classi CLR) utilizzando istruzioni di controllo di base come if / then / else, foreach, do / while, assegnazioni di variabili, ecc.
Il flusso di controllo personalizzato deve essere creato in fase di esecuzione e quindi archiviato per uso e manipolazione successivi. L'idea è di avere una rappresentazione dei dati del flusso di controllo, possibilmente nella forma di un albero sintattico astratto, con una sintassi fortemente tipizzata per poter applicare le operazioni genetiche. Il codice personalizzato risultante deve essere eseguito come parte di un altro programma.
1) Qual è la rappresentazione di codice preferita per manipolare le operazioni genetiche e quindi eseguire il codice comprese le mie classi,
2) Quali tecnologie c # dovrei usare per il problema sopra riportato? So che ci sono tecnologie correlate come reflection, le nuove funzionalità di c # 3.0 (lambda, expression trees), CodeDom, libreria DLR, ecc. Ma quale approccio o combinazione è la più efficiente.
3) Esistono tali paradigmi o implementazioni?
EDIT: la piattaforma viene fornita con dati di tipi personalizzati c # definiti, sia costanti che variabili temporali.
Ogni momento vengono applicate regole ai dati (condizioni di base o funzioni più complicate) e si decide di intraprendere alcune azioni.
Mi piacerebbe essere in grado di:
Rappresenta le regole su un albero o un grafico ed esegue il flusso.
Crea serie di regole personalizzate dall'utente tramite un kit di strumenti dell'interfaccia utente
Riorganizza l'albero o il grafico e applica le operazioni GP
Risposta accettata
Reflection è la tecnologia per ispezionare tipi, metodi, campi, ecc. Già generati, quindi probabilmente non ti aiuterà molto per ora.
Gli alberi di espressione sono piuttosto interessanti, ma AFAIK non ti permettono di creare un flusso di programma complesso poiché un'espressione lambda non può avere un corpo, il che renderebbe piuttosto difficile creare qualcosa di moderatamente complesso.
La DLR è in qualche modo in divenire. Otterrete i bit e i pezzi, ma solo la prossima versione .NET avrà il supporto per il DLR. Potrebbe essere un'alternativa interessante, creando programmi al volo e eseguendoli.
Quello che potresti fare ora è probabilmente l'emissione di IL, in un metodo dinamico o in un assembly generato dinamicamente. Tutti i possibili costrutti dovrebbero essere disponibili, ma una successiva manipolazione è probabilmente piuttosto difficile.
Anche così, c'è un progetto che fa un po 'di magia di IL e potrebbe anche essere qualcosa che potrebbe esserti utile: LinFu . Secondo la lista hai un'implementazione di Dynamic Object e puoi fare cose come dynamicObject.CreateDuck <InterfaceType> ()
Un altro percorso che può essere un po 'pesante ma anche interessante è il framework WF (Workflow Foundation). Tali flussi di lavoro dovrebbero essere costruibili dal programma e possono essere interessanti a causa del loro funzionamento in continuazione: è possibile mantenere un flusso di lavoro in esecuzione in qualsiasi momento e riprenderlo proprio dove lo hai lasciato.
Tutte le strutture di programma tradizionali dovrebbero essere disponibili in WF.
Risposta popolare
Esegui semplicemente c # (di qualsiasi altro linguaggio .net che supporti questo, f # funziona egregiamente) e usa CodeDomProvider per compilarlo al volo. Forza il codice fornito per essere un file sorgente, per includere un tipo che implementa IDynamicEntryPoint (con un metodo statico o un costruttore vuoto che è il punto di ingresso e verrà invocato dopo la costruzione)
Questo dovrebbe essere il tuo primo punto di partenza per iniziare perché è veloce provare contemporaneamente a lungo termine con le migliori possibilità di ottenere le massime prestazioni (escludendo l'output di IL dinamico ma anche in questo caso potresti non battere il compilatore)
Questo ovviamente ha due possibili difetti che potrebbero essere degli interruttori:
- Il codice risultante è un incubo per la sicurezza, dovrebbe essere consentito solo l'input del codice da parte di utenti completamente fidati.
- Il codice compilato in modo dinamico è fragile per quanto riguarda le modifiche al codice / all'interfaccia (l'insieme di dll che il codice deve includere potrebbe cambiare / potrebbe non corrispondere) o la firma di IDynamicEntryPoint potrebbe cambiare.
A meno che tu non sia interessato a scrivere la tua lingua / parser / compilatore per divertirti, usa quello che c'è già.
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow