Autor: Willmove
Homepage: http://www.amuhouse.com
E-Mail: [email protected]
Haftungsausschluss: Dies ist das Originalwerk des Autors. Bitte geben Sie beim Nachdruck die Quelle an.
ASP.NET verwendet im Allgemeinen SQL Server als Backend-Datenbank. Im Allgemeinen verwenden Beispielprogramme für den ASP.NET-Datenbankbetrieb einen separaten Datenzugriff, was bedeutet, dass jede Seite Code schreibt, um eine Verbindung zur Datenbank herzustellen, auf Daten zuzugreifen und die Datenbank zu schließen. Diese Methode bringt einige Nachteile mit sich: Wenn sich Ihre Datenbank ändert, müssen Sie den Datenbankverbindungscode Seite für Seite ändern.
Der zweite Nachteil ist die Coderedundanz. Viel Code wird wiederholt und ist unnötig.
Daher habe ich versucht, den Datenzugriff vom Typ ASP.NET über eine konsistente Datenbankoperationsklasse zu implementieren.
Nehmen wir als Beispiel das Pressemitteilungssystem, das auf allgemeinen Websites zu finden ist. Es erfordert eine Artikeldatenbank. Wir nennen diese Datenbank News_Articles. Das Pressemitteilungssystem umfasst das Veröffentlichen von Nachrichten, das Anzeigen von Artikeln, das Verwalten von Artikeln usw.
Ein Artikel hat im Allgemeinen einen Titel, einen Autor, eine Veröffentlichungszeit und einen Inhalt, und wir müssen diese nummerieren. Wir schreiben es als eine Klasse namens Article-Klasse. Der Code lautet wie folgt:
//Article.cs
using System;
Namensraum News_Articles.Data
{
/// <Zusammenfassung>
/// Zusammenfassende Beschreibung für Artikel.
/// </summary>
Artikel der öffentlichen Klasse
{
private int _id; //Artikelnummer
private string _author; //Der Autor des Artikels
private string _topic; //Der Titel des Artikels
private DateTime _postTime; //Die Veröffentlichungszeit des Artikels
private string _content; //Artikelinhalt
public int ID
{
get { return _id;}
set { _id = value;}
}
öffentlicher String Autor
{
get { return _author }
set { _author = value }
}
öffentliches String-Thema
{
get { return _topic }
set { _topic = value }
}
öffentlicher String-Inhalt
{
get { return _content }
set { _content = value }
}
öffentliche DateTime PostTime
{
get { return _postTime }
set { _postTime = value }
}
}
}
Dann schreiben wir eine Artikelsammlungsklasse ArticleCollection
Der Code lautet wie folgt
Programmcode
//ArticleCollection.cs
using System[color=#0000ff];
mit System.Collections;
Namespace News_Articles.Data
{
/// <Zusammenfassung>
/// Sammlungsklasse von Artikeln, geerbt von ArrayList
/// </summary>
öffentliche Klasse ArticleCollection: ArrayList
{
öffentliche Artikelsammlung(): base()
{
}
public ArticleCollection(ICollection c) : base(c)
{
}
}
}[/Farbe]
Diese Klasse entspricht einem DataSet in ASP.NET (eigentlich sind die beiden sehr unterschiedlich). Ihr Hauptzweck besteht darin, viele Artikel zu sammeln, damit DataGrid oder DataList als Datenquelle in ASP.NET verwendet werden können Seite. Artikel anzeigen.
Jetzt können wir die Operation in der Datenbank News_Articles implementieren. Wie gesagt, dies ist eine Datenbankoperationsklasse. Könnte es auch ArticleDb nennen. Die Implementierung ist wie folgt:
Programmcode
//ArticleDb.cs
Verwenden des Systems;
Verwenden von System.Configuration;
Verwenden von System.Data;
mit System.Data.SqlClient;
Namespace News_Articles.Data
{
/**//// <Zusammenfassung>
/// Datenbankoperationsklasse, die das Lesen, Einfügen, Aktualisieren und Löschen der Artikeldatenbank realisiert
/// </summary>
öffentliche Klasse ArticleDb
{
private SqlConnection _conn; //SQL Server-Datenbankverbindung
private string _articledb = "News_Articles"; //SQL Server-Artikeldatenbanktabelle
/**//// <Zusammenfassung>
/// Initialisierung der Klasse, Aufbau der Datenbankverbindung
/// </summary>
public ArticleDb()
{
_conn = new SqlConnection(ConfigurationSettings.AppSettings["connectionString"]);
}
/**//// <Zusammenfassung>
/// Datenbankverbindung öffnen
/// </summary>
öffentliche Leere Open()
{
if(_conn.State == ConnectionState.Closed)
_conn.Open();
}
/**//// <Zusammenfassung>
/// Datenbankverbindung schließen
/// </summary>
öffentliche Leere Close()
{
if(_conn.State == ConnectionState.Open)
_conn.Close();
}
/**//// <Zusammenfassung>
/// Alle Artikel in der Datenbank lesen
/// </summary>
/// <returns>ArticleCollection</returns>
öffentliche Artikelsammlung GetArticles()
{
ArticleCollection Articles = new ArticleCollection();
string sql = "Select * FROM " + _articledb;
SqlCommand cmd = new SqlCommand(sql,_conn);
SqlDataReader dr = cmd.ExecuteReader();
while(dr.Read())
{
Artikel art = PopulateArticle(dr);
Articles.Add(art);
}
dr.Close();
Rückgabeartikel;
}
/**//// <Zusammenfassung>
/// Bei gegebener Artikelnummer einen Artikel in der Datenbank lesen
/// </summary>
/// <returns>Artikel</returns>
öffentlicher Artikel GetArticle(int ArticleId)
{
string sql = "Select * FROM " + _articledb + "Where ID='" + ArticleId + "'";
SqlCommand cmd = new SqlCommand(sql,_conn);
SqlDataReader dr = cmd.ExecuteReader();
Artikel Article = PopulateArticle(dr);
dr.Close();
Artikel zurücksenden;
}
/**//// <Zusammenfassung>
/// Datenbankeinträge aktualisieren, bitte beachten Sie, dass Sie die Artikelnummer festlegen müssen
/// </summary>
/// <param name="article"></param>
public void UpdateArticle(Artikelartikel)
{
string sql = "Update " + _articledb +" SET Topic=@topic,Author=@author,Content=@content,PostTime=@postTime "
+ „Where ID = @articleId“;
SqlCommand cmd = new SqlCommand(sql,_conn);
cmd.Parameters.Add("@articleId",SqlDbType.Int,4).Value = Article.ID;
cmd.Parameters.Add("@topic",SqlDbType.NVarChar,100).Value = Article.Topic;
cmd.Parameters.Add("@author",SqlDbType.NVarChar,100).Value = Article.Author;
cmd.Parameters.Add("@content",SqlDbType.NText).Value = Article.Content;
cmd.Parameters.Add("@postTime",SqlDbType.DateTime).Value = Article.PostTime
(
}
/**//// <Zusammenfassung>
/// Holen Sie sich die von einem bestimmten Autor veröffentlichten Artikel in der Datenbank
/// </summary>
/// <param name="author"></param>
/// <returns>ArticleCollection</returns>
öffentliche ArticleCollection GetArticlesByAuthor(String-Autor)
{
string sql = "Select * FROM " + _articledb +" Where Author='" + author + "'";
SqlCommand cmd = new SqlCommand(sql, _conn);
ArticleCollection ArticleCollection = new SqlDataReader()
;
while (dr.Read())
{
Artikel a = PopulateArticle(dr);
ArticleCollection.Add(a);
}
dr.Close();
Artikel zurückgebenSammlung;
}
/**//// <Zusammenfassung>
/// Einen Artikel mit einer bestimmten Nummer löschen
/// </summary>
/// <param name="articleID"></param>
public void DeleteArticle(int ArticleID)
{
string sql = "Delete FROM " + _articledb + " Where ID='" + ArticleID + "'";
SqlCommand cmd = new SqlCommand(sql, _conn);
cmd.ExecuteNonQuery();
}
/**//// <Zusammenfassung>
/// Artikelobjekt über SqlDataReader generieren
/// </summary>
/// <param name="dr"></param>
/// <returns></returns>
privater Artikel PopulateArticle(SqlDataReader dr)
{
Artikel art = new Article();
art.ID = Convert.ToInt32(dr["ID"]);
art.Author = Convert.ToString(dr["Author"]);
art.Topic = Convert.ToString(dr["Topic"]);
art.Content = Convert.ToString(dr["Content"]);
art.PostTime= Convert.ToDateTime(dr["PostTime"]);
return art;
}
/**//// <Zusammenfassung>
/// Einen Artikel zur Datenbank hinzufügen und die Artikelnummer zurückgeben
/// </summary>
/// <param name="article"></param>
/// <returns>Die Nummer des gerade eingefügten Artikels</returns>
public int AddPost(Artikel Artikel)
{
string sql = "Insert INTO " + _articledb +"(Author,Topic,Content,PostTime)"+
„WERTE(@author, @topic, @content, @postTime)“+
„Wählen Sie @postID = @@IDENTITY“;
SqlCommand cmd = new SqlCommand(sql,_conn);
cmd.Parameters.Add("@postID",SqlDbType.Int,4);
cmd.Parameters["@postID"].Direction = ParameterDirection.Output;
cmd.Parameters.Add("@author",SqlDbType.NVarChar,100).Value = Article.Author;
cmd.Parameters.Add("@topic",SqlDbType.NVarChar,400).Value = Article.Topic;
cmd.Parameters.Add("@content",SqlDbType.Text).Value = Article.Content;
cmd.Parameters.Add("@postTime",SqlDbType.DateTime).Value = Article.PostTime;
cmd.ExecuteNonQuery();
Article.ID = (int)cmd.Parameters["@postID"].Value;
return Article.ID;
}
}
}
Das Grundgerüst liegt bereits vor. Wenn wir Daten aus der Artikeldatenbank News_Artices auf einer ASP.NET-Seite anzeigen möchten, müssen wir nur ein DataGrid oder eine DataList hinzufügen und dann die Datenquelle binden. Fügen Sie beispielsweise ein DataGrid in Default.aspx hinzu, nennen Sie es ArticlesDataGrid und fügen Sie
Programmcode
im Hintergrundcode Default.aspx.cs hinzu
mit News_Articles.Data;
Und fügen Sie den folgenden Code in Page_Load hinzu:
Programmcode
private void Page_Load(object sender, System.EventArgs e)
{
// Geben Sie hier den Benutzercode ein, um die Seite zu initialisieren
ArticleDb myArticleDb = new ArticleDb();
myArticleDb.Open();
ArticleCollection Articles = myArticleDb.GetArticles();
this.ArticlesDataGrid.DataSource = Artikel;
if(!Page.IsPostBack)
{
this.ArticlesDataGrid.DataBind();
}
myArticleDb.Close();
}
Auf diese Weise können alle Artikel in der Artikeldatenbank gelesen werden.
Wenn Sie einen Artikel löschen müssen, fügen Sie den folgenden Code hinzu:
Programmcode
//Löschen Sie den Artikel mit der Nummer 1
myArticleDb.DeleteArticle(1);
Fügen Sie einen Artikel ein. Der Code lautet wie folgt:
Programmcode
//Einen neuen Artikel ohne Angabe der Artikelnummer einfügen. Die Artikelnummer wird vom SQL Server zurückgegeben, nachdem die Artikelnummer erfolgreich eingefügt wurde.
Artikel newArticle = new Article();
newArticle.Author = "Willmove";
newArticle.Topic = „Testen Sie das Einfügen eines neuen Artikels“;
newArticle.Content = „Dies ist der Inhalt des Artikels, den ich geschrieben habe“;
newArticle.PostTime = DateTime.Now;
int ArticleId = myArticleDb.AddPost(newArticle);
Aktualisieren Sie einen Artikel mit dem folgenden Code:
Programmcode
//Aktualisieren Sie einen Artikel. Bitte beachten Sie, dass Sie die Artikelnummer angeben müssen
Artikel updateArticle = new Article();
updateArticle.ID = 3; //Beachten Sie, dass Sie die Artikelnummer angeben müssen
updateArticle.Author = "Willmove";
updateArticle.Topic = "Update-Daten testen";
updateArticle.Content = „Dies ist der Inhalt des Artikels, den ich aktualisiert habe“;
updateArticle.PostTime = DateTime.Now;
myArticleDb.UpdateArticle(updateArticle);
Das Obige ist nur ein Framework, und es gibt viele Details zur spezifischen Implementierung, die nicht aufgeführt sind. Basierend auf dem oben genannten Framework können Sie jedoch einfacher Code für Datenbankoperationen schreiben. Ein weiterer Vorschlag besteht darin, die obige SQL-Anweisung für den Datenbankzugriff als gespeicherte Datenbankprozedur zu schreiben, z. B. durch Hinzufügen eines Artikels:
Programmcode
Erstellen Sie PROCEDURE AddPost
(
@ID int OUTPUT,
@Author nvarchar(100),
@Topic nvarchar(100),
@Content ntext,
@PostTime Datum/Uhrzeit
)
ALS
Einfügen INTO News_Articles(Author, Topic, Content, PostTime) VALUES (@Author, @Topic, @Content, @PostTime);
Wählen Sie @ID = @@IDENTITY
GEHEN
Anhang 1: Felder der News_Articles-Datenbank
des Programmcodes
beschreibt, ob die Datentyplänge null sein kann
ID Artikelnummer int 4 Nr
Themenartikeltitel nvarchar 100 Nr
Autor Autornvarchar 100 ist
Inhalt Artikelinhalt ntext 16 Nr
PostTime-Veröffentlichungszeit datetime 8 Nein
Der Standardwert von PostTime kann auf (getutcdate()) gesetzt werden.
Die SQL-Anweisung lautet
Create TABLE [News_Articles] (
[ID] [int] IDENTITY (1, 1) NICHT NULL,
[Thema] [nvarchar] (100) COLLATE Chinese_PRC_CI_AS NOT NULL,
[Autor] [nvarchar] (100) COLLATE Chinese_PRC_CI_AS NULL ,
[Inhalt] [ntext] COLLATE Chinese_PRC_CI_AS NOT NULL,
[PostTime] [datetime] NOT NULL CONSTRAINT [DF_News_Articles_PostTime] DEFAULT (getutcdate())
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GEHEN
Anhang 2: Beschreibung des Quellcodes des News_Articles-Projekts: Bevor Sie die Projektdatei News_Articles.csproj öffnen, müssen Sie den virtuellen Pfad News_Articles festlegen oder die Einstellungen in News_Articles.csproj.webinfo ändern. Für den Normalbetrieb muss SQL Server installiert und die Artikeldatenbank News_Articles installiert sein. Im Stammverzeichnis des Projektquellcodes befinden sich SQL-Textdateien.