C# IDbCommand.GetType方法代码示例

 protected virtual void CacheOracleDbTypeEnumValues(IDbCommand command)
 {
     var assembly = command.GetType().Assembly;
     var typeEnum = assembly.GetType(OracleDbTypeEnumName);
     ReflectionCache.DbTypeRefCursor = Enum.Parse(typeEnum, "RefCursor");
     ReflectionCache.DbTypeBlob = Enum.Parse(typeEnum, "Blob");
 }

		/// <summary>
		/// Creates a provider specific implementation of IDbDataAdapter.
		/// </summary>
		/// <param name="command">The command used by the IDbDataAdapter.</param>
		/// <returns></returns>
		protected override IDbDataAdapter CreateDataAdapter(IDbCommand command)
		{
			var cmd = command as SqlCommand;
			if (cmd == null)
				throw new InvalidCastException("The command cannot be cast to SqlCommand. The actual type is: " + command.GetType().ToString());

			return new SqlDataAdapter(cmd);
		}

 public static DatabaseType GetDatabaseType( IDbCommand cmd ) {
     if (cmd is SqlCommand) {
         return DatabaseType.SqlServer;
     }
     if (cmd is OleDbCommand) {
         return DatabaseType.Access;
     }
     if (cmd.GetType() == MysqlFactory.mySqlCommandType) {
         return DatabaseType.MySql;
     }
     if (cmd is OracleCommand) {
         return DatabaseType.Oracle;
     }
     return DatabaseType.Other;
 }

        private static void DeriveParametersFromConnection(IDbCommand command)
        {
            var sqlCommand = command as SqlCommand;
            if (sqlCommand != null)
            {
                SqlCommandBuilder.DeriveParameters(sqlCommand);
                return;
            }

            var oleDbCommand = command as OleDbCommand;
            if (oleDbCommand != null)
            {
                OleDbCommandBuilder.DeriveParameters(oleDbCommand);
                return;
            }

            throw new ArgumentOutOfRangeException(
                nameof(command),
                $"Cannot derive parameters for command type [{command.GetType().Name}].");
        }

        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="connectionType"></param>
        ///// <param name="connectionString"></param>
        ///// <returns></returns>
        //private static IDbConnection AllocateConnection(DbConnectionType connectionType, string connectionString)
        //{
        //    if (connectionType == DbConnectionType.SqlClient)
        //    {
        //        return new SqlConnection(connectionString);
        //    }
        //    else if (connectionType == DbConnectionType.Odbc)
        //    {
        //        return new OdbcConnection(connectionString);
        //    }
        //    else if (connectionType == DbConnectionType.OracleClient)
        //    {
        //        return new OracleConnection(connectionString);
        //    }
        //    else if (connectionType == DbConnectionType.OleDb)
        //    {
        //        return new OleDbConnection(connectionString);
        //    }
        //    else if (connectionType == DbConnectionType.MySQL)
        //    {
        //        String s = string.Format("{0}\\MySql.Data.dll", EEPRegistry.Server);
        //        Assembly assembly = Assembly.LoadFrom(s);
        //        IDbConnection conn = (IDbConnection)assembly.CreateInstance("MySql.Data.MySqlClient.MySqlConnection");
        //        conn.ConnectionString = connectionString;
        //        return conn;
        //    }
        //    else if (connectionType == DbConnectionType.Informix)
        //    {
        //        String s = string.Format("{0}\\IBM.Data.Informix.dll", EEPRegistry.Server);
        //        Assembly assembly = Assembly.LoadFrom(s);
        //        IDbConnection conn = (IDbConnection)assembly.CreateInstance("IBM.Data.Informix.IfxConnection");
        //        conn.ConnectionString = connectionString;
        //        return conn;
        //    }
        //    else
        //    {
        //        return null;
        //    }
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="command"></param>
        /// <param name="parameterName"></param>
        /// <param name="dbType"></param>
        /// <returns></returns>
        private static IDataParameter AllocateParameter(IDbCommand command, string parameterName, DbType dbType)
        {
            if (command is SqlCommand)
            {
                return new SqlParameter(parameterName, dbType);
            }
            else if (command is OdbcCommand)
            {
                return new OdbcParameter(parameterName, dbType);
            }
            else if (command is OracleCommand)
            {
                return new OracleParameter(parameterName, dbType);
            }
            else if (command is OleDbCommand)
            {
                return new OleDbParameter(parameterName, dbType);
            }
            else if (command.GetType().Name == "MySqlCommand")
            {
                String s = string.Format("{0}\\MySql.Data.dll", EEPRegistry.Server);

                Assembly assembly = Assembly.LoadFrom(s);
                IDataParameter parameter = (IDataParameter)assembly.CreateInstance("MySql.Data.MySqlClient.MySqlParameter");
                parameter.ParameterName = parameterName;
                parameter.DbType = dbType;

                return parameter;
            }
            else if (command.GetType().Name == "IfxCommand")
            {
                String s = string.Format("{0}\\IBM.Data.Informix.dll", EEPRegistry.Server);

                Assembly assembly = Assembly.LoadFrom(s);
                IDataParameter parameter = (IDataParameter)assembly.CreateInstance("IBM.Data.Informix.IfxParameter");
                parameter.ParameterName = parameterName;
                parameter.DbType = dbType;

                return parameter;
            }
            else return null;
        }

		public override void PreExecute(IDbCommand cmd)
		{
			cmd.GetType().GetProperty("BindByName").SetValue(cmd, true, null);
            cmd.GetType().GetProperty("InitialLONGFetchSize").SetValue(cmd, -1); //see http://docs.oracle.com/html/A96160_01/features.htm#1048395
		}

		private static string GetParameterNamePrefix(IDbCommand cmd, DataParameterInfo parameterInfo)
		{
			string typeName = cmd.GetType().FullName;
			if (typeName.StartsWith("System.Data.SqlClient") ||
			    typeName.StartsWith("System.Data.SqlServerCe"))
			{
				return "@";
			}
			if (typeName.StartsWith("MySql"))
			{
				return "?";
			}

			if (!Char.IsLetterOrDigit(parameterInfo.Attribute.ParameterName[0]))
			{
				return parameterInfo.Attribute.ParameterName[0].ToString();
			}

			// TODO: probably need to look into postgres, firebird, etc
			return ":";
		}

 public override void PreExecute(IDbCommand cmd)
 {
     cmd.GetType().GetProperty("BindByName").SetValue(cmd, true, null);
     cmd.GetType().GetProperty("InitialLONGFetchSize").SetValue(cmd, -1, null);
 }

 /// <summary>
 /// 执行命令之前调用,可以修改DbCommand对象
 /// </summary>
 /// <param name="cmd">命令对象</param>
 public override void PreExecute(IDbCommand cmd)
 {
     cmd.GetType().GetProperty("BindByName").SetValue(cmd, true, null);
 }

 private IDbDataAdapter CreateDbDataAdapter(IDbCommand cmd)
 {
     IDbDataAdapter adapter = null;
     if (cmd is SqlCommand)
     {
         adapter = new SqlDataAdapter();
     }
     else if (cmd is OracleCommand)
     {
         adapter = new OracleDataAdapter();
     }
     else if (cmd is OdbcCommand)
     {
         adapter = new OdbcDataAdapter();
     }
     else if (cmd is OleDbCommand)
     {
         adapter = new OleDbDataAdapter();
     }
     #if MySql
     else if (cmd.GetType().FullName == "MySql.Data.MySqlClient.MySqlCommand")
     {
         adapter = new MySqlDataAdapter();
     }
     #endif
     adapter.SelectCommand = cmd;
     return adapter;
 }

 public static bool IsSybase(IDbCommand cmd)
 {
     return (cmd != null) && (cmd.GetType().FullName == "Sybase.Data.AseClient.AseCommand") ;
 }

 /// <summary>
 /// Gets the value of the last auto-incrementing number.  This called after doing an insert statement so that
 /// the inserted auto-number can be retrieved.  The table name, current IDbTransaction and IDbCommand are passed
 /// in so that they can be used if necessary.  
 /// </summary>
 /// <param name="tableName">The name of the table inserted into</param>
 /// <param name="tran">The current transaction, the one the insert was done in</param>
 /// <param name="command">The Command the did the insert statement</param>
 /// <returns></returns>
 public override long GetLastAutoIncrementingID(string tableName, IDbTransaction tran, IDbCommand command)
 {
     PropertyInfo propInfo = command.GetType().GetProperty("LastInsertedId", BindingFlags.Public | BindingFlags.Instance);
     return (long)propInfo.GetValue(command, null);
 }

 protected virtual void CacheCommandProperties(IDbCommand command)
 {
     var oracleDbCommandType = command.GetType();
     ReflectionCache.PropBindByName = oracleDbCommandType.GetProperty("BindByName", ReflectionHelper.NoRestrictions);
     ReflectionCache.PropArrayBindCount = oracleDbCommandType.GetProperty("ArrayBindCount", ReflectionHelper.NoRestrictions);
 }

 public static bool IsSqlAnywhere(IDbCommand cmd)
 {
     return (cmd != null) && (cmd.GetType().FullName == "iAnywhere.Data.AsaClient.AsaCommand") ;
 }

 public static bool IsOracleSystemData(IDbCommand cmd)
 {
     // 08/15/2005 Paul.  Type.GetType("Oracle.DataAccess.Client.OracleCommand") is returning NULL.  Use FullName instead.
     return (cmd != null) && (cmd.GetType().FullName == "System.Data.OracleClient.OracleCommand") ;
 }