void AddColumns() { DataColumn dc = Columns.Add(CountColumn, typeof(int)); dc.DefaultValue = 1; RowChanged += new DataRowChangeEventHandler(SessionBundlePackRelation_RowChanged); }
/// <summary> /// Constructor to initialise a new provider with the business object /// collection provided /// </summary> /// <param name="col">The business object collection</param> public EditableDataSetProvider(IBusinessObjectCollection col) : base(col) { _rowChangedHandler = RowChangedHandler; _rowDeletedHandler = RowDeletedHandler; _newRowHandler = NewRowHandler; _boAddedHandler = BOAddedHandler; }
private void InitDelegateFields() { columnChanged = new DataColumnChangeEventHandler(OnDataTableColumnChanged); rowDeleted = new DataRowChangeEventHandler(OnDataTableRowDeleted); rowChanged = new DataRowChangeEventHandler(OnDataTableRowChanged); tablesChanged = new CollectionChangeEventHandler(OnDataTableChanged); }
public override void Load() { locationTableEventHandler = new DataRowChangeEventHandler(LocationTable_RowChanged); locationTableClearEventHandler = new DataTableClearEventHandler(LocationTable_TableClearing); DB.LocationTable.RowChanged += locationTableEventHandler; DB.LocationTable.RowDeleting += locationTableEventHandler; DB.LocationTable.TableClearing += locationTableClearEventHandler; }
public override void Unload() { DB.NPCTable.RowChanged -= mobTableEventHandler; DB.NPCTable.RowDeleting -= mobTableEventHandler; DB.NPCTable.TableClearing -= mobTableClearEventHandler; mobTableEventHandler = null; mobTableClearEventHandler = null; }
public override void Load() { mobTableEventHandler = new DataRowChangeEventHandler(MobTable_RowChanged); mobTableClearEventHandler = new DataTableClearEventHandler(NPCTable_TableClearing); DB.NPCTable.RowDeleting += mobTableEventHandler; DB.NPCTable.RowChanged += mobTableEventHandler; DB.NPCTable.TableClearing += mobTableClearEventHandler; }
public override void Load() { areaTableEventHandler = new DataRowChangeEventHandler(AreaTable_RowChanged); areaTableClearEventHandler = new DataTableClearEventHandler(AreaTable_TableClearing); DB.AreaTable.RowChanged += areaTableEventHandler; DB.AreaTable.RowDeleting += areaTableEventHandler; DB.AreaTable.TableClearing += areaTableClearEventHandler; }
/// <summary>Выполнить sql, вернуть таблицу</summary> /// <param name="sql">SQL</param> /// <param name="pars">Словарь параметров</param> /// <param name="trassa">Метод для трассировки</param> /// <returns>Таблица (пустая если нет resultset) или null, если ошибка</returns> public static DataTable GetTable(this SqlConnection conn, string sql, Dictionary <string, object> pars = null, Action <string, List <SqlParameter>, string> trassa = null, SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null) { var dt = conn.ExecSql(ExecSqlType.Table, sql, pars, trassa, sync, onRowChange, onFinish); return(dt is DataTable ? (DataTable)dt : null); }
public override void Unload() { DB.LocationTable.RowChanged -= locationTableEventHandler; DB.LocationTable.RowDeleting -= locationTableEventHandler; DB.LocationTable.TableClearing -= locationTableClearEventHandler; locationTableEventHandler = null; locationTableClearEventHandler = null; }
/// <summary> /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed. /// <example> /// datarowchangeeventhandler.BeginInvoke(sender, e, callback); /// </example> /// </summary> public static IAsyncResult BeginInvoke(this DataRowChangeEventHandler datarowchangeeventhandler, Object sender, DataRowChangeEventArgs e, AsyncCallback callback) { if (datarowchangeeventhandler == null) { throw new ArgumentNullException("datarowchangeeventhandler"); } return(datarowchangeeventhandler.BeginInvoke(sender, e, callback, null)); }
/*=========================*/ #endregion #region Internal Methods /*=========================*/ /// <summary> /// Populates the collection with DataItem objects by binding to the data source. /// </summary> /// /// <remarks> /// Calling this method clears the inner table before re-populating the list, which means /// items contained in the collection before the binding call are disassociated from the collection /// (their <c>DataState</c> changes to <c>DataRowState.Detached</c>). Changes to detached items /// will not be saved when the collection is saved (unless they are re-added). /// </remarks> protected void Bind() { // Clear the table _table.Rows.Clear(); // Clear items _innerList.Clear(); if (_hash != null) { _hash.Clear(); } if (!DataManager.ProxyMode) { // Attach an event handler to the table so we can create DataItems for each row added DataRowChangeEventHandler addedHandler = new DataRowChangeEventHandler(_table_RowChanged); _table.RowChanged += addedHandler; SqlDataAdapter adapter = DataManager.CreateAdapter(this); ConnectionKey ckey = null; try { ckey = DataManager.Current.OpenConnection(this); // Fill the table adapter.Fill(this._table); } finally { DataManager.Current.CloseConnection(ckey); } // Detach the event so it doesn't get raised in future changes _table.RowChanged -= addedHandler; if (ProxyServer.InProgress) { ProxyServer.Current.Result[ProxyServer.Current.CurrentAction].AddData("_table", _table); } } else { ProxyRequestAction action = ProxyClient.Request.AddAction(this, MethodInfo.GetCurrentMethod()); action.OnComplete = delegate() { DataTable table = ProxyClient.Result[action].GetData <DataTable>("_table"); _table = table; // Create new items for each row using the existing handler foreach (DataRow row in _table.Rows) { _table_RowChanged(_table, new DataRowChangeEventArgs(row, DataRowAction.Add)); } }; } }
public Aggregation (bool cacheResults, DataRow[] rows, AggregationFunction function, ColumnReference column) { this.cacheResults = cacheResults; this.rows = rows; this.column = column; this.function = function; this.result = null; if (cacheResults) RowChangeHandler = new DataRowChangeEventHandler (InvalidateCache); }
public void DefaultFill() { DataRow nogroup_row = NewRow(); if (Columns[PrimaryKey].DataType == typeof(Guid)) { nogroup_row[PrimaryKey] = Guid.Empty; } nogroup_row[NameColumn] = "No Group"; Rows.Add(nogroup_row); RowDeleting += new DataRowChangeEventHandler(GameGroupTable_RowDeleting); }
public Aggregation(bool cacheResults, DataRow[] rows, AggregationFunction function, ColumnReference column) { this.cacheResults = cacheResults; this.rows = rows; this.column = column; this.function = function; this.result = null; if (cacheResults) { RowChangeHandler = new DataRowChangeEventHandler(InvalidateCache); } }
public void BindDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged) { if (dataGrid != null) { dataGrid.DataContext = this.DataTable; dataGrid.ItemsSource = this.DataTable.DefaultView; } // refresh data grid binding if (onRowChanged != null) { this.DataTable.RowChanged += onRowChanged; } }
public void DefaultFill() { if (Rows.Count == 0) { DataRow nogroup_row = NewRow(); if (Columns[PrimaryKey].DataType == typeof(Guid)) { nogroup_row[PrimaryKey] = Guid.Empty; } nogroup_row[NameColumn] = "No Prize"; Rows.Add(nogroup_row); RowDeleting += new DataRowChangeEventHandler(PrizeLevelNames_RowDeleting); } }
public CurrentPackCardsetRanges(DataSet set) { cardset_ranges = set.Tables[CardsetRange.TableName]; packs = set.Tables[PackTable.TableName]; pack_cardsets = set.Tables[PackCardsetRange.TableName]; TableName = "current_pack_cardsets"; Columns.Add(cardset_keyname = XDataTable.ID(cardset_ranges), typeof(int)); Columns.Add(XDataTable.Name(this), typeof(String)); Columns.Add(pack_keyname = PackTable.PrimaryKey, typeof(int)); Columns.Add("name", typeof(String)); set.Tables.Add(this); RowDeleting += new DataRowChangeEventHandler(CurrentPackCardsetRanges_RowDeleting); cardset_ranges.ColumnChanging += new DataColumnChangeEventHandler(cardset_ranges_ColumnChanging); set.Tables[CardsetInfo.TableName].ColumnChanging += new DataColumnChangeEventHandler(CurrentPackCardsetRanges_ColumnChanging); }
internal void SubscribeOnChangeEvents() { var collectionChanged = new CollectionChangeEventHandler(OnDataSetChanged); var rowChanged = new DataRowChangeEventHandler(OnDataSetChanged); Tables.CollectionChanged += collectionChanged; foreach (DataTable t in Tables) { t.Columns.CollectionChanged += collectionChanged; t.TableNewRow += new DataTableNewRowEventHandler(OnDataSetChanged); t.TableCleared += new DataTableClearEventHandler(OnDataSetChanged); t.Constraints.CollectionChanged += collectionChanged; t.RowDeleting += rowChanged; t.RowDeleted += rowChanged; t.RowChanging += rowChanged; t.RowChanged += rowChanged; } }
/// <summary>Выполнить sql, вернуть скалярный результат</summary> /// <param name="sql">SQL</param> /// <param name="pars">Словарь параметров</param> /// <param name="trassa">Метод для трассировки</param> /// <returns>Скалярный результат (object) или null, если ошибка или нет результата</returns> public static object GetValue(this SqlConnection conn, string sql, Dictionary <string, object> pars = null, Action <string, List <SqlParameter>, string> trassa = null, SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null) { return(conn.ExecSql(ExecSqlType.Scalar, sql, pars, trassa)); }
public ObjectInspector() { InitializeComponent(); rowchangeevent = new DataRowChangeEventHandler(RowChange); ColumnHeadersVisible = false; }
public void BindToDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged) { this.boundDataGrid = dataGrid; this.onFileDataTableRowChanged = onRowChanged; this.Files.BindDataGrid(dataGrid, onRowChanged); }
public override void Unload() { DB.LocationTable.RowChanged -= areaTableEventHandler; DB.LocationTable.RowDeleting-= areaTableEventHandler; DB.AreaTable.TableClearing -= areaTableClearEventHandler; areaTableEventHandler = null; areaTableClearEventHandler = null; }
public void BindToEditorDataGrid(DataGrid dataGrid, DataRowChangeEventHandler onRowChanged) { this.editorDataGrid = dataGrid; this.onTemplateTableRowChanged = onRowChanged; this.GetControlsSortedByControlOrder(); }
/// <summary>Выполнить sql, вернуть список строк</summary> /// <param name="sql">SQL</param> /// <param name="pars">Словарь параметров</param> /// <param name="trassa">Метод для трассировки</param> /// <returns>Строки полученной таблицы в виде списка</returns> public static List <DataRow> GetTableList(this SqlConnection conn, string sql, Dictionary <string, object> pars = null, Action <string, List <SqlParameter>, string> trassa = null, SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null) { return(conn.GetTable(sql, pars, trassa)?.AsEnumerable().ToList() ?? new List <DataRow>()); }
private void InitDelegateFields () { columnChanged = new DataColumnChangeEventHandler (OnDataTableColumnChanged); rowDeleted = new DataRowChangeEventHandler (OnDataTableRowDeleted); rowChanged = new DataRowChangeEventHandler (OnDataTableRowChanged); tablesChanged = new CollectionChangeEventHandler (OnDataTableChanged); }
/// <summary> /// ///////////////////////////////////////////////////////////////////////////////// /// </summary> /// <param name="table"></param> /// <param name="result"></param> /// private static CResultAErreur TraitementAvantSauvegardeExterne(CContexteDonnee contexte, Hashtable tableData) { CResultAErreur result = CResultAErreur.True; ///Stef 22/07/08 : l'appel à shouldDeclenche peut ///nécessiter GetValeurChamp (si conditions sur des champs). Or, si un élément n'a pas ///de valeur pour un champ, l'appli va aller chercher la valeur par défaut de ce ///champ, si le champ n'est pas chargé, l'appli va le lire. Comme on est souvent ///dans un contexte sans gestion par tables complètes, on est mal, parce que ///ça va génerer une requête par champ. ///Donc, on lit tous les champs custom avant de commencer CListeObjetsDonnees listeChamps = new CListeObjetsDonnees(contexte, typeof(CChampCustom)); listeChamps.PreserveChanges = true; //Pour ne pas modifier les champs modifiés listeChamps.AssureLectureFaite(); DateTime dt = DateTime.Now; CTraitementApresSauvegarde traitement = new CTraitementApresSauvegarde( ); ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(contexte); //Pour empêcher de regarder deux fois les évenements d'un même objet //Type->Dictionnaire des ids vus Dictionary <Type, Dictionary <int, bool> > elementsVus = new Dictionary <Type, Dictionary <int, bool> >(); DataRowChangeEventHandler handlerRedo = new DataRowChangeEventHandler(table_RowChanged); Dictionary <string, Dictionary <int, bool> > listeElementsARepasser = null; if (!m_listeElementsARepasser.TryGetValue(contexte, out listeElementsARepasser)) { listeElementsARepasser = new Dictionary <string, Dictionary <int, bool> >(); m_listeElementsARepasser[contexte] = listeElementsARepasser; } bool bFirstPasse = true; int nLimiteurPasses = 0; while ((bFirstPasse | listeElementsARepasser.Count > 0) && nLimiteurPasses < 5) { nLimiteurPasses++; foreach (DataTable table in lstTables) { if (table.Rows.Count > 0 && table.PrimaryKey.Length == 1) { string strChampCle = table.PrimaryKey[0].ColumnName; Type tpObjets = CContexteDonnee.GetTypeForTable(table.TableName); if (!typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpObjets)) { continue; } Type typeOriginal = tpObjets; //Lors de la modif de champs custom, l'élement parent n'est pas forcement modifié //Mais le champ peut l'être if (tpObjets.IsSubclassOf(typeof(CRelationElementAChamp_ChampCustom))) { int nLigne = 0; bool bGoOut = false; while (table.Rows.Count > nLigne && !bGoOut) { if (table.Rows[nLigne].RowState != DataRowState.Deleted) { CRelationElementAChamp_ChampCustom rel = (CRelationElementAChamp_ChampCustom)contexte.GetNewObjetForRow(table.Rows[nLigne]); tpObjets = rel.ElementAChamps.GetType(); strChampCle = ((CObjetDonnee)rel.ElementAChamps).GetChampsId()[0]; bGoOut = true; } nLigne++; } } //Les objets qui n'ont pas de relationTypeId ne peuvent pas avoir d'évenements if (tpObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length > 0) { continue; } ArrayList lstEvenements = GetListeEvenementsAutoSur(tpObjets, contexte.IdVersionDeTravail); //Id des éléments modifiés List <int> listeIdsElementsAVerifierHandlers = new List <int>(); string strPrimaryKey = ""; if (table.PrimaryKey.Length == 1 && table.PrimaryKey[0].DataType == typeof(int)) { strPrimaryKey = table.PrimaryKey[0].ColumnName; } Dictionary <int, bool> tableIdsVues = null; if (!elementsVus.TryGetValue(tpObjets, out tableIdsVues)) { tableIdsVues = new Dictionary <int, bool>(); elementsVus[tpObjets] = tableIdsVues; } Dictionary <int, bool> listeARepasserPourTable = null; if (!listeElementsARepasser.TryGetValue(table.TableName, out listeARepasserPourTable)) { listeARepasserPourTable = null; } List <CObjetDonnee> lstObjetsAvecEvenementsSpecifiques = new List <CObjetDonnee>(); //Stef 16/11/2012 : //Si c'est un élément à champs, il est consideré comme modifié //si un de ses champs custom est modifiés //Ca a été fait parce que les handlers d'évenement n'étaient //Pas pris en compte sur modif de champ custom //On n'enlève pas pour autant l'ancienne méthode qui consiste //à considérer l'élément modifié losrqu'on passe sur la table des //valeurs de champs custom if (typeof(IObjetDonneeAChamps).IsAssignableFrom(typeOriginal) && table.Rows.Count > 0) { //Regarde s'il y a des relations IObjetDonneeAChamps objAChamp = contexte.GetNewObjetForRow(table.Rows[0]) as IObjetDonneeAChamps; string strTableChamps = objAChamp.GetNomTableRelationToChamps(); //Trouve la relation à la table DataTable tableChamps = contexte.Tables[strTableChamps]; if (tableChamps != null)//Si la table champs n'est pas là, c'est //qu'elle n'a pas été modifiée !! c'est logique çà { DataRelation rel = null; foreach (DataRelation relTest in tableChamps.ParentRelations) { if (relTest.ParentTable.TableName == table.TableName) { rel = relTest; break; } } if (rel != null)//On peut vérifier ! { foreach (DataRow row in new ArrayList(table.Rows)) { if (row.RowState == DataRowState.Unchanged)//sinon, ce n'est pas la peine { DataRow[] rowsChamps = row.GetChildRows(rel); foreach (DataRow rowChamp in rowsChamps) { if (rowChamp.RowState != DataRowState.Unchanged) { //Aloue l'objet pour s'assurer que la ligne est bien pleine CObjetDonnee objTmp = contexte.GetNewObjetForRow(row); objTmp.AssureData(); row.SetModified(); string strOldContexte = (string)row[CObjetDonnee.c_champContexteModification]; if (strOldContexte.Length == 0) { row[CObjetDonnee.c_champContexteModification] = rowChamp[CObjetDonnee.c_champContexteModification, rowChamp.RowState == DataRowState.Deleted ? DataRowVersion.Original : DataRowVersion.Current] as string; } break; } } } } } } } foreach (DataRow row in new ArrayList(table.Rows)) { CObjetDonneeAIdNumerique objet = null; if (lstEvenements.Count > 0) { if (row.RowState == DataRowState.Added || row.RowState == DataRowState.Modified || row.RowState == DataRowState.Deleted) { objet = (CObjetDonneeAIdNumerique)((CContexteDonnee)table.DataSet).GetNewObjetForRow(row); if (objet.Row.RowState == DataRowState.Deleted) { objet.VersionToReturn = DataRowVersion.Original; } if (objet.Row.RowState != DataRowState.Deleted && EvenementAttribute.HasEventsSpecifiques(objet)) { lstObjetsAvecEvenementsSpecifiques.Add(objet); } if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(typeOriginal)) { CRelationElementAChamp_ChampCustom rel = objet as CRelationElementAChamp_ChampCustom; objet = (CObjetDonneeAIdNumerique)((CRelationElementAChamp_ChampCustom)objet).ElementAChamps; if (objet.Row.RowState == DataRowState.Unchanged) { objet.Row.Row.SetModified(); } if (objet.Row.RowState == DataRowState.Deleted) { objet.VersionToReturn = DataRowVersion.Original; } if (rel.ContexteDeModification.Length != 0 && objet.ContexteDeModification.Length == 0) { objet.ContexteDeModification = rel.ContexteDeModification; } } if (!tableIdsVues.ContainsKey(objet.Id) || ( listeARepasserPourTable != null && listeARepasserPourTable.ContainsKey(objet.Id))) { tableIdsVues[objet.Id] = true; foreach (CEvenement evt in lstEvenements) { if (!traitement.ContainsCouple(evt, (CObjetDonneeAIdNumerique)objet)) { //Attention, si c'est une valeur de champ custom, envoie la valeur, //c'est elle qui sera testée. CInfoDeclencheurProcess infoDeclencheur = null; if (evt.ShouldDeclenche((CObjetDonneeAIdNumerique)objet, ref infoDeclencheur)) { infoDeclencheur.DbKeyEvenementDeclencheur = evt.DbKey; infoDeclencheur.Info = evt.Libelle; traitement.AddCoupleEvenementObjet(evt, (CObjetDonneeAIdNumerique)objet, infoDeclencheur); } } } } } } //Regarde les handle d'évenement sur l'objet if (strPrimaryKey != "" && (row.RowState == DataRowState.Modified)) { listeIdsElementsAVerifierHandlers.Add((int)row[strPrimaryKey]); } } if (listeARepasserPourTable != null) { listeARepasserPourTable.Clear(); } if (listeIdsElementsAVerifierHandlers.Count > 0 && bFirstPasse) { //traitement par paquet de 500 for (int nIndexLot = 0; nIndexLot < listeIdsElementsAVerifierHandlers.Count; nIndexLot += 500) { int nMin = Math.Min(nIndexLot + 500, listeIdsElementsAVerifierHandlers.Count); StringBuilder bl = new StringBuilder(); for (int nIndex = nIndexLot; nIndex < nMin; nIndex++) { bl.Append(listeIdsElementsAVerifierHandlers[nIndex].ToString()); bl.Append(","); } string strIdsElementsAVerifierHandlers = bl.ToString().Substring(0, bl.ToString().Length - 1); //Recherche tous les handlers d'évenement pour les objets concernés CListeObjetsDonnees listeHandler = new CListeObjetsDonnees(contexte, typeof(CHandlerEvenement)); listeHandler.Filtre = new CFiltreData( CHandlerEvenement.c_champIdCible + " in (" + strIdsElementsAVerifierHandlers + ") and " + CHandlerEvenement.c_champTypeCible + "=@1 and " + CHandlerEvenement.c_champTypeEvenement + "=@2", tpObjets.ToString(), (int)TypeEvenement.Modification); listeHandler.PreserveChanges = true; foreach (CHandlerEvenement handler in listeHandler) { if (handler.Row.RowState != DataRowState.Deleted) { CObjetDonneeAIdNumerique objetTmp = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tpObjets, new object[] { contexte }); if (objetTmp.ReadIfExists(handler.IdElementCible)) { CInfoDeclencheurProcess infoDeclencheur = null; if (handler.ShoulDeclenche(objetTmp, ref infoDeclencheur)) { if (infoDeclencheur != null && handler.EvenementLie != null) { infoDeclencheur.Info = handler.EvenementLie.Libelle; } traitement.AddCoupleHandlerObjet(handler, (CObjetDonneeAIdNumerique)objetTmp, infoDeclencheur); } } } } } } //Annule les évenements spécifiques, ils ont été traités ! foreach (CObjetDonnee objet in lstObjetsAvecEvenementsSpecifiques) { EvenementAttribute.ClearEvenements(objet); } } } //Execute ce qui peut être executé tout de suite foreach (DataTable table in contexte.Tables) { table.RowChanged += handlerRedo; } listeElementsARepasser.Clear(); foreach (CTraitementApresSauvegarde.CCoupleDeclencheurObjet couple in traitement.CouplesEvenementOuHandlerObjet) { if (couple.Objet is CObjetDonneeAIdNumerique && couple.PeutEtreExecuteSurLePosteClient) { result = couple.OnDeclencheSurClient(); if (!result) { return(result); } } } foreach (DataTable table in contexte.Tables) { table.RowChanged -= handlerRedo; } bFirstPasse = false; } if (traitement.CouplesEvenementOuHandlerObjet.Count != 0) { tableData[c_cleDonneeListeTraitements] = traitement; } m_listeElementsARepasser.Remove(contexte); return(result); }
public override void BeginInit() { base.BeginInit(); RowChanging += new DataRowChangeEventHandler(tblPeopleDataTable_RowChanging); }
/// <summary>Выполнить sql, вернуть кол-во обработанных строк</summary> /// <param name="sql">SQL</param> /// <param name="pars">Словарь параметров ключ-значение</param> /// <param name="trassa">Метод для трассировки</param> /// <returns>Количество обработанных строк, -1 если ошибка</returns> public static int ExecCommand(this SqlConnection conn, string sql, Dictionary <string, object> pars = null, Action <string, List <SqlParameter>, string> trassa = null, SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null) { return((int)conn.ExecSql(ExecSqlType.NonQuery, sql, pars, trassa)); }
/// <summary>Выполнить sql</summary> /// <param name="execType">Определяет тип выполнения и результат (Table - через DataAdapter вернет DataTable, Scalar - через ExecuteScalar вернет object, NonQuery - через ExecuteNonQuery вернет int)</param> /// <param name="sql">SQL</param> /// <param name="pars">Словарь параметров</param> /// <param name="trassa">Метод для трассировки</param> /// <returns>В зависимости от execType. В случае ошибки вернет null или -1 для NonQuery</returns> public static object ExecSql(this SqlConnection conn, ExecSqlType execType, string sql, Dictionary <string, object> pars, Action <string, List <SqlParameter>, string> trassa = null, SynchronizationContext sync = null, DataRowChangeEventHandler onRowChange = null, Action <object> onFinish = null, int?cmdTimeout = null) { object res = null; if (sync == null) { sync = SynchronizationContext.Current; } if (cmdTimeout == null) { int t; if (int.TryParse(AppConfig.GetPropValue("CommandTimeout"), out t)) { cmdTimeout = t; } } if (string.IsNullOrWhiteSpace(sql)) { sync.Send(o => Loger.SendMess($"Не указан запрос", true), null); return(res); } try { List <SqlParameter> ps = null; if (pars != null) { ps = new List <SqlParameter>(); foreach (var p in pars) { object value = p.Value; if (value is DateTime && ((DateTime)value).Equals(DateTime.MinValue)) { value = null; } if (value is bool) { value = ((bool)value ? 1 : 0); } ps.Add(new SqlParameter(p.Key, value ?? DBNull.Value)); } } sync.Send(o => trassa?.Invoke(sql, ps, conn.ConnectionString), null); if (execType == ExecSqlType.NonQuery || execType == ExecSqlType.Scalar) { var cmd = new SqlCommand(sql, conn); if (cmdTimeout != null) { cmd.CommandTimeout = (int)cmdTimeout; } if (ps != null) { cmd.Parameters.AddRange(ps.ToArray()); } conn.Open(); res = (execType == ExecSqlType.NonQuery ? cmd.ExecuteNonQuery() : cmd.ExecuteScalar()); } if (execType == ExecSqlType.Table) { using (SqlDataAdapter da = new SqlDataAdapter(sql, conn)) { if (cmdTimeout != null) { da.SelectCommand.CommandTimeout = (int)cmdTimeout; } if (ps != null) { da.SelectCommand.Parameters.AddRange(ps.ToArray()); } res = new DataTable(); if (onRowChange != null) { ((DataTable)res).RowChanged += onRowChange; } da.Fill((DataTable)res); } } } catch (ThreadAbortException) { // } catch (Exception e) { sync.Send(o => Loger.SendMess(e, "Ошибка выполнения запроса"), null); res = null; } finally { if (res is DataTable && onRowChange != null) { ((DataTable)res).RowChanged -= onRowChange; } conn.Close(); if (onFinish != null) { sync.Send(o => onFinish(res), null); } } if (execType == ExecSqlType.NonQuery && res == null) { res = -1; } return(res); }