class= " lineNumbers " de
1 :
2 :
3 :
4 :
5 :
6 :
7 :
8 :
9 :
10 :
11 :
12 :
13 :
14 :
15 :
16 :
17 :
18 :
19 :
20 :
21 :
22 :
23 :
24 :
25 :
26 :
27 :
28 :
29 :
30 :
31 :
32 :
33 :
34 :
35 :
36 :
37 :
38 :
39 :
40 :
41 :
42 :
43 :
44 :
45 :
46 :
47 :
48 :
49 :
50 :
51 :
52 :
53 :
54 :
55 :
56 :
57 :
58 :
59 :
60 :
61 :
62 :
63 :
64 :
65 :
66 :
67 :
68 :
69 :
70 :
71 :
72 :
73 :
74 :
75 :
76 :
77 :
78 :
79 :
80 :
81 :
82 :
83 :
84 :
85 :
86 :
87 :
88 :
89 :
90 :
91 :
92 :
93 :
94 :
95 :
96 :
97 :
98 :
99 :
100 :
101 :
102 :
103 :
104 :
105 :
106 :
107 :
108 :
109 :
110 :
111 :
112 :
113 :
114 :
115 :
116 :
117 :
118 :
119 :
120 :
121 :
122 :
123 :
124 :
125 :
126 :
127 :
128 :
129 :
130 :
131 :
132 :
133 :
134 :
135 :
136 :
137 :
138 :
139 :
140 :
141 :
142 :
143 :
144 :
145 :
146 :
147 :
148 :
149 :
150 :
151 :
152 :
153 :
154 :
155 :
156 :
157 :
158 :
159 :
160 :
161 :
162 :
163 :
164 :
165 :
166 :
167 :
168 :
169 :
170 :
171 :
172 :
173 :
174 :
175 :
176 :
177 :
178 :
179 :
180 :
181 :
182 :
183 :
184 :
185 :
186 :
187 :
188 :
189 :
190 :
191 :
192 :
193 :
194 :
195 :
196 :
197 :
198 :
199 :
200 :
201 :
202 :
203 :
204 :
205 :
206 :
207 :
208 :
209 :
210 :
211 :
212 :
213 :
214 :
215 :
216 :
217 :
218 :
219 :
220 :
221 :
222 :
223 :
224 :
225 :
226 :
227 :
228 :
229 :
230 :
231 :
232 :
233 :
234 :
235 :
236 :
237 :
238 :
239 :
240 :
241 :
242 :
243 :
244 :
245 :
246 :
247 :
248 :
249 :
250 :
251 :
252 :
253 :
254 :
255 :
|
class= de
class= " de l'id= " codeSnippet747118 de appel commençant
bool public SetRoles (dtRoles de DataTable, roleId de corde)
{
dtDeleteRoles de DataTable = GetParentRolesInRole (roleId) ;
dtDeleteRoles.TableName = String.Format (« RolesInRoles ») ;
CreatePrimaryKey (dtDeleteRoles, « identification ») ;
dtRoles.TableName = String.Format (« RolesInRoles ») ;
résultat de bool = UpdateTable (dtRoles, dtDeleteRoles) ;
résultat de retour ;
}
// ici ci-dessous sont toutes les fonctions utilisées dans cet appel - n'importe qui
// amincissent ceci vers le bas du tout, ou trouvent une meilleure manière ?
DataTable public GetParentRolesInRole (roleId de corde)
{
sqlCommand de corde = (@ "
CHOISIR RolesInRoles.RoleId, aspnet_Roles.RoleName, RolesInRoles.ParentRoleId
De RolesInRoles
INTÉRIEUR JOINDRE les aspnet_Roles
SUR ParentRoleId = aspnet_Roles.RoleId
LÀ OÙ RolesInRoles.RoleId = « {0} »
") ;
sqlCommand = corde. Format (sqlCommand, roleId) ;
dbCommand de DbCommand = _database.GetSqlStringCommand (sqlCommand) ;
_database.ExecuteDataSet de retour (dbCommand). Tableaux [0] ;
}
public CreatePrimaryKey vide (DataTable dtbTable, strColumnName de corde)
{
dcCol de DataColumn [] = nouveau DataColumn [1] ;
dcCol [0] = dtbTable.Columns [strColumnName] ;
dtbTable.PrimaryKey = dcCol ;
}
bool public UpdateTable (DataTable s'ajoutent, les suppressions de DataTable)
{
utilisation (dbConn de DbConnection = _database.CreateConnection ())
{
dbConn.Open () ;
essai
{
utilisation (dbTxn de DbTransaction = dbConn.BeginTransaction ())
{
essai
{
si (ajouter. Rows.Count > 0)
{
UpdateInsertDataTable (ajouter, dbTxn) ;
}
si (suppression. Rows.Count > 0)
{
pour (international i = 0 ; suppression. Rows.Count - 1 du <= i ; i++)
{
suppression. Rangées [I]. Suppression () ;
}
DeleteDataTable (suppression, dbTxn) ;
}
dbTxn.Commit () ;
}
crochet
{
dbTxn.Rollback () ;
faux de retour ;
}
}
}
finalement
{
dbConn.Close () ;
}
}
de retour rectifier ;
}
international privé UpdateInsertDataTable (DataTable dtTable, txn de DbTransaction)
{
strInsert de corde = « INSERTION DANS » + dtTable.TableName + « (" ;
le strUpdate de corde = « MISE À JOUR » + dtTable.TableName + « A PLACÉ » ;
pour (international i = 0 ; i <= dtTable.Columns.Count - 1 ; i++)
{
si (_database.DbProviderFactory.ToString (). Contient (« Oracle »))
{
strInsert = strInsert + dtTable.Columns [I] .ColumnName + « , » ;
strUpdate = strUpdate + dtTable.Columns [I] .ColumnName + « = » + _paramStart + dtTable.Columns [I] .ColumnName + « , » ;
}
autrement
{
strInsert = strInsert + « [ » + dtTable.Columns [I] .ColumnName + « ], » ;
strUpdate = strUpdate + « [ » + dtTable.Columns [I] .ColumnName + « ] = » + _paramStart + dtTable.Columns [I] .ColumnName + « , » ;
}
}
strInsert = valeurs de strInsert.Substring (0, strInsert.Length - 1) + ") (" ;
pour (international i = 0 ; i <= dtTable.Columns.Count - 1 ; i++)
{
strInsert = strInsert + _paramStart + dtTable.Columns [I] .ColumnName + « , » ;
}
strInsert = strInsert.Substring (0, strInsert.Length - 1) + ") » ;
strUpdate = strUpdate.Substring (0, strUpdate.Length - 1) + « OÙ » ;
foreach (colonne de DataColumn dans dtTable.PrimaryKey)
{
strUpdate = strUpdate + column.ColumnName + « = » + _paramStart + column.ColumnName + « ET » ;
}
strUpdate = strUpdate.Substring (0, strUpdate.Length - 5) ;
insertCommand de DbCommand = _database.GetSqlStringCommand (strInsert) ;
updateCommand de DbCommand = _database.GetSqlStringCommand (strUpdate) ;
pour (international i = 0 ; i <= dtTable.Columns.Count - 1 ; i++)
{
Type de DbType = GetDataType (dtTable.Columns [I] .DataType) ;
_database.AddInParameter (insertCommand, dtTable.Columns [I] .ColumnName, type, dtTable.Columns [I] .ColumnName, DataRowVersion.Current) ;
_database.AddInParameter (updateCommand, dtTable.Columns [I] .ColumnName, type, dtTable.Columns [I] .ColumnName, DataRowVersion.Current) ;
si (! (type == DbType.String | dactylographier le == DbType.AnsiString)) continuer ;
insertCommand.Parameters [_paramStart + dtTable.Columns [I] .ColumnName]. Taille = dtTable.Columns [I] .MaxLength ;
updateCommand.Parameters [_paramStart + dtTable.Columns [I] .ColumnName]. Taille = dtTable.Columns [I] .MaxLength ;
}
GetIdsForTable (dtTable) ;
UpdateDataSet de retour (dtTable.Select ("", ""), insertCommand, updateCommand, nulle, txn, UpdateBehavior.Standard, 0) ; //DataViewRowState.ModifiedCurrent | DataViewRowState.Added
}
GetIdsForTable vide privé (table de DataTable)
{
si (table. Columns.Contains (« identification »))
{
si (table. == des colonnes [« identification »] .AutoIncrement faux)
{
//For chaque relation comme DataRelation dans table.ChildRelations
relation de //. Niché
//Next
idEnd d'international = GetLatestId (table.TableName) ; //GetIdRefs (table.TableName, rangées. Longueur) ;
international identification = idEnd + 1 ; //idEnd - rangées. Longueur + 1 ;
foreach (rangée de DataRow dans la table. Rangées)
{
rangée [« identification »] = identification ;
identification += 1 ;
}
}
}
}
international privé UpdateDataSet (les dataRows de DataRow [], insertCommand de DbCommand, updateCommand de DbCommand, deleteCommand de DbCommand, txn de DbTransaction, le comportement d'UpdateBehavior, l'international updateBatchSize)
{
rangées d'international ;
utilisation (adapteur de DbDataAdapter = _database.GetDataAdapter ())
{
si ((== UpdateBehavior.Transactional de comportement) et nulle de == de txn)
{
utilisation (dbConn de DbConnection = _database.CreateConnection ())
{
dbConn.Open () ;
essai
{
utilisation (dbTxn de DbTransaction = dbConn.BeginTransaction ())
{
essai
{
DoUpdateDataSet (l'adapteur, insertCommand, updateCommand, deleteCommand, dbTxn, comportement, updateBatchSize) ;
rangées = adapteur. Mise à jour (dataRows) ;
dbTxn.Commit () ;
}
crochet
{
dbTxn.Rollback () ;
jet ;
}
}
}
finalement
{
dbConn.Close () ;
}
}
}
autrement
{
DoUpdateDataSet (l'adapteur, insertCommand, updateCommand, deleteCommand, txn, comportement, updateBatchSize) ;
rangées = adapteur. Mise à jour (dataRows) ;
}
}
rangées de retour ;
}
DoUpdateDataSet vide statique privé (l'adapteur de DbDataAdapter, insertCommand de DbCommand, updateCommand de DbCommand, deleteCommand de DbCommand, txn de DbTransaction, le comportement d'UpdateBehavior, l'international updateBatchSize)
{
explicitAdapter = adapteur d'IDbDataAdapter ;
si (txn ! = nulle)
{
si (insertCommand ! = nulle)
PrepareCommand (insertCommand, txn) ;
si (updateCommand ! = nulle)
PrepareCommand (updateCommand, txn) ;
si (deleteCommand ! = nulle)
PrepareCommand (deleteCommand, txn) ;
}
si (insertCommand ! = nulle)
{
insertCommand.CommandTimeout = 120 ;
explicitAdapter.InsertCommand = insertCommand ;
}
si (updateCommand ! = nulle)
{
updateCommand.CommandTimeout = 120 ;
explicitAdapter.UpdateCommand = updateCommand ;
}
si (deleteCommand ! = nulle)
{
deleteCommand.CommandTimeout = 120 ;
explicitAdapter.DeleteCommand = deleteCommand ;
}
si (updateBatchSize le retour du == 1) ;
adapter.UpdateBatchSize = updateBatchSize ;
si (insertCommand ! = nulle)
adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.None ;
si (updateCommand ! = nulle)
adapter.UpdateCommand.UpdatedRowSource = UpdateRowSource.None ;
si (deleteCommand ! = nulle)
adapter.DeleteCommand.UpdatedRowSource = UpdateRowSource.None ;
}
PrepareCommand vide statique privé (commande de DbCommand, txn de DbTransaction)
{
commande. Transaction = txn ;
commande. Raccordement = txn. Raccordement ;
commande. Préparer () ;
}
international privé DeleteDataTable (DataTable dtTable, txn de DbTransaction)
{
strDelete de corde = « suppression de » + dtTable.TableName + « où » ;
foreach (colonne de DataColumn dans dtTable.PrimaryKey)
{
strDelete = strDelete + column.ColumnName + « = » + _paramStart + column.ColumnName + « et » ;
}
strDelete = strDelete.Substring (0, strDelete.Length - 5) ;
deleteCommand de DbCommand = _database.GetSqlStringCommand (strDelete) ;
//For chaque rangée comme Data.DataRow dans dtTable.Rows
foreach (colonne de DataColumn dans dtTable.PrimaryKey)
{
//db.AddInParameter (deleteCommand, column.ColumnName, GetDataType (column.DataType), rangée. Article (column.ColumnName, DataRowVersion.Original))
_database.AddInParameter (deleteCommand, column.ColumnName, GetDataType (column.DataType), column.ColumnName, DataRowVersion.Current) ;
}
UpdateDataSet de retour (dtTable.Select ("", "", DataViewRowState.Deleted), nulle, nulle, deleteCommand, txn, UpdateBehavior.Standard, 0) ;
}
|
