public void ResolveDeferred()
{
Deferred test = new Deferred();
string cur = "test2";
message = null;
Assert.AreNotEqual(cur, message);
test.Resolve(cur);
test.Then((Action<string>)Resolved);
Assert.AreEqual(cur, message);
}
public IPromise Then(PromiseFunction <object> success, PromiseFunction <object> failure = null)
{
NextDeferred = new Deferred();
Success = new Func <object, IPromise>((parm) => {
return(success(Parameter));
});
if (failure != null)
{
Failure = new Func <object, IPromise>((parm) =>
{
return(success(Parameter));
});
}
return(NextDeferred);
}
private void Configure(IEnumerable <IPromise> promises)
{
lock (_locker)
{
Success = true;
Deferred = new Deferred();
int count = 0;
foreach (var promise in promises)
{
count++;
promise.Then((Action)PromiseResolve, (Action)PromiseReject);
}
TotalCount = count;
}
}
public IPromise Then(Func <IPromise> success, Func <IPromise> failure = null)
{
NextDeferred = new Deferred();
Success = new Func <object, IPromise>((parm) =>
{
return(success());
});
if (failure != null)
{
Failure = new Func <object, IPromise>((parm) =>
{
return(failure());
});
}
return(NextDeferred);
}
public void WhenAll()
{
Deferred test = new Deferred();
Deferred test2 = new Deferred();
message = null;
IPromise all = When.All(test, test2)
.Then((Action<string>)Resolved);
test.Resolve();
Assert.AreNotEqual("resolved", message);
test2.Resolve();
Assert.AreEqual("resolved", message);
}
public IPromise Then(Action success, Action failure = null)
{
NextDeferred = new Deferred();
Success = new Func <object, IPromise>((parm) =>
{
success();
return(null);
});
if (failure != null)
{
Failure = new Func <object, IPromise>((parm) =>
{
failure();
return(null);
});
}
return(NextDeferred);
}
private void Configure(IEnumerable<IPromise> promises)
{
lock (_locker)
{
Success = true;
Deferred = new Deferred();
int count = 0;
foreach (var promise in promises)
{
count++;
promise.Then((Action)PromiseResolve, (Action)PromiseReject);
}
TotalCount = count;
}
}
public void WhenAllTimeout()
{
Deferred test = new Deferred();
Deferred test2 = new Deferred();
IPromise all = When.All(500,test, test2)
.Then((Action<string>)Resolved, (Action<string>)Rejected);
message = null;
Assert.IsNull(message);
System.Threading.Thread.Sleep(200);
Assert.IsNull(message);
System.Threading.Thread.Sleep(400);
Assert.AreEqual("rejected", message);
}
private Deferred GetNextDeferred()
{
var deferred = new Deferred();
if (NextDeferred == null)
{
NextDeferred = new List<Deferred>();
}
NextDeferred.Add(deferred);
return deferred;
}
private void Configure(IPromise[] promises)
{
Success = true;
TotalCount = promises.Length;
Deferred = new Deferred();
foreach (var promise in promises)
{
promise.Then((Action)PromiseResolve,(Action)PromiseReject);
}
}
/// <summary>
/// Chains delegates that will be executed on success or failure of a promise.
/// </summary>
///
/// <param name="success">
/// The delegate to call upon successful resolution of the promise.
/// </param>
/// <param name="failure">
/// (optional) The delegate to call upon unsuccessful resolution of the promise.
/// </param>
///
/// <returns>
/// A new promise which will be chained to this promise.
/// </returns>
public IPromise Then(Func<IPromise> success, Func<IPromise> failure = null)
{
NextDeferred = new Deferred();
Success = new Func<object, IPromise>((parm) =>
{
return success();
});
if (failure != null)
{
Failure = new Func<object, IPromise>((parm) =>
{
return failure();
});
}
return NextDeferred;
}
/// <summary>
/// Chains delegates that will be executed on success or failure of a promise.
/// </summary>
///
/// <param name="success">
/// The delegate to call upon successful resolution of the promise.
/// </param>
/// <param name="failure">
/// (optional) The delegate to call upon unsuccessful resolution of the promise.
/// </param>
///
/// <returns>
/// A new promise which will be chained to this promise.
/// </returns>
public IPromise Then(Action success, Action failure = null)
{
NextDeferred = new Deferred();
Success = new Func<object, IPromise>((parm) =>
{
success();
return null;
});
if (failure != null)
{
Failure = new Func<object, IPromise>((parm) =>
{
failure();
return null;
});
}
return NextDeferred;
}
/// <summary>
/// Chains delegates that will be executed on success or failure of a promise.
/// </summary>
///
/// <param name="success">
/// The delegate to call upon successful resolution of the promise.
/// </param>
/// <param name="failure">
/// (optional) The delegate to call upon unsuccessful resolution of the promise.
/// </param>
///
/// <returns>
/// A new promise which will resolve when this promise has resolved.
/// </returns>
public IPromise Then(PromiseFunction<object> success, PromiseFunction<object> failure = null)
{
NextDeferred = new Deferred();
Success = new Func<object,IPromise>((parm) => {
return success(Parameter);
});
if (failure != null)
{
Failure = new Func<object, IPromise>((parm) =>
{
return success(Parameter);
});
}
return NextDeferred;
}
/// <summary>
/// Chains a delegate to be invoked upon resolution or failure of the Deferred promise object.
/// </summary>
///
/// <param name="success">
/// The delegate to call upon successful resolution of the promise.
/// </param>
/// <param name="failure">
/// (optional) The delegate to call upon unsuccessful resolution of the promise.
/// </param>
///
/// <returns>
/// A new promise which will resolve when this promise has resolved.
/// </returns>
public IPromise Then(Delegate success, Delegate failure = null)
{
NextDeferred = new Deferred();
MethodInfo method = success != null ?
success.Method :
failure.Method;
Type returnType = method.ReturnType;
Type[] parameters = method.GetParameters().Select(item => item.ParameterType).ToArray();
bool useParms = parameters.Length > 0;
Success = new Func<object, IPromise>((parm) =>
{
object result = success.DynamicInvoke(GetParameters(useParms));
return result as IPromise;
});
Failure = new Func<object, IPromise>((parm) =>
{
object result = failure.DynamicInvoke(GetParameters(useParms));
return result as IPromise;
});
return NextDeferred;
}
