You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
packages
src
test
Microsoft.TestCommon
Microsoft.Web.Helpers.Test
Microsoft.Web.Http.Data.Test
Microsoft.Web.Mvc.Test
Microsoft.Web.WebPages.OAuth.Test
SPA.Test
System.Json.Test.Integration
System.Json.Test.Unit
System.Net.Http.Formatting.Test.Integration
System.Net.Http.Formatting.Test.Unit
System.Web.Helpers.Test
System.Web.Http.Integration.Test
System.Web.Http.SelfHost.Test
System.Web.Http.Test
System.Web.Http.WebHost.Test
System.Web.Mvc.Test
Ajax
Async
Test
AsyncActionDescriptorTest.cs
AsyncActionMethodSelectorTest.cs
AsyncControllerActionInvokerTest.cs
AsyncManagerTest.cs
AsyncResultWrapperTest.cs
AsyncUtilTest.cs
MockAsyncResult.cs
OperationCounterTest.cs
ReflectedAsyncActionDescriptorTest.cs
ReflectedAsyncControllerDescriptorTest.cs
SignalContainer.cs
SimpleAsyncResultTest.cs
SingleEntryGateTest.cs
SynchronizationContextUtilTest.cs
SynchronousOperationExceptionTest.cs
TaskAsyncActionDescriptorTest.cs
TaskWrapperAsyncResultTest.cs
TriggerListenerTest.cs
ExpressionUtil
Html
Properties
Razor
Test
Util
System.Web.Mvc.Test.csproj
packages.config
System.Web.Razor.Test
System.Web.WebPages.Administration.Test
System.Web.WebPages.Deployment.Test
System.Web.WebPages.Razor.Test
System.Web.WebPages.Test
WebMatrix.Data.Test
WebMatrix.WebData.Test
Settings.StyleCop
tools
.gitattributes
.gitignore
License.txt
README.md
Runtime.msbuild
Runtime.sln
Runtime.xunit
Settings.StyleCop
build.cmd
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
helix-binaries
ikdasm
ikvm
illinker-test-assets
linker
llvm
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
how-to-bump-roslyn-binaries.md
ikvm-native
libgc
llvm
m4
man
mcs
mk
mono
msvc
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
560 lines
20 KiB
C#
560 lines
20 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Moq;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Web.Mvc.Async.Test
|
|
{
|
|
public class TaskAsyncActionDescriptorTest
|
|
{
|
|
private readonly MethodInfo _taskMethod = typeof(ExecuteController).GetMethod("SimpleTask");
|
|
|
|
[Fact]
|
|
public void Constructor_SetsProperties()
|
|
{
|
|
// Arrange
|
|
string actionName = "SomeAction";
|
|
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
|
|
|
|
// Act
|
|
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(_taskMethod, actionName, cd);
|
|
|
|
// Assert
|
|
Assert.Equal(_taskMethod, ad.TaskMethodInfo);
|
|
Assert.Equal(actionName, ad.ActionName);
|
|
Assert.Equal(cd, ad.ControllerDescriptor);
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_ThrowsIfActionNameIsEmpty()
|
|
{
|
|
// Arrange
|
|
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
|
|
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { new TaskAsyncActionDescriptor(_taskMethod, "", cd); }, "actionName");
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_ThrowsIfActionNameIsNull()
|
|
{
|
|
// Arrange
|
|
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
|
|
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { new TaskAsyncActionDescriptor(_taskMethod, null, cd); }, "actionName");
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_ThrowsIfTaskMethodInfoIsInvalid()
|
|
{
|
|
// Arrange
|
|
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
|
|
MethodInfo getHashCodeMethod = typeof(object).GetMethod("GetHashCode");
|
|
|
|
// Act & assert
|
|
Assert.Throws<ArgumentException>(
|
|
delegate { new TaskAsyncActionDescriptor(getHashCodeMethod, "SomeAction", cd); },
|
|
@"Cannot create a descriptor for instance method 'Int32 GetHashCode()' on type 'System.Object' because the type does not derive from ControllerBase.
|
|
Parameter name: taskMethodInfo");
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_ThrowsIfTaskMethodInfoIsNull()
|
|
{
|
|
// Arrange
|
|
ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
|
|
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { new TaskAsyncActionDescriptor(null, "SomeAction", cd); }, "taskMethodInfo");
|
|
}
|
|
|
|
[Fact]
|
|
public void Constructor_ThrowsIfControllerDescriptorIsNull()
|
|
{
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { new TaskAsyncActionDescriptor(_taskMethod, "SomeAction", null); }, "controllerDescriptor");
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTask()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "doWork", true }
|
|
};
|
|
|
|
ControllerContext controllerContext = GetControllerContext();
|
|
|
|
// Act
|
|
object retVal = ExecuteHelper(actionDescriptor, parameters, controllerContext);
|
|
|
|
// Assert
|
|
Assert.Null(retVal);
|
|
Assert.True((controllerContext.Controller as ExecuteController).WorkDone);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskGeneric()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("GenericTask"));
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "taskId", "foo" }
|
|
};
|
|
|
|
// Act
|
|
object retVal = ExecuteHelper(actionDescriptor, parameters);
|
|
|
|
// Assert
|
|
Assert.Equal("foo", retVal);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskPreservesStackTraceOnException()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTaskException"));
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "doWork", true }
|
|
};
|
|
|
|
// Act
|
|
IAsyncResult result = actionDescriptor.BeginExecute(GetControllerContext(), parameters, null, null);
|
|
|
|
// Assert
|
|
InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
|
|
() => actionDescriptor.EndExecute(result),
|
|
"Test exception from action"
|
|
);
|
|
|
|
Assert.True(ex.StackTrace.Contains("System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest.ExecuteController."));
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskGenericPreservesStackTraceOnException()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("GenericTaskException"));
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "taskId", "foo" },
|
|
{ "throwException", true }
|
|
};
|
|
|
|
// Act
|
|
IAsyncResult result = actionDescriptor.BeginExecute(GetControllerContext(), parameters, null, null);
|
|
|
|
// Assert
|
|
InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
|
|
() => actionDescriptor.EndExecute(result),
|
|
"Test exception from action"
|
|
);
|
|
|
|
Assert.True(ex.StackTrace.Contains("System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest.ExecuteController."));
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskOfPrivateT()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskOfPrivateT"));
|
|
ControllerContext controllerContext = GetControllerContext();
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>();
|
|
|
|
// Act
|
|
object retVal = ExecuteHelper(actionDescriptor, parameters, controllerContext);
|
|
|
|
// Assert
|
|
Assert.Null(retVal);
|
|
Assert.True((controllerContext.Controller as ExecuteController).WorkDone);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskPreservesState()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "doWork", true }
|
|
};
|
|
|
|
ControllerContext controllerContext = GetControllerContext();
|
|
|
|
// Act
|
|
TaskWrapperAsyncResult result = (TaskWrapperAsyncResult)actionDescriptor.BeginExecute(GetControllerContext(), parameters, callback: null, state: "state");
|
|
|
|
// Assert
|
|
Assert.Equal("state", result.AsyncState);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskWithNullParameterAndTimeout()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeoutWithNullParam"));
|
|
|
|
Dictionary<string, object> token = new Dictionary<string, object>()
|
|
{
|
|
{ "nullParam", null },
|
|
{ "cancellationToken", new CancellationToken() }
|
|
};
|
|
|
|
// Act & assert
|
|
Assert.Throws<TimeoutException>(
|
|
() => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(0), parameters: token, callback: null, state: null)),
|
|
"The operation has timed out."
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteWithInfiniteTimeout()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskWithInfiniteTimeout"));
|
|
ControllerContext controllerContext = GetControllerContext(Timeout.Infinite);
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "cancellationToken", new CancellationToken() }
|
|
};
|
|
|
|
// Act
|
|
object retVal = ExecuteHelper(actionDescriptor, parameters);
|
|
|
|
// Assert
|
|
Assert.Equal("Task Completed", retVal);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskWithImmediateTimeout()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeout"));
|
|
|
|
Dictionary<string, object> token = new Dictionary<string, object>()
|
|
{
|
|
{ "cancellationToken", new CancellationToken() }
|
|
};
|
|
|
|
// Act & assert
|
|
Assert.Throws<TimeoutException>(
|
|
() => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(0), parameters: token, callback: null, state: null)),
|
|
"The operation has timed out."
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteTaskWithTimeout()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeout"));
|
|
|
|
Dictionary<string, object> token = new Dictionary<string, object>()
|
|
{
|
|
{ "cancellationToken", new CancellationToken() }
|
|
};
|
|
|
|
// Act & assert
|
|
Assert.Throws<TimeoutException>(
|
|
() => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(2000), parameters: token, callback: null, state: null)),
|
|
"The operation has timed out."
|
|
);
|
|
}
|
|
|
|
[Fact]
|
|
public void SynchronousExecuteThrows()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));
|
|
|
|
// Act & assert
|
|
Assert.Throws<InvalidOperationException>(
|
|
delegate { actionDescriptor.Execute(new ControllerContext(), new Dictionary<string, object>()); }, "The asynchronous action method 'someName' returns a Task, which cannot be executed synchronously.");
|
|
}
|
|
|
|
[Fact]
|
|
public void Execute_ThrowsIfControllerContextIsNull()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
|
|
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { ad.BeginExecute(null, new Dictionary<string, object>(), null, null); }, "controllerContext");
|
|
}
|
|
|
|
[Fact]
|
|
public void Execute_ThrowsIfControllerIsNotAsyncManagerContainer()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
|
|
ControllerContext controllerContext = new ControllerContext()
|
|
{
|
|
Controller = new RegularSyncController()
|
|
};
|
|
|
|
Dictionary<string, object> parameters = new Dictionary<string, object>()
|
|
{
|
|
{ "doWork", true }
|
|
};
|
|
|
|
// Act & assert
|
|
Assert.Throws<InvalidOperationException>(
|
|
delegate { ad.BeginExecute(controllerContext, parameters, null, null); },
|
|
@"The controller of type 'System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest+RegularSyncController' must subclass AsyncController or implement the IAsyncManagerContainer interface.");
|
|
}
|
|
|
|
[Fact]
|
|
public void Execute_ThrowsIfParametersIsNull()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
|
|
|
|
// Act & assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { ad.BeginExecute(new ControllerContext(), null, null, null); }, "parameters");
|
|
}
|
|
|
|
[Fact]
|
|
public void GetCustomAttributesCallsMethodInfoGetCustomAttributes()
|
|
{
|
|
// Arrange
|
|
object[] expected = new object[0];
|
|
Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
|
|
mockMethod.Setup(mi => mi.GetCustomAttributes(true)).Returns(expected);
|
|
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
|
|
{
|
|
DispatcherCache = new ActionMethodDispatcherCache()
|
|
};
|
|
|
|
// Act
|
|
object[] returned = ad.GetCustomAttributes(true);
|
|
|
|
// Assert
|
|
Assert.Same(expected, returned);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetCustomAttributesWithAttributeTypeCallsMethodInfoGetCustomAttributes()
|
|
{
|
|
// Arrange
|
|
object[] expected = new object[0];
|
|
Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
|
|
mockMethod.Setup(mi => mi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
|
|
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
|
|
{
|
|
DispatcherCache = new ActionMethodDispatcherCache()
|
|
};
|
|
|
|
// Act
|
|
object[] returned = ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);
|
|
|
|
// Assert
|
|
Assert.Same(expected, returned);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetParameters()
|
|
{
|
|
// Arrange
|
|
ParameterInfo pInfo = _taskMethod.GetParameters()[0];
|
|
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
|
|
|
|
// Act
|
|
ParameterDescriptor[] pDescsFirstCall = ad.GetParameters();
|
|
ParameterDescriptor[] pDescsSecondCall = ad.GetParameters();
|
|
|
|
// Assert
|
|
Assert.NotSame(pDescsFirstCall, pDescsSecondCall); // Should get a new array every time
|
|
Assert.Equal(pDescsFirstCall, pDescsSecondCall);
|
|
Assert.Single(pDescsFirstCall);
|
|
|
|
ReflectedParameterDescriptor pDesc = pDescsFirstCall[0] as ReflectedParameterDescriptor;
|
|
|
|
Assert.NotNull(pDesc);
|
|
Assert.Same(ad, pDesc.ActionDescriptor);
|
|
Assert.Same(pInfo, pDesc.ParameterInfo);
|
|
}
|
|
|
|
[Fact]
|
|
public void GetSelectors()
|
|
{
|
|
// Arrange
|
|
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
|
|
Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
|
|
|
|
Mock<ActionMethodSelectorAttribute> mockAttr = new Mock<ActionMethodSelectorAttribute>();
|
|
mockAttr.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object)).Returns(true).Verifiable();
|
|
mockMethod.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)).Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });
|
|
|
|
TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
|
|
{
|
|
DispatcherCache = new ActionMethodDispatcherCache()
|
|
};
|
|
|
|
// Act
|
|
ICollection<ActionSelector> selectors = ad.GetSelectors();
|
|
bool executedSuccessfully = selectors.All(s => s(controllerContext));
|
|
|
|
// Assert
|
|
Assert.Single(selectors);
|
|
Assert.True(executedSuccessfully);
|
|
mockAttr.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void IsDefined()
|
|
{
|
|
// Arrange
|
|
TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
|
|
|
|
// Act
|
|
bool isDefined = ad.IsDefined(typeof(AuthorizeAttribute), inherit: true);
|
|
|
|
// Assert
|
|
Assert.True(isDefined);
|
|
}
|
|
|
|
public static object ExecuteHelper(TaskAsyncActionDescriptor actionDescriptor, Dictionary<string, object> parameters, ControllerContext controllerContext = null)
|
|
{
|
|
SignalContainer<object> resultContainer = new SignalContainer<object>();
|
|
AsyncCallback callback = ar =>
|
|
{
|
|
object o = actionDescriptor.EndExecute(ar);
|
|
resultContainer.Signal(o);
|
|
};
|
|
|
|
actionDescriptor.BeginExecute(controllerContext ?? GetControllerContext(), parameters, callback, state: null);
|
|
return resultContainer.Wait();
|
|
}
|
|
|
|
private static TaskAsyncActionDescriptor GetActionDescriptor(MethodInfo taskMethod)
|
|
{
|
|
return new TaskAsyncActionDescriptor(taskMethod, "someName", new Mock<ControllerDescriptor>().Object)
|
|
{
|
|
DispatcherCache = new ActionMethodDispatcherCache()
|
|
};
|
|
}
|
|
|
|
private static ControllerContext GetControllerContext(int timeout = 45 * 1000)
|
|
{
|
|
Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
|
|
ExecuteController controller = new ExecuteController();
|
|
controller.AsyncManager.Timeout = timeout;
|
|
mockControllerContext.Setup(c => c.Controller).Returns(controller);
|
|
return mockControllerContext.Object;
|
|
}
|
|
|
|
private static MethodInfo GetExecuteControllerMethodInfo(string methodName)
|
|
{
|
|
return typeof(ExecuteController).GetMethod(methodName);
|
|
}
|
|
|
|
private class ExecuteController : AsyncController
|
|
{
|
|
public bool WorkDone { get; set; }
|
|
|
|
public Task<ActionResult> ReturnedTask { get; set; }
|
|
|
|
public Task<string> GenericTask(string taskId)
|
|
{
|
|
return Task.Factory.StartNew(() => taskId);
|
|
}
|
|
|
|
public Task<string> GenericTaskException(string taskId, bool throwException)
|
|
{
|
|
return Task.Factory.StartNew(() =>
|
|
{
|
|
if (throwException)
|
|
{
|
|
ThrowException();
|
|
}
|
|
;
|
|
return taskId;
|
|
});
|
|
}
|
|
|
|
private void ThrowException()
|
|
{
|
|
throw new InvalidOperationException("Test exception from action");
|
|
}
|
|
|
|
[Authorize]
|
|
public Task SimpleTask(bool doWork)
|
|
{
|
|
return Task.Factory.StartNew(() => { WorkDone = doWork; });
|
|
}
|
|
|
|
public Task SimpleTaskException(bool doWork)
|
|
{
|
|
return Task.Factory.StartNew(() => { ThrowException(); });
|
|
}
|
|
|
|
public Task<ActionResult> TaskTimeoutWithNullParam(Object nullParam, CancellationToken cancellationToken)
|
|
{
|
|
return TaskTimeout(cancellationToken);
|
|
}
|
|
|
|
public Task<string> TaskWithInfiniteTimeout(CancellationToken cancellationToken)
|
|
{
|
|
return Task.Factory.StartNew(() => "Task Completed");
|
|
}
|
|
|
|
public Task<ActionResult> TaskTimeout(CancellationToken cancellationToken)
|
|
{
|
|
TaskCompletionSource<ActionResult> completionSource = new TaskCompletionSource<ActionResult>();
|
|
cancellationToken.Register(() => completionSource.TrySetCanceled());
|
|
ReturnedTask = completionSource.Task;
|
|
return ReturnedTask;
|
|
}
|
|
|
|
public Task TaskOfPrivateT()
|
|
{
|
|
var completionSource = new TaskCompletionSource<PrivateObject>();
|
|
completionSource.SetResult(new PrivateObject());
|
|
WorkDone = true;
|
|
return completionSource.Task;
|
|
}
|
|
|
|
private class PrivateObject
|
|
{
|
|
public override string ToString()
|
|
{
|
|
return "Private Object";
|
|
}
|
|
}
|
|
}
|
|
|
|
// Controller is async, so derive from ControllerBase to get sync behavior.
|
|
private class RegularSyncController : ControllerBase
|
|
{
|
|
protected override void ExecuteCore()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
}
|
|
}
|