Implementare metodi parziali su più assiemi

Question

In una delle applicazioni su cui sto lavorando, sono incluse due funzionalità di base: Creazione e aggiornamento.

Tuttavia, v'è la necessità a volte di aggiungere codice personalizzato, così ho pensato di estendere il codice, consentendo 3 parti di scrivere e incorporare il proprio codice:

OnCreating OnCreated OnUpdating OnUpdated

C'è un modo per abilitare il sopra attraverso più assiemi? MEF potrebbe aiutare qui?

Grazie saluti

---

Grazie a tutti per le vostre risposte.

Avere una tale interfaccia significa che ogni assembly esterno deve implementare tale interfaccia secondo necessità. Quindi, il codice dell'applicazione, deve scorrere gli assembly attualmente in esecuzione, rilevare tutte le classi che implementano tale interfaccia ed eseguire i loro metodi?

MEF si adatta a questo? Posso esportare l'implementazione da assembly esterni e importarli nella mia app?

Grazie saluti

Answer 1

quanto riguarda la tua domanda MEF, probabilmente si potrebbe fare qualcosa di simile a quanto segue per eseguire i metodi di un'interfaccia:

var catalog = new DirectoryCatalog("bin"); 
var container = new CompositionContainer(catalog); 
container.ComposeParts(); 

var plugins = container.GetExportedValues<IPlugin>(); 
foreach (IPlugin plugin in plugins) 
{ 
    plugin.OnCreating(); 
} 

Oppure creare un'interfaccia con eventi come suggerito Brian Mains:

public interface IPlugin 
{ 
    event OnCreatingEventHandler OnCreating; 
} 

poi il codice sopra sarebbe più simile a:

var catalog = new DirectoryCatalog("bin"); 
var container = new CompositionContainer(catalog); 
container.ComposeParts(); 

var plugins = container.GetExportedValues<IPlugin>(); 
foreach (IPlugin plugin in plugins) 
{ 
    plugin.OnCreating += MyOnCreatingHandler; 
} 

Penso che mi piaccia e quest'ultimo per i nomi dei metodi specificati. Per il mio lavoro plug-in, ho creato un'interfaccia simile a quanto segue:.

public interface IPlugin 
{ 
    void Setup(); 
    void RegisterEntities(); 
    void SeedFactoryData(); 
} 

Il metodo RegisterEntities() estende lo schema del database in fase di esecuzione, e il metodo SeedFactoryData() aggiunge tutti i dati predefiniti (ad esempio l'aggiunta di utente predefinito, pre- popolazione della tabella delle città, ecc.).

Answer 2

Non si può avere classi partical accross assemblee perché le classi parziali sono una caratteristica del linguaggio, e non una caratteristica CLR. Il compilatore C# unisce tutte le classi parziali in una vera classe, e quella singola è l'unica cosa rimasta dopo la compilazione.

Hai un paio di alternative:

1. eventi offrono
2. Rendere i metodi virtuali e ignorare le
3. utilizzare un'interfaccia

Il tuo problema sembra si adatta eventi meglio. L'utente può semplicemente iscriversi a loro nell'altro assembly.

Answer 3

Avere classi parziali supportate tra gli assembly non è supportato.

Il motivo è che tutte le definizioni di classi parziali sono combinate in una singola classe durante la compilazione. Quella singola classe risiede in un unico assemblaggio.

Answer 4

I metodi e le classi parziali devono essere nello stesso assieme. I metodi parziali sono compilati se non utilizzati. Se hai bisogno di punti di estensione per le tue lezioni dovresti esaminare metodi o eventi virtuali.

Answer 5

Considerare l'utilizzo di un'interfaccia:

IUpdatableObject<X> 
    Creating(X obj); 
    Created(X obj); 
    Updating(X obj); 
    Updated(X obj); 

E poi utilizzare questa interfaccia per aggiungere nel codice personalizzato; ogni terza parte può implementare questa interfaccia (o è possibile o tramite un wrapper) e questo può essere un legame con l'aggiunta di una logica aziendale personalizzata.

HTH.

Answer 6

È (o l'utente) possono utilizzare metodi di estensione: http://msdn.microsoft.com/en-us/library/bb383977.aspx

Answer 7

classi parziali attraverso gruppi non sono supportati perché il concetto alla base della classe parziale è quello di permettere a più sviluppatori di contribuire metodi e membri diversi per lo stesso classe sotto un particolare spazio dei nomi.
Questo è stato fatto per aiutare gli sviluppatori a sincronizzare il codice in una singola classe, all'interno di un assembly, compilazione dopo la compilazione.