DI rispetto al modello di fabbrica? Tutti e due ? o un approccio diverso?

Question

DI rispetto al modello di fabbrica? Tutti e due ? o un approccio diverso?

#1 da (4 voti)

2

Diciamo che abbiamo una classe astratta chiamata BaseSwitch , ereditata da implementazioni concrete Switch A e Switch B , ogni switch rappresenta un interruttore di vita reale (uno strumento di telefonia che tra le sue responsabilità sta scrivendo CDR; tutti i record di dati delle chiamate che colpiscono l'interruttore).

Ogni switch nella vita reale scrive CDR in un formato diverso e in diverse fonti, ad esempio alcuni switch scrivono su un file di testo che un altro scrive su un database MySQL.

Gli switch come entità e dettagli CDR sono definiti dall'utente finale del sistema

Il mio obiettivo è scrivere Importer classi responsabili dell'importazione di CDR in base all'origine dei dati determinati dall'entità switch nel mio sistema, ma nascondendo Importer dalle classi switch.

Lo strato responsabile dell'importazione del CDR eseguirà un loop su switch e instatterà un oggetto "Importer", in base al formato CDR definito in ogni switch.

Qualcuno può suggerire un approccio da usare?

MODIFICA: Ulteriori chiarimenti di seguito:

SwitchBase di classe pubblica { public abstract string CDRFormat {get; } }

public class SwitchA:SwitchBase
{
    public override string abc
    {
        get { return "Text"; }
    }


}

public class SwitchB : SwitchBase
{
    public override string CDRFormat
    {
        get { return "MySQLDatabase"; }
    }
}


public class CDR
{ }

public class MySQLImporter
{
    ICollection<CDR> GetCDR()
    {
        //DoSomething
    }
}

public class TextImporter
{
    ICollection<CDR> GetCDR()
    {
        //DoSomething
    }
}

c# dependency-injection design-patterns asp.net

posta Siraj Mansour 30.01.2014 - 19:34

fonte

1 risposta

Leggi altre domande sui tag c# dependency-injection design-patterns asp.net

Criteri di accettazione del backlog del prodotto Perché le Entità non sono autorizzate a fare riferimento ad altre entità all'interno di un aggregato ad eccezione della radice?

score 4 · Accepted Answer

Il modello di fabbrica consente di creare oggetti con tipi diversi ma conformi alla stessa interfaccia da creare, il tipo specifico creato in base ad alcune condizioni. Sembra particolarmente appropriato qui.

Quindi crea alcuni metodi statici con sovraccarichi diversi che accettano ciascuno una firma di parametro diversa e restituiscono l'oggetto appropriato (polimorfismo), oppure creano un singolo metodo statico e inseriscono un'istruzione switch che passa a un parametro di metodo e restituisce l'oggetto appropriato.

public static class MyCDRFactory
{
    public static ICDRInterface Create(CDRFormat format)
    {
        switch (format)
            case CDRFormat.Alpha: return new CDRAlpha();

            case CDRFormat.Beta: return new CDRBeta();

        // ..etc
    }
}

% implementazioni diICDRInterface:

public Class CDRAlpha: ICDRInterface
{
    // Implementation for Alpha format goes here
}


public Class CDRBeta: ICDRInterface
{
    // Implementation for Beta Format goes here
}

Utilizzo:

var processor = MyCDRFactory.Create(CDRFormat.Alpha);