コード例 #1
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        public static T ExecuteScalar <T>(
            this IDbCmd source)
        {
            var obj = source.ExecuteScalar();

            return(ConvertTo <object, T> .From(obj));
        }
コード例 #2
0
        public void AddParameters()
        {
            SetupAndAssert(dbCmd =>
            {
                Assert.NotNull(dbCmd.Parameters);
                Assert.Empty(dbCmd.Parameters);

                List <IDbDataParameter> list = new List <IDbDataParameter>()
                {
                    dbCmd.Connection.CreateParameter(),
                    dbCmd.Connection.CreateParameter(),
                };

                IDbCmd dbCmd2 = dbCmd.AddParameter(list.ToArray());

                Assert.Same(dbCmd, dbCmd2);
                Assert.NotNull(dbCmd.Parameters);
                Assert.Equal(list.Count, dbCmd.Parameters.Count);

                for (int i = 0; i < list.Count; i++)
                {
                    Assert.Same(list[i], dbCmd.Parameters.ElementAt(i));
                }

                dbCmd.Parameters.Clear();
                Assert.Empty(dbCmd.Parameters);
            });
        }
コード例 #3
0
ファイル: IDbCommandExtensions.cs プロジェクト: deipax/Deipax
        public static async Task <DbDataReader> ExecuteReaderAsync(
            this IDbCommand source,
            IDbCmd dbCmd)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            if (dbCmd == null)
            {
                throw new ArgumentNullException(nameof(dbCmd));
            }

            if (source is DbCommand dbCommand)
            {
                Task <DbDataReader> task;

                if (dbCmd.CommandBehavior.HasValue)
                {
                    task = dbCmd.CancellationToken.HasValue
                        ? dbCommand.ExecuteReaderAsync(dbCmd.CommandBehavior.Value, dbCmd.CancellationToken.Value)
                        : dbCommand.ExecuteReaderAsync(dbCmd.CommandBehavior.Value);
                }
                else
                {
                    task = dbCmd.CancellationToken.HasValue
                        ? dbCommand.ExecuteReaderAsync(dbCmd.CancellationToken.Value)
                        : dbCommand.ExecuteReaderAsync();
                }

                return(await task.ConfigureAwait(false));
            }

            throw new InvalidOperationException("Async operations require use of a DbConnection or an IDbConnection where .CreateCommand() returns a DbCommand");
        }
コード例 #4
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        private static IDbCommand CreateCommand(
            this IDbCmd source)
        {
            var cmd = source.Connection.CreateCommand();

            var init = GetInit(cmd.GetType());

            init?.Invoke(cmd);

            if (source.CommandTimeout.HasValue)
            {
                cmd.CommandTimeout = source.CommandTimeout.Value;
            }
            cmd.CommandType = source.CommandType ?? System.Data.CommandType.Text;
            cmd.Transaction = source.Transaction;
            cmd.CommandText = source.CommandText;
            cmd.Connection  = source.Connection;

            cmd.Parameters.Clear();

            foreach (var p in source.Parameters)
            {
                cmd.Parameters.Add(p);
            }

            return(cmd);
        }
コード例 #5
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        public static async Task <T> ExecuteScalarAsync <T>(
            this IDbCmd source)
        {
            var obj = await source.ExecuteScalarAsync().ConfigureAwait(false);

            return(ConvertTo <object, T> .From(obj));
        }
コード例 #6
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        private static IDbCommand CreateAndOpen(
            this IDbCmd source)
        {
            var cmd = source.CreateCommand();

            cmd.Connection.EnsureOpen();
            return(cmd);
        }
コード例 #7
0
 public ManagedEnumerable(
     IDbCmd dbCmd,
     IDbCommand dbCommand,
     IDataReader reader)
 {
     _dbCmd     = dbCmd;
     _dbCommand = dbCommand;
     _reader    = reader;
 }
コード例 #8
0
 public void SetConnection()
 {
     SetupAndAssert(dbCmd =>
     {
         Assert.NotNull(dbCmd.Connection);
         IDbCmd dbCmd2 = dbCmd.Connection(null);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Null(dbCmd.Connection);
     });
 }
コード例 #9
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd CommandText(
     this IDbCmd source,
     string text)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.CommandText = text;
     return(source);
 }
コード例 #10
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd Connection(
     this IDbCmd source,
     IDbConnection con)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.Connection = con;
     return(source);
 }
コード例 #11
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd CommandType(
     this IDbCmd source,
     CommandType?type)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.CommandType = type;
     return(source);
 }
コード例 #12
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd CommandTimeout(
     this IDbCmd source,
     int?timeout)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.CommandTimeout = timeout;
     return(source);
 }
コード例 #13
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd CancellationToken(
     this IDbCmd source,
     CancellationToken?token)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.CancellationToken = token;
     return(source);
 }
コード例 #14
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 public static IDbCmd Transaction(
     this IDbCmd source,
     IDbTransaction trans)
 {
     if (source == null)
     {
         throw new ArgumentNullException(nameof(source));
     }
     source.Transaction = trans;
     return(source);
 }
コード例 #15
0
 public void SetCommandTimeout()
 {
     SetupAndAssert(dbCmd =>
     {
         Assert.Null(dbCmd.CommandTimeout);
         IDbCmd dbCmd2 = dbCmd.CommandTimeout(1000);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Equal(1000, dbCmd.CommandTimeout);
         dbCmd.CommandTimeout(null);
         Assert.Null(dbCmd.CommandTimeout);
     });
 }
コード例 #16
0
 public void SetCommandBehavior()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         IDbCmd cmd = dbCon.CommandBehavior(CommandBehavior.CloseConnection);
         Assert.NotNull(cmd);
         Assert.Equal(CommandBehavior.CloseConnection, cmd.CommandBehavior);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #17
0
 public void Dispose()
 {
     if (!Diposed)
     {
         _dbCmd = null;
         _dbCommand?.Dispose();
         _dbCommand = null;
         _reader?.Dispose();
         _reader = null;
         Diposed = true;
     }
 }
コード例 #18
0
 public void SetCommandText()
 {
     SetupAndAssert(dbCmd =>
     {
         Assert.True(string.IsNullOrEmpty(dbCmd.CommandText));
         IDbCmd dbCmd2 = dbCmd.CommandText("Bill");
         Assert.Same(dbCmd, dbCmd2);
         Assert.Equal("Bill", dbCmd.CommandText);
         dbCmd.CommandText(null);
         Assert.Null(dbCmd.CommandText);
     });
 }
コード例 #19
0
 public void SetCommandBehavior()
 {
     SetupAndAssert(dbCmd =>
     {
         Assert.Null(dbCmd.CommandBehavior);
         IDbCmd dbCmd2 = dbCmd.CommandBehavior(CommandBehavior.SingleRow);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Equal(CommandBehavior.SingleRow, dbCmd.CommandBehavior);
         dbCmd.CommandBehavior(null);
         Assert.Null(dbCmd.CommandBehavior);
     });
 }
コード例 #20
0
 public void SetCommandType()
 {
     SetupAndAssert(dbCmd =>
     {
         Assert.Null(dbCmd.CommandType);
         IDbCmd dbCmd2 = dbCmd.CommandType(CommandType.StoredProcedure);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Equal(CommandType.StoredProcedure, dbCmd.CommandType);
         dbCmd.CommandType(null);
         Assert.Null(dbCmd.CommandType);
     });
 }
コード例 #21
0
 public void SetCommandType()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         IDbCmd cmd = dbCon.CommandType(CommandType.TableDirect);
         Assert.NotNull(cmd);
         Assert.Equal(CommandType.TableDirect, cmd.CommandType);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #22
0
 public void SetCommandTimeout()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         IDbCmd cmd = dbCon.CommandTimeout(21);
         Assert.NotNull(cmd);
         Assert.Equal(21, cmd.CommandTimeout);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #23
0
 public void SetCommandText()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         IDbCmd cmd = dbCon.CommandText("TestText");
         Assert.NotNull(cmd);
         Assert.Equal("TestText", cmd.CommandText);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #24
0
 public void SetCancellationToken()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         var token  = new CancellationToken();
         IDbCmd cmd = dbCon.CancellationToken(token);
         Assert.NotNull(cmd);
         Assert.Equal(token, cmd.CancellationToken);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #25
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        /// <summary>
        /// Either read all items or use a using block to ensure all
        /// resources are fully cleaned up.
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static IManagedEnumerable <T> AsEnumerable <T>(
            this IDbCmd source) where T : new()
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            source.CommandBehavior(CmdBehavior.SingleResult);
            var cmd    = source.CreateAndOpen();
            var reader = cmd.ExecuteReader(source);

            return(new ManagedEnumerable <T>(source, cmd, reader));
        }
コード例 #26
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
        public static int ExecuteNonQuery(
            this IDbCmd source)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            using (var cmd = source.CreateAndOpen())
            {
                return(cmd.ExecuteNonQuery());
            }
        }
コード例 #27
0
 public void SetTransaction()
 {
     SetupAndAssert(dbCmd =>
     {
         TestTransaction trans = new TestTransaction();
         Assert.Null(dbCmd.Transaction);
         IDbCmd dbCmd2 = dbCmd.Transaction(trans);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Same(trans, dbCmd.Transaction);
         dbCmd.Transaction(null);
         Assert.Null(dbCmd.Transaction);
     });
 }
コード例 #28
0
ファイル: IDbCmdExtensions.cs プロジェクト: deipax/Deipax
 private static Task <T> CreateTask <T>(
     this IDbCmd source,
     Func <DbCommand, T> func,
     DbCommand dbCmd)
 {
     return(Task.Factory.StartNew(() =>
     {
         return func(dbCmd);
     },
                                  source.CancellationToken ?? System.Threading.CancellationToken.None,
                                  TaskCreationOptions.None,
                                  TaskScheduler.Default));
 }
コード例 #29
0
 public void SetTransaction()
 {
     SetupConnection(dbCon =>
     {
         Assert.Equal(ConnectionState.Closed, dbCon.State);
         var trans  = new TestTransaction();
         IDbCmd cmd = dbCon.Transaction(trans);
         Assert.NotNull(cmd);
         Assert.Same(trans, cmd.Transaction);
         Assert.Same(dbCon, cmd.Connection);
         Assert.Equal(ConnectionState.Closed, dbCon.State);
     });
 }
コード例 #30
0
 public void SetCancellationToken()
 {
     SetupAndAssert(dbCmd =>
     {
         var token = new CancellationToken();
         Assert.Null(dbCmd.CancellationToken);
         IDbCmd dbCmd2 = dbCmd.CancellationToken(token);
         Assert.Same(dbCmd, dbCmd2);
         Assert.Equal(token, dbCmd.CancellationToken);
         dbCmd.CancellationToken(null);
         Assert.Null(dbCmd.CancellationToken);
     });
 }