Die Implementierung eines CRUD, die über eine Schnittstelle

Was ist der beste Ansatz zur Umsetzung einer CRUD auf der BL unter Verwendung der Schnittstelle, die verwendet werden, um abstrakte DAL Operationen? Ich brauche Ihre Meinung, Jungs..

Hier ist mein Entwurf..

Daten, die Personen zugeordnet sind, die in der Datenbank-Tabelle

 public class Student
 {
    public string StudentId { get; set; }
    public string StudentName { get; set; }
    public Course StudentCourse { get; set; }
 }

 public class Course
 {
    public string CourseCode { get; set; }
    public string CourseDesc { get; set; }
 }

Erstellte ich eine CRUD-Schnittstelle für die Abstraktion der Objekt-Operationen

public interface IMaintanable<T>
{
   void Create(T obj);
   T Retrieve(string key);
   void Update(string key);
   void Delete(string key);
 }

Dann eine Komponente, verwaltet das Unternehmen und seine Operationen durch die Implementierung der Schnittstelle

public class StudentManager : IMaintainable<Student>
{
    public void Create(Student obj)
    {
        //inserts record in the DB via DAL
    }

    public Student Retrieve(string userId)
    {
        //retrieveds record from the DB via DAL
    }

    public void Update()
    {
        //should update the record in the DB
    }

    public void Delete(string userId)
    {
        //deletes record from the DB
    }
}

Beispiel für die Nutzung

    public void Button_SaveStudent(Event args, object sender)
    {
        Student student = new Student()
        {
           StudentId = "1", StudentName = "Cnillincy"
        }

        new StudentManager().Create(student);   
     }

wie Sie sehen können, es ist ziemlich Anomalien auf der update-Methode

    public void Update()
    {
        //should update the record in the DB
    }

was sollte diese Methode zum aktualisieren der Objekte Immobilie? sollte ich Erben die Student?

    public class StudentManager : Student , IMaintainable<Student>
    {
        public void Update()
        {
            //update record via DAL
         }
    }


    public void Button_SaveStudent(Event args, object sender)
    {
        Student student = new StudentManager();
        student.StudentId = "1";
        student.StudentName = "Cnillincy"
        student.Update()
    }

Oder sollte ich nur die Student-Klasse als ein Attribut des Studenten, manager?

     public class StudentManager : IMaintainable<Student>
    {
        public Student student { get; private set };

        public void Create() {}
        public void Update() {}
        public void Retrieve() {}
        public void Delete() {}
    }

Welche besser geeignet? Was ist die Schnittstelle? Andere Anregungen, Jungs? danke..C

InformationsquelleAutor CSharpNoob | 2010-09-21

architecture c#crud

15

Ihre CRUD-Schnittstelle sollte wohl Aussehen wie
```
public interface IMaintanable<T>
{
    string Create(T obj);
    T Retrieve(string key);
    void Update(T obj);
    void Delete(string key);
}
```
ist, sowohl Create und Update nehmen Sie eine Kopie des Objekts, die Sie aktualisieren. Der Unterschied ist, dass die Update können die key von der obj, damit es weiß, welches Objekt er sich verändert. Create würde normalerweise dazu führen, die Schlüssel erstellt werden, damit Sie Ihr übergeben, als Rückgabewert. Hoffe, das hilft.

(Das Update könnte auch wieder übergeben Sie die-Taste.)

Sie denkt, dass es effizienter als die Erben das Objekt, weil es bedeutet, dass Sie erstellen Sie eine andere Kopie von obj, anstatt einfach zu aktualisieren,,
Erben würde keinen Sinn machen. Ihre StudentManager IST KEIN student.
Was Matthieu sagt. Denken Sie an die Schüler wie eine Schallplatte und Ihr StudentManager, wie der Direktor die Sekretärin, die Eingabe der Datensätze, wie Sie kommen in. Single Responsibility Prinzip FTW.
Warum sind die keys Typ string? Müsste es nicht ein uint oder int für die id für Delete()? Ich kann mich auch irren. Korrigiert mich, wenn ich Sie bitte.
Keine Sorge. Du hast Recht; ids / keys könnte alles sein, solange Sie einzigartig sind. Ich gehe mit Guids mich.

InformationsquelleAutor
9

Persönlich denke ich, dass alles, was Sie fehlt, ist die entsprechende Terminologie. Was dies wirklich eine Annäherung an ein sehr hilfreiches Muster, genannt das repository-pattern. Soweit Art-Bewusstsein geht, wäre die Implementierung bezeichnet als generisches repository.

Den Weg habe ich selbst umgesetzt, in der Vergangenheit war, ein interface zu definieren das repository, wie IRepository<T>, und eine Basis-Klasse, die spezifisch für die Art des repository, wie ein SqlRepositoryBase<T>. Der Grund, dass ich tun würde, ist, dass ich die Umsetzung-spezifischen code in der Basisklasse. So, die Heizung ist fertig und ich kann die Sorge über domain-spezifischen Implementierung in das endlager, das wäre StudentRepository eine SqlRepository<Student> (oder SqlRepository<IStudent> wenn Sie die Definition von Schnittstellen für Ihre Person).

Es scheint, dass Sie besorgt darüber, wie viele Objekte sind instansiated, und ich kann Ihnen sagen, dass Sie nicht erzeugen eine erhebliche genug Belastung für die Ressourcen, die wirklich besorgt über die Umsetzung in diesem Mode. Alten Hasen mag erschaudern bei der Tat, aber wir versuchen nicht, die Optimierung für 64 Kb RAM oder mehr. 😉 Es geht mehr um die Wartbarkeit, code-Verträge, etc.

Nicht hinzufügen uneeded Komplexität up-front, aber vielleicht möchten Sie auch zu schauen in das Unit of Work Pattern aus, wenn Sie sich eintragen können mehrere Elemente von verschiedenen Typen, die in atomaren Transaktionen.

Hier sind ein paar gute Referenzen für diese Themen:
- neue Repository - ().DoMagic()
- Das Unit of Work Pattern
Zwei take-aways aus dieser im Allgemeinen (IMHO):
- Ich persönlich bin nicht einverstanden mit der Annahme, dass ein Repository-pattern-Ansatz hat nur nutzen bei grösseren Projekten, insbesondere die Generischen Repository-pattern. Wenn Sie beginnen, putting-code wie folgt in eine wieder verwendbare Bibliothek, Sie werden überrascht sein, wie schnell können Sie beginnen, erstellen eine unschätzbare Ressource, die der building blocks.
- Das größte plus an diesem Ansatz ist die schiere Testbarkeit von ihm; sogar mehr als dies die Wiederverwendbarkeit. Wenn Sie auf der Suche nach mock aus den Online-repositories für jede Art von ein TDD-Ansatz, können Sie dies mit wenig Aufwand. Dies ermöglicht es Ihnen zu schreiben, reicher tests, um die Nutzungen des repositories im gesamten code.
Eine CRUD-Muster wie dieses ist im Grunde ein repository-Muster sowieso, was auch immer Sie es nennen mögen. Ich Stimme mit Ihrem Kommentar etwa, dass es nützlich, auch für kleine Projekte. Die gute Sache über die bevorstehenden es aus CRUD-Sicht ist, dass es übersetzt wirklich schön zum REST. Pause, auch nicht schlecht getan, ist ziemlich performant und skalierbar. Mit einer domain wie Studenten zugänglich ist, stark für nur ein paar Tage jeden Jahres - performance könnte es tatsächlich eine überlegung sein, auch wenn es kein Unterscheidungsmerkmal.
Joseph, Jahre später, immer noch wertvoll, da so der link für Die "unit Of Work Pattern" gebrochen ist, kann man aktualisieren?
getan. Benutzt die Zeitmaschine in die Vergangenheit zu ziehen, ein Archiv. Danke!

InformationsquelleAutor

Sah ich das, von Rob Conery, die ich wirklich mag. Es ist Leistung ist in der Flexibilität der Argumente, die übergeben werden können, um die Methoden. Ihre Umsetzung ist nicht robust genug, IMO. Check-out seine MVC-starter-kit hier http://mvcstarter.codeplex.com/ (man nennt das ISession dort).

public interface IMaintainable : IDisposable
    {
       T Single<T>(Expression<Func<T, bool>> expression) where T : class, new();
       System.Linq.IQueryable<T> All<T>() where T : class, new();
       void Add<T>(T item) where T : class, new();
       void Update<T>(T item) where T : class, new();
       void Delete<T>(T item) where T : class, new();
       void Delete<T>(Expression<Func<T, bool>> expression) where T : class, new();
       void DeleteAll<T>() where T : class, IEntity, new();
       void CommitChanges();
    }

das ist wie IEnumerable<T> Erweiterung Methoden .. danke
Keine Sorge... Sobald man einen Blick auf seine Lösung Sie werden sehen, wie wenig code Sie wirklich brauchen, zu tun, die meisten von CRUD-Operationen.
immer Fehler auf IEntity keyword

InformationsquelleAutor

1

Ich würde das nicht machen StudentManager Erben, Student, hätte ich mein Update-Methode staatenlos, wie Ihre create-Methode, D. H.
```
public interface IMaintanable<T>
{
  void Create(T obj);
  T Retrieve(string key);
  void Update(T obj);
  void Delete(string key);
}
```
und
```
public void Update(T obj)
{
  //should update the record in the DB
}
```
können Sie erklären, warum dies sinnvoller als Erben oder die Zuteilung der DataEntity? Dank
Für mich ist es nach unten zu OO "Richtigkeit" und Trennung von Bedenken, Eine StudentManager ist nicht ein Student (im OO-Sinne). Die Schüler der Klassen Verantwortung ist die Modellierung der Daten, die StudentManagers Aufgabe ist es, zu bestehen, dass die Daten, die ich gerade denke, diese sollten nicht vermischt werden. Aber das ist nur meine Meinung, ich kann nicht Recht sein 🙂

InformationsquelleAutor
0

Werfen Sie einen Blick auf die neue Entity Framework 4, die kürzlich veröffentlicht wurde. Sie sind mit einem "code-Konvention" - Modell, können Sie leicht ordnen Sie Ihre business-Objekte direkt auf der Datenbank, ohne zu befürchten, DAL.

"Gu" hat eine tolle Serie skizziert, wie einfach es ist, ordnen Sie Ihre Objekte und sogar einige einfache änderungen, wenn die Verknüpfung auf die Datenbank durch den DbContext-Modell verwendet.

Es ist erwähnenswert, dass die aktuelle Version ist auf CTP4, aber ich erwarte die meisten Probleme wurden bereits ausgearbeitet, mit dem Rahmen und sollten Sie gut zu dienen.

InformationsquelleAutor
0

Änderte ich die Antworten hier ein wenig, zu diesem:
```
public interface IMaintanable<T>
{
    Guid Create(T obj);
    T Read(Guid key);
    bool Update(T obj);
    bool Delete(Guid key);
}
```
Diese Schnittstelle basiert auf meine Datenbank-Struktur. Ich verwende Guids für Primärschlüssel.

Könnte gut sein, zu erklären, warum Sie vorschlagen, das zu ändern...

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.