Frage zu benutzerdefinierten Sammlungen in C#

Question

Ich würde gerne wissen, was ist das beste Muster beim Zurückgeben von Objekten aus benutzerdefinierten Auflistungsklassen. Zu meinem Problem veranschaulichen, hier ein Beispiel:

ich eine Customer-Klasse haben:

public class Customer 
{ 
    //properties 
    //methods 
} 

Dann habe ich eine Kunden Sammlung Klasse:

public class Customercollection: Collection<Customer> 
{ 

    public Collection<Customer> FindCustomers() 
    { 
    //calls DAL and gets a Collection of customers 
    Collection<Customer> customers = DAL.GetCustomers(); 

    return customers; 
    } 
} 

nun eine alternative Version dieses Verfahrens kann sein:

public class Customercollection: Collection<Customer> 
{ 

    public Collection<Customer> FindCustomers() 
    { 
    //calls DAL and gets a Collection of customers 
    Collection<Customer> customers = DAL.GetCustomers(); 
    foreach(Customer c in customers) 
    this.Add(c); 
    return this; 
    } 
} 

Ich möchte gerne diskutieren Welches ist der bessere Ansatz? Und gibt es einen anderen Ansatz als zwei über zwei?

Answer 1

würde ich einen dritten Ansatz vorschlagen:

Edit:ich dieses Codebeispiel aktualisiert haben unter dem OP Kommentare zu reflektieren.

public class Customer 
{ 
    public static ICollection<Customer> FindCustomers() 
    { 
     Collection<Customer> customers = new Collection<Customer>(); 

     foreach (CustomerDTO dto in DAL.GetCustomers()) 
      customers.Add(new Customer(dto)); // Do what you need to to create the customer 

     return customers; 
    } 
} 

Die meiste Zeit eine individuelle Sammlung nicht benötigt wird - ich gehe davon aus, dass dies einer der Fälle ist. Sie können dem Typ auch Hilfsmethoden hinzufügen (in diesem Fall der Typ Customer), da dies die Entwicklererkennung dieser Methoden unterstützt. (Dieser Punkt ist eher eine Frage des Geschmacks - da es sich um eine statische Methode handelt, können Sie sie in den von Ihnen gewünschten Typ setzen, z. B. CustomerUtility oder CustomerHelper).

Mein letzter Vorschlag ist, einen Schnittstellentyp von FindCustomers() zurückzugeben, um Ihnen größere Flexibilität in der Zukunft für Implementierungsänderungen zu geben. Offensichtlich müsste DAL.GetCustomers() einen Typ zurückgeben, der IList<T> ebenfalls implementiert hat, aber dann sollte jede API-Methode (insbesondere in einer anderen Schicht wie eine Datenschicht) auch Schnittstellentypen zurückgeben.

Answer 2

Wenn Sie wirklich diese Methoden des CustomerCollection Klasse wollen, dann würde ich

public static ICollection<Customer> GetAllCustomers() 

oder

public void FillWithAllCustomers() 

jedoch vorschlagen, würde ich argumentieren, dass Ihre CustomerCollection Klasse redundant ist und Verbraucher direkt gehen können an die DAL, wenn sie eine Sammlung von Kundenobjekten erhalten möchten.

Answer 3

Meiner Meinung nach sind beide etwas komisch und verwirrend. Wenn Sie die Collection-Klasse erweitern, implizieren Sie, dass Ihre Klasse eine Sammlung ist - damit sie die Daten enthält. Ich denke, wenn man im ersten Fall diese Methode statisch machen wird es am meisten Sinn machen:

public class Customercollection: Collection<Customer> 
{ 

    public static Collection<Customer> FindCustomers() 
    { 
    //calls DAL and gets a Collection of customers 
    Collection<Customer> customers = DAL.GetCustomers(); 

    return customers; 
    } 
} 

Answer 4

Noch ein anderer Weg wäre:

public class Customercollection: Collection<Customer> 
{ 
} 

public class Customer 
{ 
    public static CustomerCollection FindCustomers() 
    { 
     return DAL.GetCustomers(); 
    } 
} 

Answer 5

Sie erweitern Sammlung in Ihrem ersten Beispiel, aber Sie nie benutzen Kundensammlung zur Speicherung von Kunden. Stattdessen senden Sie eine Collection <Customer> zurück.Mein Vorschlag ist:

public static class Customers 
{ 

    public static Collection<Customer> FindCustomers() 
    { 
    //calls DAL and gets a Collection of customers 
    Collection<Customer> customers = DAL.GetCustomers(); 

    return customers; 
    } 
} 

wie folgt verwendet:

Collection<Customer> customers = Customers.FindCustomers(); 

Ihr zweites Beispiel ist auch ein bisschen komisch, denn wenn man FindCustomers zweimal anrufen werden Sie jeden Kunden zwei Mal in der Liste erhalten.

Answer 6

Ich würde die FindCustomers-Methode in der DAL-Klasse oder erstellen Sie eine Finder-Klasse, um die Methode zu halten. Wahrscheinlich werden Sie später weitere Finder-Methoden benötigen.

Answer 7

Was ist, wenn Sie etwas tun, wie folgt aus:

public class CustomerCollection: Collection<Customer> 
{ 
    public CustomerCollection: : base(new List<Customer>()) 
    {} 

    public static IList<Customer> FindCustomers() 
    { 
    //return them from DAL 
    } 
} 

in Ihrem Konstruktor mit der Anwendung lassen Sie ohne die Notwendigkeit nützliche Methoden in List in Ihrer Klasse verwenden, um Ihre eigene Implementierung zu schreiben.

public static Collection<T> ToCollection(this IEnumerable<T> seq) { 
    return new Collection<T>(seq.ToList()); 
} 

und es wie folgt verwenden:

Answer 8

würde ich diese Erweiterung Methode Andrew Vorschlag hinzufügen

public static Collection<Customer> FindCustomers() { 
    return DAL.GetCustomers().Select(dto => new Customer(dto)).ToCollection(); 
} 

Oder wenn Sie gehen mit Andrew Rat über Schnittstellentypen Rückkehr

public static IList<Customer> FindCustomers() { // or ICollection 
    return DAL.GetCustomers().Select(dto => new Customer(dto)).ToList(); 
}