Co powinienem zrobić, jeśli chcę utworzyć wiele przeciążeń metod CRUD?

Question

Jeśli mam klasy, która reprezentuje mapowanie do konkretnej tabela w moim db w jakiś sposób .. Ta klasa zawiera około 30 właściwości.

Utworzono CRUD Methods.

i potrzebuję innej metody (UPDATE), która powinna zaktualizować tylko dwa pola.

---

Co powinienem zrobić w dobry sposób z prostym przykładem?

1. Korzystanie moja metoda istnieje, wypełniające cały obiekt i zaktualizować wszystkie pola w tym moich przeznaczonych dwoma polami? (Bezużyteczny pracy)
2. -create metoda statyczna z inną nazwą (ale chcę, aby moje nazwisko bo metoda jest ekspresyjny) i bierze dwa parametry?

Answer 1

pójdę przez tworząc dwa oddzielne interfejs i tworzyć przeciążone funkcje dla każdego interfejsu. Chciałbym grupować właściwości na podstawie użycia, tak jak chcę, aby status był aktualizowany jakiś czas od innych wspólnych właściwości.

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. 
} 

Dodatkowo, jeśli chcesz, możesz utworzyć oddzielną klasę dla właśnie aktualizację statusu, i że będzie nadal pasował:

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

Ale tak, jeśli obie właściwości nie można oddzielane logicznie, nie zrobiłbym tego i trzymam je razem.

Answer 2

To zależy co Pana priorytety są na projekcie: stosując swoją już istniejącą metoda aktualizacji będzie aktualizować wszystko w tym czasie, incressing ruchu, IO i czas procesu (walidacja i tak dalej ...) Jeśli jesteś w projekcie, w którym właściwości są znacznikami czasowymi, byłyby aktualizowane, nawet jeśli ich wartość naprawdę nie uległa zmianie ...

Jeśli nie masz nic przeciwko temu, używaj metody update() przez cały czas .

Moje osobiste POV to: utwórz nową metodę (z jawną nazwą). To będzie ten sam czas przetwarzania od teraz i czas myślenia w ciągu 2 lat, kiedy będziesz musiał zmienić tę klasę;)

Answer 3

Nie wiem, czy to właśnie powinieneś zrobić, ale jest coś, co możesz zrobić: Utwórz SetAll lub SetMany lub dowolną metodę, w której przechodzisz w innej instancji klasy (źródło). Sprawdź każdą właściwość, a jeśli ma wartość inną niż null, ustaw wartość właściwości obiektu docelowego na wartość właściwości obiektu źródłowego. Zauważ, że ta taktyka będzie zależeć od typów nullable i zakłada, że ​​możesz zignorować wartości null przekazane do nowej metody ustawiającej. Oto ilustracja:

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"); 
     } 
    } 
} 

W tej pierwszej próbce kodu, mamy moją klasę klastrową SomeClass. Ma 4 właściwości, z których wszystkie są zerowe. Godną uwagi częścią tej klasy jest metoda SetAllMethod, w której mogę przekazać obiekt źródłowy, który jest również typu SomeClass. Ustawia wartości właściwości tej instancji na wartości przekazane w parametrze źródłowym, ale tylko wtedy, gdy mają wartość inną niż null. Oto 2nd kod krótką informację gdzie używam tej rzeczy:

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()); 
     } 
    } 
} 

Tworzenie obiektu docelowego, obiekt źródłowy, wywołać nową metodę, voila! Wyjście to:

"fn: Freddy, LN: Płetwy, wysokość: 80, DOB: 01/01/1970"

Answer 4

Powinieneś raczej używać Entity Framework i niech kontekst zrobi to za Ciebie.Korzystanie EF, będziesz mógł zaktualizować Podmioty tak:

 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

Proponuję pójść swoją drugą opcję, ale nie ma potrzeby, aby zmienić nazwę jako liczba parametr metody będą różne na obu to Chodźmy na kilka przykładów:

Spróbuję stworzyć podobną sytuację, mam nadzieję, że to twoja sytuacja. możesz wyjaśnić, czy źle pomyślałem.

KLASY I SPOSÓB

/// <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> 

public static class ObjectC {public static aktualizacja bool (to String, string b) { // implementacja aktualizacji i sprawdzania wartości zwracanej powrót prawdziwe; } }

METODY Calling i wyjaśnienie

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 
    } 

Proponuję dodać opcjonalny parametr od metody zdecydować, które UPDATE KORZYSTAĆ