Vraag : Toevoegend Rollen aan Rollen in de Leverancier van het Lidmaatschap van de Douane - een Betere Manier? C#, SQL, Oracle, ASP.NET

Ik moet een betere manier vinden om rollen aan rollen in onze leverancier van douanemebership te bewaren - vanaf rifgr nu, hier is de lijst:

ID (PK)
RoleID (FK aan aspnet_Roles.ID)
ParentRoleID (FK aan aspnet_Roles.ID)

Currently, hier is de stappen die om worden gebruikt toe te voegen een rol (wij zullen deze c-rol roepen) aan een andere rol (wij zullen deze p-rol roepen)

- alle huidige ouderrollen van de p-rol, de ouderrollen van alle ouder, de ouderrollen van alle ouderouder, etc. etc., krijgt en releventdata in een gegevenslijst zette (evenals het zelfde voor de c-rol.)

- schrapt alle ingangen voor de c-rol met datatable van alle c-rollen parents

- toevoegt de lijst die wij dat wij enkel schrapten hebben verzameld, samen met de nieuwe gegevens betreffende de ouder role

I am er daar iemand hopen is wie dit vóór, aangezien ik een betere manier zou willen vinden om dit te doen, evenals een betere manier voor de de laagfunctionaliteit heeft aangepakt van de gegevenstoegang vinden die ik hieronder - alles werkt, ik wil enkel snellere, minder ingewikkelde DAL, en als mogelijk een andere optie als beschikbaar - dank vooraf voor uw kennis heb omvat!
" codeBody " 
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:
" notpretty " 
//Beginnende vraag

        openbare bool SetRoles (DataTable dtRoles, koord roleId)
        {
            DataTable dtDeleteRoles = GetParentRolesInRole (roleId);
            dtDeleteRoles.TableName = String.Format („RolesInRoles“);
            CreatePrimaryKey (dtDeleteRoles, „Identiteitskaart“);
            dtRoles.TableName = String.Format („RolesInRoles“);
            bool resultaat = UpdateTable (dtRoles, dtDeleteRoles);
            terugkeer resultaat;
        }

// hier hieronder is alle die functies in deze vraag worden gebruikt - iedereen 
// slank dit neer bij allen, of vindt een betere manier?

        openbare DataTable GetParentRolesInRole (koord roleId)
        {
            koord sqlCommand = (@ "
                SELECTEER RolesInRoles.RoleId, aspnet_Roles.RoleName, RolesInRoles.ParentRoleId 
                VAN RolesInRoles 
                BINNEN TREED aspnet_Roles toe
	                OP ParentRoleId = aspnet_Roles.RoleId
                WAAR RolesInRoles.RoleId = „{0}“
                „);
            sqlCommand = koord. Formaat (sqlCommand, roleId);
            DbCommand dbCommand = _database.GetSqlStringCommand (sqlCommand);
            terugkeer _database.ExecuteDataSet (dbCommand). Lijsten [0];
        }


        openbare nietige CreatePrimaryKey (dtbTable DataTable, koord strColumnName)
        {
            dcCol van DataColumn [] = nieuwe DataColumn [1];
            dcCol [0] = dtbTable.Columns [strColumnName];
            dtbTable.PrimaryKey = dcCol;
        }


  openbare bool UpdateTable (DataTable voegt, schrapping DataTable toe)
        {
            het gebruiken (DbConnection dbConn = _database.CreateConnection ())
            {
                dbConn.Open ();
                probeer
                {
                    het gebruiken (DbTransaction dbTxn = dbConn.BeginTransaction ())
                    {
                        probeer
                        {
                            als (voeg. Rows.Count > 0 toe)
                            {
                                UpdateInsertDataTable (voeg, dbTxn toe);
                            }
                            als (schrapping. Rows.Count > 0)
                            {
                                voor (int. i = 0; i <= schrapt. Rows.Count - 1; i++)
                                {
                                    schrap. Rijen [I]. Schrap ();
                                }
                                DeleteDataTable (schrapping, dbTxn);
                            }
                            dbTxn.Commit ();
                        }
                        vangst
                        {
                            dbTxn.Rollback ();
                            valse terugkeer;
                        }
                    }
                }
                tot slot
                {
                    dbConn.Close ();
                }
            }
            ware terugkeer;
        }

  privé int. UpdateInsertDataTable (dtTable DataTable, DbTransaction txn)
        {
            het koord strInsert = „NEEMT op IN“ + dtTable.TableName + „(“;
            het koord strUpdate = „UPDATE“ + dtTable.TableName + „PLAATSTE“;

            voor (int. i = 0; i <= dtTable.Columns.Count - 1; i++)
            {
                als (_database.DbProviderFactory.ToString (). Bevat („Oracle“))
                {
                    strInsert = strInsert + dtTable.Columns [I] .ColumnName + „,“;
                    strUpdate = strUpdate + dtTable.Columns [I] .ColumnName + „=“ + _paramStart + dtTable.Columns [I] .ColumnName + „,“;
                }
                anders
                {
                    strInsert = strInsert + „[“ + dtTable.Columns [I] .ColumnName + „],“;
                    strUpdate = strUpdate + „[“ + dtTable.Columns [I] .ColumnName + „] =“ + _paramStart + dtTable.Columns [I] .ColumnName + „,“;
                }
            }

            strInsert = strInsert.Substring (0, strInsert.Length - 1) + „) waarden (“;
            voor (int. 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) + „WAAR“;
            foreach (kolom DataColumn in dtTable.PrimaryKey)
            {
                strUpdate = strUpdate + column.ColumnName + „=“ + _paramStart + column.ColumnName + „EN“;
            }
            strUpdate = strUpdate.Substring (0, strUpdate.Length - 5);

            DbCommand insertCommand = _database.GetSqlStringCommand (strInsert);
            DbCommand updateCommand = _database.GetSqlStringCommand (strUpdate);

            voor (int. i = 0; i <= dtTable.Columns.Count - 1; i++)
            {
                Het type van 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);
                als (! (type == DbType.String | type == DbType.AnsiString)) ga verder;
                insertCommand.Parameters [_paramStart + dtTable.Columns [I] .ColumnName]. Grootte = [I] .MaxLength dtTable.Columns;
                updateCommand.Parameters [_paramStart + dtTable.Columns [I] .ColumnName]. Grootte = [I] .MaxLength dtTable.Columns;
            }
            (dtTable) GetIdsForTable;

            terugkeer UpdateDataSet (dtTable.Select (ongeldige "", ""), insertCommand, updateCommand, txn, UpdateBehavior.Standard, 0); //DataViewRowState.ModifiedCurrent | DataViewRowState.Added
        }

      privé nietige GetIdsForTable (lijst DataTable)
        {
            als (lijst. Columns.Contains („Identiteitskaart“))
            {
                als (lijst. Valse kolommen [„Identiteitskaart“] .AutoIncrement ==)
                {
                    //For Elke relatie als DataRelation in table.ChildRelations 
                    // relatie. Genesteld 
                    //Next 
                    int. idEnd = GetLatestId (table.TableName); //GetIdRefs (table.TableName, rijen. Lengte);
                    int. identiteitskaart = idEnd + 1; //idEnd - rijen. Lengte + 1;
                    foreach (rij DataRow in lijst. Rij)
                    {
                        rij [„Identiteitskaart“] = identiteitskaart;
                        identiteitskaart += 1;
                    }
                }
            }

        }


 privé int. UpdateDataSet (DataRow [] dataRows, DbCommand insertCommand, DbCommand updateCommand, DbCommand deleteCommand, DbTransaction txn, UpdateBehavior gedrag, int. updateBatchSize)
        {
            int. rijen;
            het gebruiken (adapter DbDataAdapter = _database.GetDataAdapter ())
            {
                als ((gedrag == UpdateBehavior.Transactional) & txn ongeldige ==)
                {
                    het gebruiken (DbConnection dbConn = _database.CreateConnection ())
                    {
                        dbConn.Open ();
                        probeer
                        {
                            het gebruiken (DbTransaction dbTxn = dbConn.BeginTransaction ())
                            {
                                probeer
                                {
                                    DoUpdateDataSet (de adapter, insertCommand, updateCommand, deleteCommand, dbTxn, gedrag, updateBatchSize);
                                    rijen = adapter. Update (dataRows);
                                    dbTxn.Commit ();
                                }
                                vangst
                                {
                                    dbTxn.Rollback ();
                                    werp;
                                }
                            }
                        }
                        tot slot
                        {
                            dbConn.Close ();
                        }
                    }
                }
                anders
                {
                    DoUpdateDataSet (de adapter, insertCommand, updateCommand, deleteCommand, txn, gedrag, updateBatchSize);
                    rijen = adapter. Update (dataRows);
                }
            }
            terugkeer rijen;
        }

 privé statische nietige DoUpdateDataSet (DbDataAdapter de adapter, DbCommand insertCommand, DbCommand updateCommand, DbCommand deleteCommand, DbTransaction txn, UpdateBehavior gedrag, int. updateBatchSize)
        {

            IDbDataAdapter explicitAdapter = adapter;
            als (txn! = verklaar) nietig
            {
                als (insertCommand! = verklaar) nietig
                    PrepareCommand (insertCommand, txn);
                als (updateCommand! = verklaar) nietig
                    PrepareCommand (updateCommand, txn);
                als (deleteCommand! = verklaar) nietig
                    PrepareCommand (deleteCommand, txn);
            }
            als (insertCommand! = verklaar) nietig
            {
                insertCommand.CommandTimeout = 120;
                explicitAdapter.InsertCommand = insertCommand;
            }
            als (updateCommand! = verklaar) nietig
            {
                updateCommand.CommandTimeout = 120;
                explicitAdapter.UpdateCommand = updateCommand;
            }
            als (deleteCommand! = verklaar) nietig
            {
                deleteCommand.CommandTimeout = 120;
                explicitAdapter.DeleteCommand = deleteCommand;
            }

            als (updateBatchSize == 1) terugkeer;
            adapter.UpdateBatchSize = updateBatchSize;
            als (insertCommand! = verklaar) nietig
                adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.None;
            als (updateCommand! = verklaar) nietig
                adapter.UpdateCommand.UpdatedRowSource = UpdateRowSource.None;
            als (deleteCommand! = verklaar) nietig
                adapter.DeleteCommand.UpdatedRowSource = UpdateRowSource.None;
        }

        privé statische nietige PrepareCommand (DbCommand bevel, DbTransaction txn)
        {
            bevel. Transactie = txn;
            bevel. Verbinding = txn. Verbinding;
            bevel. Tref voorbereidingen ();
        }

   privé int. DeleteDataTable (dtTable DataTable, DbTransaction txn)
        {
            het koord strDelete = „schrapt van“ + dtTable.TableName + „waar“;
            foreach (kolom DataColumn in dtTable.PrimaryKey)
            {
                strDelete = strDelete + column.ColumnName + „=“ + _paramStart + column.ColumnName + „en“;
            }
            strDelete = strDelete.Substring (0, strDelete.Length - 5);
            DbCommand deleteCommand = _database.GetSqlStringCommand (strDelete);
            //For Elke rij als Data.DataRow in dtTable.Rows 
            foreach (kolom DataColumn in dtTable.PrimaryKey)
            {
                //db.AddInParameter (deleteCommand, column.ColumnName, GetDataType (column.DataType), rij. Punt (column.ColumnName, DataRowVersion.Original)) 
                _database.AddInParameter (deleteCommand, column.ColumnName, GetDataType (column.DataType), column.ColumnName, DataRowVersion.Current);
            }
            terugkeer UpdateDataSet (dtTable.Select (ongeldig, ongeldige "", "", DataViewRowState.Deleted), deleteCommand, txn, UpdateBehavior.Standard, 0);
        }

Antwoord : Toevoegend Rollen aan Rollen in de Leverancier van het Lidmaatschap van de Douane - een Betere Manier? C#, SQL, Oracle, ASP.NET

De beetjes zijn beetjes, kunt u de overdracht sneller door het hebben van zowel een grotere pijp to/from de opslag, als een snellere opslagserie slechts maken.  

De momentopnamen zijn tijdens de vlucht, kunt u hen zelfs plannen.  Dan kunt u een file op de momentopname met VM uitvoeren die nog loopt.  Opnieuw, VOORZICHTIG ZIJN van prestatiesdegradatie op uw opslagserie.

U kunt de sluiting, de uitvoer en de terugwinning absoluut automatiseren.  U kunt op VMs tellen om te komen file zolang uw scripting goed en goed getest is.

Vrij veel is alles u wilt reeds in versie 5.6 van XenServer.  Ook verbetert de controle uit StorageLink, die met Onderneming XS komt, en verder deze functies.
Andere oplossingen  
 
programming4us programming4us