C# SqlCeEngine.Upgrade方法代码示例

        public static DataTable ExecuteSqlQuery(string query, params SqlCeParameter[] sqlParams)
        {
            var dt = new DataTable();

            using (var conn = new SqlCeConnection(connStr))
            using (var cmd = new SqlCeCommand(query, conn))
            {
                try
                {
                    SqlCeEngine engine = new SqlCeEngine(conn.ConnectionString);
                    engine.Upgrade(conn.ConnectionString);
                }
                catch
                {
                }

                cmd.CommandType = CommandType.Text;
                cmd.Parameters.AddRange(sqlParams);

                conn.Open();
                dt.Load(cmd.ExecuteReader());
            }

            return dt;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            string cs = GetConnectionString();

            //need to upgrade to sql engine v4.0?
            if (!IsV40Installed())
            {
                SqlCeEngine engine = new SqlCeEngine(cs);
                engine.Upgrade();
            }

            //open connection
            SqlCeConnection sc = new SqlCeConnection(cs);

            //query customers
            string sql = "SELECT * FROM Customers";
            SqlCeCommand cmd = new SqlCeCommand(sql, sc);

            //create grid
            SqlCeDataAdapter sda = new SqlCeDataAdapter(cmd);
            DataTable dt = new DataTable();
            sda.Fill(dt);
            dataGridView1.DataSource = dt;
            dataGridView1.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader);

            //close connection
            sc.Close();
        }

        public void UpgrateSQLServerCe()
        {
            SqlCeEngine engine = new SqlCeEngine(getConnectionString());

            // https://msdn.microsoft.com/en-us/library/bb896160.aspx

            engine.Upgrade(getConnectionString());
        }

 private void Upgrade()
 {
     try
     {
         const string connectionString = @"Data Source=App_Data\tests.sdf";
         var ce = new SqlCeEngine(connectionString);
         ce.Upgrade(connectionString);
     }
     catch (Exception)
     {
         // throw;
     }
 }

 public override void PrepareEngine(string connectionString, DbConnection connection)
 {
     try {
         connection.Open();
     }
     catch {
         SqlCeEngine e = new SqlCeEngine(connectionString);
         e.Upgrade();
     }
     finally
     {
         connection.Close();
     }
 }

 public MainWindow()
 {
     InitializeComponent();
       SqlCeConnection connection = new SqlCeConnection("Data Source=Panic.sdf");
       // Upgrade the database if required
       SqlCeEngine engine = new SqlCeEngine(connection.ConnectionString);
       engine.Upgrade();
       siteRepository = new SiteSQL(connection);
       linkRepository = new LinkSQL(connection);
       hardwareRepository = new HardwareSQL(connection);
       graphVisualiser.InitialiseRepository(siteRepository, linkRepository);
       dataConfiguration.InitialiseRepository(siteRepository, linkRepository, hardwareRepository);
       graphVisualiser.Refresh();
 }

        public LocalDatabase(string FilePath)
            : base()
        {
            try
            {
                string fileName = Path.Combine(FilePath, "caselist.sdf");               

                connectionString = string.Format("Data Source=\"{0}\"", fileName);

                SqlCeEngine en = new SqlCeEngine(connectionString);

                if (!File.Exists(fileName))
                {                    
                    en.CreateDatabase();
                }

                m_connection = new SqlCeConnection();
                m_connection.ConnectionString = connectionString;

                if (m_connection.State == System.Data.ConnectionState.Closed)
                {
                    try
                    {
                        m_connection.Open();
                    }
                    catch (SqlCeInvalidDatabaseFormatException)
                    {
                        en.Upgrade();
                        m_connection.Open();
                    }                  
                }

                SqlCeCommand SelectTableCommand = new SqlCeCommand();
                SelectTableCommand.CommandText = QuerySelectRowString;
                SelectTableCommand.Connection = m_connection;

                m_adapter = new SqlCeDataAdapter((SqlCeCommand)SelectTableCommand);

                // Create the DbCommandBuilder.
                m_builder = new SqlCeCommandBuilder();
                m_builder.DataAdapter = m_adapter;

                m_adapter.SelectCommand = SelectTableCommand;                
            }
            catch
            {
                throw;
            }
        }

        public void UpgradeTo40(string connectionString)
        {
            string filename;
            using (SqlCeConnection conn = new SqlCeConnection(connectionString))
            {
                filename = conn.Database;
            }
            if (filename.Contains("|DataDirectory|"))
                throw new ApplicationException("DataDirectory macro not supported for upgrade");

            SQLCEVersion fileversion = DetermineVersion(filename);
            if (fileversion == SQLCEVersion.SQLCE20)
                throw new ApplicationException("Unable to upgrade from 2.0 to 4.0");

            if (SQLCEVersion.SQLCE40 > fileversion)
            {
                SqlCeEngine engine = new SqlCeEngine(connectionString);
                engine.Upgrade();
            }
        }

        public static void ExequteSqlCommand(string command, params SqlCeParameter[] sqlParams)
        {
            using (var conn = new SqlCeConnection(connStr))
            using (var cmd = new SqlCeCommand(command, conn))
            {
                try
                {
                    SqlCeEngine engine = new SqlCeEngine(conn.ConnectionString);
                    engine.Upgrade(conn.ConnectionString);
                }
                catch
                {
                }

                cmd.CommandType = CommandType.Text;
                cmd.Parameters.AddRange(sqlParams);

                conn.Open();
                cmd.ExecuteReader();
            }
        }

        public static void Upgrade()
        {
            System.Data.SqlServerCe.SqlCeEngine engine = new SqlCeEngine("Data Source = 'Database.sdf'");

            engine.Upgrade();
        }

 /// <summary>
 /// Tries to establish a connection to the given database. If this fails with a <see cref="SqlCeInvalidDatabaseFormatException"/>, we try
 /// to update the database to current engine version.
 /// </summary>
 /// <param name="engine">Database engine instance to upgrade.</param>
 protected void CheckUpgrade(SqlCeEngine engine)
 {
   try
   {
     using (SqlCeConnection conn = new SqlCeConnection(_connectionString))
     {
       conn.Open();
       conn.Close();
     }
   }
   catch (SqlCeInvalidDatabaseFormatException)
   {
     ServiceRegistration.Get<ILogger>().Warn("Upgrading existing SQL CE database format to v4.0...");
     engine.Upgrade();
     ServiceRegistration.Get<ILogger>().Warn("Upgrade successful!");
   }
 }

        protected override DbConnection CreateConnection(Type t, string connectionString)
        {
            SqlCeConnection connection = null;
            try
            {
                connection = new SqlCeConnection(connectionString);
                connection.Open();
            }
            catch (System.Data.SqlServerCe.SqlCeInvalidDatabaseFormatException)
            {
                try
                {
                    var engine = new SqlCeEngine(connectionString);
                    engine.Upgrade();

                    try
                    {
                        connection = new SqlCeConnection(connectionString);
                        connection.Open();
                    }
                    catch (System.Exception){}
                }
                catch (System.Exception ex)
                {
                    Console.WriteLine("Attempt on Upgrading SQL CE Database Failed (Reason = \"" + ex.Message + "\")");
                }
            }
            catch (Exception ex) { Console.WriteLine("Unexpected Error Occurred ! Error Details : " + ex.Message); }
            return connection;
        }

        public static SqlCeDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlCeParameter[] commandParameters)
        {
            if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
            SqlCeConnection connection = null;
            try
            {
                connection = new SqlCeConnection(connectionString);
                try
                {
                    connection.Open();
                }
                catch (SqlCeInvalidDatabaseFormatException)
                {
                    using (SqlCeEngine engine = new SqlCeEngine())
                    {
                        engine.Upgrade(connectionString);
                    }

                    connection = new SqlCeConnection(connectionString);
                    connection.Open();

                }

                using (SqlCeCommand command = new SqlCeCommand())
                {
                    PrepareCommand(
                        command,
                        connection,
                        null,
                        commandType,
                        commandText,
                        commandParameters);

                    return command.ExecuteReader(CommandBehavior.CloseConnection);
                }
            }
            catch
            {
                if ((connection != null) && (connection.State == ConnectionState.Open)) { connection.Close(); }
                throw;
            }
        }

 public static SqlCeConnection GetOpenSettingsConnection()
 {
     if (_settingsConn.State != System.Data.ConnectionState.Open)
     {
         try
         {
             _settingsConn.Open();
         }
         catch (SqlCeInvalidDatabaseFormatException)
         {
             SqlCeEngine engine = new SqlCeEngine(_settingsConn.ConnectionString);
             engine.Upgrade();
             _settingsConn.Open();
         }
     }
     return _settingsConn;
 }