[ASP.NET] Basierend auf. .LINQ zur SQL-Drei-Schicht-Architekturentwicklung

Unsinn vorne geschrieben

Basierend auf. Die dreistufige Architektur von .NET lässt sich in folgende Schichten unterteilen: Data Linq-Schicht, Datenzugriffsschicht, Geschäftslogik-Schicht und Präsentationsschicht. Die Pfeilsymbole in Abbildung 1 unten veranschaulichen die Interaktion zwischen den Schichten: Die Datenzugriffsschicht verweist auf die Data LINQ-Schicht; Die Business Logic Layer verweist auf die Datenzugriffsschicht und die Entitätsklassen in der Data LINQ-Schicht. Die Präsentationsschicht bezieht sich sowohl auf die Geschäftslogikschicht als auch auf die Entitätsklassen in der Data-LINQ-Schicht.

Die Data LINQ-Schicht umfasst hauptsächlich Entitätsklassen und Datenkontextklassen. Typischerweise ist eine Entitätsklasse für eine Tabelle in der Datenbank. Wir können Instanzen von Entitätsklassen erstellen, die zwischen verschiedenen Schichten als Datenobjekte übertragen werden.

        Abbildung 1: LINQ zu SQL-Drei-Stufen-Architektur

Im Folgenden ist ein Beispiel für das Login-Fenster bei der Erstellung eines Projekts, um die dreistufige Architekturentwicklung von LINQ in SQL einzuführen.

Präparat

1. Zuerst benötigen Sie eine Datenbank und eine Datentabelle, um den Benutzernamen und das Passwort der eingeloggten Person zu speichern. Hier wird eine SQL Server 2005-Datenbank verwendet. Die Datenbanktabellenstruktur ist in Abbildung 2 dargestellt.

Abbildung 2 Datenbank-Benutzertabelle

2. VS öffnen und ein neues Projekt ---> anderen Projekttypen erstellen---> Visual Studio-Lösungen---> leere Lösungen. Wie in Abbildung 3 gezeigt. (Visual Studio 2008 wird hier verwendet)

Abbildung 3 Erstellen Sie eine leere Lösung

3. Fügen Sie eine Klassenbibliothek hinzu. Rechtsklick auf die neu erstellte Lösung im Lösungs-Explorer ---> ---> neues Projekt ---> Klassenbibliothek hinzufügen. Wie in Abbildung 4 gezeigt. Die gleiche Methode erfordert das Hinzufügen von drei Bibliotheken, BLL, DAL und DataLinq, sowie einer Windows Forms-Anwendung (falls es sich um eine Webanwendungsentwicklung handelt, wählen Sie ASP.NET Webanwendung) und sie UI zu benennen.

Abbildung 4 Hinzufügen eines Bibliotheksprojekts

Die Struktur nach dem Anbau ist in Abbildung 5 dargestellt. Gleichzeitig klicke mit Rechtsklick auf die Benutzeroberfläche und setze die Benutzeroberfläche als Startobjekt.

Abbildung 5: Projektstrukturdiagramm

Fügen Sie ein Zitat hinzu

Füge im Solution Explorer Referenzen zu jeder Stufe hinzu. BLL-Ebene Referenzen auswählen --->Rechtsklick ---> Referenzen hinzufügen. Wie in Abbildung 6 gezeigt. Fügen Sie eine Referenz zu System.Data.Linq hinzu. Gleichzeitig fügen Sie gemäß der Beziehung zwischen den in Abbildung 1 gezeigten Schichten Projektreferenzen zu DAL und DataLinq hinzu. Ebenso fügt die DAL-Schicht Projektreferenzen zu System.Data.Linq und DataLinq hinzu, die DataLinq-Schicht fügt Referenzen zu System.Data.Linq hinzu, und die UI-Schicht fügt Verweise auf System.Data.Linq sowie Projektreferenzen auf BLL und DataLinq hinzu.

Abbildung 6 Projektreferenzen hinzufügen

Bisher wurde eine dreistufige Architektur etabliert. Im Folgenden werden die entsprechenden Klassen zu jeder Ebene hinzugefügt.

1. Zuerst die DataLinq-Schicht. Rechtsklick auf DataLinq---> füge ---> neues Projekt hinzu---> wähle die LINQ-zu-SQL-Klasse aus, wie in Abbildung 7 dargestellt.

Abbildung 7 Hinzufügen eines LINQ zur SQL-Klasse

2. Nach Abschluss der Ergänzung wird automatisch ein leerer Designer (.dbml-Datei) mit einem Link zum Server Explorer sowie die zugehörige dbml.layout-Datei (XML-Datei) und designer.cs Datei erstellt. Öffnen Sie Server Explorer und stellen Sie einen Link zur Datenbank her.

Abbildung 8 Open Server Explorer

3. Verbinden Sie sich mit der Datenbank. Wählen Sie das Werkzeug ---> Datenbank hinzufügen. Wie in Abbildung 9 gezeigt. Wählen Sie die neu erstellte Datenbank aus und bestimmen Sie die Verbindungsdatenbank. An diesem Punkt erscheint die Datenbank im Server Explorer.

4. Wählen Sie den Benutzer der Datentabelle aus, den Sie verwenden möchten, ziehen und lassen Sie ihn auf den Designer fallen, wie in Abbildung 10 unten gezeigt. Speichere die Datei. Jetzt wurden DataContext-Klassen und Entitätsklassen mit verwandten Eigenschaften, Methoden und Methoden automatisch generiert.

Abbildung 10 Benutzerklasse

Fügen Sie Codeschichten hinzu

DAL-Schicht

Erstelle eine neue UserDAL-Klasse und füge folgenden Code hinzu

//UserDAL.cs

unter Verwendung von DataLinq;
unter Verwendung von System.Data.Linq;

Namensraum DAL
{
    öffentliche Klasse UserDAL
    {
        private DataLinq.DBLinqDataContext objDataContext = neuer DataLinq.DBLinqDataContext();

        public User SelectRecordByID (String-Benutzerid)
        {
            Versuch es
            {
                return (aus u in objDataContext.User, wobei u.Id == userid select u). Einzel();
            }
            catch (Ausnahme z. B.)
            {
                Throw Ex;
            }
        }
    }
}

BLL-Schicht

Erstelle eine neue UserBLL-Klasse und füge folgenden Code hinzu

//UserBLL.cs

unter Verwendung von System.Data.Linq;
unter Verwendung von DataLinq;

Namensraum BLL
{
    öffentliche Klasse UserBLL
    {
        Private DAL. UserDAL objUserDAL = neues DAL. UserDAL();

        public User SelectRecordByID (String-Benutzerid)
        {
            return objUserDAL.SelectRecordByID(userid);
        }
    }
}

UI-Layer-Code

//LoginForm.cs

privat BLL. UserBLL objUserBLL = neuer BLL. UserBLL();
      
        private Void btnSubmit_Click(Objektsender, EventArgs e)
        {
            string id = txtId.Text.Trim();
            String psd = txtPsd.Text.Trim();

            User localDataTable = objUserBLL.SelectRecordByID(id);

            if (localDataTable != null && localDataTable.Psd == psd)
            {
                MessageBox.Show ("Erfolg");
            }
            oder
            {
                MessageBox.Show("falsch");
            }
        }

An diesem Punkt ist der Code für die Login-Oberfläche abgeschlossen. Du kannst es laufen lassen, um den Effekt zu sehen.