Comment éliminer le code en double

Question

J'ai les méthodes suivantes, qui renvoient tous des types différents. J'ai quatre de ces méthodes. Dans l'esprit de bonnes pratiques de programmation (DRY), vous devriez utiliser certaines techniques de POO telles que l'héritage ou les interfaces ici ou simplement rouler avec. Tous les commentaires ou exemples de code sont les bienvenus. Je vous remercie.

static AttendeeResponse GetAttendees(HttpWebRequest request) 
    { 
     HttpWebResponse resp = (HttpWebResponse)request.GetResponse(); 

     try 
     { 
      XmlSerializer ser = new XmlSerializer(typeof(AttendeeResponse)); 
      return (AttendeeResponse)ser.Deserialize(resp.GetResponseStream()); 
     } 
     catch(Exception e) 
     { 
      error = e.InnerException.ToString(); 
      return null; 
     } 

    } 

    static MemberResponse GetMembers(HttpWebRequest request) 
    { 
     HttpWebResponse resp = (HttpWebResponse)request.GetResponse(); 

     try 
     { 
      XmlSerializer ser = new XmlSerializer(typeof(MemberResponse)); 
      return (MemberResponse)ser.Deserialize(resp.GetResponseStream()); 
     } 
     catch (Exception e) 
     { 
      error = e.InnerException.ToString(); 
      return null; 
     } 

    } 

Answer 1

Que diriez-vous:

// TODO: Improve the name :) 
static T FetchItem<T>(HttpWebRequest request) 
{ 
    using (HttpWebResponse resp = (HttpWebResponse)request.GetResponse()) 
    { 
     try 
     { 
      XmlSerializer ser = new XmlSerializer(typeof(T)); 
      return (T) ser.Deserialize(resp.GetResponseStream()); 
     } 
     catch (Exception e) 
     { 
      error = e.InnerException.ToString(); 
      return default(T); 
     } 
    } 
} 

Notez que j'ai inclus un using statment pour vous éviter les connexions qui fuient. Vous n'avez pas besoin de fermer le flux, selon les docs.

Le return null a dû être remplacé par return default(T) dans le cas où T est un type de valeur non nullable; une alternative consisterait à limiter T à un type de référence en utilisant where T : class dans le cadre de la déclaration de méthode.

utiliser comme ceci:

MemberResponse members = FetchItem<MemberResponse>(request); 
... 
AttendeeResponse attendee = FetchItem<AttendeeResponse>(request); 

Answer 2

Vous pouvez utiliser Génériques:

static T GetMembers<T>(HttpWebRequest request) 
{ 
    HttpWebResponse resp = (HttpWebResponse)request.GetResponse(); 

    try 
    { 
     XmlSerializer ser = new XmlSerializer(typeof(T)); 
     return (T)ser.Deserialize(resp.GetResponseStream()); 
    } 
    catch (Exception e) 
    { 
     error = e.InnerException.ToString(); 
     return null; 
    } 

} 

Answer 3

Utilisez génériques?

static T GetResponse<T>(HttpWebRequest request) 
{ 
    HttpWebResponse resp = (HttpWebResponse)request.GetResponse(); 

    try 
    { 
     XmlSerializer ser = new XmlSerializer(typeof(T)); 
     return (T)ser.Deserialize(resp.GetResponseStream()); 
    } 
    catch(Exception e) 
    { 
     error = e.InnerException.ToString(); 
     return null; 
    } 

} 

Answer 4

Cela ressemble à un bon candidat pour les génériques. Peut-être ..?

static E GetPiece<E>(HttpWebRequest request) { 
{ 
    ... 
} 

Answer 5

MemberResponse membResp = (MemberResponse)StaticClassName.SerializeIt(request); 

static Object SerializeIt(HttpWebRequest request) 
    { 
     HttpWebResponse resp = (HttpWebResponse)request.GetResponse(); 

     try 
     { 
      XmlSerializer ser = new XmlSerializer(typeof(MemberResponse)); 
      return (Object)ser.Deserialize(resp.GetResponseStream()); 
     } 
     catch (Exception e) 
     { 
      error = e.InnerException.ToString(); 
      return null; 
     } 

    } 

Answer 6

Vous pouvez éliminer la duplication de code par les délégués. par exemple: si je dois finir deux tâches avec la base:

OleDbCommand oci = new OleDbCommand(queryString, connection); 
oci.Connection.Open(); 
oci.CommandText = "delete * from firstTable"; 
oci.ExecuteNonQuery(); 
oci.Connection.Close(); 

OleDbCommand ocn = new OleDbCommand(queryString, connection); 
ocn.Connection.Open(); 
ocn.CommandText = "select count(*) from secondTable"; 
int affected = convert.ToInt32(ocn.ExecuteScalar(); 
ocn.Connection.Close(); 

comme vous pouvez le voir, nous avons le code dupliqué ici. Je dois donc factoriser mon code comme ceci:

OleDbCommand myAccessCommand = null; 
int count = -1; 
OleDbWork(secondConnectionString, "SELECT COUNT(*) FROM secondTable", 
out myAccessCommand, 
() => 
{ 
    count = Convert.ToInt32(myAccessCommand.ExecuteScalar()); 

}); 

OleDbWork(firstConnectionString, "delete * from firstTable", 
out myAccessCommand, 
() => 
{ 
    myAccessCommand.ExecuteNonQuery(); 
} 

et ma méthode de OleDbWork ressemblera à ceci:

internal bool OleDbWork(string connString, string command, 
out OleDbCommand myAccessCommand, Action action) 
    { 
     OleDbConnection myAccessConn = null; 
     myAccessCommand = null; 
     try 
     { 
      myAccessConn = new OleDbConnection(connString); 
     } 
     catch (Exception) 
     { 
      MessageBox.Show("Cannot connect to database!"); 

      return false; 
     } 

     try 
     { 

      myAccessCommand = new OleDbCommand(command, myAccessConn); 

      myAccessConn.Open(); 

      action(); 
      return true; 

     } 
     catch (Exception ex) 
     { 
      MessageBox.Show("Cannot retrieve data from database. \n{0}", 
      ex.Message); 

      return false; 
     } 
     finally 
     { 
      myAccessConn.Close(); 
     } 
    } 

J'espère que cela vous aidera