Dans le domaine du développement .Net, vous et votre entreprise êtes-vous préoccupés par les problèmes suivants ?
1. DataRow dans DataSet ne peut obtenir des données que sous la forme de DataTable[0].Rows[0]["Name"]
2. Configuration SQL. Le SQL n'est pas dynamique et clair.
3. Utilisez l'ORM de JAVA pour concevoir .Net et utiliser la couche objet. Chaque modification affectera l'objet réfléchi.
Alors veuillez continuer à lire l'article suivant
Mappage relationnel objet/DataSet
(Mappage relationnel objet/ensemble de données)
Le mode NickLee.ODRM peut bien résoudre les problèmes ci-dessus
1. DataRow dans DataSet ne peut être que DataTable[0].Rows[0][" Nom"] méthode pour obtenir
la solution de données : DataRow est converti en un objet sérialisé, mais l'objet sérialisé n'est utilisé que comme une entité d'opération d'objet claire pour traiter le jugement commercial et les données
2. La configuration SQL n'est pas une solution patchwork SQL dynamique et peu claire
: en utilisant l'architecture de couche de données IBatisNet, en utilisant la syntaxe SQL dynamique d'IBatisNet, mais en renvoyant DataSet
3. Utilisez l'ORM de JAVA pour concevoir .Net et utiliser la couche objet. Chaque modification affectera l'objet réfléchi.
Solution : Effacer O (couche d'objet), pas de mécanisme de réflexion, éviter les modifications du calque d'objet à chaque modification.
Une explication détaillée est donnée ci-dessous.
La démonstration de code suivante sera incluse dans NickLee.Framework.2.0.1.2 et ci-dessus. Bien entendu, nous ne fournissons qu'une idée et une solution flexible, qui ne représente que la réflexion de l'équipe TheFallAngel.
La dll qui doit être référencée
IBatisNet (Version 1.5 et ultérieure) avec NickLee.Framework version modifiée
NickLee.Web.UI (Version 2006.2.1447 et ultérieure)
1. cXTM_User.cs
utilisant System
utilisant System.Data
utilisant System.Configuration ;
en utilisant System.Web ;
en utilisant System.Web.Security ;
en
utilisant System.Web.UI.WebControls ;
en utilisant System.Web.UI.HtmlControls
;
/// <summary>
/// cXTM_User.Serialization
/// </summary>
[Sérialisable]
public class cXTM_User
{
private int _dID;
privatestring _userName
()
{
//
// TODO : Ajouter ici la logique du constructeur
/ /
}
public int DID
{
get
{
return _dID;
}
set
{
_dID=
value;
}
}
public string UserName
{
get
{
return
_userName
}
set
{
_userName =
value
;
propriétés de cette classe pour le tableau dans Propertylist et assurez-vous que le nom est unique
/// et cohérent avec le nom de la requête dans SelectXTM_UserByKey_Test dans XTM_User
/// </summary>
public string[] Propertylist
{
get
{
return new string[ ] { " Nom d'utilisateur", "DID" };
}
}
}
2. XTM_User.xml
<?xml version='1.0' encoding='UTF-8' ?>
<sqlMap namespace='XTM_User' xmlns=" http:// ibatis.apache .org/mapping " xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance ">
<statements>
<select id='SelectXTM_UserByKey_Test' parameterClass='System.Collections.Hashtable'>
SELECT
Top 5
[DID],
[UserName],
[LoginName],
[PWD],
[LoginFlag],
[StopFlag],
[LoginTime],
[LASTUPDATE]
FROM [XTM_User]
</select>
</statements>
</sqlMap>
3. test.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="test.aspx.cs" Inherits="ODRM_test" %>
<%@ Register Assembly="NickLee.Web.UI" Namespace= "NickLee.Web.UI" TagPrefix="NickLee" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" " http://www.w3.org/TR/xhtml1/DTD /xhtml1-transitional.dtd ">
<html xmlns=" http://www.w3.org/1999/xhtml " >
<head runat="server">
<title>Mappage relationnel objet/DataSet (Mappage relationnel objet/DataSet )</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<NickLee:ExDataGrid ID="ExDataGrid1" runat="server" OnItemDataBound="ExDataGrid1_ItemDataBound"
>
< /NickLee:ExDataGrid></div>
</form>
</body>
</html>
4. test.aspx.cs
utilisant System ;
utilisant System.Data
utilisant System.Configuration
utilisant
System.Collections ;
Web ;
en utilisant System.Web.Security ;
en utilisant
System.Web.UI.WebControls ;
en utilisant System.Web.UI.WebControls.WebParts
;
en utilisant IBatisNet.DataMapper ;
en utilisant System.Reflection ;
classe partielle publique ODRM_test : PageBase
{
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
DataSet set11 = Mapper.Instance().QueryForDataSet("SelectXTM_UserByKey_Test",UIhashtable
table1 = ConvertDataTable(set11, " ");
//Voici la classe de sérialisation auto-définie
cXTM_User[] objModel = new cXTM_User[table1.Rows.Count];
//DataTable est converti en un tableau de classe de sérialisation
pour (int y = 0; y < table1.Rows . Count; y++)
{
objModel[y] = new cXTM_User();
DataTableReturnOO(table1.Rows[y], objModel[y]);
//
LierExDataGrid1.DataSource = table1
en mode DataSet
// Sérialiser le mode objet
;liaison
//ExDataGrid1.DataSource = objModel;
ExDataGrid1.DataBind(
)
;
protected void ExDataGrid1_ItemDataBound(object sender, DataGridItemEventArgs e)
{
/*
* Le champ d'application de cette partie
* Pour interroger la modification d'une donnée, vous pouvez utiliser objModel.UserName
* au lieu d'utiliser DataTable[0].Rows[0] ["UserName"] Modèle
* Améliorer le degré d'orientation objet et réduire une partie du codage des processus métier
*/
if (e.Item.ItemIndex != -1)
{
cXTM_User objModel = new cXTM_User();
//Si le DataGrid est rempli pour le DataSet
if (e.Item.DataItem.GetType().FullName == "System.Data.DataRowView")
{
DataTableReturnOO((DataRow)((DataRowView)e.Item.DataItem). Row, objModel);
}
//Sinon, il est considéré comme un objet sérialisé rempli
else
{
objModel = (cXTM_User)e.Item.DataItem;
}
}
}
/// <summary>
/// DataSet est converti en fonction de classe de sérialisation, la définition de classe fait référence à cXTM_User
/// </summary>
private void DataTableReturnOO(DataRow row, cXTM_User objModel)
{
Hashtable hTable = new Hashtable();
hTable = ReturnHashtable (ligne);
Tapezentitytype = Type.GetType(objModel.GetType().AssemblyQualifiedName);
pour (int j = 0; j < objModel.Propertylist.Length; j++)
{
PropertyInfo propertyinfo =entitytype.GetProperty(
objModel.Propertylist[j
]););
}
}
/// <summary>
/// Convertir en DataTable
/// </summary>
/// <param name="Source">Source de données</param>
/// <param name="DataMember">Nom de la table de données </param>
public static DataTable ConvertDataTable(object Source, string DataMember)
{
DataTable baseTable = new DataTable();
if (La source est DataTable)
{ baseTable = (DataTable)Source }
if
(
La
source est DataSet)
{
DataSet set1 = (DataSet)Source;
if ((set1.Tables.Count > 1) && ((DataMember == null) || (DataMember == "")))
{
throw new Exception("S'il y en a plusieurs table dans votre ensemble de données, vous devez définir la propriété DataMember pour spécifier quelle table utiliser.");
}
if (set1.Tables.Count < 1)
{
throw new Exception("Il n'y a aucune table dans la source de données.");
}
if ((DataMember != null) && (DataMember != ""))
{
baseTable = set1.Tables[DataMember]
;
else
{
baseTable
= set1.Tables[0
]
;
}
renvoie la Table de base
}
/// <summary>
/// Renvoyer DataTable sous forme de paire clé-valeur de table de hachage
/// </summary>
/// <param name="SourceTable">Objet de ligne de données</param>
/// <returns>< /returns>
public static Hashtable ReturnHashtable(DataRow SourceRow)
{
Hashtable hTable = new Hashtable();
IList list = SourceRow.ItemArray;
object[] tObj = new object[SourceRow.Table.Columns.Count];
pour (int i = 0; i < SourceRow.Table.Columns.Count; i++)
{
tObj[SourceRow.Table.Columns.IndexOf(SourceRow.Table.Columns[i].ColumnName)] = SourceRow.Table.Columns[i ].NomColonne
}
for (int x = 0; x < list.Count; x++)
{
hTable.Add(tObj[x].ToString(), list[x]
}
return hTable
}
}
5. PageBase.cs
utilisant System ;
utilisant System.Data ;
utilisant System.Configuration ;
utilisantSystem.Web.Security
;
utilisant
System.Web.UI.WebControls
; Web.UI.WebControls.WebParts ;
utilisant System.Web.UI.HtmlControls ;
en utilisant System.Reflection ;
en utilisant System.Text ;
en utilisant System.Collections ;
//un espace de noms est requis
//namespace Framework.Web.UIProcess
//{
/// <summary>
/// Description récapitulative de PageBase
/// </summary>
/// <summary>
/// Couche de page ( Couche de présentation ) classe de base, toutes les pages héritent de cette page
/// </summary>
classe publique PageBase : System.Web.UI.Page
{
#region L'ensemble du système a une
chaîne privée _baseselect;
/// <summary>
/// Champ de requête
/// </summary>
protected string baseselect
{
get
{
// TODO : ajoutez le getter BaseRule.OperationCode pour implémenter
return _baseselect
}
set
{
// TODO : Ajouter un setter BaseRule.OperationCode pour implémenter
_baseselect = value;
}
}
/// <summary>
/// La table de hachage de la classe de base existe dans tout le système
/// </summary>
protected Hashtable baseHashtable = new Hashtable( );
/// <summary>
/// Table de hachage d'interface, obtient les contrôles et les valeurs de contrôle obtenues à partir de l'usine d'interface utilisateur
/// </summary>
protected
Hashtable UIhashtable = new Hashtable( );
/// Invite d'erreur, valeur par défaut ""
/// </summary>
protected string errMsg = ""
/// <summary>
/// Statut d'erreur, valeur par défaut false
/// </summary>
protected bool errState = false;
/ // <summary>
/// Variable privée _UISet
/// </summary>
private DataSet _UISet = new DataSet();
/// <summary>
/// Ensemble de données de la couche d'interface
/// </summary>
protected DataSet UISet
{
get
{
// TODO : ajouter le getter BaseRule.OperationCode pour implémenter
return _UISet ;
}
set
{
// TODO :ajouter
le setter BaseRule.OperationCode pour implémenter
_UISet = value
}
}
private DataTable _UITable = new DataTable(/);
// <summary >
/// Table de données de la couche d'interface
/// </summary>
protected DataTable UITable
{
get
{
// TODO : ajouter le getter BaseRule.OperationCode pour implémenter
return _UITable;
}
set
{
// TODO : ajouter BaseRule.OperationCode
setter
pour implémenter
_UITable = value
;
private string _pageTitle = "" ;
/// <summary>
/// Titre de la page
/// </summary>
protected string pageTitle
{
get
{
// À FAIRE : ajouter le getter BaseRule.OperationCode pour implémenter
return _pageTitle
}
set
{
// TODO : Ajoutez le setter BaseRule.OperationCode pour implémenter
_pageTitle = value
}
}
#endregion;
#region Interroger la partie existante de la page
/// <summary>
/// Table dehachage
de classe de base de la page de liste
/// </summary>
protected
Hashtable baseListHashtable = new Hashtable();
nombre de pages. Variables 1 000 w, utilisation de l'ensemble de données 10 000 w
/// </summary>
protected int pageCount ;
/// <summary>
/// Nombre total d'enregistrements. Utilisation d'ensembles de données 1000w et 10000w
/// </summary>
protected int recordCount;
/// <summary>
/// Nombre total d'enregistrements. Ensembles de données 1000w et 10000w Utiliser
/// </summary>
protected int RecordCount
{
get
{
return recordCount
}
}
#endregion
#region La partie existante de la page d'édition
/// <summary>
/// Modifier la table de hachage de la classe de base de la page
///
</summary>
protected
Hashtable baseEditHashtable = new Hashtable();
page, Modifier la table de hachage des données
/// </summary>
protected Hashtable baseEditFillHashtable = newHashtable
();
/// <summary>
/// Constructeur
/// </summary>
public PageBase()
{
this.Load += new EventHandler(PageBase_Load })
;
private void PageBase_Load (expéditeur d'objet, EventArgs e)
{
if (!Page.IsPostBack)
{
//La partie de contrôle requise pour l'ensemble du processus
if (Session["baseHashtable"] != null)
{
//Obtenir la liste des objets de hachage à partir de Session
baseHashtable = (Hashtable)Session["baseHashtable"]
}
//Les droits d'accès et le contrôle d'accès à la page de modification ne sont valides que lorsque la page est chargée pour la première fois
if (Session["baseEditHashtable"] != null)
{
//Obtenir la liste des objets de hachage de la page de modification
baseEditHashtable = (Hashtable)Session[ "baseEditHashtable"];
//Libérez l'objet Session correspondant après l'acquisition
Session.Remove("baseEditHashtable");
else
{
//S'il s'agit de l'état initial, ajoutez s'il est sûr de modifier la valeur de l'état, la valeur par défaut
est
false, ce n'est pas sûr
baseEditHashtable.Add ("EditSafeState", false } }
)
;
//Requête du contrôle d'accès à la page
if (Session["baseListHashtable"] != null)
{
//Obtenir la liste des objets de hachage de la page d'édition
baseListHashtable
= (Hashtable
)Session["baseListHashtable"];
.Remove("baseListHashtable");
}
else
{
//S'il s'agit de l'état initial, ajoutez s'il faut actualiser la page de requête, la valeur par défaut est false,
baseListHashtable ne sera pas actualisée.Add("IsRefresh", false })
;
}
Fonction générale de l'interface utilisateur #region
/// <summary>
/// Lancer un message d'erreur
/// </summary>
/// <param name="page">Page</param>
/// <param name=" errMsg" >Message d'erreur</param>
protected void throwErrMsg(Page page, string errMsg)
{
page.Response.Write("<script>window.alert("" + errMsg.Replace(""", "'" ) + "");</script>");
}
/// <summary>
/// Actualisez la page Liste qui ouvre le formulaire d'édition
/// </summary>
/// <param name="page">Page</param>
protected void parentPageRefresh(Page page)
{
StringBuilder scriptString = new StringBuilder();
scriptString.Append("<script langage = javascript>");
//Appelez rafraîchir() dans Function.js pour actualiser le formulaire parent
scriptString.Append("window.opener.refresh(false, " ");");
scriptString.Append(" window.focus();");
scriptString.Append(" window.opener=null;
");
scriptString.Append("</" + "script>");
page.Response.Write(scriptString.ToString())
;
/// <summary>
/// Réinitialiser la page
/// </summary>
/// <param name="page">Page</param>
protected void pageReset(Page page)
{
StringBuilder scriptString = new StringBuilder() ;
scriptString.Append("<langage de script = javascript>");
scriptString.Append(" this.location.reset(); ");
scriptString.Append("</" + "script>");
page.Response.Write(scriptString.ToString())
;
/// <summary>
/// La table de hachage est générée après la transmission de la fabrique d'interface js dans
/// </summary>
/// <param name="splitStr">la fabrique d'interface js passe dans la chaîne</param>
/// < return></returns>
public Hashtable AjaxUIFactory(string splitStr)
{
string[] fristStr = splitStr.Split(',');
for
(int x = 0; x < fristStr.Length; x++ )
{
string[] secondStr = fristStr[x].Split('|');
if (secondStr.Length == 3)
{
//Obtenir la chaîne interceptée et
la table de valeurs.Add(secondStr[1], secondStr[2 ]);
}
}
table de retour ;
}
#endregion
}
http://www.cnblogs.com/mail-ricklee/archive/2006/11/23/569270.html