diff --git a/ACUtils.SqlDb.Utils/ACUtils.SqlDb.Utils.csproj b/ACUtils.SqlDb.Utils/ACUtils.SqlDb.Utils.csproj index 08d2726..78356ad 100644 --- a/ACUtils.SqlDb.Utils/ACUtils.SqlDb.Utils.csproj +++ b/ACUtils.SqlDb.Utils/ACUtils.SqlDb.Utils.csproj @@ -4,8 +4,8 @@ Andrea Cattaneo true false - 1.0.0.143 - 1.0.0.143 + 1.0.0.144 + 1.0.0.144 Utilities per gestione DataTable it true diff --git a/ACUtils.SqlDb.Utils/DBModel.cs b/ACUtils.SqlDb.Utils/DBModel.cs index 366be85..8507fe5 100644 --- a/ACUtils.SqlDb.Utils/DBModel.cs +++ b/ACUtils.SqlDb.Utils/DBModel.cs @@ -51,20 +51,38 @@ public static List Idrate(DataTable dt) return IdrateGenerator(dt).ToList(); } - public static IEnumerable Idrate(SqlDataReader reader) + public static IEnumerable Idrate(IDataReader reader) { while (reader.Read()) { - for (int i = 0; i < reader.FieldCount; i++) + foreach (var o in _returnIdrate(reader)) { - var obj = new T(); - obj.idrate((IDataRecord)reader); - yield return obj; + yield return o; } } } - + public async static IAsyncEnumerable IdrateAsync(SqlDataReader reader) + { + while (await reader.ReadAsync()) + { + foreach (var o in _returnIdrate(reader)) + { + yield return o; + } + } + } + + private static IEnumerable _returnIdrate(IDataReader reader) + { + for (int i = 0; i < reader.FieldCount; i++) + { + var obj = new T(); + obj.idrate(reader); + yield return obj; + } + } + #endregion diff --git a/ACUtils.SqlDb/ACUtils.SqlDb.csproj b/ACUtils.SqlDb/ACUtils.SqlDb.csproj index cf7c5ed..fe97431 100644 --- a/ACUtils.SqlDb/ACUtils.SqlDb.csproj +++ b/ACUtils.SqlDb/ACUtils.SqlDb.csproj @@ -1,12 +1,12 @@ - + net461;netstandard2.0 Andrea Cattaneo true false - 1.0.0.144 - 1.0.0.144 + 1.0.0.146 + 1.0.0.146 Utility per interrogazione database MSSQL it true diff --git a/ACUtils.SqlDb/ConnectionWrapper.cs b/ACUtils.SqlDb/ConnectionWrapper.cs new file mode 100644 index 0000000..ebb0547 --- /dev/null +++ b/ACUtils.SqlDb/ConnectionWrapper.cs @@ -0,0 +1,28 @@ +using System; +using System.Data.SqlClient; + +namespace ACUtils +{ + class ConnectionWrapper : IDisposable + { + public readonly SqlConnection Connection; + private bool _closeOnDispose; + public ConnectionWrapper(SqlConnection connection, bool closeOnDispose = true) + { + this.Connection = connection; + _closeOnDispose = closeOnDispose; + } + + public void Dispose() + { + if (_closeOnDispose) + { + if (Connection?.State == System.Data.ConnectionState.Open) + { + Connection.Close(); + } + Connection?.Dispose(); + } + } + } +} diff --git a/ACUtils.SqlDb/SqlDb.cs b/ACUtils.SqlDb/SqlDb.cs index f7ea2f6..5456d58 100644 --- a/ACUtils.SqlDb/SqlDb.cs +++ b/ACUtils.SqlDb/SqlDb.cs @@ -4,6 +4,7 @@ using System.Data.SqlClient; using System.Globalization; using System.Linq; +using System.Threading.Tasks; using System.Transactions; namespace ACUtils @@ -17,7 +18,7 @@ public class SqlDb : IDisposable private static MissingSchemaAction? missingSchemaAction; private bool _persistentConnection = false; - + private SqlConnection _connection = null; public static MissingSchemaAction MissingSchemaAction { get @@ -120,7 +121,7 @@ public string Switch(object x) } } - internal static string ValueToString(object obj) + private static string ValueToString(object obj) { TypeSwitch ts = new TypeSwitch() .Case((bool x) => x ? "1" : "0") @@ -136,26 +137,6 @@ internal static string ValueToString(object obj) return ts.Switch(obj); } - internal void WriteLog(string queryString) - { - if (logger == null) - { - return; - } - string callerStack = GetCallerStack(4, 3); - logger.Debug($"SQL {callerStack}{Environment.NewLine}{queryString}"); - } - - internal void WriteLog(Exception exception, string queryString) - { - if (logger == null) - { - return; - } - string callerStack = GetCallerStack(4, 3); - logger.Error($"SQL {callerStack} : {exception}"); - } - internal void WriteLog(string queryString, KeyValuePair[] queryParams) { if (logger == null) @@ -352,9 +333,63 @@ protected virtual void Dispose(bool disposing) AbortTransaction(); } catch { } + + try + { + if (_connection?.State == ConnectionState.Open) + { + _connection.Close(); + SqlConnection.ClearPool(_connection); + } + } + catch { } } #endregion + private SqlConnection _rawConnection() + { + if (_persistentConnection) + { + if (_connection == null) + { + _connection = new SqlConnection(ConnectionString); + } + + return _connection; + } + var newConn = new SqlConnection(ConnectionString); + return newConn; + } + + internal ConnectionWrapper _getConnection() + { + var conn = _rawConnection(); + if (conn.State != ConnectionState.Open) + { + conn.Open(); + } + return new ConnectionWrapper(conn, !this._persistentConnection); + + } + + internal async Task _getConnectionAsync(System.Threading.CancellationToken? cancellationToken = null) + { + var conn = _rawConnection(); + if (conn.State != ConnectionState.Open) + { + if (cancellationToken.HasValue) + { + await conn.OpenAsync(cancellationToken.Value); + + } + else + { + await conn.OpenAsync(); + } + } + return new ConnectionWrapper(conn, !this._persistentConnection); + } + public static T GetColVal(DataRow dataRow, string columnName) { // dataRow.Field(columnName) diff --git a/ACUtils.SqlDb/SqlDb_BulkInsert.cs b/ACUtils.SqlDb/SqlDb_BulkInsert.cs index 635f5b9..e2bae0f 100644 --- a/ACUtils.SqlDb/SqlDb_BulkInsert.cs +++ b/ACUtils.SqlDb/SqlDb_BulkInsert.cs @@ -8,16 +8,22 @@ public static class SqlDb_BulkInsert { public static void BulkInsert(this SqlDb self, string tablename, IEnumerable records) { - using (var bc = new SqlBulkCopy(self.ConnectionString)) + using (var connection = self._getConnection()) { - bc.WriteToServer(self.BulkInsertPrepare(bc, tablename, records)); + using (var bc = new SqlBulkCopy(connection.Connection)) + { + bc.WriteToServer(self.BulkInsertPrepare(bc, tablename, records)); + } } } public static async System.Threading.Tasks.Task BulkInsertAsync(this SqlDb self, string tablename, IEnumerable records) { - using (var bc = new SqlBulkCopy(self.ConnectionString)) + using (var connection = await self._getConnectionAsync()) { - await bc.WriteToServerAsync(self.BulkInsertPrepare(bc, tablename, records)); + using (var bc = new SqlBulkCopy(connection.Connection)) + { + await bc.WriteToServerAsync(self.BulkInsertPrepare(bc, tablename, records)); + } } } diff --git a/ACUtils.SqlDb/SqlDb_Execute.cs b/ACUtils.SqlDb/SqlDb_Execute.cs index 4b7f51b..33d81e3 100644 --- a/ACUtils.SqlDb/SqlDb_Execute.cs +++ b/ACUtils.SqlDb/SqlDb_Execute.cs @@ -8,101 +8,77 @@ namespace ACUtils { public static class SqlDb_Execute { - public static bool Execute(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + #region static without params + public static int Execute(SqlConnection connection, string queryString) + { + return Execute(connection, queryString, new KeyValuePair[0]); + } + #endregion + #region static with simple params + public static int Execute(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) { //queryString = queryString.Trim().Replace(System.Environment.NewLine, " "); //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " "); - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - try - { - connection.Open(); - var value = self.Execute(connection, queryString, queryParams); - return value; - } - catch (Exception ex) - { - self.WriteLog(ex, queryString, queryParams); - throw; - } - finally - { - try { connection.Close(); } catch { } - } + return selectCommand.ExecuteNonQuery(); } } - - public static bool Execute(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) + #endregion + #region static with typed params + public static int Execute(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) { - //queryString = queryString.Trim().Replace(System.Environment.NewLine, " "); - //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " "); using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - var value = selectCommand.ExecuteNonQuery() > 0; - return value; + return selectCommand.ExecuteNonQuery(); } } + #endregion - public static bool Execute(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + #region without params + public static int Execute(this SqlDb self, string queryString) + { + return self.Execute(queryString, new KeyValuePair[0]); + } + #endregion + #region with simple params + public static int Execute(this SqlDb self, string queryString, params KeyValuePair[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + //queryString = queryString.Trim().Replace(System.Environment.NewLine, " "); + //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " "); + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - var value = self.Execute(connection, queryString, queryParams); - return value; + return Execute(connection.Connection, queryString, queryParams); } catch (Exception ex) { self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } - } - } - - public static bool Execute(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) - { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) - { - var value = selectCommand.ExecuteNonQuery() > 0; - return value; } } - - public static bool Execute(this SqlDb self, string queryString) + #endregion + #region whit typed params + public static int Execute(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - self.WriteLog(queryString); - var value = self.Execute(connection, queryString); - return value; + return Execute(connection.Connection, queryString, queryParams); } catch (Exception ex) { - self.WriteLog(ex, queryString); + self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } } } - public static bool Execute(this SqlDb self, SqlConnection connection, string queryString) - { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString)) - { - return selectCommand.ExecuteNonQuery() > 0; - } - } + #endregion } } diff --git a/ACUtils.SqlDb/SqlDb_QueryDataRow.cs b/ACUtils.SqlDb/SqlDb_QueryDataRow.cs index b7ced0e..57e564a 100644 --- a/ACUtils.SqlDb/SqlDb_QueryDataRow.cs +++ b/ACUtils.SqlDb/SqlDb_QueryDataRow.cs @@ -1,4 +1,5 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; using System.Data; using System.Data.SqlClient; @@ -6,33 +7,61 @@ namespace ACUtils { public static class SqlDb_QueryDataRow { - public static DataRow QueryDataRow(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + + #region static without params + public static DataRow QueryDataRow(SqlConnection connection, string queryString) + { + return QueryDataRow( + connection, + queryString, + new KeyValuePair[0] + ); + } + #endregion + #region static with simple params + public static DataRow QueryDataRow(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) { - DataTable dt = self.QueryDataTable( + DataTable dt = SqlDb_QueryDataTable.QueryDataTable( + connection, queryString, queryParams ); - - if (dt.Rows.Count == 0) - { - throw new Exceptions.NotFoundException("nessun risultato ottenuto"); - } - - if (dt.Rows.Count > 1) - { - throw new Exceptions.TooMuchResultsException("ottenuto più valori"); - } - return dt.Rows[0]; + return _return(dt); } - - public static DataRow QueryDataRow(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) + #endregion + #region static with typed params + public static DataRow QueryDataRow(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) { - DataTable dt = self.QueryDataTable( + DataTable dt = SqlDb_QueryDataTable.QueryDataTable( connection, queryString, queryParams ); + return _return(dt); + } + #endregion + #region without params + public static DataRow QueryDataRow(this SqlDb self, string queryString) + { + return self.QueryDataRow(queryString, new KeyValuePair[0]); + } + #endregion + #region with simple params + public static DataRow QueryDataRow(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + { + return _return(self.QueryDataTable(queryString, queryParams)); + } + #endregion + #region whit typed params + public static DataRow QueryDataRow(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + { + return _return(self.QueryDataTable(queryString, queryParams)); + } + #endregion + + private static DataRow _return(DataTable dt) + { if (dt.Rows.Count == 0) { throw new Exceptions.NotFoundException("nessun risultato ottenuto"); @@ -45,6 +74,5 @@ public static DataRow QueryDataRow(this SqlDb self, SqlConnection connection, st return dt.Rows[0]; } - } } diff --git a/ACUtils.SqlDb/SqlDb_QueryDataSet.cs b/ACUtils.SqlDb/SqlDb_QueryDataSet.cs index b0cfd2b..005d832 100644 --- a/ACUtils.SqlDb/SqlDb_QueryDataSet.cs +++ b/ACUtils.SqlDb/SqlDb_QueryDataSet.cs @@ -7,52 +7,46 @@ namespace ACUtils { public static class SqlDb_QueryDataSet { - public static DataSet QueryDataSet(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + #region static without params + public static DataSet QueryDataSet(SqlConnection connection, string queryString) + { + return QueryDataSet(connection, queryString, new KeyValuePair[0]); + } + #endregion + #region static with simple params + public static DataSet QueryDataSet(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - try - { - connection.Open(); - self.WriteLog(queryString, queryParams); - var ds = self.QueryDataSet(connection, queryString, queryParams); - return ds; - } - catch (Exception ex) - { - self.WriteLog(ex, queryString, queryParams); - throw; - } - finally - { - try { connection.Close(); } catch { } - } + return _return(selectCommand); } } - - public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) + #endregion + #region static with typed params + public static DataSet QueryDataSet(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) { using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand)) - { - DataSet ds = new DataSet(); - adapter.MissingSchemaAction = SqlDb.MissingSchemaAction; - adapter.Fill(ds); - return ds; - } + return _return(selectCommand); } } + #endregion + #region without params + public static DataSet QueryDataSet(this SqlDb self, string queryString) + { + return self.QueryDataSet(queryString, new KeyValuePair[0]); + } + #endregion + #region with simple params public static DataSet QueryDataSet(this SqlDb self, string queryString, params KeyValuePair[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - self.WriteLog(queryString, queryParams); - var ds = self.QueryDataSet(connection, queryString, queryParams); + var ds = QueryDataSet(connection.Connection, queryString, queryParams); return ds; } catch (Exception ex) @@ -60,61 +54,37 @@ public static DataSet QueryDataSet(this SqlDb self, string queryString, params K self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } } } - - public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) - { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) - { - using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand)) - { - DataSet ds = new DataSet(); - adapter.MissingSchemaAction = SqlDb.MissingSchemaAction; - adapter.Fill(ds); - return ds; - } - } - } - - public static DataSet QueryDataSet(this SqlDb self, string queryString) + #endregion + #region whit typed params + public static DataSet QueryDataSet(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - self.WriteLog(queryString); - var ds = self.QueryDataSet(connection, queryString); + var ds = QueryDataSet(connection.Connection, queryString, queryParams); return ds; } catch (Exception ex) { - self.WriteLog(ex, queryString); + self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } } } + #endregion - public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString) + private static DataSet _return(SqlCommand selectCommand) { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString)) + using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand)) { - using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand)) - { - DataSet ds = new DataSet(); - adapter.MissingSchemaAction = SqlDb.MissingSchemaAction; - adapter.Fill(ds); - return ds; - } + DataSet ds = new DataSet(); + adapter.MissingSchemaAction = SqlDb.MissingSchemaAction; + adapter.Fill(ds); + return ds; } } } diff --git a/ACUtils.SqlDb/SqlDb_QueryDataTable.cs b/ACUtils.SqlDb/SqlDb_QueryDataTable.cs index f81ad6b..7bbcc31 100644 --- a/ACUtils.SqlDb/SqlDb_QueryDataTable.cs +++ b/ACUtils.SqlDb/SqlDb_QueryDataTable.cs @@ -6,50 +6,49 @@ namespace ACUtils { public static class SqlDb_QueryDataTable { - /// - /// Esegue la query e restituisce il DataTable del risultato - /// - /// - /// db.QueryDataTable("SELECT * FROM A WHERE B = @B", "@B".WithValue("1")); - /// - /// stringa contenente la stringa di interrogazione SQL - /// nomi dei parametri associati a i loro valori. utilizzare come helper - /// - public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + #region static without params + public static DataTable QueryDataTable(SqlConnection connection, string queryString) { - DataSet ds = self.QueryDataSet(queryString, queryParams); - return ds.Tables[0]; + return QueryDataTable(connection, queryString, new KeyValuePair[0]); } - - public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) + #endregion + #region static with simple params + public static DataTable QueryDataTable(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) { - DataSet ds = self.QueryDataSet(connection, queryString, queryParams); - return ds.Tables[0]; + DataSet ds = SqlDb_QueryDataSet.QueryDataSet(connection, queryString, queryParams); + return _return(ds); } - - public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + #endregion + #region static with typed params + public static DataTable QueryDataTable(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) { - DataSet ds = self.QueryDataSet(queryString, queryParams); - return ds.Tables[0]; + DataSet ds = SqlDb_QueryDataSet.QueryDataSet(connection, queryString, queryParams); + return _return(ds); } + #endregion - public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) + #region without params + public static DataTable QueryDataTable(this SqlDb self, string queryString) { - DataSet ds = self.QueryDataSet(connection, queryString, queryParams); - return ds.Tables[0]; + return self.QueryDataTable(queryString, new KeyValuePair[0]); } - - public static DataTable QueryDataTable(this SqlDb self, string queryString) + #endregion + #region with simple params + public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair[] queryParams) { - DataSet ds = self.QueryDataSet(queryString); - return ds.Tables[0]; + return _return(self.QueryDataSet(queryString, queryParams)); } + #endregion + #region whit typed params + public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + { + return _return(self.QueryDataSet(queryString, queryParams)); + } + #endregion - public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString) + private static DataTable _return(DataSet ds) { - DataSet ds = self.QueryDataSet(connection, queryString); return ds.Tables[0]; } - } } diff --git a/ACUtils.SqlDb/SqlDb_QueryMany.cs b/ACUtils.SqlDb/SqlDb_QueryMany.cs index f995820..3f8b7ee 100644 --- a/ACUtils.SqlDb/SqlDb_QueryMany.cs +++ b/ACUtils.SqlDb/SqlDb_QueryMany.cs @@ -1,29 +1,53 @@  using System.Collections.Generic; +using System.Data; using System.Data.SqlClient; namespace ACUtils { public static class SqlDb_QueryMany { - public static List QueryMany(this SqlDb self, string sql, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + + #region static without params + public static List QueryMany(SqlConnection connection, string queryString) where T : ACUtils.DBModel, new() { - var dt = self.QueryDataTable(sql, queryParams); - return ACUtils.DBModel.Idrate(dt); + return QueryMany(connection, queryString, new KeyValuePair[0]); + } + #endregion + #region static with simple params + public static List QueryMany(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + { + return _return(SqlDb_QueryDataTable.QueryDataTable(connection, queryString, queryParams)); + } + #endregion + #region static with typed params + public static List QueryMany(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) where T : ACUtils.DBModel, new() + { + return _return(SqlDb_QueryDataTable.QueryDataTable(connection: connection, queryString: queryString, queryParams: queryParams)); } + #endregion - public static async IAsyncEnumerable QueryManyAsync(this SqlDb self, string sql, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + #region without params + public static List QueryMany(this SqlDb self, string queryString) where T : ACUtils.DBModel, new() + { + return self.QueryMany(queryString, new KeyValuePair[0]); + } + #endregion + #region with simple params + public static List QueryMany(this SqlDb self, string queryString, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + { + return _return(self.QueryDataTable(queryString: queryString, queryParams: queryParams)); + } + #endregion + #region whit typed params + public static List QueryMany(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) where T : ACUtils.DBModel, new() { - var dt = self.QueryDataTable(sql, queryParams); - await foreach (var q in ACUtils.DBModel.IdrateAsyncGenerator(dt)) - { - yield return q; - } + return _return(self.QueryDataTable(queryString: queryString, queryParams: queryParams)); } + #endregion - public static List QueryMany(this SqlDb self, SqlConnection connection, string sql, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + private static List _return(DataTable dt) where T : ACUtils.DBModel, new() { - var dt = self.QueryDataTable(connection, sql, queryParams); return ACUtils.DBModel.Idrate(dt); } } diff --git a/ACUtils.SqlDb/SqlDb_QueryManyAsync.cs b/ACUtils.SqlDb/SqlDb_QueryManyAsync.cs new file mode 100644 index 0000000..5678e83 --- /dev/null +++ b/ACUtils.SqlDb/SqlDb_QueryManyAsync.cs @@ -0,0 +1,90 @@ +using System.Collections.Generic; +using System.Data; +using System.Data.SqlClient; + +namespace ACUtils +{ + public static class SqlDb_QueryManyAsync + { + #region static without params + public static async IAsyncEnumerable QueryManyAsync(SqlConnection connection, string queryString) where T : ACUtils.DBModel, new() + { + await foreach (var q in QueryManyAsync(connection, queryString, new KeyValuePair[0])) + { + yield return q; + } + } + #endregion + #region static with simple params + public static async IAsyncEnumerable QueryManyAsync(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + { + using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) + { + using (var dr = selectCommand.ExecuteReader()) + { + await foreach (var q in _return(dr)) + { + yield return q; + } + } + } + } + #endregion + #region static with typed params + public static async IAsyncEnumerable QueryManyAsync(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) where T : ACUtils.DBModel, new() + { + using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) + { + using (var dr = selectCommand.ExecuteReader()) + { + await foreach (var q in _return(dr)) + { + yield return q; + } + } + } + } + #endregion + + #region without params + public static async IAsyncEnumerable QueryManyAsync(this SqlDb self, string queryString) where T : ACUtils.DBModel, new() + { + await foreach (var q in self.QueryManyAsync(queryString, new KeyValuePair[0])) + { + yield return q; + } + } + #endregion + #region with simple params + public static async IAsyncEnumerable QueryManyAsync(this SqlDb self, string queryString, params KeyValuePair[] queryParams) where T : ACUtils.DBModel, new() + { + using (var connection = await self._getConnectionAsync()) + { + self.WriteLog(queryString, queryParams); + await foreach (var q in QueryManyAsync(connection.Connection, queryString, queryParams)) + { + yield return q; + } + } + } + #endregion + #region whit typed params + public static async IAsyncEnumerable QueryManyAsync(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) where T : ACUtils.DBModel, new() + { + using (var connection = await self._getConnectionAsync()) + { + self.WriteLog(queryString, queryParams); + await foreach (var q in QueryManyAsync(connection.Connection, queryString, queryParams)) + { + yield return q; + } + } + } + #endregion + + private static IAsyncEnumerable _return(SqlDataReader dr) where T : ACUtils.DBModel, new() + { + return ACUtils.DBModel.IdrateAsync(dr); + } + } +} diff --git a/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs b/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs deleted file mode 100644 index 88d595d..0000000 --- a/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs +++ /dev/null @@ -1,32 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Data.SqlClient; - -namespace ACUtils -{ - public static class SqlDb_QueryNullableSingleValue - { - public static T? QueryNullableSingleValue(this SqlDb self, string queryString, params KeyValuePair[] queryParams) where T : struct - { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) - { - try - { - connection.Open(); - self.WriteLog(queryString, queryParams); - var value = self.QueryNullableSingleValue(connection, queryString, queryParams); - return value; - } - catch (Exception ex) - { - self.WriteLog(ex, queryString, queryParams); - throw; - } - finally - { - try { connection.Close(); } catch { } - } - } - } - } -} diff --git a/ACUtils.SqlDb/SqlDb_QueryOne.cs b/ACUtils.SqlDb/SqlDb_QueryOne.cs index b06d8e0..6a7e890 100644 --- a/ACUtils.SqlDb/SqlDb_QueryOne.cs +++ b/ACUtils.SqlDb/SqlDb_QueryOne.cs @@ -1,29 +1,73 @@ using System.Collections.Generic; +using System.Data; using System.Data.SqlClient; namespace ACUtils { public static class SqlDb_QueryOne { + #region static without params public static T QueryOne( - this SqlDb self, - string sql, + SqlConnection connection, + string queryString + ) where T : ACUtils.DBModel, new() + { + return QueryOne(connection, queryString, new KeyValuePair[0]); + } + #endregion + #region static with simple params + public static T QueryOne( + SqlConnection connection, + string queryString, params KeyValuePair[] queryParams ) where T : ACUtils.DBModel, new() { - var dr = self.QueryDataRow(sql, queryParams); - return ACUtils.DBModel.Idrate(dr); + return _return(SqlDb_QueryDataRow.QueryDataRow(connection, queryString, queryParams)); } + #endregion + #region static with typed params + public static T QueryOne( + SqlConnection connection, + string queryString, + params KeyValuePair>[] queryParams + ) where T : DBModel, new() + { + return _return(SqlDb_QueryDataRow.QueryDataRow(connection, queryString, queryParams)); + } + #endregion - + #region without params public static T QueryOne( this SqlDb self, - SqlConnection connection, - string sql, + string queryString + ) where T : DBModel, new() + { + return _return(self.QueryDataRow(queryString, new KeyValuePair[0])); + } + #endregion + #region with simple params + public static T QueryOne( + this SqlDb self, + string queryString, params KeyValuePair[] queryParams - ) where T : ACUtils.DBModel, new() + ) where T : DBModel, new() + { + return _return(self.QueryDataRow(queryString, queryParams)); + } + #endregion + #region whit typed params + public static T QueryOne( + this SqlDb self, + string queryString, + params KeyValuePair>[] queryParams + ) where T : DBModel, new() + { + return _return(self.QueryDataRow(queryString, queryParams)); + } + #endregion + + private static T _return(DataRow dr) where T : ACUtils.DBModel, new() { - var dr = self.QueryDataRow(connection, sql, queryParams); return ACUtils.DBModel.Idrate(dr); } } diff --git a/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs b/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs index e08862a..c010c8a 100644 --- a/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs +++ b/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs @@ -8,115 +8,77 @@ namespace ACUtils { public static class SqlDb_QuerySingleValue { - public static T QuerySingleValue(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + #region static without params + public static T QuerySingleValue(SqlConnection connection, string queryString) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) - { - try - { - connection.Open(); - self.WriteLog(queryString, queryParams); - var value = self.QuerySingleValue(connection, queryString, queryParams); - return value; - } - catch (Exception ex) - { - self.WriteLog(ex, queryString, queryParams); - throw; - } - finally - { - try { connection.Close(); } catch { } - } - } + return QuerySingleValue(connection, queryString, new KeyValuePair[0]); } - public static T QuerySingleValue(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) + #endregion + #region static with simple params + public static T QuerySingleValue(SqlConnection connection, string queryString, params KeyValuePair[] queryParams) { using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - object value = selectCommand.ExecuteScalar(); - return SqlDb._changeType(value); + return _return(selectCommand.ExecuteScalar()); } } - - public static Nullable QueryNullableSingleValue(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair[] queryParams) where T : struct + #endregion + #region static with typed params + public static T QuerySingleValue(SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) { using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) { - object value = selectCommand.ExecuteScalar(); - if (value == null || value == DBNull.Value || value is DBNull) - { - return null; - } - // conversione variabile da object a type specificato - //return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value); - return SqlDb._changeType(value); + return _return(selectCommand.ExecuteScalar()); } } + #endregion - public static T QuerySingleValue(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) + #region without params + public static T QuerySingleValue(this SqlDb self, string queryString) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + return self.QuerySingleValue(queryString, new KeyValuePair[0]); + } + #endregion + #region with simple params + public static T QuerySingleValue(this SqlDb self, string queryString, params KeyValuePair[] queryParams) + { + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - self.WriteLog(queryString, queryParams); - var value = self.QuerySingleValue(connection, queryString, queryParams); - return value; + return QuerySingleValue(connection.Connection, queryString, queryParams); } catch (Exception ex) { self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } - } - } - - public static T QuerySingleValue(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair>[] queryParams) - { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams)) - { - object value = selectCommand.ExecuteScalar(); - return SqlDb._changeType(value); } } - - - public static T QuerySingleValue(this SqlDb self, string queryString) + #endregion + #region whit typed params + public static T QuerySingleValue(this SqlDb self, string queryString, params KeyValuePair>[] queryParams) { - using (SqlConnection connection = new SqlConnection(self.ConnectionString)) + using (var connection = self._getConnection()) { + self.WriteLog(queryString, queryParams); try { - connection.Open(); - var value = self.QuerySingleValue(connection, queryString); - return SqlDb._changeType(value); + return QuerySingleValue(connection.Connection, queryString, queryParams); } catch (Exception ex) { - self.WriteLog(ex, queryString); + self.WriteLog(ex, queryString, queryParams); throw; } - finally - { - try { connection.Close(); } catch { } - } } } + #endregion - - public static T QuerySingleValue(this SqlDb self, SqlConnection connection, string queryString) + private static T _return(object value) { - using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString)) - { - object value = selectCommand.ExecuteScalar(); - return SqlDb._changeType(value); - } + return SqlDb._changeType(value); } } } diff --git a/ACUtils.SqlDbExt/ACUtils.SqlDbExt.csproj b/ACUtils.SqlDbExt/ACUtils.SqlDbExt.csproj index 4116b58..00eca5d 100644 --- a/ACUtils.SqlDbExt/ACUtils.SqlDbExt.csproj +++ b/ACUtils.SqlDbExt/ACUtils.SqlDbExt.csproj @@ -1,12 +1,12 @@ - + net461;netstandard2.0 Andrea Cattaneo true false - 1.0.0.140 - 1.0.0.140 + 1.0.0.142 + 1.0.0.142 Utility per interrogazione database MSSQL it true diff --git a/ACUtils.SqlDbExt/SqlDbExt.cs b/ACUtils.SqlDbExt/SqlDbExt.cs index 9bdbd39..d8a2198 100644 --- a/ACUtils.SqlDbExt/SqlDbExt.cs +++ b/ACUtils.SqlDbExt/SqlDbExt.cs @@ -1,5 +1,4 @@ -using System; -using System.Collections.Generic; +using System.Collections.Generic; using System.Data; using System.Data.SqlClient; using System.Globalization; @@ -24,7 +23,7 @@ public static class SqlDbExt public static void ToCSV(SqlConnection connection, string queryString, string csvFilePath, char Escape = '"', char Quote = '"', string Delimiter = ";", bool BoolToIntConvert = false, params KeyValuePair[] queryParams) { - DataTable dt = SqlDb.QueryDataTable(connection, queryString, queryParams); + DataTable dt = SqlDb_QueryDataTable.QueryDataTable(connection, queryString, queryParams); SqlDbExt.ToCsv( dataTable: dt, csvFilePath: csvFilePath, diff --git a/ACUtils.StringUtils/ACUtils.StringUtils.csproj b/ACUtils.StringUtils/ACUtils.StringUtils.csproj index 141cd9b..04ce2e6 100644 --- a/ACUtils.StringUtils/ACUtils.StringUtils.csproj +++ b/ACUtils.StringUtils/ACUtils.StringUtils.csproj @@ -1,17 +1,15 @@ - net461;netstandard2.0 Andrea Cattaneo true false - 1.0.0.140 - 1.0.0.140 + 1.0.0.141 + 1.0.0.141 Collezione di utility varie it true snupkg ..\dist\ - \ No newline at end of file diff --git a/Tests/SqlDbTest.cs b/Tests/SqlDbTest.cs index 87261e9..7912624 100644 --- a/Tests/SqlDbTest.cs +++ b/Tests/SqlDbTest.cs @@ -38,7 +38,7 @@ public void Teardown() public void TestSelect(string value) { SqlDb.MissingSchemaAction = System.Data.MissingSchemaAction.AddWithKey; - SqlDb.QueryDataRow( + SqlDb_QueryDataRow.QueryDataRow( new System.Data.SqlClient.SqlConnection(CONNECTION_STRING), "SELECT @a AS A", "@a".WithValue(value, 3) @@ -73,7 +73,7 @@ public void TestSelect(string value) public void TestSelectInt(int value) { SqlDb.MissingSchemaAction = System.Data.MissingSchemaAction.AddWithKey; - SqlDb.QueryDataRow( + SqlDb_QueryDataRow.QueryDataRow( new System.Data.SqlClient.SqlConnection(CONNECTION_STRING), "SELECT @a AS A", "@a".WithValue(value) @@ -102,7 +102,7 @@ public void TestSelectInt(int value) public void TestSelectNullableInt(int? value) { SqlDb.MissingSchemaAction = System.Data.MissingSchemaAction.AddWithKey; - SqlDb.QueryDataRow( + SqlDb_QueryDataRow.QueryDataRow( new System.Data.SqlClient.SqlConnection(CONNECTION_STRING), "SELECT @a AS A", "@a".WithValue(value)