tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge remote-tracking branch 'origin/dev' 

Former-commit-id: 412def30749a89c6d6686f830a218809c8271f38
af/merge-core
James South 13 years ago
parent
fef8d73098 b9b21a77e0
commit
c37359ee99
5 changed files with 414 additions and 446 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      src/ImageProcessor.Web/NET45/HttpModules/ImageProcessingModule.cs
  2. 4
      src/ImageProcessor.Web/NET45/Properties/AssemblyInfo.cs
  3. 1
      src/Nuget/ImageProcessor.Web.2.3.0.1.nupkg.REMOVED.git-id
  4. 2
      src/packages/sqlite-net.1.0.7/content/SQLite.cs.REMOVED.git-id
  5. 381
      src/packages/sqlite-net.1.0.7/content/SQLiteAsync.cs

12
src/ImageProcessor.Web/NET45/HttpModules/ImageProcessingModule.cs
View File

@ -167,7 +167,9 @@ namespace ImageProcessor.Web.HttpModules
private async Task ProcessImageAsync(HttpContext context) private async Task ProcessImageAsync(HttpContext context)
{ {
HttpRequest request = context.Request; HttpRequest request = context.Request;
bool isRemote = request.Path.Equals(RemotePrefix, StringComparison.OrdinalIgnoreCase);
// Fixes issue 10.
bool isRemote = request.Path.EndsWith(RemotePrefix, StringComparison.OrdinalIgnoreCase);
string requestPath = string.Empty; string requestPath = string.Empty;
string queryString = string.Empty; string queryString = string.Empty;
@ -176,8 +178,14 @@ namespace ImageProcessor.Web.HttpModules
// We need to split the querystring to get the actual values we want. // We need to split the querystring to get the actual values we want.
string urlDecode = HttpUtility.UrlDecode(request.QueryString.ToString()); string urlDecode = HttpUtility.UrlDecode(request.QueryString.ToString());
if (urlDecode != null) if (!string.IsNullOrWhiteSpace(urlDecode))
{
// UrlDecode seems to mess up in some circumstance.
if (urlDecode.IndexOf("://", StringComparison.OrdinalIgnoreCase) == -1)
{ {
urlDecode = urlDecode.Replace(":/", "://");
}
string[] paths = urlDecode.Split('?'); string[] paths = urlDecode.Split('?');
requestPath = paths[0]; requestPath = paths[0];

4
src/ImageProcessor.Web/NET45/Properties/AssemblyInfo.cs
View File

@ -31,5 +31,5 @@ using System.Runtime.InteropServices;
// //
// You can specify all the values or you can default the Build and Revision Numbers // You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
[assembly: AssemblyVersion("2.3.0.0")] [assembly: AssemblyVersion("2.3.0.1")]
[assembly: AssemblyFileVersion("2.3.0.0")] [assembly: AssemblyFileVersion("2.3.0.1")]

1
src/Nuget/ImageProcessor.Web.2.3.0.1.nupkg.REMOVED.git-id
View File

@ -0,0 +1 @@
8a839fc32a168bcddd1bd9043d64e9502bab4e99

2
src/packages/sqlite-net.1.0.7/content/SQLite.cs.REMOVED.git-id
View File

@ -1 +1 @@
86139d135bd91c43d8ffe8808f0f04975fd22a82 d2856e3733eb6c7d85057c37ae415e54c8bf2386

381
src/packages/sqlite-net.1.0.7/content/SQLiteAsync.cs
View File

@ -34,67 +34,64 @@ namespace SQLite
{ {
SQLiteConnectionString _connectionString; SQLiteConnectionString _connectionString;
public SQLiteAsyncConnection(string databasePath, bool storeDateTimeAsTicks = false) public SQLiteAsyncConnection (string databasePath, bool storeDateTimeAsTicks = false)
{ {
_connectionString = new SQLiteConnectionString(databasePath, storeDateTimeAsTicks); _connectionString = new SQLiteConnectionString (databasePath, storeDateTimeAsTicks);
} }
SQLiteConnectionWithLock GetConnection() SQLiteConnectionWithLock GetConnection ()
{ {
return SQLiteConnectionPool.Shared.GetConnection(_connectionString); return SQLiteConnectionPool.Shared.GetConnection (_connectionString);
} }
public Task<CreateTablesResult> CreateTableAsync<T>() public Task<CreateTablesResult> CreateTableAsync<T> ()
where T : new() where T : new ()
{ {
return CreateTablesAsync(typeof(T)); return CreateTablesAsync (typeof (T));
} }
public Task<CreateTablesResult> CreateTablesAsync<T, T2>() public Task<CreateTablesResult> CreateTablesAsync<T, T2> ()
where T : new() where T : new ()
where T2 : new() where T2 : new ()
{ {
return CreateTablesAsync(typeof(T), typeof(T2)); return CreateTablesAsync (typeof (T), typeof (T2));
} }
public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3>() public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3> ()
where T : new() where T : new ()
where T2 : new() where T2 : new ()
where T3 : new() where T3 : new ()
{ {
return CreateTablesAsync(typeof(T), typeof(T2), typeof(T3)); return CreateTablesAsync (typeof (T), typeof (T2), typeof (T3));
} }
public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3, T4>() public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3, T4> ()
where T : new() where T : new ()
where T2 : new() where T2 : new ()
where T3 : new() where T3 : new ()
where T4 : new() where T4 : new ()
{ {
return CreateTablesAsync(typeof(T), typeof(T2), typeof(T3), typeof(T4)); return CreateTablesAsync (typeof (T), typeof (T2), typeof (T3), typeof (T4));
} }
public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3, T4, T5>() public Task<CreateTablesResult> CreateTablesAsync<T, T2, T3, T4, T5> ()
where T : new() where T : new ()
where T2 : new() where T2 : new ()
where T3 : new() where T3 : new ()
where T4 : new() where T4 : new ()
where T5 : new() where T5 : new ()
{ {
return CreateTablesAsync(typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5)); return CreateTablesAsync (typeof (T), typeof (T2), typeof (T3), typeof (T4), typeof (T5));
} }
public Task<CreateTablesResult> CreateTablesAsync(params Type[] types) public Task<CreateTablesResult> CreateTablesAsync (params Type[] types)
{
return Task.Factory.StartNew(() =>
{
CreateTablesResult result = new CreateTablesResult();
var conn = GetConnection();
using (conn.Lock())
{
foreach (Type type in types)
{ {
int aResult = conn.CreateTable(type); return Task.Factory.StartNew (() => {
CreateTablesResult result = new CreateTablesResult ();
var conn = GetConnection ();
using (conn.Lock ()) {
foreach (Type type in types) {
int aResult = conn.CreateTable (type);
result.Results[type] = aResult; result.Results[type] = aResult;
} }
} }
@ -102,51 +99,43 @@ namespace SQLite
}); });
} }
public Task<int> DropTableAsync<T>() public Task<int> DropTableAsync<T> ()
where T : new() where T : new ()
{ {
return Task.Factory.StartNew(() => return Task.Factory.StartNew (() => {
{ var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) return conn.DropTable<T> ();
{
return conn.DropTable<T>();
} }
}); });
} }
public Task<int> InsertAsync(object item) public Task<int> InsertAsync (object item)
{
return Task.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Insert(item); return Task.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Insert (item);
} }
}); });
} }
public Task<int> UpdateAsync(object item) public Task<int> UpdateAsync (object item)
{
return Task.Factory.StartNew(() =>
{ {
var conn = GetConnection(); return Task.Factory.StartNew (() => {
using (conn.Lock()) var conn = GetConnection ();
{ using (conn.Lock ()) {
return conn.Update(item); return conn.Update (item);
} }
}); });
} }
public Task<int> DeleteAsync(object item) public Task<int> DeleteAsync (object item)
{
return Task.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Delete(item); return Task.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Delete (item);
} }
}); });
} }
@ -164,20 +153,18 @@ namespace SQLite
}); });
} }
public Task<T> FindAsync<T>(object pk) public Task<T> FindAsync<T> (object pk)
where T : new() where T : new ()
{
return Task.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Find<T>(pk); return Task.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Find<T> (pk);
} }
}); });
} }
public Task<T> GetAsync<T>(Expression<Func<T, bool>> predicate) public Task<T> GetAsync<T> (Expression<Func<T, bool>> predicate)
where T : new() where T : new()
{ {
return Task.Factory.StartNew(() => return Task.Factory.StartNew(() =>
@ -185,65 +172,55 @@ namespace SQLite
var conn = GetConnection(); var conn = GetConnection();
using (conn.Lock()) using (conn.Lock())
{ {
return conn.Get<T>(predicate); return conn.Get<T> (predicate);
} }
}); });
} }
public Task<T> FindAsync<T>(Expression<Func<T, bool>> predicate) public Task<T> FindAsync<T> (Expression<Func<T, bool>> predicate)
where T : new() where T : new ()
{
return Task.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Find<T>(predicate); return Task.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Find<T> (predicate);
} }
}); });
} }
public Task<int> ExecuteAsync(string query, params object[] args) public Task<int> ExecuteAsync (string query, params object[] args)
{
return Task<int>.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Execute(query, args); return Task<int>.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Execute (query, args);
} }
}); });
} }
public Task<int> InsertAllAsync(IEnumerable items) public Task<int> InsertAllAsync (IEnumerable items)
{ {
return Task.Factory.StartNew(() => return Task.Factory.StartNew (() => {
{ var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) return conn.InsertAll (items);
{
return conn.InsertAll(items);
} }
}); });
} }
[Obsolete("Will cause a deadlock if any call in action ends up in a different thread. Use RunInTransactionAsync(Action<SQLiteConnection>) instead.")] [Obsolete("Will cause a deadlock if any call in action ends up in a different thread. Use RunInTransactionAsync(Action<SQLiteConnection>) instead.")]
public Task RunInTransactionAsync(Action<SQLiteAsyncConnection> action) public Task RunInTransactionAsync (Action<SQLiteAsyncConnection> action)
{ {
return Task.Factory.StartNew(() => return Task.Factory.StartNew (() => {
{ var conn = this.GetConnection ();
var conn = this.GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) conn.BeginTransaction ();
{ try {
conn.BeginTransaction(); action (this);
try conn.Commit ();
{ }
action(this); catch (Exception) {
conn.Commit(); conn.Rollback ();
}
catch (Exception)
{
conn.Rollback();
throw; throw;
} }
} }
@ -272,39 +249,35 @@ namespace SQLite
}); });
} }
public AsyncTableQuery<T> Table<T>() public AsyncTableQuery<T> Table<T> ()
where T : new() where T : new ()
{ {
// //
// This isn't async as the underlying connection doesn't go out to the database // This isn't async as the underlying connection doesn't go out to the database
// until the query is performed. The Async methods are on the query iteself. // until the query is performed. The Async methods are on the query iteself.
// //
var conn = GetConnection(); var conn = GetConnection ();
return new AsyncTableQuery<T>(conn.Table<T>()); return new AsyncTableQuery<T> (conn.Table<T> ());
} }
public Task<T> ExecuteScalarAsync<T>(string sql, params object[] args) public Task<T> ExecuteScalarAsync<T> (string sql, params object[] args)
{
return Task<T>.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
var command = conn.CreateCommand(sql, args); return Task<T>.Factory.StartNew (() => {
return command.ExecuteScalar<T>(); var conn = GetConnection ();
using (conn.Lock ()) {
var command = conn.CreateCommand (sql, args);
return command.ExecuteScalar<T> ();
} }
}); });
} }
public Task<List<T>> QueryAsync<T>(string sql, params object[] args) public Task<List<T>> QueryAsync<T> (string sql, params object[] args)
where T : new() where T : new ()
{
return Task<List<T>>.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{ {
return conn.Query<T>(sql, args); return Task<List<T>>.Factory.StartNew (() => {
var conn = GetConnection ();
using (conn.Lock ()) {
return conn.Query<T> (sql, args);
} }
}); });
} }
@ -315,91 +288,81 @@ namespace SQLite
// execution can still work after a Pool.Reset. // execution can still work after a Pool.Reset.
// //
public class AsyncTableQuery<T> public class AsyncTableQuery<T>
where T : new() where T : new ()
{ {
TableQuery<T> _innerQuery; TableQuery<T> _innerQuery;
public AsyncTableQuery(TableQuery<T> innerQuery) public AsyncTableQuery (TableQuery<T> innerQuery)
{ {
_innerQuery = innerQuery; _innerQuery = innerQuery;
} }
public AsyncTableQuery<T> Where(Expression<Func<T, bool>> predExpr) public AsyncTableQuery<T> Where (Expression<Func<T, bool>> predExpr)
{ {
return new AsyncTableQuery<T>(_innerQuery.Where(predExpr)); return new AsyncTableQuery<T> (_innerQuery.Where (predExpr));
} }
public AsyncTableQuery<T> Skip(int n) public AsyncTableQuery<T> Skip (int n)
{ {
return new AsyncTableQuery<T>(_innerQuery.Skip(n)); return new AsyncTableQuery<T> (_innerQuery.Skip (n));
} }
public AsyncTableQuery<T> Take(int n) public AsyncTableQuery<T> Take (int n)
{ {
return new AsyncTableQuery<T>(_innerQuery.Take(n)); return new AsyncTableQuery<T> (_innerQuery.Take (n));
} }
public AsyncTableQuery<T> OrderBy<U>(Expression<Func<T, U>> orderExpr) public AsyncTableQuery<T> OrderBy<U> (Expression<Func<T, U>> orderExpr)
{ {
return new AsyncTableQuery<T>(_innerQuery.OrderBy<U>(orderExpr)); return new AsyncTableQuery<T> (_innerQuery.OrderBy<U> (orderExpr));
} }
public AsyncTableQuery<T> OrderByDescending<U>(Expression<Func<T, U>> orderExpr) public AsyncTableQuery<T> OrderByDescending<U> (Expression<Func<T, U>> orderExpr)
{ {
return new AsyncTableQuery<T>(_innerQuery.OrderByDescending<U>(orderExpr)); return new AsyncTableQuery<T> (_innerQuery.OrderByDescending<U> (orderExpr));
} }
public Task<List<T>> ToListAsync() public Task<List<T>> ToListAsync ()
{
return Task.Factory.StartNew(() =>
{ {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) return Task.Factory.StartNew (() => {
{ using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
return _innerQuery.ToList(); return _innerQuery.ToList ();
} }
}); });
} }
public Task<int> CountAsync() public Task<int> CountAsync ()
{
return Task.Factory.StartNew(() =>
{ {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) return Task.Factory.StartNew (() => {
{ using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
return _innerQuery.Count(); return _innerQuery.Count ();
} }
}); });
} }
public Task<T> ElementAtAsync(int index) public Task<T> ElementAtAsync (int index)
{
return Task.Factory.StartNew(() =>
{ {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) return Task.Factory.StartNew (() => {
{ using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
return _innerQuery.ElementAt(index); return _innerQuery.ElementAt (index);
} }
}); });
} }
public Task<T> FirstAsync() public Task<T> FirstAsync ()
{
return Task<T>.Factory.StartNew(() =>
{
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock())
{ {
return _innerQuery.First(); return Task<T>.Factory.StartNew(() => {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
return _innerQuery.First ();
} }
}); });
} }
public Task<T> FirstOrDefaultAsync() public Task<T> FirstOrDefaultAsync ()
{ {
return Task<T>.Factory.StartNew(() => return Task<T>.Factory.StartNew(() => {
{ using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) return _innerQuery.FirstOrDefault ();
{
return _innerQuery.FirstOrDefault();
} }
}); });
} }
@ -409,9 +372,9 @@ namespace SQLite
{ {
public Dictionary<Type, int> Results { get; private set; } public Dictionary<Type, int> Results { get; private set; }
internal CreateTablesResult() internal CreateTablesResult ()
{ {
this.Results = new Dictionary<Type, int>(); this.Results = new Dictionary<Type, int> ();
} }
} }
@ -422,23 +385,23 @@ namespace SQLite
public SQLiteConnectionString ConnectionString { get; private set; } public SQLiteConnectionString ConnectionString { get; private set; }
public SQLiteConnectionWithLock Connection { get; private set; } public SQLiteConnectionWithLock Connection { get; private set; }
public Entry(SQLiteConnectionString connectionString) public Entry (SQLiteConnectionString connectionString)
{ {
ConnectionString = connectionString; ConnectionString = connectionString;
Connection = new SQLiteConnectionWithLock(connectionString); Connection = new SQLiteConnectionWithLock (connectionString);
} }
public void OnApplicationSuspended() public void OnApplicationSuspended ()
{ {
Connection.Dispose(); Connection.Dispose ();
Connection = null; Connection = null;
} }
} }
readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry>(); readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry> ();
readonly object _entriesLock = new object(); readonly object _entriesLock = new object ();
static readonly SQLiteConnectionPool _shared = new SQLiteConnectionPool(); static readonly SQLiteConnectionPool _shared = new SQLiteConnectionPool ();
/// <summary> /// <summary>
/// Gets the singleton instance of the connection tool. /// Gets the singleton instance of the connection tool.
@ -451,16 +414,14 @@ namespace SQLite
} }
} }
public SQLiteConnectionWithLock GetConnection(SQLiteConnectionString connectionString) public SQLiteConnectionWithLock GetConnection (SQLiteConnectionString connectionString)
{
lock (_entriesLock)
{ {
lock (_entriesLock) {
Entry entry; Entry entry;
string key = connectionString.ConnectionString; string key = connectionString.ConnectionString;
if (!_entries.TryGetValue(key, out entry)) if (!_entries.TryGetValue (key, out entry)) {
{ entry = new Entry (connectionString);
entry = new Entry(connectionString);
_entries[key] = entry; _entries[key] = entry;
} }
@ -471,15 +432,13 @@ namespace SQLite
/// <summary> /// <summary>
/// Closes all connections managed by this pool. /// Closes all connections managed by this pool.
/// </summary> /// </summary>
public void Reset() public void Reset ()
{
lock (_entriesLock)
{
foreach (var entry in _entries.Values)
{ {
entry.OnApplicationSuspended(); lock (_entriesLock) {
foreach (var entry in _entries.Values) {
entry.OnApplicationSuspended ();
} }
_entries.Clear(); _entries.Clear ();
} }
} }
@ -487,39 +446,39 @@ namespace SQLite
/// Call this method when the application is suspended. /// Call this method when the application is suspended.
/// </summary> /// </summary>
/// <remarks>Behaviour here is to close any open connections.</remarks> /// <remarks>Behaviour here is to close any open connections.</remarks>
public void ApplicationSuspended() public void ApplicationSuspended ()
{ {
Reset(); Reset ();
} }
} }
class SQLiteConnectionWithLock : SQLiteConnection class SQLiteConnectionWithLock : SQLiteConnection
{ {
readonly object _lockPoint = new object(); readonly object _lockPoint = new object ();
public SQLiteConnectionWithLock(SQLiteConnectionString connectionString) public SQLiteConnectionWithLock (SQLiteConnectionString connectionString)
: base(connectionString.DatabasePath, connectionString.StoreDateTimeAsTicks) : base (connectionString.DatabasePath, connectionString.StoreDateTimeAsTicks)
{ {
} }
public IDisposable Lock() public IDisposable Lock ()
{ {
return new LockWrapper(_lockPoint); return new LockWrapper (_lockPoint);
} }
private class LockWrapper : IDisposable private class LockWrapper : IDisposable
{ {
object _lockPoint; object _lockPoint;
public LockWrapper(object lockPoint) public LockWrapper (object lockPoint)
{ {
_lockPoint = lockPoint; _lockPoint = lockPoint;
Monitor.Enter(_lockPoint); Monitor.Enter (_lockPoint);
} }
public void Dispose() public void Dispose ()
{ {
Monitor.Exit(_lockPoint); Monitor.Exit (_lockPoint);
} }
} }
} }

Write Preview
Loading…
Cancel
Save