Come faccio ad implementare ganci / filtri / azioni all'interno della mia applicazione?

Ci sono molti modi per farlo in C #. Ecco un paio di loro:

Gli eventi C # sono ampiamente utilizzati da Win Form e Web Le forme. Questi sono molto simili ai gestori di interrupt, ma in realtà sono solo dei delegati (puntatori di funzioni).

// Declaration
public event EventHandler BeforeOrderPlaced;
public event EventHandler AfterOrderPlaced;

// Raising events
public void ProcessOrder()
{
    if (BeforeOrderPlaced != null)
        BeforeOrderPlaced(this, new EventArgs());

    PlaceOrder();

    if (AfterOrderPlaced != null)
        AfterOrderPlaced(this, new EventArgs());
}

// Subscribe to events
BeforeOrderPlaced += MyHandler;

private void MyHandler(object sender, EventArgs e)
{
   // do something before the order is placed
}

I metodi virtuali C # è l'approccio orientato agli oggetti.

public class OrderSystem
{
    // Defaults - do nothing
    public virtual void BeforeOrderPlaced() {}
    public virtual void AfterOrderPlaced() {}

    public void ProcessOrder()
    {
        BeforeOrderPlaced();
        PlaceOrder();
        AfterOrderPlaced();
    }
}

// Override the defaults to insert code before/after placing the order.
public class MyOrderSystem : OrderSystem
{
    public override void BeforeOrderPlaced()
    {
        // do something before the order is placed
    }    
}

Ciò di cui stai parlando è noto come multi-tenancy .

Ecco un modo per farlo:

1. Implementa funzionalità di base in classi non sigillate con metodi chiave definiti come virtuali. Immaginiamo per questo esempio che tutta la tua logica aziendale si trovi in una classe chiamata BaseBusinessLogic e che esiste un metodo chiamato DoSomething() .

2. Per funzionalità specifiche del cliente, scrivi classi che ereditano dalle classi base, sovrascrivendo i metodi virtuali secondo necessità. Se Kodak è uno dei tuoi clienti, forse la classe potrebbe essere definita come class KodakBusinessLogic : BaseBusinessLogic .

3. Crea una tabella di database che mappa i tenant (forse identificati da customer_code ) su DLL e classi. Ci sarebbero 3 colonne:

   customer_code - Qualunque tipo di dati che utilizzi

   custom_assembly: il nome della DLL, ad es. KodakBusinessLibrary.dll

   class_name: il nome della classe derivata che contiene la logica specifica del cliente (ad esempio KodakBusinessLogic )

4. Quando devi eseguire funzionalità che possono essere specifiche del cliente, chiama una stored procedure per ottenere custom_assembly e class_name per quel codice_cliente.

Quindi puoi istanziare la classe derivata in questo modo:

var asm = Assembly.LoadFile(custom_assembly);
var type = asm.GetType(class_name);
var o = Activator.CreateInstance(type) as BaseBusinessLogic;
if (o == null) throw new Exception("Couldn't load the custom logic.");

Esegui la logica specifica del cliente in questo modo:

o.DoSomething();

Anche se hai un riferimento a un oggetto BaseBusinessLogic, in realtà quel puntatore punta a un KodakBusinessLogic e chiamando DoSomething eseguirà il metodo sottoposto a override che contiene la logica per Kodak.

Ora, se non vuoi sovrascrivere il metodo stesso, puoi definire cose come questa:

class BaseBusinessLogic
{
    public void DoSomething() //notice it's not virtual
    {
        this.OnBeforeProcessing();
        //Execute basic logic here
        this.OnAfterProcessing();
    }

    abstract void OnBeforeProcessing();
    abstract void OnAfterProcessing();
}

Quindi nella tua classe derivata, devi solo eseguire l'override di OnBeforeProcessing e OnAfterProcessing.