C# SqlHelper.Rollback方法代码示例

 /// <summary>
 /// Updates a Access into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="access_id">access_id</param>
 /// <param name="company_id">company_id</param>
 /// <param name="iPaddress">iPaddress</param>
 /// <param name="access_type">access_type</param>
 /// <param name="entry_datetime">entry_datetime</param>
 public static void UpdateAccess(int @access_id, int @company_id, string @iPaddress, string @access_type, DateTime @entry_datetime)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateAccess(@access_id, @company_id, @iPaddress, @access_type, @entry_datetime, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a RewardSetting from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="setting_id">setting_id</param>
 public static void DeleteRewardSetting(int @setting_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeleteRewardSetting(@setting_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a PurchaseOrderItem from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="purchaseorder_id">purchaseorder_id</param>
 /// <param name="product_code">product_code</param>
 public static void DeletePurchaseOrderItem(int @purchaseorder_id, string @product_code)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeletePurchaseOrderItem(@purchaseorder_id, @product_code, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a DocketItem into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="docketitem_id">docketitem_id</param>
 /// <param name="docket_id">docket_id</param>
 /// <param name="product_code">product_code</param>
 /// <param name="description">description</param>
 /// <param name="quantity">quantity</param>
 /// <param name="product_barcode">product_barcode</param>
 /// <param name="department">department</param>
 /// <param name="cost_ex">cost_ex</param>
 /// <param name="sale_ex">sale_ex</param>
 /// <param name="category">category</param>
 /// <param name="sale_inc">sale_inc</param>
 public static void UpdateDocketItem(int @docketitem_id, int @docket_id, string @product_code, string @description, double @quantity, string @product_barcode, string @department, decimal @cost_ex, decimal @sale_ex, string @category, decimal @sale_inc)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateDocketItem(@docketitem_id, @docket_id, @product_code, @description, @quantity, @product_barcode, @department, @cost_ex, @sale_ex, @category, @sale_inc, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a Admin from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="admin_id">admin_id</param>
 public static void DeleteAdmin(int @admin_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeleteAdmin(@admin_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a Company into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="company_id">company_id</param>
 /// <param name="name">name</param>
 /// <param name="brand_name">brand_name</param>
 /// <param name="company_number">company_number</param>
 /// <param name="contact_name">contact_name</param>
 /// <param name="contact_email">contact_email</param>
 /// <param name="transactions_email">transactions_email</param>
 /// <param name="address">address</param>
 /// <param name="suburb">suburb</param>
 /// <param name="state">state</param>
 /// <param name="country">country</param>
 /// <param name="postcode">postcode</param>
 /// <param name="phone">phone</param>
 /// <param name="website">website</param>
 /// <param name="api_key">api_key</param>
 /// <param name="notes">notes</param>
 /// <param name="is_active">is_active</param>
 /// <param name="is_customer">is_customer</param>
 /// <param name="is_supplier">is_supplier</param>
 /// <param name="is_manufacturer">is_manufacturer</param>
 /// <param name="paidto_datetime">paidto_datetime</param>
 /// <param name="creation_datetime">creation_datetime</param>
 /// <param name="has_POSSystem">has_POSSystem</param>
 public static void UpdateCompany(int @company_id, string @name, string @brand_name, string @company_number, string @contact_name, string @contact_email, string @transactions_email, string @address, string @suburb, string @state, string @country, string @postcode, string @phone, string @website, string @api_key, string @notes, bool @is_active, bool @is_customer, bool @is_supplier, bool @is_manufacturer, DateTime @paidto_datetime, DateTime @creation_datetime, bool @has_POSSystem)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateCompany(@company_id, @name, @brand_name, @company_number, @contact_name, @contact_email, @transactions_email, @address, @suburb, @state, @country, @postcode, @phone, @website, @api_key, @notes, @is_active, @is_customer, @is_supplier, @is_manufacturer, @paidto_datetime, @creation_datetime, @has_POSSystem, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a AllowedStore into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="entry_id">entry_id</param>
 /// <param name="customer_id">customer_id</param>
 /// <param name="supplier_id">supplier_id</param>
 /// <param name="account_number">account_number</param>
 /// <param name="is_member">is_member</param>
 /// <param name="authoriser_email">authoriser_email</param>
 /// <param name="creation_datetime">creation_datetime</param>
 public static void UpdateAllowedStore(int @entry_id, int @customer_id, int @supplier_id, string @account_number, bool @is_member, string @authoriser_email, DateTime @creation_datetime)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateAllowedStore(@entry_id, @customer_id, @supplier_id, @account_number, @is_member, @authoriser_email, @creation_datetime, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a PurchaseOrder from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="purchaseorder_id">purchaseorder_id</param>
 public static void DeletePurchaseOrder(int @purchaseorder_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeletePurchaseOrder(@purchaseorder_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a PurchaseOrder into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="purchaseorder_id">purchaseorder_id</param>
 /// <param name="customer_id">customer_id</param>
 /// <param name="supplier_id">supplier_id</param>
 /// <param name="person">person</param>
 /// <param name="creation_datetime">creation_datetime</param>
 /// <param name="local_code">local_code</param>
 /// <param name="is_submitted">is_submitted</param>
 /// <param name="submitted_datetime">submitted_datetime</param>
 /// <param name="due_datetime">due_datetime</param>
 public static void UpdatePurchaseOrder(int @purchaseorder_id, int @customer_id, int @supplier_id, string @person, DateTime @creation_datetime, string @local_code, bool @is_submitted, DateTime @submitted_datetime, DateTime @due_datetime)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdatePurchaseOrder(@purchaseorder_id, @customer_id, @supplier_id, @person, @creation_datetime, @local_code, @is_submitted, @submitted_datetime, @due_datetime, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a OutgoingSMS from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="outgoingSMS_id">outgoingSMS_id</param>
 public static void DeleteOutgoingSMS(int @outgoingSMS_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeleteOutgoingSMS(@outgoingSMS_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Insert a OutgoingSMS into the data store based on the primitive properties. This can be used as the 
 /// insert method for an ObjectDataSource.
 /// </summary>
 /// <param name="admin_id">admin_id</param>
 /// <param name="billingitem_id">billingitem_id</param>
 /// <param name="customerlist_id">customerlist_id</param>
 /// <param name="message_text">message_text</param>
 /// <param name="notes">notes</param>
 /// <param name="receipient_list">receipient_list</param>
 /// <param name="count">count</param>
 /// <param name="verification_sms">verification_sms</param>
 /// <param name="unsubscribe_list">unsubscribe_list</param>
 /// <param name="sent_datetime">sent_datetime</param>
 /// <param name="response_list">response_list</param>
 /// <param name="broken_list">broken_list</param>
 public static void InsertOutgoingSMS(int @admin_id, int @billingitem_id, int @customerlist_id, string @message_text, string @notes, string @receipient_list, int @count, string @verification_sms, string @unsubscribe_list, DateTime @sent_datetime, string @response_list, string @broken_list)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             InsertOutgoingSMS(@admin_id, @billingitem_id, @customerlist_id, @message_text, @notes, @receipient_list, @count, @verification_sms, @unsubscribe_list, @sent_datetime, @response_list, @broken_list, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Deletes a PointsLog from the data store based on the primitive primary keys. This can be used as the 
 /// delete method for an ObjectDataSource.
 /// </summary>
 /// <param name="pointlog_id">pointlog_id</param>
 public static void DeletePointsLog(int @pointlog_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             DeletePointsLog(@pointlog_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a PointsLog into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="pointlog_id">pointlog_id</param>
 /// <param name="customer_id">customer_id</param>
 /// <param name="company_id">company_id</param>
 /// <param name="reward_points">reward_points</param>
 /// <param name="description">description</param>
 /// <param name="creation_datetime">creation_datetime</param>
 /// <param name="docket_id">docket_id</param>
 /// <param name="voucher_id">voucher_id</param>
 /// <param name="admin_id">admin_id</param>
 public static void UpdatePointsLog(int @pointlog_id, int @customer_id, int @company_id, int @reward_points, string @description, DateTime @creation_datetime, int @docket_id, int @voucher_id, int @admin_id)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdatePointsLog(@pointlog_id, @customer_id, @company_id, @reward_points, @description, @creation_datetime, @docket_id, @voucher_id, @admin_id, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a BillingItem into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="billingitem_id">billingitem_id</param>
 /// <param name="invoice_id">invoice_id</param>
 /// <param name="company_id">company_id</param>
 /// <param name="description">description</param>
 /// <param name="quantity">quantity</param>
 /// <param name="unit_cost">unit_cost</param>
 /// <param name="total_amount">total_amount</param>
 /// <param name="creation_datetime">creation_datetime</param>
 public static void UpdateBillingItem(int @billingitem_id, int @invoice_id, int @company_id, string @description, int @quantity, decimal @unit_cost, decimal @total_amount, DateTime @creation_datetime)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateBillingItem(@billingitem_id, @invoice_id, @company_id, @description, @quantity, @unit_cost, @total_amount, @creation_datetime, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }

 /// <summary>
 /// Updates a RequestedAd into the data store based on the primitive properties. This can be used as the 
 /// update method for an ObjectDataSource.
 /// </summary>
 /// <param name="admatch_id">admatch_id</param>
 /// <param name="uploadedad_id">uploadedad_id</param>
 /// <param name="num_wanted">num_wanted</param>
 /// <param name="daily_quota">daily_quota</param>
 /// <param name="num_printed">num_printed</param>
 /// <param name="is_active">is_active</param>
 public static void UpdateRequestedAd(int @admatch_id, int @uploadedad_id, int @num_wanted, int @daily_quota, int @num_printed, bool @is_active)
 {
     using (SqlHelper helper = new SqlHelper())
     {
         try
         {
             helper.BeginTransaction();
             UpdateRequestedAd(@admatch_id, @uploadedad_id, @num_wanted, @daily_quota, @num_printed, @is_active, helper);
             helper.Commit();
         }
         catch
         {
             helper.Rollback();
             throw;
         }
     }
 }