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. 841
      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

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

@ -30,126 +30,115 @@ using System.Threading.Tasks;
namespace SQLite namespace SQLite
{ {
public partial class SQLiteAsyncConnection public partial class SQLiteAsyncConnection
{ {
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(() => return Task.Factory.StartNew (() => {
{ CreateTablesResult result = new CreateTablesResult ();
CreateTablesResult result = new CreateTablesResult(); var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) foreach (Type type in types) {
{ int aResult = conn.CreateTable (type);
foreach (Type type in types) result.Results[type] = aResult;
{ }
int aResult = conn.CreateTable(type); }
result.Results[type] = aResult; return result;
} });
} }
return result;
}); public Task<int> DropTableAsync<T> ()
} where T : new ()
{
public Task<int> DropTableAsync<T>() return Task.Factory.StartNew (() => {
where T : new() var conn = GetConnection ();
{ using (conn.Lock ()) {
return Task.Factory.StartNew(() => return conn.DropTable<T> ();
{ }
var conn = GetConnection(); });
using (conn.Lock()) }
{
return conn.DropTable<T>(); public Task<int> InsertAsync (object item)
} {
}); return Task.Factory.StartNew (() => {
} var conn = GetConnection ();
using (conn.Lock ()) {
public Task<int> InsertAsync(object item) return conn.Insert (item);
{ }
return Task.Factory.StartNew(() => });
{ }
var conn = GetConnection();
using (conn.Lock()) public Task<int> UpdateAsync (object item)
{ {
return conn.Insert(item); return Task.Factory.StartNew (() => {
} var conn = GetConnection ();
}); using (conn.Lock ()) {
} return conn.Update (item);
}
public Task<int> UpdateAsync(object item) });
{ }
return Task.Factory.StartNew(() =>
{ public Task<int> DeleteAsync (object item)
var conn = GetConnection(); {
using (conn.Lock()) return Task.Factory.StartNew (() => {
{ var conn = GetConnection ();
return conn.Update(item); using (conn.Lock ()) {
} return conn.Delete (item);
}); }
} });
}
public Task<int> DeleteAsync(object item)
{
return Task.Factory.StartNew(() =>
{
var conn = GetConnection();
using (conn.Lock())
{
return conn.Delete(item);
}
});
}
public Task<T> GetAsync<T>(object pk) public Task<T> GetAsync<T>(object pk)
where T : new() where T : new()
@ -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(() => return Task.Factory.StartNew (() => {
{ var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) return conn.Find<T> (pk);
{ }
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,70 +172,60 @@ 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(() => return Task.Factory.StartNew (() => {
{ var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) return conn.Find<T> (predicate);
{ }
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 ();
return Task<int>.Factory.StartNew(() => using (conn.Lock ()) {
{ return conn.Execute (query, args);
var conn = GetConnection(); }
using (conn.Lock()) });
{ }
return conn.Execute(query, args);
} public Task<int> InsertAllAsync (IEnumerable items)
}); {
} return Task.Factory.StartNew (() => {
var conn = GetConnection ();
public Task<int> InsertAllAsync(IEnumerable items) using (conn.Lock ()) {
{ return conn.InsertAll (items);
return Task.Factory.StartNew(() => }
{ });
var conn = GetConnection(); }
using (conn.Lock())
{
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 ();
} throw;
catch (Exception) }
{ }
conn.Rollback(); });
throw; }
}
}
});
}
public Task RunInTransactionAsync(Action<SQLiteConnection> action) public Task RunInTransactionAsync(Action<SQLiteConnection> action)
{ {
@ -272,256 +249,238 @@ 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(() => return Task<T>.Factory.StartNew (() => {
{ var conn = GetConnection ();
var conn = GetConnection(); using (conn.Lock ()) {
using (conn.Lock()) var command = conn.CreateCommand (sql, args);
{ return command.ExecuteScalar<T> ();
var command = conn.CreateCommand(sql, args); }
return command.ExecuteScalar<T>(); });
} }
});
} public Task<List<T>> QueryAsync<T> (string sql, params object[] args)
where T : new ()
public Task<List<T>> QueryAsync<T>(string sql, params object[] args) {
where T : new() return Task<List<T>>.Factory.StartNew (() => {
{ var conn = GetConnection ();
return Task<List<T>>.Factory.StartNew(() => using (conn.Lock ()) {
{ return conn.Query<T> (sql, args);
var conn = GetConnection(); }
using (conn.Lock()) });
{ }
return conn.Query<T>(sql, args); }
}
}); //
} // TODO: Bind to AsyncConnection.GetConnection instead so that delayed
} // execution can still work after a Pool.Reset.
//
// public class AsyncTableQuery<T>
// TODO: Bind to AsyncConnection.GetConnection instead so that delayed where T : new ()
// execution can still work after a Pool.Reset. {
// TableQuery<T> _innerQuery;
public class AsyncTableQuery<T>
where T : new() public AsyncTableQuery (TableQuery<T> innerQuery)
{ {
TableQuery<T> _innerQuery; _innerQuery = innerQuery;
}
public AsyncTableQuery(TableQuery<T> innerQuery)
{ public AsyncTableQuery<T> Where (Expression<Func<T, bool>> predExpr)
_innerQuery = innerQuery; {
} return new AsyncTableQuery<T> (_innerQuery.Where (predExpr));
}
public AsyncTableQuery<T> Where(Expression<Func<T, bool>> predExpr)
{ public AsyncTableQuery<T> Skip (int n)
return new AsyncTableQuery<T>(_innerQuery.Where(predExpr)); {
} return new AsyncTableQuery<T> (_innerQuery.Skip (n));
}
public AsyncTableQuery<T> Skip(int n)
{ public AsyncTableQuery<T> Take (int n)
return new AsyncTableQuery<T>(_innerQuery.Skip(n)); {
} return new AsyncTableQuery<T> (_innerQuery.Take (n));
}
public AsyncTableQuery<T> Take(int n)
{ public AsyncTableQuery<T> OrderBy<U> (Expression<Func<T, U>> orderExpr)
return new AsyncTableQuery<T>(_innerQuery.Take(n)); {
} return new AsyncTableQuery<T> (_innerQuery.OrderBy<U> (orderExpr));
}
public AsyncTableQuery<T> OrderBy<U>(Expression<Func<T, U>> orderExpr)
{ public AsyncTableQuery<T> OrderByDescending<U> (Expression<Func<T, U>> orderExpr)
return new AsyncTableQuery<T>(_innerQuery.OrderBy<U>(orderExpr)); {
} return new AsyncTableQuery<T> (_innerQuery.OrderByDescending<U> (orderExpr));
}
public AsyncTableQuery<T> OrderByDescending<U>(Expression<Func<T, U>> orderExpr)
{ public Task<List<T>> ToListAsync ()
return new AsyncTableQuery<T>(_innerQuery.OrderByDescending<U>(orderExpr)); {
} return Task.Factory.StartNew (() => {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
public Task<List<T>> ToListAsync() return _innerQuery.ToList ();
{ }
return Task.Factory.StartNew(() => });
{ }
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock())
{ public Task<int> CountAsync ()
return _innerQuery.ToList(); {
} return Task.Factory.StartNew (() => {
}); using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
} return _innerQuery.Count ();
}
public Task<int> CountAsync() });
{ }
return Task.Factory.StartNew(() =>
{ public Task<T> ElementAtAsync (int index)
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) {
{ return Task.Factory.StartNew (() => {
return _innerQuery.Count(); using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
} return _innerQuery.ElementAt (index);
}); }
} });
}
public Task<T> ElementAtAsync(int index)
{ public Task<T> FirstAsync ()
return Task.Factory.StartNew(() => {
{ return Task<T>.Factory.StartNew(() => {
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
{ return _innerQuery.First ();
return _innerQuery.ElementAt(index); }
} });
}); }
}
public Task<T> FirstOrDefaultAsync ()
public Task<T> FirstAsync() {
{ return Task<T>.Factory.StartNew(() => {
return Task<T>.Factory.StartNew(() => using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock ()) {
{ return _innerQuery.FirstOrDefault ();
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock()) }
{ });
return _innerQuery.First(); }
}
});
}
public Task<T> FirstOrDefaultAsync()
{
return Task<T>.Factory.StartNew(() =>
{
using (((SQLiteConnectionWithLock)_innerQuery.Connection).Lock())
{
return _innerQuery.FirstOrDefault();
}
});
}
}
public class CreateTablesResult
{
public Dictionary<Type, int> Results { get; private set; }
internal CreateTablesResult()
{
this.Results = new Dictionary<Type, int>();
}
} }
class SQLiteConnectionPool public class CreateTablesResult
{ {
class Entry public Dictionary<Type, int> Results { get; private set; }
{
public SQLiteConnectionString ConnectionString { get; private set; } internal CreateTablesResult ()
public SQLiteConnectionWithLock Connection { get; private set; } {
this.Results = new Dictionary<Type, int> ();
public Entry(SQLiteConnectionString connectionString) }
{ }
ConnectionString = connectionString;
Connection = new SQLiteConnectionWithLock(connectionString); class SQLiteConnectionPool
} {
class Entry
public void OnApplicationSuspended() {
{ public SQLiteConnectionString ConnectionString { get; private set; }
Connection.Dispose(); public SQLiteConnectionWithLock Connection { get; private set; }
Connection = null;
} public Entry (SQLiteConnectionString connectionString)
} {
ConnectionString = connectionString;
readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry>(); Connection = new SQLiteConnectionWithLock (connectionString);
readonly object _entriesLock = new object(); }
static readonly SQLiteConnectionPool _shared = new SQLiteConnectionPool(); public void OnApplicationSuspended ()
{
/// <summary> Connection.Dispose ();
/// Gets the singleton instance of the connection tool. Connection = null;
/// </summary> }
public static SQLiteConnectionPool Shared }
{
get readonly Dictionary<string, Entry> _entries = new Dictionary<string, Entry> ();
{ readonly object _entriesLock = new object ();
return _shared;
} static readonly SQLiteConnectionPool _shared = new SQLiteConnectionPool ();
}
/// <summary>
public SQLiteConnectionWithLock GetConnection(SQLiteConnectionString connectionString) /// Gets the singleton instance of the connection tool.
{ /// </summary>
lock (_entriesLock) public static SQLiteConnectionPool Shared
{ {
Entry entry; get
string key = connectionString.ConnectionString; {
return _shared;
if (!_entries.TryGetValue(key, out entry)) }
{ }
entry = new Entry(connectionString);
_entries[key] = entry; public SQLiteConnectionWithLock GetConnection (SQLiteConnectionString connectionString)
} {
lock (_entriesLock) {
return entry.Connection; Entry entry;
} string key = connectionString.ConnectionString;
}
if (!_entries.TryGetValue (key, out entry)) {
/// <summary> entry = new Entry (connectionString);
/// Closes all connections managed by this pool. _entries[key] = entry;
/// </summary> }
public void Reset()
{ return entry.Connection;
lock (_entriesLock) }
{ }
foreach (var entry in _entries.Values)
{ /// <summary>
entry.OnApplicationSuspended(); /// Closes all connections managed by this pool.
} /// </summary>
_entries.Clear(); public void Reset ()
} {
} lock (_entriesLock) {
foreach (var entry in _entries.Values) {
/// <summary> entry.OnApplicationSuspended ();
/// Call this method when the application is suspended. }
/// </summary> _entries.Clear ();
/// <remarks>Behaviour here is to close any open connections.</remarks> }
public void ApplicationSuspended() }
{
Reset(); /// <summary>
} /// Call this method when the application is suspended.
} /// </summary>
/// <remarks>Behaviour here is to close any open connections.</remarks>
class SQLiteConnectionWithLock : SQLiteConnection public void ApplicationSuspended ()
{ {
readonly object _lockPoint = new object(); Reset ();
}
public SQLiteConnectionWithLock(SQLiteConnectionString connectionString) }
: base(connectionString.DatabasePath, connectionString.StoreDateTimeAsTicks)
{ class SQLiteConnectionWithLock : SQLiteConnection
} {
readonly object _lockPoint = new object ();
public IDisposable Lock()
{ public SQLiteConnectionWithLock (SQLiteConnectionString connectionString)
return new LockWrapper(_lockPoint); : base (connectionString.DatabasePath, connectionString.StoreDateTimeAsTicks)
} {
}
private class LockWrapper : IDisposable
{ public IDisposable Lock ()
object _lockPoint; {
return new LockWrapper (_lockPoint);
public LockWrapper(object lockPoint) }
{
_lockPoint = lockPoint; private class LockWrapper : IDisposable
Monitor.Enter(_lockPoint); {
} object _lockPoint;
public void Dispose() public LockWrapper (object lockPoint)
{ {
Monitor.Exit(_lockPoint); _lockPoint = lockPoint;
} Monitor.Enter (_lockPoint);
} }
}
public void Dispose ()
{
Monitor.Exit (_lockPoint);
}
}
}
} }

Write Preview
Loading…
Cancel
Save