Je fais du développement web depuis plusieurs années. J'ai des compréhensions différentes dans différentes entreprises. J'ai récemment travaillé sur un projet de blog. J'ai réalisé le rôle des classes de modèles dans le développement Web. Je suis à la maison la nuit. J'ai toujours pensé que je pouvais créer une classe de modèles spécialement conçue pour le développement asp.ne. J'ai donc écrit cette classe modèle.
Adresse de téléchargement cliquez ici
Renommez simplement le fichier 500sea.txt téléchargé en Templet.rar et ouvrez-le.
si ouvert
http://img.club.163.com/images/user/other/500sea
Il n'y a aucune invite pour télécharger le fichier 500sea.txt. Utilisez ensuite Internet Express et d'autres outils pour télécharger cette adresse et modifiez le fichier 500sea.txt téléchargé en fichier *.rar.
Vous trouverez ci-dessous un fichier de description à l'intérieur
//------------------------------------------------ -------------------------------------------------- --------------------------//
introduire:
Cette classe de modèle est écrite pour le développement de sites Web à architecture à trois niveaux. Composant StringTempletReplet.dll
Contient des classes de modèles. Les classes de modèles dans l'espace de noms StringTempletReplet peuvent être utilisées dans la couche UI ou
à utiliser dans la couche logique.
************************************************** * ****************************
Comment exécuter :
Créez un répertoire virtuel nommé Templet pour faire référence au dossier Templet décompressé.
Exécutez les fichiers internes RetuenString.aspx, ReturnText.aspx, WriteArticon.aspx,
Page LongLoop.aspx. Il y a des instructions correspondantes sur le fichier cs correspondant à la page.
Lorsque la page est ouverte pour la première fois, l'objet délégué et le fichier modèle doivent être enregistrés dans le cache, la vitesse réelle dépend donc de la première page.
Une fois plus tard.
************************************************** * ****************************
Introduction du principe :
Un modèle pour le remplacement des étiquettes. Utilisation de l'arithmétique du pointeur en C# pour trouver l'emplacement de l'étiquette.
Utilisez l'objet délégué pour pointer vers la fonction d'analyse correspondant à la balise d'image et utilisez des objets statiques pour mettre en cache tous les objets délégués.
Mettez en cache l’intégralité du contenu du modèle sans modifier le corps du modèle. Les modèles peuvent être modifiés dynamiquement.
************************************************** * ****************************
Présentation de la balise :
Le contenu entre la paire de symboles spéciaux {$ et $} est une étiquette
comme
{$Nom de la balise :Paramètre 1 :Paramètre 2 :Paramètre 3 ::Caractère 10$}
{$tagname:paramètre1:paramètre2::octet10$}
{$dt[5][nom]$}
L'étiquette est divisée en deux parties (partie paramètre d'étiquette) et (partie contrôle de commande) via le symbole :: à l'intérieur de l'étiquette.
{$tagname:paramètre1:paramètre2:paramètre3::octet10$}
(Partie paramètre Tag) :: (Partie contrôle commande)
Dans ces deux parties, séparez la partie paramètre label et la partie contrôle commande par un signe :.
Partie paramètre de balise --- le premier est le nom de balise, qui est le nom correspondant de la fonction d'analyse de balise, et les suivants sont les paramètres de la fonction.
La fonction d'analyse de balises accepte tous les types de paramètres comme type de chaîne et le nombre de paramètres est compris entre 0 et 20.
Fonction, le type de retour est de type chaîne. Les paramètres peuvent être codés en dur sur l’étiquette ou écrits dynamiquement.
La partie contrôle des commandes --- il n'y a maintenant que deux caractères et octets de symbole de commande, suivis d'un paramètre numérique, indiquant la norme d'interception
La longueur du résultat de l'analyse de signature, par exemple 10 caractères et 10 octets.
Je développerai d'autres symboles de commandement et de contrôle à l'avenir.
Pour la correspondance entre les étiquettes et les fonctions, veuillez consulter les instructions dans le fichier Business.cs.
Pour les règles d'utilisation spécifiques des balises, veuillez consulter les instructions dans template/templet/aa1.htm.
Pour les règles d'appel spécifiques, veuillez consulter les trois pages aspx du projet.
WriteArticon.aspx - Système de nouvelles qui lit les modèles et analyse les fichiers écrits pour générer des pages statiques
ReturnText.aspx - Lit l'analyse du modèle et les chaînes de retour, utilisées pour écrire des pages qui doivent souvent modifier leur apparence.
Page écorchée. Les modèles peuvent être modifiés dynamiquement.
RetuenString.aspx - accepte les chaînes de balises et renvoie les résultats de l'analyse. Couramment utilisé avec ajax.
************************************************** * *****************************
Valeur dynamique de l'étiquette :
La fonction d'analyse de balise peut accepter des paramètres fixes transmis dans la balise. Il existe trois façons d'accepter les paramètres dynamiques
Après avoir transmis les objets Datatable et Hashtable à la classe de modèle
(Datatable est obtenu à partir de la couche de données, Hashtable est généralement constitué de variables de page et d'autres variables)
1. dt[5][name] ---- signifie obtenir la valeur dans la colonne de nom de 5 lignes du Datatable, la première est un nombre,
Le second est le nom de la colonne
2. dt[name] ---- En dehors de la boucle, cela signifie prendre la valeur dans la colonne nom de la ligne 0 du Datatable.
Un paramètre représente le nom de la colonne
---- Dans la boucle, cela signifie prendre la valeur de la colonne de nom dans le Datatable, prendre cela
Ces lignes sont déterminées par les paramètres de la balise de boucle.
3. page[PageId] ----- Représente la prise de la valeur de la clé PageId dans l'objet Hashtable et le renvoi du type de chaîne
Par exemple, {$deux paramètres bookmarks :dt[3][word]:page[UserId]::character 10$}
{$dt[5][name]$} {$dt[name]$} {$page[ ID de page ]$}
ou
{$dt[5][name]::Caractère 10$} {$dt[name]::Caractère 10$} {$page[PageId]::Caractère 10$}
Une telle balise indique que la valeur de l'objet est affichée directement sur la page.
************************************************** * ****************************
Appelez la méthode de classe modèle dans la page ou la classe :
Peut être appelé dans une page ou une classe
Générer des objets et associer les classes d'analyse de fonctions de balises correspondantes
//Ici, il suffit d'ajouter un objet de classe Business après cette ligne new Business()
//En utilisant des interfaces pour implémenter le polymorphisme, le code semble un peu lourd. Lorsque vous l'utilisez vous-même, modifiez simplement le dernier "new Business()" en votre propre classe contenant la fonction d'analyse des balises.
ILabelAnalyStart objILabel=(ILabelAnalyStart) new TempletReplet(new Business());
//Lire l'attribut du chemin du modèle
objILabel.ReadFilePath=this.Server.MapPath("templet/aa1.htm");
//Écrit l'attribut du chemin du fichier
objILabel.WritFilePath=this.Server.MapPath("page/aa1.html");
//Obtenir l'objet de table de données
objILabel.LabelDatatable=ds.Tables[0];
//Passez les variables de cette page à la classe modèle à l'aide d'objets Hashtable
objILabel.LabelHashtable=ht;
Ensuite, trois remplacements peuvent être réalisés.
// Commencer à remplacer et à écrire le modèle
objILabel.LaberReplet();
// renvoie le résultat de l'analyse
string aa=objILabel.LaberRepletText();
//Renvoie le résultat de l'analyse. Cela accepte directement la chaîne du modèle. Voir le fichier RetuenString.cs pour plus de détails.
string aa=objILabel.LaberRepletString();
Pour plus de détails, veuillez consulter les fichiers cs de ces trois fichiers
WriteArticon.aspx - Système de nouvelles qui lit les modèles et analyse les fichiers écrits pour générer des pages statiques
ReturnText.aspx - Lisez l'analyse du modèle pour renvoyer une chaîne et utilisez-la pour écrire des pages qui changent souvent d'apparence.
Page de changement de peau
RetuenString.aspx - accepte les chaînes de balises et renvoie les résultats analysés. Couramment utilisé avec ajax
********************************************** *** *******************************
Association de fonction d'étiquette :
Veuillez consulter le fichier Business.cs pour plus de détails.
Dans le constructeur statique de la classe correspondant à la couche logique, ajoutez le code suivant.
//Appelle le constructeur statique et place le délégué de la fonction d'exécution de balise dans la table de hachage statique
//Cette méthode doit être exécutée
Entreprise statique()
{
Business _this=new Business();
FunctionList.objFunctionHashtable.Add("Aucun signet de paramètre",new KeyItemDelegate(new UserDelegate.Run_0(_this.show),0));
FunctionList.objFunctionHashtable.Add("Un signet de paramètre",new KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
FunctionList.objFunctionHashtable.Add("Deux signets de paramètres",new KeyItemDelegate(new UserDelegate.Run_2(_this.tag_two),2));
//Les signets sont associés aux fonctions d'exécution. Mettez-le dans le constructeur statique de la classe d'analyse des signets. Il s'agit d'utiliser pleinement les objets en mémoire sans les exécuter à chaque fois.
// Le caractère "Un signet de paramètre" correspond à la fonction public string tag(string aa) Le mode correspondant consiste à ajouter une clé et une valeur à la table de hachage.
// ("Un signet de paramètre",new KeyItemDelegate(new UserDelegate.Run_1(_this.tag),1));
// nom de la balise |
// Utilisez le délégué Run_1 pour un paramètre. |
// Fonction d'exécution de balise correspondante |
// Pour un paramètre, écrivez le numéro un
// 0 ou plusieurs exemples correspondants ci-dessus
}
Veuillez consulter le fichier Business.cs pour plus de détails
******************************************* * ***********************************
Introduction à la boucle dans les balises :
Des boucles non imbriquées peuvent être réalisées grâce à certains symboles spéciaux dans les balises.
//------------------------------------------------ --------------------------
{$loop(3,0,alter)$} //Affichez trois lignes, en commençant par la ligne 0. S'il y a des colonnes alternées, exécutez les colonnes alternées.
{$BlockItem$} //Ligne de boucle par défaut,
<td bgcolor="#33ccff">Titre :{$dt[5][name]$}, Auteur :{$Un paramètre :dt[dddf]$}</td>
{$/BlocArticle$}
{$BlockAlterItem$} // Boucler alternativement les lignes Lorsqu'il n'y a pas de paire d'étiquettes de ligne par défaut, il existe une paire d'étiquettes de boucle alternative. Traitez la paire d'étiquettes alternées comme la paire d'étiquettes de ligne par défaut
<td bgcolor="#ff6699">Titre :{$dt[5][name]$}, auteur :{$one paramètre :dt[dddf]$}</td>
{$/BlockAlterItem$}
{$BlockPatch$} //Lorsque le nombre de lignes à boucler est supérieur au nombre de lignes dans le Datatable, utilisez le contenu ici pour compléter l'affichage. S'il n'y a pas de paire de balises "supplémentaires". Ensuite, lorsque le nombre de lignes affichées est supérieur au nombre de lignes du Datatable, seul le nombre de lignes du Datatable sera affiché.
<td bgcolor="#33ccff">Supplément (les balises peuvent également être utilisées à l'intérieur)</td>
{$/BlocPatch$}
{$BlockAlterPatch$} //Il n'y a pas de paire d'étiquettes supplémentaire, mais il existe des paires d'étiquettes supplémentaires alternatives. traiter les paires de balises supplémentaires alternées comme des paires de balises supplémentaires
<td bgcolor="#ff6699">Supplément alternatif (les tags peuvent également être utilisés à l'intérieur)</td>
{$/BlockAlterPatch$}
{$/loop$} //fin de boucle
//------------------------------------------------ ---------------
{$BlockItem$} {$/BlockItem$} : paire d'étiquettes de ligne en boucle par défaut
{$BlockAlterItem$} {$/BlockAlterItem$} : cyclez alternativement les paires d'étiquettes de ligne
{$BlockPatch$} {$/BlockPatch$} : paire d'étiquettes de ligne supplémentaire par défaut
{$BlockAlterPatch$} {$/BlockAlterPatch$} : Compléter alternativement les paires d'étiquettes de ligne
//------------------------------- -- -------------
Si vous n'avez que la ligne de boucle par défaut, vous ne pouvez pas ajouter la paire de balises {$BlockItem$}.
comme
{$boucle(3,0,altérer)$}
<tr><td>{$balise de fonction$}</td></tr>
{$/boucle$}
et
{$boucle(3,0,altérer)$}
{$BlockItem$}<tr><td>{$function label$}</td></tr>{$/BlockItem$}
{$/boucle$}
Cela signifie le même effet
//------------------------------------------------ -------------
{$boucle(3,0,altérer)$}
{$BlockAlterPatch$}
<tr><td>{$balise de fonction$}</td></tr>
{$/BlockAlterPatch$}
{$/boucle$}
S'il n'y a que des paires d'étiquettes de ligne de cycle alternées et qu'il n'y a pas de paire d'étiquettes de ligne de cycle par défaut, la paire d'étiquettes de ligne de cycle alternée sera automatiquement convertie en
Paires d'étiquettes de ligne de boucle par défaut
//------------------------------------------------ ---------------
{$boucle(3,0,altérer)$}
{$BlockAlterPatch$}
<tr><td>{$balise de fonction$}</td></tr>
{$/BlockAlterPatch$}
{$/boucle$}
S'il n'y a que des paires d'étiquettes de ligne supplémentaires alternées et qu'il n'y a pas de paire d'étiquettes de ligne supplémentaire par défaut, les paires d'étiquettes de ligne supplémentaires alternées seront automatiquement converties en
Paires d'étiquettes de ligne de boucle par défaut
************************************************** * **********************
Description du paramètre de boucle :
{$boucle(3,0,altérer)$}
Il y a trois paramètres en boucle, qui peuvent être réduits de manière appropriée.
Premier paramètre :
3 : Bouclez 3 fois, pas moyen de tout boucler
Deuxième paramètre :
2 : Commencer à 2, ne veut pas dire commencer à 0
Le troisième paramètre :
modifier : alterner
noalter : pas d'alternance S'il n'y a aucune indication, la valeur par défaut est l'alternance, donc c'est la même chose si alter est ajouté ou non.
Si les trois paramètres sont omis, au moins une paire de crochets vides {$loop()$} doit être conservée.
Représente le nombre de lignes dans la boucle Datatable
À partir de la ligne 0, s’il y a un supplément, le supplément sera affiché.
************************************************** * *************************
Il y a eu une mise à jour. Principalement une boucle d'optimisation.
Il faut désormais 300 à 400 millisecondes pour parcourir une table de 50 000 lignes.
************************************************** * *************************
Il est recommandé que le modèle ne dépasse pas 85 Ko et veillez à ne pas devenir un objet de grande taille. Il est recommandé que le nombre de modèles de page pour les objets de deuxième génération soit inférieur ou égal à 919 et que le nombre de balises de fonction correspondantes ne dépasse pas 1 597.
C'est agréable de voir la classe de modèles grandir avec ma propre compréhension.
************************************************** * ****************************