public async Task <TResult> DeleteAsync <TResult>(long id, string username, Func <TResult> success, Func <string, TResult> failed)
{
using (var internalConnection = new SqlConnection(connectionString))
{
SqlTransaction transaction = null;
try
{
await internalConnection.OpenAsync();;
transaction = internalConnection.BeginTransaction();
var query = "Delete From Tasks where Id = @Id";
var cmd = new SqlCommand(string.Empty, internalConnection)
{
CommandText = query
};
cmd.Parameters.Clear();
cmd.Transaction = transaction;
cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.BigInt)
{
Value = id
});
var rowsAffected = await cmd.ExecuteNonQueryAsync();
try
{
await transaction.LogDeleteAsync(entityName, id, username);
}
catch (Exception ex)
{
_log.Error(ex, ex.Message, ex.StackTrace);
}
transaction.Commit();
return(rowsAffected > 0 ? success() : failed("Item not found, or error occurred."));
}
catch (SqlException sqlEx)
{
transaction?.Rollback();
_log.Error(sqlEx, sqlEx.Message, sqlEx.StackTrace);
}
catch (Exception ex)
{
transaction?.Rollback();
_log.Error(ex, ex.Message, ex.StackTrace);
}
return(default(TResult));
}
}
public void InsertUser(User user)
{
using (var connection = new SqlConnection(_connectionString))
using (var command = connection.CreateCommand())
{
try
{
connection.Open();
transaction = connection.BeginTransaction();
command.CommandText = "insert into Users values(@login, @password)";
var loginParameter = new SqlParameter();
loginParameter.ParameterName = "@login";
loginParameter.SqlDbType = System.Data.SqlDbType.NVarChar;
loginParameter.SqlValue = user.Login;
var passwrodParameter = new SqlParameter();
passwrodParameter.ParameterName = "@password";
passwrodParameter.SqlDbType = System.Data.SqlDbType.NVarChar;
passwrodParameter.SqlValue = user.Password;
command.Parameters.Add(passwrodParameter);
command.Parameters.Add(loginParameter);
command.Transaction = transaction;
int affectedRows = command.ExecuteNonQuery();
if (affectedRows < 1)
{
throw new Exception("Вставка не удалась");
}
transaction.Commit();
}
catch (SqlException exception)
{
// обработать
transaction?.Rollback();
throw;
}
catch (Exception exception)
{
// обработать
transaction?.Rollback();
throw;
}
}
}
public void InsertValues(int basketId, int pizzaId)
{
using (var connection = new SqlConnection(_connectionString))
using (var command = connection.CreateCommand())
{
try
{
connection.Open();
transaction = connection.BeginTransaction();
command.CommandText = "insert into Users values(@basketId, @pizzaId)";
var basketIdParameter = new SqlParameter();
basketIdParameter.ParameterName = "@basketId";
basketIdParameter.SqlDbType = System.Data.SqlDbType.Int;
basketIdParameter.SqlValue = basketId;
var pizzaIdParameter = new SqlParameter();
pizzaIdParameter.ParameterName = "@pizzaId";
pizzaIdParameter.SqlDbType = System.Data.SqlDbType.Int;
pizzaIdParameter.SqlValue = pizzaId;
command.Parameters.Add(basketIdParameter);
command.Parameters.Add(pizzaIdParameter);
command.Transaction = transaction;
int affectedRows = command.ExecuteNonQuery();
if (affectedRows < 1)
{
throw new Exception("Вставка не удалась");
}
transaction.Commit();
}
catch (SqlException exception)
{
transaction?.Rollback();
throw;
}
catch (Exception exception)
{
transaction?.Rollback();
throw;
}
}
}
public async Task <bool> DeleteAllAsync()
{
bool deleteOk;
using (var connection = new SqlConnection(_connectionString.Path))
{
SqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
deleteOk = await connection.DeleteAllAsync <T>(transaction);
transaction.Commit();
}
catch
{
transaction?.Rollback();
deleteOk = false;
}
finally
{
connection?.Close();
}
}
return(deleteOk);
}
public async Task <bool> UpdateAsync(IEnumerable <T> list)
{
bool updateOk;
using (var connection = new SqlConnection(_connectionString.Path))
{
SqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
updateOk = await connection.UpdateAsync <IEnumerable <T> >(list, transaction);
transaction.Commit();
}
catch
{
updateOk = false;
transaction?.Rollback();
}
finally
{
connection?.Close();
}
}
return(updateOk);
}
public async Task <int> InsertAsync(IEnumerable <T> list)
{
int committedCount = 0;
using (var connection = new SqlConnection(_connectionString.Path))
{
SqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
committedCount = await connection.InsertAsync <IEnumerable <T> >(list, transaction);
transaction.Commit();
}
catch
{
transaction?.Rollback();
}
finally
{
connection?.Close();
}
}
return(committedCount);
}
public static List <dynamic> Fetch(this SqlConnection conn, string sql, object parameters = null, SqlTransaction trans = null)
{
try
{
var command = new SqlCommand(sql, conn, trans);
if (parameters != null)
{
command.Parameters.AddRange(ConvertToDbParameter(parameters).Parameters);
}
var mapper = new SqlDataReaderSelectConverter();
List <dynamic> result;
using (var sdr = command.ExecuteReader())
{
result = mapper.ConvertToDynamicList(sdr);
}
return(result);
}
catch (Exception)
{
trans?.Rollback();
}
finally
{
conn.Close();
}
return(new List <dynamic>());
}
public async Task <int> InsertAsync(ChangeLogItem item)
{
int newId;
using (var connection = new SqlConnection(_connectionString.Path))
{
SqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
newId = await connection.InsertAsync <ChangeLogItem>(item, transaction);
transaction.Commit();
}
catch
{
newId = -1;
transaction?.Rollback();
}
finally
{
connection?.Close();
}
}
return(newId);
}
//Traisition과 sql 실행관련 함수
public int sqlTran(SqlConnection conn, SqlCommand sqlCmd)
{
int result = -2;
SqlTransaction sqlTran = null;
try
{
conn.Open();
sqlTran = conn.BeginTransaction();
sqlCmd.Transaction = sqlTran;
// 결과는 행수, 기타결과 -1
result = sqlCmd.ExecuteNonQuery();
sqlTran.Commit();
conn.Close();
}
catch (Exception e)
{
Console.WriteLine(e);
sqlTran?.Rollback();
conn.Close();
}
return(result);
}
public static async Task <T> SingleOrDefaultAsync <T>(this SqlConnection conn, string sql, object parameters = null, SqlTransaction trans = null)
{
try
{
var command = new SqlCommand(sql, conn, trans);
if (parameters != null)
{
command.Parameters.AddRange(ConvertToDbParameter(parameters).Parameters);
}
var mapper = new SqlDataReaderSelectConverter();
T result;
using (var sdr = await command.ExecuteReaderAsync())
{
result = mapper.ConvertToEntity <T>(sdr);
}
return(result);
}
catch (Exception)
{
trans?.Rollback();
}
finally
{
conn.Close();
}
return(default(T));
}
public bool AddUserActivity(IUserInfo user)
{
foreach (var account in user.Accounts.ToList())
{
using (var aConnection = new SqlConnection(_connectionString))
{
var cmd = new SqlCommand("INSERT INTO [dbo].[UserActivity] ([User],[Broker],[Account],[Date])" +
"VALUES(@user, @broker, @account, @date)", aConnection);
cmd.Parameters.AddWithValue("user", user.Login);
cmd.Parameters.AddWithValue("broker", account.BrokerName);
cmd.Parameters.AddWithValue("account", account.UserName);
cmd.Parameters.AddWithValue("date", DateTime.UtcNow);
SqlTransaction transaction = null;
try
{
aConnection.Open();
transaction = aConnection.BeginTransaction();
cmd.Transaction = transaction;
cmd.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
Logger.Error("Failed to add [UserActivity] item.", e);
transaction?.Rollback();
return(false);
}
}
}
return(true);
}
public bool RemovePortfolio(Portfolio portfolio)
{
using (var aConnection = new SqlConnection(_connectionString))
{
var cmd = new SqlCommand("DELETE FROM [dbo].[Portfolios] WHERE [ID] = @id", aConnection);
cmd.Parameters.AddWithValue("id", portfolio.ID);
SqlTransaction transaction = null;
try
{
aConnection.Open();
transaction = aConnection.BeginTransaction();
cmd.Transaction = transaction;
cmd.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception e)
{
Logger.Error("Failed to remove portfolio", e);
transaction?.Rollback();
return(false);
}
return(true);
}
}
/// <summary>
/// The method saves all list of the details.
/// </summary>
/// <param name="idList"></param>
/// <param name="userDep"></param>
/// <param name="dgvListAdd"></param>
public void SaveListDetails(int idList, string userDep, DataGridView dgvListAdd)
{
string query = "EXEC FillListAdd @idlist, @sort, @type, @model, @quantity, @abbrev,@notices";
using (SqlCommand cmd = new SqlCommand(query, _sqlCn))
{
SqlTransaction sqlTx = null;
try
{
sqlTx = _sqlCn.BeginTransaction();
cmd.Transaction = sqlTx;
for (int i = 0; i < dgvListAdd.RowCount; i++)
{
cmd.Parameters.AddWithValue("@idlist", idList);
cmd.Parameters.AddWithValue("@sort", dgvListAdd.Rows[i].Cells[0].Value);
cmd.Parameters.AddWithValue("@type", dgvListAdd.Rows[i].Cells[1].Value);
cmd.Parameters.AddWithValue("@model", dgvListAdd.Rows[i].Cells[2].Value);
cmd.Parameters.AddWithValue("@quantity", Convert.ToInt32(dgvListAdd.Rows[i].Cells[3].Value));
cmd.Parameters.AddWithValue("@abbrev", userDep);
cmd.Parameters.AddWithValue("@notices", dgvListAdd.Rows[i].Cells[4].Value);
cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
sqlTx.Commit();
}
catch (Exception ex)
{
MessageBox.Show(text: ex.Message);
sqlTx?.Rollback();
}
}
}
public void ExecuteQueryForDb(List <string> queries)
{
if (queries == null || queries.Count <= 0)
{
return;
}
SqlTransaction trans = null;
try {
Conn.Open();
trans = Conn.BeginTransaction();
foreach (var commandString in queries)
{
var command = new SqlCommand(commandString, Conn, trans);
command.ExecuteNonQuery();
}
trans.Commit();
}
catch (Exception ex)
{
trans?.Rollback();
throw new Exception("Exception occurred while executing query in database.", ex);
}
}
public void ProcessCreditRisk(bool throwEx, int custId)
{
// First, look up current name based on customer ID
string fName;
string lName;
var cmdSelect = new SqlCommand($"SELECT * FROM Customers WHERE CustId = {custId}", _sqlConnection);
using (var dataReader = cmdSelect.ExecuteReader())
{
if (dataReader.HasRows)
{
dataReader.Read();
fName = (string)dataReader["FirstName"];
lName = (string)dataReader["LastName"];
}
else
{
return;
}
}
// Create command objects that represent each step of the operation.
var cmdRemove = new SqlCommand($"DELETE FROM Customers WHERE CustId = {custId}", _sqlConnection);
var cmdInsert = new SqlCommand($"INSERT INTO CreditRisks(FirstName, LastName) VALUES ('{fName}', '{lName}')", _sqlConnection);
// We will get this from the connection object
SqlTransaction tx = null;
try
{
tx = _sqlConnection.BeginTransaction();
// Enlist the commands in to this transaction
cmdInsert.Transaction = tx;
cmdRemove.Transaction = tx;
// Execute the commands
cmdInsert.ExecuteNonQuery();
cmdRemove.ExecuteNonQuery();
// Simulate error
if (throwEx)
{
throw new Exception("Sorry! Database error! Tx failed...");
}
// Commit it!
tx.Commit();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
// Any error will roll back transaction.
// Using the new conditional access operator to check for null.
tx?.Rollback();
}
}
public int ExecuteNonQuery(string sql, params SqlParameter[] parameters)
{
using (var connection = new SqlConnection(_connectionString))
{
SqlTransaction transaction = null;
connection.Open();
try
{
transaction = connection.BeginTransaction();
var executed = 0;
using (var cmd = new SqlCommand(sql, connection))
{
if (parameters != null)
{
foreach (var parameter in parameters)
{
cmd.Parameters.Add(parameter);
}
}
executed = cmd.ExecuteNonQuery();
}
transaction.Commit();
return(executed);
}
catch
{
transaction?.Rollback();
throw;
}
}
}
public string SaveData(DataSet oDs)
{
string message;
SqlTransaction oTran = null;
try
{
InitializeConnection();
mOCn.Open();
oTran = mOCn.BeginTransaction();
long lRecordsAffected = mODa.Update(oDs, MsClassName);
oTran.Commit();
message = lRecordsAffected + " Doctor Records Were Updated";
}
catch (Exception e)
{
oTran?.Rollback();
message = "Records were not updated" + e.Message;
}
finally
{
mOCn.Close();
mOCn = null;
}
return(message);
}
public static async Task <T> ExecuteScalarAsync <T>(this SqlConnection conn, string sql, object parameters = null, SqlTransaction trans = null)
{
try
{
var command = new SqlCommand(sql, conn, trans);
if (parameters != null)
{
command.Parameters.AddRange(ConvertToDbParameter(parameters).Parameters);
}
var obj = await command.ExecuteScalarAsync();
if (obj != DBNull.Value)
{
return((T)obj);
}
}
catch (Exception)
{
trans?.Rollback();
}
finally
{
conn.Close();
}
return(default(T));
}
/// <summary>
/// Execute a list of commands as a transaction
/// </summary>
/// <param name="commandList">Command list</param>
/// <param name="rowsAffected">Action to received rows affected by each command</param>
public void Transaction(IEnumerable <SqlCommand> commandList, Action <int> rowsAffected)
{
using (var connection =
new SqlConnection(actions.ConnectionString.ConnectionString)) {
SqlTransaction transaction = null;
try {
connection.Open();
transaction = connection.BeginTransaction();
foreach (var cmd in commandList.Where(cmd => cmd != null))
{
cmd.Connection = connection;
cmd.Transaction = transaction;
var r = cmd.ExecuteNonQuery();
cmd.Dispose();
rowsAffected?.Invoke(r);
}
transaction.Commit();
} catch {
transaction?.Rollback();
throw;
} finally {
connection.Close();
}
}
}
/// <summary>
/// Releases all recources held by the <see cref="Database"/> object.
/// </summary>
public void Dispose()
{
try
{
// If transaction exist, commit it
if (_sqlTransaction != null)
{
_sqlTransaction.Commit();
_sqlTransaction.Dispose();
_sqlTransaction = null;
}
}
catch (Exception)
{
// Cannot commit transaction, try to rollback
_sqlTransaction?.Rollback();
throw;
}
finally
{
var connection = _sqlConnection;
// If connection exist, close it
if (connection != null)
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
connection.Dispose();
_sqlConnection = null;
}
}
}
/// <summary>
/// 执行事务
/// </summary>
/// <param name="strCmd">sql代码</param>
/// <param name="ps">sql参数</param>
/// <returns></returns>
public static int ExecuteTransaction(string strCmd, params SqlParameter[] ps)
{
int result = 0;
SqlTransaction tran = null;
try
{
using (SqlConnection con = new SqlConnection(connStr))
{
con.Open();
using (SqlCommand cmd = new SqlCommand(strCmd, con))
{
tran = con.BeginTransaction();
cmd.Parameters.AddRange(ps);
result = cmd.ExecuteNonQuery();
tran.Commit();
return(result);
}
}
}
catch (Exception e)
{
tran?.Rollback();
Console.WriteLine(e.Message);
return(result);
}
}
public void BulkCopy(DataTable table)
{
using (var connection = new SqlConnection(_connectionString))
{
SqlTransaction transaction = null;
connection.Open();
try
{
transaction = connection.BeginTransaction();
using (var sqlBulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, transaction))
{
sqlBulkCopy.BatchSize = table.Rows.Count;
sqlBulkCopy.DestinationTableName = table.TableName;
sqlBulkCopy.MapColumns(table);
sqlBulkCopy.WriteToServer(table);
}
transaction.Commit();
}
catch
{
transaction?.Rollback();
throw;
}
}
}
public bool Execute(string[] cmdText)
{
var res = true;
lock (_lockObj)
{
SqlTransaction transaction = null;
try
{
_con.Open();
transaction = _con.BeginTransaction();
var sqlCmd = _con.CreateCommand();
sqlCmd.Transaction = transaction;
foreach (var cmd in cmdText)
{
sqlCmd.CommandText = cmd;
sqlCmd.ExecuteNonQuery();
}
transaction.Commit();
}
catch (Exception ex)
{
transaction?.Rollback();
_log?.Error($"Execute sql error ,message = {ex.Message}");
res = false;
}
finally
{
_con.Close();
}
}
return(res);
}
public void ProcessCreditRisk(bool throwEx, int custId)
{
string firstName, lastName;
var cmdSelect = new SqlCommand($"Select * from Customers where CustomerId = {custId}",
_sqlConnection);
using (var dataReader = cmdSelect.ExecuteReader())
{
if (dataReader.HasRows)
{
dataReader.Read();
firstName = (string)dataReader["FirstName"];
lastName = (string)dataReader["LastName"];
}
else
{
return;
}
}
// Create command objects that represent each step of the operation.
var cmdRemove =
new SqlCommand($"Delete from Customers where CustomerId = {custId}",
_sqlConnection);
var cmdInsert =
new SqlCommand("Insert Into CreditRisks" +
$"(FirstName, LastName) Values('{firstName}', '{lastName}')",
_sqlConnection);
// We will get this from the connection object
SqlTransaction tx = null;
try
{
tx = _sqlConnection.BeginTransaction();
cmdInsert.Transaction = tx;
cmdRemove.Transaction = tx;
cmdInsert.ExecuteNonQuery();
cmdRemove.ExecuteNonQuery();
if (throwEx)
{
throw new Exception("Sorry! Database error! Tx failed.");
}
tx.Commit();
}
catch (Exception e)
{
Console.WriteLine(e);
// Any error will roll back transaction.
// Using the new conditional access operator to check for null.
tx?.Rollback();
}
}
public async Task <bool> StoreData(
SourceFileModel sourceFile,
SupplementaryDataWrapper wrapper,
CancellationToken cancellationToken)
{
bool successfullyCommitted = false;
using (SqlConnection connection =
new SqlConnection(_dbConfiguration.ESFNonEFConnectionString))
{
SqlTransaction transaction = null;
try
{
await connection.OpenAsync(cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
return(false);
}
transaction = connection.BeginTransaction();
var ukPrn = Convert.ToInt32(sourceFile.UKPRN);
var storeClear = new StoreClear(connection, transaction);
await storeClear.ClearAsync(ukPrn, sourceFile.ConRefNumber, cancellationToken);
int fileId = await _storeFileDetails.StoreAsync(connection, transaction, cancellationToken, sourceFile);
await _storeValidation.StoreAsync(connection, transaction, fileId, wrapper.ValidErrorModels, cancellationToken);
await _store.StoreAsync(connection, transaction, fileId, wrapper.SupplementaryDataModels, cancellationToken);
transaction.Commit();
successfullyCommitted = true;
}
catch (Exception ex)
{
_logger.LogError("Failed to persist to DEDs", ex);
}
finally
{
if (!successfullyCommitted)
{
try
{
transaction?.Rollback();
}
catch (Exception ex2)
{
_logger.LogError("Failed to rollback DEDs persist transaction", ex2);
}
}
}
}
return(successfullyCommitted);
}
public async Task LogValidationErrorsAsync(IEasJobContext easJobContext, IEnumerable <ValidationErrorModel> validationErrors, CancellationToken cancellationToken)
{
var sourceFile = new SourceFile()
{
Ukprn = easJobContext.Ukprn.ToString(),
DateTime = easJobContext.SubmissionDateTimeUtc,
FileName = easJobContext.FileReference,
FilePreparationDate = BuildFilePrepDate(easJobContext.FileReference)
};
var successfullyCommitted = false;
_logger.LogInfo("Starting Validation Error persist to DEDs");
using (var connection = new SqlConnection(_easServiceConfiguration.EasdbConnectionString))
{
SqlTransaction transaction = null;
try
{
await connection.OpenAsync(cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
transaction = connection.BeginTransaction();
int sourceFileId = await LogErrorSourceFileAsync(transaction, connection, sourceFile);
var validationErrorList = BuildErrors(validationErrors, sourceFileId);
await LogValidationErrorsAsync(connection, transaction, validationErrorList, cancellationToken);
transaction.Commit();
successfullyCommitted = true;
_logger.LogInfo("Finished Validation Error persist to DEDs");
}
catch (Exception ex)
{
_logger.LogError("Failed - Validation Error persist to DEDs", ex);
throw;
}
finally
{
if (!successfullyCommitted)
{
try
{
transaction?.Rollback();
}
catch (Exception ex)
{
_logger.LogError("Failed to rollback DEDs persist transaction", ex);
throw;
}
}
}
}
}
public async Task Save(List <TransactionModel> transactions)
{
int affectdRecords = 0;
using (var connection = new SqlConnection(_conntectionString))
{
SqlTransaction trans = null;
try
{
connection.Open();
trans = connection.BeginTransaction();
int chunkSize = 500;
var chunks = transactions.Select((x, j) => new { index = 1, value = x })
.GroupBy(x => x.index / chunkSize)
.Select(x => x.Select(v => v.value).ToList())
.ToList();
foreach (var chunk in chunks)
{
using (var sqlCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, trans)
{
DestinationTableName = "[dbo].[TRANSACTION]",
BatchSize = chunk.Count,
NotifyAfter = chunk.Count
})
{
sqlCopy.SqlRowsCopied += (sender, args) => { affectdRecords += (int)args.RowsCopied; };
sqlCopy.ColumnMappings.Add("TransactionIdentificator", "TransactionIdentificator");
sqlCopy.ColumnMappings.Add("Amount", "Amount");
sqlCopy.ColumnMappings.Add("CurrencyCode", "CurrencyCode");
sqlCopy.ColumnMappings.Add("TransactionDate", "TransactionDate");
sqlCopy.ColumnMappings.Add("Status", "TransactionStatus");
var reader = ObjectReader.Create(chunk);
{
await sqlCopy.WriteToServerAsync(reader);
}
}
}
trans.Commit();
}
catch (Exception ex)
{
trans?.Rollback();
trans?.Dispose();
_logger.Log(LogLevel.Error, ex.Message);
}
finally
{
trans?.Dispose();
}
}
_logger.Log(LogLevel.Information, $"Inserted Transactions: {affectdRecords} records");
}
public override void Rollback()
{
ThrowIfDisposed();
if (!_ownsTransaction && _transaction != null)
{
throw new InvalidOperationException(Messages.RollbackExternalTransaction);
}
_transaction?.Rollback();
}
public void Close()
{
logger.StartMethod(MethodBase.GetCurrentMethod().Name);
tran?.Rollback();
tran?.Dispose();
con.Close();
con.Dispose();
}
private static void Main(string[] args)
{
DataTable dataTable = new DataTable();
dataTable.Columns.Add("Name");
dataTable.Columns.Add("Floor");
foreach (DataColumn column in dataTable.Columns)
{
Console.WriteLine(column.ColumnName);
}
DataTable dt = ReadExcelFile("D:\\damon\\room1.xlsx");
string connectionString = "Data Source=kc-fengniaowu-dev.database.chinacloudapi.cn;Initial Catalog=KC.Fengniaowu.Talos-Dev-Local;Integrated Security=False;User ID=KC;Password=V245ZGxbEhn3Sakk;Connect Timeout=60;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
SqlTransaction transaction = null;
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
using (transaction = conn.BeginTransaction())
{
using (SqlBulkCopy copy = new SqlBulkCopy(conn, SqlBulkCopyOptions.Default, transaction))
{
copy.DestinationTableName = "dbo.[KC.Fengniaowu.Talos.Rooms1]";
copy.ColumnMappings.Add("ActorId", "ActorId");
copy.ColumnMappings.Add("RoomId", "RoomId");
copy.ColumnMappings.Add("ApartmentId", "ApartmentId");
copy.ColumnMappings.Add("Floor", "Floor");
copy.ColumnMappings.Add("Price", "Price");
copy.ColumnMappings.Add("RoomNumber", "RoomNumber");
copy.ColumnMappings.Add("Enabled", "Enabled");
copy.ColumnMappings.Add("CreateTime", "CreateTime");
copy.ColumnMappings.Add("UpdateTime", "UpdateTime");
copy.ColumnMappings.Add("Data", "Data");
copy.WriteToServer(dt);
}
transaction.Commit();
}
}
}
catch (Exception)
{
transaction?.Rollback();
throw;
}
Console.ReadLine();
}
