OO Design vs Datenbank Design

Question

Angenommen, ich entwickle eine Anwendung für einen Produktverteiler in C#.

Der Verteiler hat die folgenden drei Arten von Transaktionen:

(1) einrücken

(2) Verkauf

(3) Stock

ich meine Klassen bin der Gestaltung wie folgt:

public abstract class Transaction 
{ 
} 

public class Indent : Transaction 
{ 
} 

public class Sell : Transaction 
{ 
}  

public class Stock : Transaction 
{ 
} 

Jetzt wenn ich diese drei Arten von in speichern möchte Bildung in drei separaten Tabellen, wie sollte ich dann meine DA-Schicht entwerfen?

Soll ich separate DA Klassen bauen wie

(1) IndentDA 
(2) SellDA 
(3) StockDA 

oder eine einzelne Klasse TransactionDA und CRUD-Operationen durchführt, indem ihre Typ Überprüfung von as/is Operatoren?

Oder was kann ich noch tun? Irgendwelche Vorschläge?

Answer 1

Erstens, wenn Sie eine einzelne Klasse TransactionDA erstellt und Typen in der Klasse überprüft CRUD-Operationen durchzuführen, würden Sie die Open/Closed Principle verletzen, also würde ich definitiv nicht diesen Pfad gehen.

Für Vorschläge, wie Sie Ihre DAL aufbauen können, würde ich vorschlagen, einige Blog-Posts über Menschen zu schreiben, die viel klüger sind als ich darüber, was sie über dieses Thema denken.

Repository is the new Singleton

Repository is Dead: Long Live Repository

Night of the Living Repositories

Das Gespräch weiter, glaube ich, aber das sollte Ihnen den Einstieg.

Answer 2

Überprüfen Sie die Gang of 4 design patterns.

Answer 3

Wenn Sie wissen, dass Ihre Daten in drei separate Tabellen aufgeteilt werden, hätte ich normalerweise drei separate DA-Klassen.

Wenn Ihre Tabellen jedoch weitgehend identisch sind, können Sie TransactionDA generisch machen und Ihre Datenschicht vereinfachen. Ich würde das nur tun, wenn Sie wissen, dass Sie ein hohes Transaktionsvolumen haben und Ihre Tabellen in verschiedene Dateien oder etwas anderes aufteilen werden, sonst würde ich wahrscheinlich einfach alles vereinfachen und alles kombinieren.

Versuchen Sie nicht, eine TransactionDA zu erstellen, es sei denn, alle Ihre separaten Transaktionstypen sind extrem ähnlich.

Answer 4

Sie können Dependency Injection verwenden, erstellen Sie jeweils eine DA-Klasse und lassen Sie alle die gleiche Schnittstelle ITransactionDA mit Ihren CRUD-Operationen implementieren.

public interface ITransactionDA 
{ 
    void Read(); 
    void Update(); 
... 
} 

public class StockDA : ITransactionDA 
{ 
    //implement interface methods 
} 

Stock stock = new Stock(new StockDA()); 

Answer 5

Ich würde Entität Subtypen hier verwenden.Erstellen Sie eine Tabelle für die Transaktionen (und wie ein früheres Poster sagte, vielleicht wäre ein anderer Begriff besser) und speichern Sie alles, was dort üblich ist. Erstellen Sie dann eine "Untertyp" -Tabelle für jede Spezialisierung. Diese Subtypentabellen sollten den gleichen Primärschlüssel wie die Haupttabelle (die "starke" Entität) und die Felder aufweisen, die für diese spezielle Spezialisierung eindeutig sind. Jeder Subtyp steht in einer Eins-zu-Eins-Beziehung mit der starken Entität in Verbindung, mit optionaler Teilnahme am Ende des Subtyps und erforderlicher Partizipation am Ende der starken Entität.

Um die Abfrage zu vereinfachen, definieren Sie dann eine Ansicht, die (äußerlich) die starke Entität mit allen Entitätsuntertypen verbindet, sodass Sie einfach alles "sehen" können.

Hier ist ein einfaches (und häufig) Beispiel dafür, wie dies einzurichten:

create table Employee (
    eid  int primary key, 
    first_name text, 
    last_name text not null 
) 

create table Salaried (
    eid    int primary key, 
    annualSalaryUSD money not null 
) 

create table Hourly (
    eid    int primary key, 
    hourlyRateUSD money not null 
) 

Answer 6

ich etwas wie die

public abstract class DistributerTransaction 
{ 
    DistributerDA dataaccess; 
} 
public class Indent : DistributerTransaction 
{ 
} 
public class Sell : DistributerTransaction 
{ 
} 
public class Stock : DistributerTransaction 
{ 
} 

public abstract class DistributerDA 
{ 
    /*Read(); 
    Update();*/ 
} 
public class IndentDA : DistributerDA 
{ 
} 
public class SellDA : DistributerDA 
{ 
} 
public class StockDA : DistributerDA 
{ 
} 

Answer 7

tun werde ich ein ORM wie NHibernate verwenden würde, und verwenden Sie es Multi-Table-Vererbungsfunktionen und müssen sich dann nicht selbst darum kümmern.