Ich beschäftige mich seit mehreren Jahren mit der Webentwicklung. Ich habe in verschiedenen Unternehmen unterschiedliche Verständnisse. Ich habe kürzlich an einem Blog-Projekt gearbeitet. Ich habe die Rolle von Vorlagenklassen in der Webentwicklung erkannt. Ich bin nachts zu Hause. Ich dachte immer, ich könnte eine Vorlagenklasse erstellen, die speziell für die asp.ne-Entwicklung entwickelt wurde. Also habe ich diese Vorlagenklasse geschrieben.
Klicken Sie hier, um die Adresse herunterzuladen
Benennen Sie einfach die heruntergeladene Datei 500sea.txt in Templet.rar um und öffnen Sie sie.
wenn geöffnet
http://img.club.163.com/images/user/other/500sea
Es erfolgt keine Aufforderung zum Herunterladen der Datei 500sea.txt. Verwenden Sie dann Internet Express und andere Tools, um diese Adresse herunterzuladen und die heruntergeladene Datei 500sea.txt in eine *.rar-Datei umzuwandeln.
Unten finden Sie eine Beschreibungsdatei
//------------------------------------------------ -------------------------------------------------- --------------------------//
einführen:
Diese Vorlagenklasse ist für die Entwicklung von Websites mit dreistufiger Architektur geschrieben. StringTempletReplet.dll-Komponente
Enthält Vorlagenklassen. Die Vorlagenklassen im StringTempletReplet-Namespace können in der UI-Ebene oder verwendet werden
zur Verwendung in der Logikschicht.
************************************************** * **************************
So führen Sie aus:
Erstellen Sie ein virtuelles Verzeichnis mit dem Namen Templet, um auf den dekomprimierten Templet-Ordner zu verweisen.
Führen Sie die internen Dateien RetuenString.aspx, ReturnText.aspx, WriteArticon.aspx aus.
LongLoop.aspx-Seite. Es gibt entsprechende Anweisungen in der CS-Datei, die der Seite entspricht.
Wenn die Seite zum ersten Mal geöffnet wird, sollten das Delegate-Objekt und die Vorlagendatei im Cache gespeichert werden, sodass die tatsächliche Geschwindigkeit von der ersten Seite abhängt.
Einmal später.
************************************************** * **************************
Prinzipeinführung:
Eine Vorlage zum Ersetzen von Etiketten. Verwendete Zeigerarithmetik in c#, um die Position der Beschriftung zu finden.
Verwenden Sie das Delegate-Objekt, um auf die dem Bild-Tag entsprechende Analysefunktion zu verweisen, und verwenden Sie statische Objekte, um alle Delegate-Objekte zwischenzuspeichern.
Cachen Sie den gesamten Vorlageninhalt, ohne den Vorlagentext zu ändern. Vorlagen können dynamisch geändert werden.
************************************************** * **************************
Tag-Einführung:
Der Inhalt zwischen dem Paar Sonderzeichen {$ und $} ist eine Beschriftung
wie
{$Tag name:Parameter 1:Parameter 2:Parameter 3::Zeichen 10$}
{$tagname:parameter1:parameter2::byte10$}
{$dt[5][name]$}
Das Etikett ist durch das ::-Symbol innerhalb des Etiketts in zwei Teile (Etikettenparameterteil) und (Befehlssteuerungsteil) unterteilt.
{$tagname:parameter1:parameter2:parameter3::byte10$}
(Tag-Parameterteil) :: (Befehlssteuerungsteil)
Trennen Sie in diesen beiden Teilen den Beschriftungsparameterteil und den Befehlssteuerungsteil durch ein :-Zeichen.
Tag-Parameterteil – der erste ist der Tag-Name, der dem Namen der Tag-Parsing-Funktion entspricht, und die folgenden sind die Parameter der Funktion.
Die Tag-Parsing-Funktion akzeptiert alle Parametertypen als Zeichenfolgentyp und die Anzahl der Parameter beträgt 0-20.
Funktion, der Rückgabetyp ist der String-Typ. Parameter können auf dem Etikett fest codiert oder dynamisch geschrieben werden.
Der Befehlssteuerungsteil – jetzt gibt es nur noch zwei Befehlssymbolzeichen und Bytes, gefolgt von einem numerischen Parameter, der den Abfangstandard angibt
Die Länge des Signatur-Parsing-Ergebnisses, z. B. 10 Zeichen und 10 Byte.
Ich werde in Zukunft weitere Befehls- und Kontrollsymbole erweitern.
Informationen zur Entsprechung zwischen Beschriftungen und Funktionen finden Sie in den Anweisungen in der Datei Business.cs.
Spezifische Nutzungsregeln für Tags finden Sie in den Anweisungen in template/templet/aa1.htm.
Spezifische Aufrufregeln finden Sie auf den drei ASPX-Seiten im Projekt.
WriteArticon.aspx – Nachrichtensystem, das Vorlagen liest und geschriebene Dateien analysiert, um statische Seiten zu generieren
ReturnText.aspx – Vorlagenanalyse lesen und Zeichenfolgen zurückgeben, die zum Schreiben von Seiten verwendet werden, deren Erscheinungsbild häufig geändert werden muss.
Gehäutete Seite. Vorlagen können dynamisch geändert werden.
RetuenString.aspx – akzeptiert Tag-Strings und gibt Parsing-Ergebnisse zurück. Wird häufig mit Ajax verwendet.
************************************************** *******************************
Dynamischer Labelwert:
Die Tag-Parsing-Funktion kann im Tag übergebene feste Parameter akzeptieren. Es gibt drei Möglichkeiten, dynamische Parameter zu akzeptieren
Nach der Übergabe von Datatable- und Hashtable-Objekten an die Vorlagenklasse
(Die Datentabelle wird aus der Datenschicht abgerufen. Hashtable besteht im Allgemeinen aus Seitenvariablen und anderen Variablen.)
1. dt[5][name] ---- bedeutet, den Wert in der Namensspalte von 5 Zeilen in der Datentabelle abzurufen, der erste ist eine Zahl,
Der zweite ist der Spaltenname
2. dt[name] ---- Außerhalb der Schleife bedeutet dies, dass der Wert in der Namensspalte von Zeile 0 in der Datentabelle übernommen wird.
Ein Parameter repräsentiert den Spaltennamen
---- In der Schleife bedeutet es, den Wert der Namensspalte in der Datentabelle zu übernehmen
Diese Zeilen werden durch die Parameter des Loop-Tags bestimmt.
3. page[PageId] ----- Stellt dar, dass der Wert des PageId-Schlüssels im Hashtable-Objekt übernommen und der Zeichenfolgentyp zurückgegeben wird
Zum Beispiel: {$two Parameter bookmarks:dt[3][word]:page[UserId]::character 10$}
{$dt[5][name]$} {$dt[name]$} {$page[ Seiten-ID ]$}
oder
{$dt[5][name]::Zeichen 10$} {$dt[name]::Zeichen 10$} {$page[PageId]::Zeichen 10$}
Ein solches Tag gibt an, dass der Wert im Objekt direkt auf der Seite angezeigt wird.
************************************************** * **************************
Rufen Sie die Vorlagenklassenmethode innerhalb der Seite oder Klasse auf:
Kann innerhalb einer Seite oder Klasse aufgerufen werden
Generieren Sie Objekte und ordnen Sie entsprechende Parsing-Klassen für Tag-Funktionen zu
//Hier müssen wir nach dieser Zeile nur ein Business-Klassenobjekt hinzufügen new Business()
//Der Code sieht etwas umständlich aus, wenn Schnittstellen zum Implementieren von Polymorphismus verwendet werden. Wenn Sie es selbst verwenden, ändern Sie einfach das letzte „new Business()“ in Ihre eigene Klasse, die die Tag-Parsing-Funktion enthält.
ILabelAnalyStart objILabel=(ILabelAnalyStart) new TempletReplet(new Business());
//Vorlagenpfadattribut lesen
objILabel.ReadFilePath=this.Server.MapPath("templet/aa1.htm");
//Schreiben Sie das Dateipfadattribut
objILabel.WritFilePath=this.Server.MapPath("page/aa1.html");
//Datentabellenobjekt abrufen
objILabel.LabelDatatable=ds.Tables[0];
//Übergeben Sie die Variablen auf dieser Seite mithilfe von Hashtable-Objekten an die Vorlagenklasse
objILabel.LabelHashtable=ht;
Dann können drei Ersetzungen erreicht werden
// Beginnen Sie mit dem Ersetzen und Schreiben der Vorlage
objILabel.LaberReplet();
//Parsing-Ergebnis zurückgeben
string aa=objILabel.LaberRepletText();
//Das Parsing-Ergebnis zurückgeben. Dies akzeptiert direkt die Vorlagenzeichenfolge.
string aa=objILabel.LaberRepletString();
Einzelheiten finden Sie in den CS-Dateien dieser drei Dateien
WriteArticon.aspx – Nachrichtensystem, das Vorlagen liest und geschriebene Dateien analysiert, um statische Seiten zu generieren
ReturnText.aspx – Vorlagenanalyse lesen, um eine Zeichenfolge zurückzugeben und diese zum Schreiben von Seiten zu verwenden, die häufig ihr Erscheinungsbild ändern.
Seite zum Hautwechsel
RetuenString.aspx – akzeptiert Tag-Strings und gibt analysierte Ergebnisse zurück. Wird häufig mit Ajax verwendet
********************************************** *** *******************************
Label-Funktionszuordnung:
Weitere Informationen finden Sie in der Datei „Business.cs“.
Fügen Sie im statischen Konstruktor der Klasse, die der Logikschicht entspricht, den folgenden Code hinzu.
// Rufen Sie den statischen Konstruktor auf und platzieren Sie den Delegaten der Tag-Ausführungsfunktion in der statischen Hash-Tabelle
//Diese Methode muss ausgeführt werden
statisches Geschäft()
{
Business _this=new Business();
FunctionList.objFunctionHashtable.Add("Kein Parameter-Lesezeichen",new KeyItemDelegate(new UserDelegate.Run_0(_this.show),0));
FunctionList.objFunctionHashtable.Add("Ein Parameter-Lesezeichen",neu KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
FunctionList.objFunctionHashtable.Add("Zwei Parameter-Lesezeichen",new KeyItemDelegate(new UserDelegate.Run_2(_this.tag_two),2));
//Lesezeichen sind mit Ausführungsfunktionen verknüpft. Fügen Sie es in den statischen Konstruktor der Lesezeichen-Analyseklasse ein. Dies dient dazu, die Objekte im Speicher vollständig zu nutzen, ohne sie jedes Mal auszuführen.
// Das Zeichen „Ein Parameter-Lesezeichen“ entspricht der öffentlichen Zeichenfolgen-Tag-Funktion (Zeichenfolge aa). Der entsprechende Modus besteht darin, Schlüssel und Wert zur Hash-Tabelle hinzuzufügen.
// ("Ein Parameter-Lesezeichen",new KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
// Tag-Name |. |
// Den Run_1-Delegaten für einen Parameter verwenden. |. |
// Entsprechende Tag-Ausführungsfunktion |
// Für einen Parameter schreibe die Nummer Eins
// 0 oder mehr entsprechende Beispiele oben
}
Weitere Informationen finden Sie in der Datei „Business.cs“
. ***************************************** * ************************************
Einführung in die Schleife innerhalb von Tags:
Nicht verschachtelte Schleifen können durch einige spezielle Symbole in den Tags realisiert werden.
//------------------------------------------------ --------------------------
{$loop(3,0,alter)$} //Drei Zeilen anzeigen, beginnend mit Zeile 0. Wenn alternierende Spalten vorhanden sind, führen Sie die alternierenden Spalten aus.
{$BlockItem$} //Standardschleifenzeile,
<td bgcolor="#33ccff">Titel:{$dt[5][name]$}, Autor:{$One Parameter:dt[dddf]$}</td>
{$/BlockItem$}
{$BlockAlterItem$} // Zeilen abwechselnd schleifen Wenn es kein standardmäßiges Zeilenbeschriftungspaar gibt, gibt es ein alternatives Schleifenbeschriftungspaar. Behandeln Sie das alternierende Beschriftungspaar als Standardzeilenbeschriftungspaar
<td bgcolor="#ff6699">Titel:{$dt[5][name]$}, Autor:{$one Parameter:dt[dddf]$}</td>
{$/BlockAlterItem$}
{$BlockPatch$} //Wenn die Anzahl der zu durchlaufenden Zeilen größer ist als die Anzahl der Zeilen in der Datentabelle, verwenden Sie den Inhalt hier, um die Anzeige zu ergänzen. Wenn kein „ergänzendes“ Tag-Paar vorhanden ist. Wenn dann die Anzahl der angezeigten Zeilen größer ist als die Anzahl der Zeilen in der Datentabelle, wird nur die Anzahl der Zeilen in der Datentabelle angezeigt.
<td bgcolor="#33ccff">Ergänzung (Tags können auch im Inneren verwendet werden)</td>
{$/BlockPatch$}
{$BlockAlterPatch$} //Es gibt kein zusätzliches Label-Paar, aber es gibt alternative ergänzende Label-Paare. Behandeln Sie abwechselnde Ergänzungs-Tag-Paare als Ergänzungs-Tag-Paare
<td bgcolor="#ff6699">Alternative Ergänzung (Tags können auch im Inneren verwendet werden)</td>
{$/BlockAlterPatch$}
{$/loop$} //Ende der Schleife
//------------------------------------------------ ---------------
{$BlockItem$} {$/BlockItem$}: Standardbeschriftungspaar für Schleifenzeilen
{$BlockAlterItem$} {$/BlockAlterItem$} : Zeilenbeschriftungspaare abwechselnd durchlaufen
{$BlockPatch$} {$/BlockPatch$}: Standard-Zusatzzeilenbeschriftungspaar
{$BlockAlterPatch$} {$/BlockAlterPatch$}: Zeilenbeschriftungspaare abwechselnd ergänzen
//------------------------------- -- -----------------------
Wenn Sie nur über die Standardschleifenlinie verfügen, können Sie das Tag-Paar {$BlockItem$} nicht hinzufügen.
wie
{$loop(3,0,alter)$}
<tr><td>{$function tag$}</td></tr>
{$/loop$}
Und
{$loop(3,0,alter)$}
{$BlockItem$}<tr><td>{$function label$}</td></tr>{$/BlockItem$}
{$/loop$}
Es bedeutet den gleichen Effekt
//------------------------------------------------ -------------
{$loop(3,0,alter)$}
{$BlockAlterPatch$}
<tr><td>{$function tag$}</td></tr>
{$/BlockAlterPatch$}
{$/loop$}
Wenn es nur Beschriftungspaare für alternierende Zykluszeilen und kein standardmäßiges Zeilenbeschriftungspaar für Zykluszeilen gibt, wird automatisch das Beschriftungspaar für abwechselnde Zykluszeilen konvertiert
Standardbeschriftungspaare für Schleifenlinien
//------------------------------------------------ ---------------
{$loop(3,0,alter)$}
{$BlockAlterPatch$}
<tr><td>{$function tag$}</td></tr>
{$/BlockAlterPatch$}
{$/loop$}
Wenn nur alternierende zusätzliche Zeilenbeschriftungspaare vorhanden sind und es kein standardmäßiges zusätzliches Zeilenbeschriftungspaar gibt, werden die alternierenden zusätzlichen Zeilenbeschriftungspaare automatisch konvertiert
Standardbeschriftungspaare für Schleifenlinien
************************************************** * **********************
Schleifenparameterbeschreibung:
{$loop(3,0,alter)$}
Es gibt drei Parameter in der Schleife, die entsprechend reduziert werden können.
Erster Parameter:
3: 3-mal wiederholen, nicht alles wiederholen
Zweiter Parameter:
2: Beginnen Sie bei 2, bedeutet nicht, dass Sie bei 0 beginnen müssen
Der dritte Parameter:
ändern: abwechselnd
noalter: keine Alternation. Wenn kein Hinweis vorhanden ist, ist die Standardeinstellung alternation, es ist also gleich, ob alternation hinzugefügt wird oder nicht.
Wenn alle drei Parameter weggelassen werden, muss mindestens ein Paar leerer Klammern {$loop()$} erhalten bleiben.
Stellt die Anzahl der Zeilen in der Schleifendatentabelle dar
Ab Zeile 0 wird, wenn ein Nachtrag vorhanden ist, der Nachtrag angezeigt.
************************************************** **************************
Es gab ein Update. Hauptsächlich Optimierungsschleife.
Jetzt dauert es 300–400 Millisekunden, eine Tabelle mit 50.000 Zeilen zu durchlaufen.
************************************************** **************************
Es wird empfohlen, dass die Vorlage nicht größer als 85 KB ist und darauf geachtet wird, dass sie nicht zu einem großen Objekt wird. Es wird empfohlen, dass die Anzahl der Seitenvorlagen für Objekte der zweiten Generation kleiner oder gleich 919 sein sollte und die Anzahl der entsprechenden Funktions-Tags 1597 nicht überschreiten sollte.
Es ist schön zu sehen, wie die Vorlagenklasse mit meinem eigenen Verständnis wächst.
************************************************** * **************************