C# überladene Konstruktoren Problem

Question

Ich habe die folgende Klasse, die ich verwende, um Code-Duplizierung zu minimieren, wenn oft unterschiedliche Datensätze aus einer Oracle-Datenbank aufgerufen werden. In erster Linie brauche ich Hilfe, um die Code-Duplizierung im überladenen Konstruktor zu entfernen, aber jeder andere Rat würde auch geschätzt werden.

public class UniformData 
{ 
    private string connection = "My Connection String"; 
    private OracleConnection con; 
    private OracleCommand com; 
    private OracleDataReader reader; 

    public UniformData(string sql) 
    { 
     con = new OracleConnection(connection); 
     con.Open(); 
     com = new OracleCommand(sql, con); 
    } 

    public UniformData(string sql, List<SqlParameters> myParams) 
    { 
     con = new OracleConnection(connection); 
     con.Open(); 
     com = new OracleCommand(sql, con); 

     foreach (SqlParameters Param in myParams) 
     { 
      com.Parameters.Add(Param.ParamName, Param.ParamValue); 
     } 
    } 

    public OracleDataReader GetReader() 
    { 
     reader = com.ExecuteReader(); 
     return reader; 
    } 

    ~UniformData() 
    { 
     con.Close(); 
     con.Dispose(); 
     com.Dispose(); 
     reader.Close(); 
     reader.Dispose(); 
    } 
} 

Answer 1

Lassen Sie einfach einen der Konstruktoren den anderen aufrufen. Entweder hat die Überladung ohne die Parameter die Überladung mit den Parametern aufzurufen, aber eine leere Liste übergeben, oder die Überladung mit Parametern ruft die Überladung ohne Parameter auf, um die Verbindung zu initialisieren, so dass sie nur die Parameter hinzufügen muss.

Answer 2

können Sie die einfachere Konstruktor aus dem komplexeres this(parameter)

public UniformData(string sql) 
{ 
    con = new OracleConnection(connection); 
    con.Open(); 
    com = new OracleCommand(sql, con); 
} 

public UniformData(string sql, List<SqlParameters> myParams): this(sql) 
{ 
    foreach (SqlParameters Param in myParams) 
    { 
     com.Parameters.Add(Param.ParamName, Param.ParamValue); 
    } 
} 

Die original post 7 Jahre alt ist, kann mit Hilfe rufen Sie es verpasst bei der Recherche.

Die Using Constructors (C# Programming Guide) könnte ergeben weitere hilfreiche Informationen, einschließlich meine Antwort

Answer 3

Normalerweise würde ich eine „kanonische“ Konstruktor haben, die alle anderen Konstrukteuren Kette. In Ihrem Fall, dass wenn eine leere Liste zu schaffen bedeuten würde:

public UniformData(string sql) : this(sql, new List<SqlParameters>()) 
{ 
} 

public UniformData(string sql, List<SqlParameters> parameters) 
{ 
    con = new OracleConnection(connection); 
    con.Open(); 
    com = new OracleCommand(sql, con); 

    foreach (SqlParameters parameter in parameters) 
    { 
     com.Parameters.Add(parameter.ParamName, parameter.ParamValue); 
    } 
} 

Alternativ ändern Sie den Typ des Parameters zu IEnumerable<SqlParameters>, an dem Sie zeigen Enumerable.Empty verwenden:

public UniformData(string sql) : this(sql, Enumerable.Empty<SqlParameters>()) 
{ 
} 

public UniformData(string sql, IEnumerable<SqlParameters> parameters) 
{ 
    // Body as before 
} 

Sie können spaltete sich die Ich arbeite andersherum, wie es der Code von Mong Zhu tut - aber ich tendiere dazu, sauberer zu sein, um alle Arbeiten an einem einzigen Ort zu halten, wo es möglich ist. Das macht es einfach zu überprüfen, dass Sie alle Ihre Variablen in allen Fällen richtig initialisiert haben - Sie müssen nur überprüfen, ob alle Konstruktoren zur kanonischen ketten und dass die kanonische alles initialisiert.

Zusätzlich würde ich:

• Machen Sie Ihre Klasse implementieren IDisposable
• die Finalizers entfernen