Avrei dovuto usare un metodo di fabbrica anziché un costruttore. Posso cambiarlo ed essere ancora compatibile con le versioni precedenti?

Il problema

Diciamo che ho una classe chiamata DataSourceche fornisce un ReadDatametodo (e forse altri, ma manteniamo le cose semplici) per leggere i dati da un .mdbfile:

var source = new DataSource("myFile.mdb");
var data = source.ReadData();

Qualche anno dopo, decido di voler supportare i .xmlfile oltre ai .mdbfile come origini dati. L'implementazione per "leggere i dati" è abbastanza diversa per .xmle .mdbfile; quindi, se dovessi progettare il sistema da zero, lo definirei così:

abstract class DataSource {
    abstract Data ReadData();
    static DataSource OpenDataSource(string fileName) {
        // return MdbDataSource or XmlDataSource, as appropriate
    }
}

class MdbDataSource : DataSource {
    override Data ReadData() { /* implementation 1 */ }
}

class XmlDataSource : DataSource {
    override Data ReadData() { /* implementation 2 */ }
}

Fantastico, una perfetta implementazione del modello del metodo Factory. Sfortunatamente, DataSourcesi trova in una libreria e il refactoring del codice in questo modo interromperebbe tutte le chiamate esistenti

var source = new DataSource("myFile.mdb");

nei vari client usando la libreria. Guai a me, perché non ho usato un metodo di fabbrica in primo luogo?

soluzioni

Queste sono le soluzioni che potrei trovare:

1. Fare in modo che il costruttore DataSource restituisca un sottotipo ( MdbDataSourceo XmlDataSource). Ciò risolverebbe tutti i miei problemi. Sfortunatamente, C # non lo supporta.

2. Usa nomi diversi:

   abstract class DataSourceBase { ... }    // corresponds to DataSource in the example above
   
   class DataSource : DataSourceBase {      // corresponds to MdbDataSource in the example above
       [Obsolete("New code should use DataSourceBase.OpenDataSource instead")]
       DataSource(string fileName) { ... }
       ...
   }
   
   class XmlDataSource : DataSourceBase { ... }

   Questo è quello che ho finito per usare poiché mantiene il codice compatibile con le versioni precedenti (ovvero le chiamate new DataSource("myFile.mdb")funzionano ancora). Svantaggio: i nomi non sono così descrittivi come dovrebbero essere.

3. Crea DataSourceun "wrapper" per la vera implementazione:

   class DataSource {
       private DataSourceImpl impl;
   
       DataSource(string fileName) {
           impl = ... ? new MdbDataSourceImpl(fileName) : new XmlDataSourceImpl(fileName);
       }
   
       Data ReadData() {
           return impl.ReadData();
       }
   
       abstract private class DataSourceImpl { ... }
       private class MdbDataSourceImpl : DataSourceImpl { ... }
       private class XmlDataSourceImpl : DataSourceImpl { ... }
   }

   Svantaggio: ogni metodo di origine dei dati (come ReadData) deve essere instradato dal codice di boilerplate. Non mi piace il codice boilerplate. È ridondante e ingombra il codice.

C'è qualche soluzione elegante che mi è sfuggita?

Vorrei fare una variante alla tua seconda opzione che ti permetta di eliminare gradualmente il vecchio, troppo generico, nome DataSource:

abstract class AbstractDataSource { ... } // corresponds to the abstract DataSource in the ideal solution

class XmlDataSource : AbstractDataSource { ... }
class MdbDataSource : AbstractDataSource { ... } // contains all the code of the existing DataSource class

[Obsolete("New code should use AbstractDataSource instead")]
class DataSource : MdbDataSource { // an 'empty shell' to keep old code working.
    DataSource(string fileName) { ... }
}

L'unico inconveniente qui è che la nuova classe base non può avere il nome più ovvio, perché quel nome era già stato rivendicato per la classe originale e deve rimanere tale per la compatibilità con le versioni precedenti. Tutte le altre classi hanno i loro nomi descrittivi.

La soluzione migliore sarà qualcosa vicino alla tua opzione # 3. Mantieni il DataSourcepiù com'è adesso ed estrai solo la parte del lettore nella sua classe.

class DataSource {
    private Reader reader;

    DataSource(string fileName) {
        reader = ... ? new MdbReader(fileName) : new XmlReader(fileName);
    }

    Data ReadData() {
        return reader.next();
    }

    abstract private class Reader { ... }
    private class MdbReader : Reader { ... }
    private class XmlReader : Reader { ... }
}

In questo modo, eviti il ​​codice duplicato e sei aperto a ulteriori estensioni.