Cosa devo fare se voglio creare sovraccarichi multipli di metodi CRUD?

Question

Se ho una classe che rappresenta in qualche modo una mappatura ad una tabella specifica nel mio db .. Questa classe contiene circa 30 proprietà.

Ho creato il CRUD Methods.

e mi trovo necessario un altro (UPDATE) metodo che dovrebbe aggiornare solo due campi.

---

Cosa devo fare in modo corretto con un semplice esempio?

1. Usando il mio metodo exist, riempiendo l'intero oggetto e aggiornare tutti i campi tra cui i miei due campi destinati? (Lavoro inutile)
2. metodo statico -Creare con un altro nome (ma voglio mantenere il mio nome del metodo cuz è espressivo) !! e prende due parametri?

Answer 1

Vorrei andare da con la creazione di due distinti interfaccia e crea funzioni sovraccariche per ogni interfaccia. Raggrupperei le proprietà in base all'utilizzo, come se volessi aggiornare lo stato un po 'di tempo separato dalle altre proprietà comuni.

public interface ICommonProperties 
{ 
    public string P1{get; set;} 
    public string P2{get; set;} 
    public string P3{ get; set; } 
} 
public interface ITrackable 
{ 
    public string Status{get; set;} 
} 
public class FinalClass : ICommonProperties, ITrackable 
{ 
    public string P1{get; set;} 
    public string P2{get; set;} 
    public string P3{get; set;} 
    public string Status{get; set;} 
} 

public class FinalClassOperations 
{ 
    public void Update(FinalClass finalClassInstance) { }; //Updates everything 
    public void Update(ICommonProperties finalClassInstance) { }; //Updates only ICommonProperties 
    public void Update(ITrackable finalClassInstance) { }; //updates only Status. 
} 

Inoltre, se si desidera è possibile creare una classe separata solo per l'aggiornamento dello stato, e che sarebbe ancora in forma in:

public class Tracker : ITrackable{ 
    public string Status{get; set;} 
} 

Ma sì, se le due proprietà non possono essere separati fuori logicamente, non lo farei e li terrò insieme.

Answer 2

Dipende da che cosa sono le vostre priorità sul progetto: utilizzando il metodo di aggiornamento già esistente sta andando aggiornare tutto ogni volta, incressing traffico, IO e tempo di processo (convalida e così via ...) Se sei su un progetto in cui le proprietà sono timestampate, sarebbero aggiornate anche se il valore non è realmente cambiato ...

Se non ti dispiace di tutto questo, usa il tuo metodo update() tutto il tempo .

Il mio POV personale è: creare un nuovo metodo (con un nome esplicito). Questo sarà lo stesso processo da ora in poi e il tempo di pensare tra 2 anni quando dovrai cambiare questa classe;)

Answer 3

Non so se questo è ciò che dovresti fare necessariamente, ma ecco qualcosa che potresti fare: Crea un SetAll o SetMany o qualsiasi altro metodo in cui passi in un'altra istanza della tua classe (fonte). Controllare ciascuna proprietà e se non è nulla, si imposta il valore della proprietà dell'oggetto di destinazione sul valore della proprietà dell'oggetto di origine. Nota che questa tattica dipenderà dai tipi nullable e presuppone che tu possa ignorare i valori nulli passati in un nuovo metodo setter. Ecco una illustrazione:

using System; 

namespace BlogPartialUpdateTrick 
{ 
    public class SomeClass 
    { 
     public string FirstName { get; set; } 
     public string LastName { get; set; } 
     public int? HeightInches { get; set; } 
     public DateTime? Dob { get; set; } 

     public void SetAll(SomeClass source) 
     { 
      this.FirstName = source.FirstName ?? this.FirstName; 
      this.LastName = source.LastName ?? this.LastName; 
      this.HeightInches = source.HeightInches ?? this.HeightInches; 
      this.Dob = source.Dob ?? this.Dob; 
     } 

     public override string ToString() 
     { 
      return String.Format("fn: {0}, ln: {1}, height: {2}, DOB: {3}", FirstName ?? String.Empty, LastName ?? String.Empty, 
       HeightInches.HasValue ? HeightInches.Value.ToString() : "null", Dob.HasValue ? Dob.Value.ToShortDateString() : "null"); 
     } 
    } 
} 

In questo primo esempio di codice, abbiamo la mia classe spiffy SomeClass. Ha 4 proprietà, tutte sono annullabili. La parte degna di nota di questa classe è SetAllMethod dove posso passare in un oggetto sorgente che è anche di tipo SomeClass. Imposta i valori di proprietà di questa istanza sui valori passati nel parametro source, ma solo se non sono nulli. Ecco un codice di 2 ° trafiletto in cui sto usando questa roba:

using System; 
using System.Windows.Forms; 

namespace BlogPartialUpdateTrick 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     private void button1_Click(object sender, EventArgs e) 
     { 
      var destination = new SomeClass() { FirstName = "Freddy", LastName = "Fingers", Dob = DateTime.Parse("01/01/1970"), HeightInches = 72 }; 
      var source = new SomeClass() { FirstName = null, LastName="Flippers", Dob = null, HeightInches = 80 }; 
      destination.SetAll(source); 
      MessageBox.Show(destination.ToString()); 
     } 
    } 
} 

Creare un oggetto di destinazione, un oggetto di origine, chiamare il nuovo metodo, voilà! output è questo:

"fn: Freddy, ln: Flippers, altezza: 80, Data di nascita: 1/1/1970"

Answer 4

Probabilmente è meglio usare Entity Framework e lasciare che il contesto farlo per voi.Utilizzando EF, sarete in grado di aggiornare Entità in questo modo:

 try 
     { 
      var original = ObjectContext.Set<Request>().SingleOrDefault(x => x.Id.Equals(_request.Id)); 
      if (original != null) 
      { 
       ObjectContext.Entry(original).CurrentValues.SetValues(_request); 
      } 

      return ObjectContext.SaveChanges(); 

     } 
     catch (Exception ee) 
     { 
      return -1; 
     } 

Answer 5

vorrei suggerire di seguire il vostro seconda opzione, ma non c'è bisogno di cambiare il nome e il numero di parametro del metodo sarà diverso su entrambi è Andiamo a pochi esempi

Cercherò di creare una situazione simile, spero che sia la vostra situazione. puoi chiarire se ho sbagliato la domanda.

LEZIONI E METODO

/// <summary> 
/// CLass to store properties related to database 
/// </summary> 
class ObjectoA 
{ 
    public string A{get; set;} 
    public string B{get; set;} 
    public string C{ get; set; } 
} 

/// <summary> 
/// class to call method to update. 
/// 
/// </summary> 
class ObjectB 
{ 
    /// <summary> 
    /// update method. 
    /// I would go with this solution. 
    /// optionlay you can call the method which receive parameter of object 
    /// </summary> 
    /// <param name="A"> Object with properties mapped to database</param> 
    /// <param name="updatetwoproperties">Optional paramneter to decide which update to run. 
    /// the default value should be for update that run most. For your need if you want to create an update methods for other 
    /// two sets of parameter a suggest you create an Enum and pass this enum as optional parameter instead of bool parameter or you 
    /// can pass as string and map each string value to specific update inside. IF YOU NEED EXAMPLE 
    /// REPLAY ON COMMENTS</param> 
    /// <returns></returns> 
    public bool update(ObjectoA A, bool updatetwoproperties=false) 
    { 
     //method implementation 
     if (updatetwoproperties) 
     { 
      //implement a update to all field 
     } 
     else 
     { 
      //implement update just to two field 
     } 
     return true; 
    } 

    /// <summary> 
    /// update method based on parameter to update 
    /// </summary> 
    /// <param name="a">this properties is mapped on database</param> 
    /// <param name="b">this propertie is mapped on database</param> 
    /// <returns></returns> 
    public bool update(string a, string b) 
    { 
     //method implementation e validate the return value 
     return true; 
    }  
} 

/// <summary> 
/// I don't suggest to use this solution because 
/// it will add a method on string type while this method isn't related to string 
/// I just added here as a workaround for you. 
/// </summary> 

classe public static ObjectC { aggiornamento public static bool (questa stringa Una corda b) { // implementazione di aggiornamento e convalidare il valore di ritorno di ritorno vero; } }

chiamando il metodo E SPIEGAZIONE

static void Main(string[] args) 
    { 
        ObjectB B = new ObjectB(); //Class with methods 
     ObjectoA A = new ObjectoA(); //object with properties 

     #region Using Optional parameter to decide which update to run 
     //Calling a method to update all columns 
     B.update(A); 
     //Calling a method to update two columns 
     B.update(A, true); 
     #endregion 

     #region Using polymorphism to update 
     //Calling a method to update all columns 
     B.update(A); 
     //Update only using paramenter 
     B.update(A.B, A.C); 
     #endregion 

     //NOT RECOMMEND BECAUSE THIS UPDATE ISN'T RELATED TO STRING TYPE 
     #region Using extension method to update 
     //Calling a method to update all columns 
     B.update(A); 
     //using the extension method on variable type 
     A.B.update(A.C); 
     #endregion 

     //WE COULD USE EXTENSION METHOD ON YOUR OBJECT BUT IT WILL FAIL BECAUSE WE ALREADY AS UPDATE METHOD ON CLASS 
     //IF YOU WANT TO SEE HOW JUST REPLAY 
    } 

io suggerisco di aggiungere un parametro opzionale del metodo per decidere quali aggiornamenti per l'utilizzo