/// <summary> /// Method to create and connect to a SQLite database. /// </summary> /// <param name="database">The database file name.</param> /// <param name="createFile">Create file if not exists ?</param> /// <param name="scheme">The path to the database scheme.</param> /// <exception cref="FileNotFoundException"></exception> /// <exception cref="SQLiteException"></exception> public void CreateConnection(string database, bool createFile = false, string scheme = "") { try { log.Debug(@"WPFSQLitePCL connecting : Data Source=" + database + ";Version=3;FailIfMissing=False;UTF8Encoding=True;"); Db = new SQLiteConnection(new SQLitePlatformWin32(), @"Data Source=" + database + ";Version=3;FailIfMissing=False;UTF8Encoding=True;", SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.ProtectionNone); if (createFile) { CreateDatabase(scheme); InitializeSetting(); } } catch (FileNotFoundException e) { string message = string.Format(CultureInfo.InvariantCulture, "Database file not found : {0}", database); log.Fatal(string.Format(message)); log.Fatal(e); throw new Exception("Database file not found : " + database, e); } catch (SQLiteException e) { string message = string.Format(CultureInfo.InvariantCulture, "Database file not found : {0}", database); log.Fatal(string.Format(message)); log.Fatal(e); throw SQLiteException.New(e.Result, e.Message); } }
public void InitOrCreateDatabase(Boolean AutoCreateDB) { // create a DbMetadataProvider _DBMetadataProvider = new SQLiteMetadataProvider(); _DBMetadataProvider.AutoCreateDB = AutoCreateDB; SQLiteConnectionStringBuilder builder = new SQLiteConnectionStringBuilder(_DBAccess.DBConnectStr); try { // Let caller know about anything we logged to this point LogMessage(TraceLevel.Verbose, "Attempting database connection...", System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId); _DBAccess.TryDBConnection(); LogMessage(TraceLevel.Verbose, " Connection successful. (DataSource: " + builder.DataSource + ")", System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId); } catch (Exception loExcept) { LogMessage(TraceLevel.Error, " Connection Failed! (DataSource: " + builder.DataSource + ")", System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId); // Let caller know about anything we logged to this point if (loExcept is SQLiteException) { SQLiteException loSQLError = (loExcept as SQLiteException); LogMessage(TraceLevel.Error, loSQLError.Message + "; ErrorCode = " + loSQLError.ErrorCode.ToString(), System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId); } else { LogMessage(TraceLevel.Error, loExcept.Message, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name, System.Threading.Thread.CurrentThread.ManagedThreadId); } // re-throw the error throw loExcept; } }
/// <summary> /// Method to create a new database base on a file of scheme. /// </summary> /// <param name="scheme">An application relative path to the database scheme to create.</param> /// <exception cref="FileNotFoundException"></exception> /// <exception cref="SQLiteException"></exception> protected void CreateDatabase(string scheme) { string query = ""; string path = Path.Combine(Environment.CurrentDirectory, scheme); try { query = File.ReadAllText(path); } catch (Exception e) { string message = string.Format(CultureInfo.InvariantCulture, "Database scheme file not found : {0}", scheme); log.Fatal(string.Format(message)); log.Fatal(e); throw new FileNotFoundException(message, e); } try { Db.RunInTransaction(() => { Db.Execute(query); }); } catch (SQLiteException e) { string message = string.Format(CultureInfo.InvariantCulture, "Failed to create database scheme : {0}", scheme); log.Fatal(string.Format(message)); log.Fatal(e); throw SQLiteException.New(e.Result, message); } }
/// <summary> /// Gets a message from an exception raised by the connector. /// Removes the initial #{number} and the ending dot. /// </summary> /// <param name="e">Exception.</param> /// <returns>The message.</returns> /// <exception cref="ArgumentNullException"><paramref name="e"/> is a <B>null</B> reference.</exception> public override string GetExceptionMessage(Exception /*!*/ e) { if (e == null) { throw new ArgumentNullException("e"); } SQLiteException mye = e as SQLiteException; if (mye == null || mye.Message.Length == 0) { return(e.Message); } string msg = StripErrorNumber(mye.Message); // skip last dot: int j = msg.Length; if (msg[j - 1] == '.') { j--; } return(String.Format("{0} (error {1})", msg.Substring(0, j), mye.ErrorCode)); }
public override T ExecuteScalar <T>() { T val = default(T); var stmt = Prepare(); try { var r = SQLite3.Step(stmt); if (r == SQLite3.Result.Row) { var colType = SQLite3.ColumnType(stmt, 0); var colval = ReadCol(stmt, 0, colType, typeof(T)); if (colval != null) { val = (T)colval; } } else if (r == SQLite3.Result.Done) { } else { throw SQLiteException.New(r, SQLite3.GetErrmsg(_conn.Handle)); } } finally { Finalize(stmt); } return(val); }
public int ExecuteNonQuery() { if (_conn.Trace) { Debug.WriteLine("Executing: " + this); } var r = SQLite3.Result.OK; var stmt = Prepare(); r = SQLite3.Step(stmt); Finalize(stmt); if (r == SQLite3.Result.Done) { int rowsAffected = SQLite3.Changes(_conn.Handle); return(rowsAffected); } else if (r == SQLite3.Result.Error) { string msg = SQLite3.GetErrmsg(_conn.Handle); throw SQLiteException.New(r, msg); } else if (r == SQLite3.Result.Constraint) { if (SQLite3.ExtendedErrCode(_conn.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(_conn.Handle)); } } throw SQLiteException.New(r, r.ToString()); }
public T ExecuteScalar <T>() { if (_conn.Trace) { Debug.WriteLine("Executing Query: " + this); } T val = default(T); var stmt = Prepare(); try { var r = SQLite3.Step(stmt); if (r == SQLite3.Result.Row) { var colType = SQLite3.ColumnType(stmt, 0); val = (T)ReadCol(stmt, 0, colType, typeof(T)); } else if (r == SQLite3.Result.Done) { } else { throw SQLiteException.New(r, SQLite3.GetErrmsg(_conn.Handle)); } } finally { Finalize(stmt); } return(val); }
private ActionResult Handle(SQLiteException exception) { //todo: some logic handle sqlite exception return(new ViewResult { ViewName = "CustomError", ViewData = { Model = new FriendlyUserErrorMessage("Error", exception.Message, "contact to support") } }); }
private void HandleSQLite_Exception(SQLiteException e) { switch (e.ResultCode) { case SQLiteErrorCode.Constraint: throw new SQL_Exception(SQL_Exception_Type.Unique_Failed); } }
// protected static UserError Handle(Win32Exception ex, string action) { // return ex.NativeErrorCode == Win32ErrorCodes.ERROR_CANCELLED_ELEVATION // ? new CanceledUserError(action, innerException: ex) // : Handle((Exception) ex, action); // } protected static UserErrorModel Handle(SQLiteException ex, string action) { var message = $"There appears to be a problem with your database. If the problem persists, you can delete the databases from:\n{Common.Paths.LocalDataPath} and {Common.Paths.DataPath}" + "\nError message: " + ex.Message; var title = "An error has occured while trying to '" + action + "'"; return(new UserErrorModel(title, message, innerException: ex)); }
public int ExecuteNonQuery(object[] source) { if (Initialized && Statement == NullStatement) { throw new ObjectDisposedException(nameof(PreparedSqlLiteInsertCommand)); } if (Connection.IsClosed) { Connection.RenewConnection(); } var r = SQLite3.Result.OK; if (!Initialized) { Statement = SQLite3.Prepare2(Connection.Handle, CommandText); Initialized = true; } //bind the values. if (source != null) { for (int i = 0; i < source.Length; i++) { SQLiteCommand.BindParameter(Statement, i + 1, source[i], Connection.StoreDateTimeAsTicks, Connection.DateTimeStringFormat, Connection.StoreTimeSpanAsTicks); } } r = SQLite3.Step(Statement); if (r == SQLite3.Result.Done) { int rowsAffected = SQLite3.Changes(Connection.Handle); SQLite3.Reset(Statement); return(rowsAffected); } else if (r == SQLite3.Result.Error) { string msg = SQLite3.GetErrmsg(Connection.Handle); SQLite3.Reset(Statement); throw SQLiteException.New(r, msg); } else if (r == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(Connection.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { SQLite3.Reset(Statement); throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(Connection.Handle)); } else if (r == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(Connection.Handle) == SQLite3.ExtendedResult.ConstraintUnique) { SQLite3.Reset(Statement); throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(Connection.Handle)); } else { SQLite3.Reset(Statement); throw SQLiteException.New(r, SQLite3.GetErrmsg(Connection.Handle)); } }
/// <summary> /// 在qqlite控制台输出异常信息 /// </summary> /// <param name="funcName">执行的函数名</param> /// <param name="E">异常</param> private static void PrintErrorMessage(string funcName, SQLiteException E) { string errorString = string.Format("Message:{0}\nSource:{1}\nTargetSite:{2}\nStackTrace:{3}", E.Message, E.Source, E.TargetSite.ToString(), E.StackTrace); QQLog.WriteLog(DbBase.RobotQQ, string.Format("{0} Error Begin", funcName)); QQLog.WriteLog(DbBase.RobotQQ, errorString); QQLog.WriteLog(DbBase.RobotQQ, string.Format("{0} Error End", funcName)); }
public static IDbStatement Prepare2(IDbHandle db, string query) { IDbStatement stmt; var r = Prepare2(db, query, query.Length, out stmt, IntPtr.Zero); if (r != Result.OK) { throw SQLiteException.New(r, GetErrmsg(db)); } return(stmt); }
public IDbStatement Prepare2(IDbHandle db, string query) { var internalDbHandle = (DbHandle)db; var r = SQLiteApiGenericInternal.sqlite3_prepare16_v2(internalDbHandle.DbPtr, query, -1, out IntPtr stmt, IntPtr.Zero); if (r != Result.OK) { throw SQLiteException.New(r, Errmsg16(internalDbHandle)); } return(new DbStatement(stmt)); }
/// <summary> /// Gets last error number. /// </summary> /// <returns>The error number it is known, -1 if unknown error occured, or zero on success.</returns> public override int GetLastErrorNumber() { if (LastException == null) { return(0); } SQLiteException e = LastException as SQLiteException; return((e != null) ? (int)e.ErrorCode : -1); }
public static IntPtr Prepare2(IntPtr db, string query) { IntPtr stmt; var r = Prepare2(db, query, query.Length, out stmt, IntPtr.Zero); if (r != SQLite3.Result.OK) { throw SQLiteException.New(r, GetErrmsg(db)); } return(stmt); }
public void Issue604_RecoversFromFailedCommit() { db.Trace = true; var initialCount = db.Table <TestObj> ().Count(); // // Well this is an issue because there is an internal variable called _transactionDepth // that tries to track if we are in an active transaction. // The problem is, _transactionDepth is set to 0 and then commit is executed on the database. // Well, the commit fails and "When COMMIT fails in this way, the transaction remains active and // the COMMIT can be retried later after the reader has had a chance to clear" // var rollbacks = 0; db.Tracer = m => { if (m == "Executing: commit") { throw SQLiteException.New(SQLite3.Result.Busy, "Make commit fail"); } if (m == "Executing: rollback") { rollbacks++; } }; db.BeginTransaction(); db.Insert(new TestObj()); try { db.Commit(); Assert.Fail("Should have thrown"); } catch (SQLiteException ex) when(ex.Result == SQLite3.Result.Busy) { db.Tracer = null; } Assert.False(db.IsInTransaction); Assert.AreEqual(1, rollbacks); // // The catch statements in the RunInTransaction family of functions catch this and call rollback, // but since _transactionDepth is 0, the transaction isn't actually rolled back. // // So the next time begin transaction is called on the same connection, // sqlite-net attempts to begin a new transaction (because _transactionDepth is 0), // which promptly fails because there is still an active transaction on the connection. // // Well now we are in big trouble because _transactionDepth got set to 1, // and when begin transaction fails in this manner, the transaction isn't rolled back // (which would have set _transactionDepth to 0) // db.BeginTransaction(); db.Insert(new TestObj()); db.Commit(); Assert.AreEqual(initialCount + 1, db.Table <TestObj> ().Count()); }
protected override bool IsTransactionFailure(Exception exception) { SQLiteException localException = exception as SQLiteException; if (localException != null) { return(IsTransactionFailure(localException.ErrorCode)); } return(false); }
public IDbStatement Prepare2(IDbHandle db, string query) { var dbHandle = (DbHandle)db; var stmt = default(Sqlite3Statement); var r = SQLite3.Prepare2(dbHandle.InternalDbHandle, query, query.Length, out stmt, IntPtr.Zero); if (r != Result.OK) { throw SQLiteException.New(r, SQLite3.GetErrmsg(dbHandle.InternalDbHandle)); } return(new DbStatement(stmt)); }
private static InjectOutcomePolicy CreateRetryChaos(IPolicies policies) { var fault = new SQLiteException( (SQLiteErrorCode)ChaosPolicyShared.GetRandomEnum <RetryableSqlErrors>(), "Policy chaos testing"); return(MonkeyPolicy.InjectException(with => with.Fault(fault) .InjectionRate((context, token) => ChaosPolicyShared.InjectionRate(context, RetryConstants.RetryCount, RetryAttempts)) .Enabled(policies.EnableChaos) )); }
/// <summary> /// Logs SQLiteExceptions /// </summary> /// <param name="sqlex">SQLiteException </param> private static void LogException(SQLiteException sqlex) { LogFile log = new LogFile(); string errorMessage; errorMessage = "Exception Number : " + sqlex.ErrorCode + "(" + sqlex.Message + ") has occurred"; log.Create(errorMessage); }
public IDbStatement Prepare2(IDbHandle db, string query) { var internalDbHandle = (DbHandle)db; IntPtr stmt; Result r = SQLiteApiIOSInternal.sqlite3_prepare_v2(internalDbHandle.DbPtr, query, query.Length, out stmt, IntPtr.Zero); if (r != Result.OK) { throw SQLiteException.New(r, Errmsg16(internalDbHandle)); } return(new DbStatement(stmt)); }
public IDbStatement Prepare2(IDbHandle db, string query) { var dbHandle = (DbHandle)db; var stmt = new Sqlite3.Vdbe(); int r = Sqlite3.sqlite3_prepare_v2(dbHandle.InternalDbHandle, query, -1, ref stmt, 0); if (r != 0) { throw SQLiteException.New((Result)r, GetErrmsg(db)); } return(new DbStatement(stmt)); }
public static IntPtr Prepare2(IntPtr db, string query) { IntPtr stmt; byte[] queryBytes = Encoding.UTF8.GetBytes(query); var r = Prepare2(db, queryBytes, queryBytes.Length, out stmt, IntPtr.Zero); if (r != Result.OK) { throw SQLiteException.New(r, GetErrmsg(db)); } return(stmt); }
private async Task RunIntegrityCheckAsync(Context context) { try { System.IO.FileInfo dbFileInfo = new System.IO.FileInfo(DatabaseFilePath.Path); Tracer.RecordSQLiteDatabaseSize(context, dbFileInfo.Length); // Getting file stats is supposed to be safe and should not interfere // with future file opens and reads. } catch (Exception exception) { Tracer.Error(context, exception, "Could not get file size of master DB"); } try { Tracer.SQLiteIntegrityCheckStart(context); var integrityCheckWatch = Stopwatch.StartNew(); await ExecuteReaderAsync(string.Empty, "PRAGMA integrity_check", reader => { const string integrityCheckOk = "ok"; var result = (string)reader[0]; // The reader should always have something to read, by design if (result != integrityCheckOk) { integrityCheckWatch.Stop(); SQLiteException sqle = new SQLiteException( SQLiteErrorCode.Corrupt, $"Sqlite integrity check result expected to be [{integrityCheckOk}] but is instead [{result}]"); Tracer.SQLiteIntegrityCheckStopAtFailure(context, sqle, integrityCheckWatch.Elapsed); throw sqle; } integrityCheckWatch.Stop(); Tracer.SQLiteIntegrityCheckStopAtSuccess(context, integrityCheckWatch.Elapsed); return(ReadResponse.StopReadingIgnoreFurther); }); } catch (Exception exception) { SQLiteException sqle = exception as SQLiteException; if (sqle != null && sqle.ResultCode == SQLiteErrorCode.Corrupt) { throw sqle; } // else ignore and continue. Treat other exceptions as a failure to perform the check and not // a real integrity check failure. Tracer.Error(context, exception, "Unable to perform an integrity check"); } }
public async Task RecreateCorruptedDatabaseOnInnerCorruptException() { var mockStorageAdapter = Mock.Of <IStorageAdapter>(); using (var storage = new Microsoft.AppCenter.Storage.Storage(mockStorageAdapter)) { var exception = new StorageException(SQLiteException.New(SQLite3.Result.Corrupt, "Corrupt")); Mock.Get(mockStorageAdapter).Setup(adapter => adapter.InsertAsync(It.IsAny <LogEntry>())).Throws(exception); await Assert.ThrowsExceptionAsync <StorageException>(() => storage.PutLog(StorageTestChannelName, TestLog.CreateTestLog())); Mock.Get(mockStorageAdapter).Verify(adapter => adapter.DeleteDatabaseFileAsync()); Mock.Get(mockStorageAdapter).Verify(adapter => adapter.InitializeStorageAsync(), Times.Exactly(2)); } }
public int ExecuteNonQuery(object[] source) { if (Connection.Trace) { Debug.WriteLine("Executing: " + CommandText); } var r = SQLite3.Result.OK; if (!Initialized) { Statement = Prepare(); Initialized = true; } //bind the values. if (source != null) { for (int i = 0; i < source.Length; i++) { // TODO: Handle null case var sqlType = SQLite3.GetSQLiteType(source[i].GetType()); sqlType.Bind(Statement, i + 1, source[i], Connection.StoreDateTimeAsTicks); } } r = SQLite3.Step(Statement); if (r == SQLite3.Result.Done) { int rowsAffected = SQLite3.Changes(Connection.Handle); SQLite3.Reset(Statement); return(rowsAffected); } else if (r == SQLite3.Result.Error) { string msg = SQLite3.GetErrmsg(Connection.Handle); SQLite3.Reset(Statement); throw SQLiteException.New(r, msg); } else if (r == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(Connection.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { SQLite3.Reset(Statement); throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(Connection.Handle)); } else { SQLite3.Reset(Statement); throw SQLiteException.New(r, r.ToString()); } }
public IDbStatement Prepare2(IDbHandle db, string query) { var dbHandle = (DbHandle)db; var stmt = default(Sqlite3Statement); int queryByteCount = Encoding.UTF8.GetByteCount(query); int r = (int)NativeMethods.Prepare2(dbHandle.InternalDbHandle, query, queryByteCount, out stmt, default(IntPtr)); if (r != 0) { throw SQLiteException.New((Result)r, GetErrmsg(db)); } return(new DbStatement(stmt)); }
// // WriteToEventLog // A helper function that writes exception detail to the event log. Exceptions // are written to the event log as a security measure to avoid private database // details from being returned to the browser. If a method does not return a status // or boolean indicating the action succeeded or failed, a generic exception is also // thrown by the caller. // private void WriteToEventLog(SQLiteException e, string action) { EventLog log = new EventLog(); log.Source = eventSource; log.Log = eventLog; string message = exceptionMessage + "\n\n"; message += "Action: " + action + "\n\n"; message += "Exception: " + e.ToString(); log.WriteEntry(message); }
/// <summary> /// Executes the statement /// </summary> public static void ExecutePreparedNonQuery(this IDbStatement me, bool reuse = true) { var sqlite3 = ApplicationContext.Current.GetService <ISQLitePlatform>().SQLiteApi; var r = sqlite3.Step(me); if (r != Result.Done) { throw SQLiteException.New(r, "Error executing SQLite prepared statement"); } if (reuse) { sqlite3.Reset(me); } }
public void TestReadOnlyDB() { Exception exception = null; var numRecords = this.rnd.Next(1, 11); var insertedRecords = new List<Tuple<int, long, string, double>>(numRecords); var queriedRecords = new List<Tuple<int, long, string, double>>(numRecords); for (var i = 0; i < numRecords; i++) { insertedRecords.Add(new Tuple<int, long, string, double>(i, this.GetRandomInteger(), this.GetRandomString(), this.GetRandomReal())); } using (var connection = new SQLiteConnection(this.databaseRelativePath, SQLiteOpen.READWRITE)) { using (var statement = connection.Prepare("DROP TABLE IF EXISTS TestReadOnlyDB;")) { statement.Step(); } using (var statement = connection.Prepare("CREATE TABLE TestReadOnlyDB(id INTEGER, i INTEGER, t TEXT, r REAL);")) { statement.Step(); } foreach (var record in insertedRecords) { var command = "INSERT INTO TestReadOnlyDB(id, i, t, r) VALUES(" + record.Item1.ToString(this.invClt) + "," + record.Item2.ToString(this.invClt) + ",'" + record.Item3 + "'," + record.Item4.ToString(this.invClt) + ");"; using (var statement = connection.Prepare(command)) { statement.Step(); } } } using (var connection = new SQLiteConnection(this.databaseRelativePath, SQLiteOpen.READONLY)) { foreach (var record in insertedRecords) { var command = "SELECT id, i, t, r FROM TestReadOnlyDB WHERE id = " + record.Item1.ToString(this.invClt) + " AND i = " + record.Item2.ToString(this.invClt) + " AND t = '" + record.Item3 + "' AND r = " + record.Item4.ToString(this.invClt) + ";"; using (var statement = connection.Prepare(command)) { while (statement.Step() == SQLiteResult.ROW) { var id = (long)statement[0]; var i = (long)statement[1]; var t = (string)statement[2]; var r = (double)statement[3]; queriedRecords.Add(new Tuple<int, long, string, double>((int)id, i, t, r)); } } } using (var statement = connection.Prepare("DROP TABLE TestReadOnlyDB;")) { var result = statement.Step(); if (result == SQLiteResult.READONLY) { exception = new SQLiteException(connection.ErrorMessage()); } else { throw new SQLiteException(connection.ErrorMessage()); } } } using (var connection = new SQLiteConnection(this.databaseRelativePath, SQLiteOpen.READWRITE)) { using (var statement = connection.Prepare("DROP TABLE TestReadOnlyDB;")) { var result = statement.Step(); if (result != SQLiteResult.DONE) { throw new SQLiteException(connection.ErrorMessage()); } } } Assert.AreEqual(insertedRecords.Count, queriedRecords.Count); insertedRecords.Sort((x, y) => { return x.Item1 - y.Item1; }); queriedRecords.Sort((x, y) => { return x.Item1 - y.Item1; }); for (var i = 0; i < insertedRecords.Count; i++) { var insertedRecord = insertedRecords[i]; var queriedRecord = queriedRecords[i]; Assert.AreEqual(insertedRecord.Item1, queriedRecord.Item1); Assert.AreEqual(insertedRecord.Item2, queriedRecord.Item2); Assert.AreEqual(insertedRecord.Item3, queriedRecord.Item3); Assert.IsTrue(Math.Abs(insertedRecord.Item4 - queriedRecord.Item4) <= Math.Abs(insertedRecord.Item4 * 0.0000001)); } Assert.IsNotNull(exception); }
// protected static UserError Handle(Win32Exception ex, string action) { // return ex.NativeErrorCode == Win32ErrorCodes.ERROR_CANCELLED_ELEVATION // ? new CanceledUserError(action, innerException: ex) // : Handle((Exception) ex, action); // } protected static UserErrorModel Handle(SQLiteException ex, string action) { var message = $"There appears to be a problem with your database. If the problem persists, you can delete the databases from:\n{Common.Paths.LocalDataPath} and {Common.Paths.DataPath}" + "\nError message: " + ex.Message; var title = "An error has occured while trying to '" + action + "'"; return new UserErrorModel(title, message, innerException: ex); }