Qual è il modo migliore per gestire le dipendenze circolari tra gli oggetti?

Question

Nel mio codice, ho le seguenti oggetti:

• ErrorManager - controlla il modo in errori vengono registrati nell'applicazione
• configmanager - controlla come si ottiene le informazioni di configurazione

On Nel progetto su cui sto lavorando, ErrorManager deve estrarre le informazioni di configurazione utilizzando l'istanza di ConfigManager mentre ConfigManager utilizza l'ErrorManager in caso di errore.

Al momento, sto facendo quanto segue in codice:

ErrorManager _errorManager = new CustomErrorManager(); 
ConfigManager _configManager = new CustomConfigManager(_errorManager); 
_errorManager.SetConfigurationManager(_configManager); 

C'è un modo per me per ripulire questo riferimento circolare delle dipendenze?

Answer 1

vorrei creare la seguente:

ErrorConfig _errorConfig = ...; 
// ErrorConfig is a new config object containing only ErrorManager Configuration 
ErrorManager _errorManager = new CustomErrorManager(_errorConfig); 
ConfigManager _configManager = new CustomConfigManager(_errorManager); 

Ora, il ConfigManager può può utilizzare il ready-to-run ErrorManager senza problemi il bootstrap in cui il ErrorManager non è pronto per gestire gli errori.

Answer 2

I riferimenti circolari di solito vengono ripuliti meglio rifattorizzando una terza classe da cui dipendono entrambi. Ad esempio, potresti avere qualcosa di simile a questo:

BootstrapConfigManager _bcm = new BootstrapConfigManager(); 
ErrorManager _errorManager = new CustomErrorManager(_bcm); 
ConfigManager _configManager = new CustomConfigManager(_bcm, _errorManager); 

Answer 3

Rif. Codice. Probabilmente puoi suddividere le classi per isolare una porzione che puoi inizializzare per prima e passare ad entrambe le classi.

Answer 4

Vorrei creare un metodo di estensione per ogni AddRelationship chiamato, passando l'altro oggetto come parametro.

L'oggetto passato aggiungerebbe il rapporto e quindi chiamare il metodo AddRelationship dell'altro:

static void AddRelationship(this ConfigManager configMgr, ErrorManager errMgr) 
{ 
    this.ErrorManager = errMgr; 
    if (this != errMgr.ConfigManager) 
     errMgr.AddRelationship(this); 
} 

static void AddRelationship(this ErrorManager errMgr, ConfigManager configMgr) 
{ 
    this.ConfigManager = configMgr; 
    if (this != configManager.errMgr) 
     configMgr.AddRelationship(this); 
} 

Questo significa che è possibile aggiungere il rapporto utilizzando oggetto.

ConfigManager cfg = new ConfigManager(); 
ErrorManager err = new ErrorManager(); 
//Assign using either: 
err.AddRelationship(cfg); 
//Or 
cfg.AddRelationship(err); 

È inoltre necessario creare estensioni RemoveRelationship.

static void RemoveRelationship(this ConfigManager configMgr, ErrorManager errMgr) 
{ 
    if (this.errorManager == errMgr) 
    { 
     this.errorManager = null; 
     if (errManager.configManager == this) 
      errMgr.RemoveRelationship(this); 
    } 
} 

static void RemoveRelationship(this ErrorManager errMgr, ConfigManager cfgMgr) 
{ 
    if (this.ConfigManager == cfgMgr) 
    { 
     this.configManager = null; 
     if (cfgMgr.errorManager == this) 
      cfgMgr.RemoveRelationship(this); 
    } 
} 

Non so che i riferimenti circolari sono un particolarmente buona pratica di codifica, ma questo dovrebbe risolvere la questione come chiesto.