/// <summary>
/// Implementation of the world of effectful computations. It respects the threading model of WPF.
/// </summary>
/// <param name="effect">
/// The effectful computation to be performed.
/// </param>
/// <param name="messageDestination">
/// A function which accepts the message produced by <paramref name="effect"/>, when it completes.
/// </param>
private static async void ExecuteEffect(FSharpAsync <Message> effect, Action <Message> messageDestination)
{
var m = await FSharpAsync.StartAsTask(
effect,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None);
messageDestination(m);
}
static async Task <Gateway> Connect(string appName, ConnectionMode mode, Discovery discovery, TimeSpan operationTimeout,
int maxRetryForThrottling, TimeSpan maxRetryWait)
{
var log = Log.ForContext <CosmosContext>();
var c = new Connector(operationTimeout, maxRetryForThrottling, maxRetryWait, log, mode: mode);
var conn = await FSharpAsync.StartAsTask(c.Connect(appName, discovery), null, null);
return(new Gateway(conn, new BatchingPolicy(defaultMaxItems: 500)));
}
static async Task <Equinox.EventStore.EventStoreContext> Connect(EventStoreConfig config)
{
var c = new Connector(config.Username, config.Password, reqTimeout: TimeSpan.FromSeconds(5), reqRetries: 1);
var conn = await FSharpAsync.StartAsTask(
c.Establish("Twin", Discovery.NewGossipDns(config.Host), ConnectionStrategy.ClusterTwinPreferSlaveReads),
null, null);
return(new Equinox.EventStore.EventStoreContext(conn, new BatchingPolicy(maxBatchSize: 500)));
}
static async Task <GesGateway> Connect(EventStoreConfig config)
{
var log = Logger.NewSerilogNormal(Serilog.Log.ForContext <EventStoreContext>());
var c = new GesConnector(config.Username, config.Password, reqTimeout: TimeSpan.FromSeconds(5), reqRetries: 1);
var conn = await FSharpAsync.StartAsTask(
c.Establish("Twin", Discovery.NewGossipDns(config.Host), ConnectionStrategy.ClusterTwinPreferSlaveReads),
null, null);
return(new GesGateway(conn, new GesBatchingPolicy(maxBatchSize: 500)));
}
/// Run the decision method, letting it decide whether or not the Command's intent should manifest as Events
public async Task <Unit> Execute(Func <TState, IEnumerable <TEvent> > interpret)
{
FSharpList <TEvent> decide_(TState state)
{
var a = new Accumulator <TEvent, TState>(_fold, state);
a.Execute(interpret);
return(ListModule.OfSeq(a.Accumulated));
}
return(await FSharpAsync.StartAsTask(Transact(FuncConvert.FromFunc <TState, FSharpList <TEvent> >(decide_)), null, null));
}
public static async Task WarmUpAsync()
{
try
{
var fsasync = CodeFormatter.FormatDocumentAsync("tmp.fs", SourceOrigin.SourceOrigin.NewSourceString(SampleCode), FormatConfig.FormatConfig.Default, FSharpParsingOptions.Default, FSharpChecker.Create(null, null, null, null, null, null, null, null, null));
var _ = await FSharpAsync.StartAsTask(fsasync, null, null);
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
}
}
public static Tuple <Action, FSharpMailboxProcessor <SystemMessage> > StartSystemMailbox(IProcess self, ProcessId supervisor)
{
bool active = true;
Action quit = () => active = false;
var body = FuncConvert.ToFSharpFunc <FSharpMailboxProcessor <SystemMessage>, FSharpAsync <Microsoft.FSharp.Core.Unit> >(
mbox =>
CreateAsync <Microsoft.FSharp.Core.Unit>(async() =>
{
while (active)
{
var msg = await FSharpAsync.StartAsTask(mbox.Receive(FSharpOption <int> .None), FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None);
if (msg == null || !active)
{
active = false;
}
else
{
switch (msg.GetType().Name)
{
case "SystemShutdownMessage":
self.Shutdown();
active = false;
break;
case "SystemChildIsFaultedMessage":
((IProcessInternal)self).HandleFaultedChild((SystemChildIsFaultedMessage)msg);
break;
case "SystemRestartMessage":
self.Restart();
break;
case "SystemUnLinkChildMessage":
((IProcessInternal)self).UnlinkChild(((SystemUnLinkChildMessage)msg).ChildId);
break;
}
}
}
return(null);
})
);
var mailbox = FSharpMailboxProcessor <SystemMessage> .Start(body, FSharpOption <CancellationToken> .None);
mailbox.Error += (object sender, Exception args) =>
Process.tell(supervisor, SystemMessage.ChildIsFaulted(self.Id, args));
return(tuple(quit, mailbox));
}
public async void AsyncLambda()
{
var x = 0;
Equal(x, 0);
var t = new Task(() => { x = 1; });
A0(async() => { await t; });
await FSharpAsync.StartAsTask(FSharpAsync.Sleep(200), null, null);
// await Task.Delay(200);
Equal(x, 1);
}
public Task <HttpResponseMessage> ExecuteRequest(string url = "http://www.com", string user = null)
{
var request = new HttpRequestMessage();
request.RequestUri = new Uri(url);
if (user != null)
{
request.Headers.Add(UserHeader, user);
}
var reader = client(request, default(CancellationToken));
var response = reader.Item.Invoke(Dependencies.Object);
return(FSharpAsync.StartAsTask(response, FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None));
}
protected override async Task Compile(
string code,
string[] references)
{
var sourcePath = Path.GetTempFileName() + ".fs";
File.WriteAllText(sourcePath, code);
var compilerArgs =
new[] {
"fsc",
sourcePath,
$"--out:{FileName}",
$"--pdb:{PdbName}",
$"--lib:\"{BasePath}\"",
"--debug",
"--target:library"
}
.Concat(GetStandardReferences().Concat(references).Select(r => $"--reference:{r}"))
.ToArray();
var checker = FSharpChecker.Create(
FSharpOption <int> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
#pragma warning disable CS0618
FSharpOption <LegacyReferenceResolver> .None,
#pragma warning restore CS0618
FSharpOption <FSharpFunc <Tuple <string, DateTime>, FSharpOption <Tuple <object, IntPtr, int> > > > .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None
);
var resultFSharpAsync = checker.Compile(compilerArgs, FSharpOption <string> .None);
var result = await FSharpAsync.StartAsTask(resultFSharpAsync, FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None);
if (result.Item2 != 0)
{
var errors =
result
.Item1
.Select(e => $"{e.FileName}({e.StartLine},{e.StartColumn}): {(e.Severity.IsError ? "error" : "warning")} {e.ErrorNumber}: {e.Message}");
throw new InvalidOperationException($"Compilation Failed:{Environment.NewLine}{string.Join(Environment.NewLine, errors)}");
}
}
public async void TargetMethodReturningFSharpAsync_CanBeInvokedViaExecute()
{
// Arrange
var executor = GetExecutorForMethod("FSharpAsyncMethod");
// Act
var fsharpAsync = (FSharpAsync <string>)executor.Execute(_targetObject, new object[] { "test result" });
var result = await FSharpAsync.StartAsTask(fsharpAsync,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None);
// Assert
Assert.True(executor.IsMethodAsync);
Assert.Same(typeof(string), executor.AsyncResultType);
Assert.Equal("test result", result);
}
TryParseAndCheckAsync(string path, ISourceText sourceText, CancellationToken token)
{
if (this.projectOptions == null)
{
var optionsAsync = _provider.CheckerInstance.GetProjectOptionsFromScript(
filename: path,
source: sourceText,
assumeDotNetFramework: false,
useSdkRefs: true,
useFsiAuxLib: true,
previewEnabled: true,
otherFlags: new string[] { "--targetprofile:netstandard" },
loadedTimeStamp: null,
extraProjectInfo: null,
optionsStamp: null,
userOpName: null,
sdkDirOverride: null
);
var(options, errors) = await FSharpAsync.StartAsTask(optionsAsync, null, token);
if (!errors.IsEmpty)
{
return(null, null);
}
this.projectOptions = options;
}
var performParseAndCheck = _provider.CheckerInstance.ParseAndCheckFileInProject(
filename: path,
fileVersion: 1,
sourceText: sourceText,
options: projectOptions,
userOpName: null
);
var(parseResults, checkAnswer) = await FSharpAsync.StartAsTask(performParseAndCheck, null, token);
if (checkAnswer is FSharpCheckFileAnswer.Succeeded succeeded)
{
return(parseResults, succeeded.Item);
}
return(parseResults, null);
}
public static Assembly Compile(string source)
{
var fileHelpersAssembly = typeof(EngineBase).Assembly;
var checker = FSharpChecker.Create(
FSharpOption <int> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <LegacyReferenceResolver> .None,
FSharpOption <FSharpFunc <Tuple <string, DateTime>, FSharpOption <Tuple <object, IntPtr, int> > > > .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None,
FSharpOption <bool> .None);
var file = Path.GetTempFileName();
File.WriteAllText(file + ".fs", source);
var action = checker.CompileToDynamicAssembly(
new[] { "-o", file + ".dll", "-a", file + ".fs", "--reference:" + fileHelpersAssembly.Location },
FSharpOption <Tuple <TextWriter, TextWriter> > .None,
FSharpOption <string> .None);
var compileResult = FSharpAsync
.StartAsTask(action, FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None)
.Result;
var exitCode = compileResult.Item2;
var compilationErrors = compileResult.Item1;
if (compilationErrors.Any() && exitCode != 0)
{
var errors = new StringBuilder();
foreach (var error in compilationErrors)
{
errors.AppendLine(error.ToString());
}
throw new InvalidOperationException($"Cannot compile fsharp: {errors}");
}
return(compileResult.Item3.Value);
}
public async void TargetMethodReturningFailingFSharpAsync_CanBeInvokedViaExecute()
{
// Arrange
var executor = GetExecutorForMethod("FSharpAsyncFailureMethod");
// Act
var fsharpAsync = (FSharpAsync <string>)executor.Execute(_targetObject, new object[] { "test result" });
var resultTask = FSharpAsync.StartAsTask(fsharpAsync,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None);
// Assert
Assert.True(executor.IsMethodAsync);
Assert.Same(typeof(string), executor.AsyncResultType);
var exception = await Assert.ThrowsAsync <AggregateException>(async() => await resultTask);
Assert.IsType(typeof(InvalidOperationException), exception.InnerException);
Assert.Equal("Test exception", exception.InnerException.Message);
}
public async Task Invoke(HttpContext context)
{
var suaveContext = await context.ToSuaveHttpContext(_preserveHttpHeaderCasing);
var asyncWorkflow = _app.Invoke(suaveContext);
var result = await FSharpAsync.StartAsTask(
asyncWorkflow,
FSharpOption<TaskCreationOptions>.Some(TaskCreationOptions.None),
FSharpOption<CancellationToken>.Some(CancellationToken.None));
// Set the Suave result if the request could be handled by Suave
if (FSharpOption<Http.HttpContext>.get_IsSome(result))
{
await context.SetResponseFromSuaveResult(result.Value.response);
}
else
{
await _next.Invoke(context);
}
}
TryParseAsync(string path, ISourceText sourceText, CancellationToken token)
{
if (parseOpts == null)
{
var defaults = FSharpParsingOptions.Default;
this.parseOpts = new FSharpParsingOptions(
sourceFiles: new string[] { path },
conditionalCompilationDefines: defaults.ConditionalCompilationDefines,
errorSeverityOptions: defaults.ErrorSeverityOptions,
isInteractive: defaults.IsInteractive,
lightSyntax: defaults.LightSyntax,
compilingFsLib: defaults.CompilingFsLib,
isExe: defaults.IsExe
);
}
var parseAsync = _provider.CheckerInstance.ParseFile(path, sourceText, parseOpts, "FsLint");
var parseResults = await FSharpAsync.StartAsTask(parseAsync, null, token).ConfigureAwait(false);
return(parseResults, null);
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
try
{
var suaveContext = await context.ToSuaveHttpContext(_preserveHttpHeaderCasing);
var asyncWorkflow = _errorHandler.Invoke(ex).Invoke("").Invoke(suaveContext);
var result = await FSharpAsync.StartAsTask(
asyncWorkflow,
FSharpOption <TaskCreationOptions> .Some(TaskCreationOptions.None),
FSharpOption <CancellationToken> .Some(CancellationToken.None));
// Set the Suave result if the request could be handled by Suave and return
if (FSharpOption <Http.HttpContext> .get_IsSome(result))
{
await context.SetResponseFromSuaveResult(result.Value.response);
return;
}
}
catch (Exception ex2)
{
_logger.LogError(0, ex, $"An unhandled exception has occured: {ex.Message}.");
_logger.LogError(0, ex2, $"An exception was thrown attempting to execute the error handler: {ex2.Message}.");
}
// Re -throw the original exception
throw;
}
}
/// <summary>
/// Clears the state (keeps the mailbox items)
/// </summary>
public Unit Restart()
{
lock (actorLock)
{
// Take a copy of the messages from the dead mailbox
var msgs = new Queue <UserControlMessage>(userMailbox.CurrentQueueLength);
while (userMailbox.CurrentQueueLength > 0)
{
UserControlMessage userMessage = FSharpAsync.StartAsTask(
userMailbox.Receive(FSharpOption <int> .None),
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None
).Result;
if (userMessage != null)
{
msgs.Enqueue(userMessage);
}
}
// We shutdown the children, because we're about to restart which will
// recreate them.
Shutdown(false);
// Start new mailboxes
StartMailboxes();
// Copy the old messages
while (msgs.Count > 0)
{
userMailbox.Post(msgs.Dequeue());
}
return(unit);
}
}
/// <summary>
/// Prevents dead locks when waiting for FCS while under write lock.
/// FCS may request a read lock from a background thread before processing this request.
/// We grant read access by passing the write lock.
/// </summary>
private static T RunTransferringWriteLock <T>(FSharpAsync <T> async)
{
var shellLocks = Shell.Instance.GetComponent <IShellLocks>();
shellLocks.AssertWriteAccessAllowed();
var task = FSharpAsync.StartAsTask(async, null, null);
var isLockTransferred = false;
while (!task.IsCompleted || isLockTransferred)
{
var finished = task.Wait(InterruptCheckTimeout, ourEternalCancellationToken);
if (finished)
{
if (!isLockTransferred)
{
break;
}
Thread.Sleep(GetTransferredWriteLockTimeout);
}
if (!isLockTransferred && FSharpLocks.ThreadRequestingWriteLock != null)
{
isLockTransferred = true;
shellLocks.ContentModelLocks.TransferWriteLock(FSharpLocks.ThreadRequestingWriteLock);
}
if (isLockTransferred && shellLocks.IsWriteAccessAllowed())
{
isLockTransferred = false;
}
}
return(task.Result);
}
public async Task DoUpdateAsync()
{
if (IsDisposed)
{
return;
}
var buffer = _currentSnapshot;
var path = _document.FilePath;
// replace with user token
var token = _cts.Token;
var instance = await FsLintVsPackage.Instance.WithCancellation(token);
// this acts as a throttle
await Task.Delay(200, token);
if (Project == null)
{
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
var project = instance.Dte.Solution.FindProjectItem(path)?.ContainingProject;
if (project == null)
{
return;
}
if (instance.SolutionService.GetProjectOfUniqueName(project.UniqueName, out var vsHierarchy) != VSConstants.S_OK)
{
return;
}
if (instance.SolutionService.GetGuidOfProject(vsHierarchy, out var guid) != VSConstants.S_OK)
{
return;
}
Project = new LintProjectInfo(project.Name, guid, vsHierarchy);
}
await Task.Yield();
var connectionString = SqlAnalyzer.tryFindConnectionString(path);
if (string.IsNullOrWhiteSpace(connectionString))
{
return;
}
var loadedSchema = SqlAnalysis.databaseSchema(connectionString);
if (loadedSchema.IsError)
{
return;
}
var source = _currentSnapshot.GetText();
var sourceText = SourceText.ofString(source);
var getProjectOptions = _provider.CheckerInstance.GetProjectOptionsFromScript(
filename: path,
sourceText: sourceText,
assumeDotNetFramework: false,
useSdkRefs: true,
useFsiAuxLib: true,
previewEnabled: true,
otherFlags: new string[] { "--targetprofile:netstandard" },
loadedTimeStamp: FSharpOption <DateTime> .None,
extraProjectInfo: FSharpOption <object> .None,
optionsStamp: FSharpOption <long> .None,
userOpName: FSharpOption <string> .None
);
var(options, errors) = await FSharpAsync.StartAsTask(getProjectOptions, null, token);
if (errors.Any())
{
return;
}
var performParseAndCheck = _provider.CheckerInstance.ParseAndCheckFileInProject(
filename: path,
fileversion: 1,
sourceText: sourceText,
options: options,
textSnapshotInfo: FSharpOption <object> .None,
userOpName: FSharpOption <string> .None
);
var(parseResults, checkAnswer) = await FSharpAsync.StartAsTask(performParseAndCheck, null, token);
if (parseResults.ParseHadErrors || checkAnswer.IsAborted)
{
return;
}
var checkResults = SqlAnalyzer.checkAnswerResult(checkAnswer).Value;
var context = new SqlAnalyzerContext(
fileName: path,
content: source.Split('\n'),
parseTree: parseResults.ParseTree.Value,
symbols: SqlAnalyzer.getSymbols(checkResults)
);
var databaseSchema = loadedSchema.ResultValue;
var errorMessages =
from operation in SyntacticAnalysis.findSqlOperations(context)
from analysisOutput in SqlAnalysis.analyzeOperation(operation, connectionString, databaseSchema)
select analysisOutput;
var oldLintingErrors = this.Factory.CurrentSnapshot;
var newLintErrors = new LintingErrorsSnapshot(_document, oldLintingErrors.VersionNumber + 1);
foreach (var error in errorMessages)
{
var span = RangeToSpan(error.Range, buffer);
newLintErrors.Errors.Add(new LintError(span, error, Project));
}
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
if (token.IsCancellationRequested)
{
return;
}
UpdateLintingErrors(newLintErrors);
}
public async Task DoUpdateAsync()
{
if (IsDisposed)
{
return;
}
var buffer = _currentSnapshot;
var path = _document.FilePath;
// replace with user token
var token = _cts.Token;
var instance = await FsLintVsPackage.Instance.WithCancellation(token);
// this acts as a throttle
await Task.Delay(200, token);
if (Project == null)
{
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
var project = instance.Dte.Solution.FindProjectItem(path)?.ContainingProject;
if (project == null)
{
return;
}
if (instance.SolutionService.GetProjectOfUniqueName(project.UniqueName, out var vsHierarchy) != VSConstants.S_OK)
{
return;
}
if (instance.SolutionService.GetGuidOfProject(vsHierarchy, out var guid) != VSConstants.S_OK)
{
return;
}
Project = new LintProjectInfo(project.Name, guid, vsHierarchy);
}
await Task.Yield();
var connectionString = SqlAnalyzer.tryFindConnectionString(path);
if (string.IsNullOrWhiteSpace(connectionString))
{
return;
}
var source = _currentSnapshot.GetText();
var sourceText = SourceText.ofString(source);
var getProjectOptions = _provider.CheckerInstance.GetProjectOptionsFromScript(
filename: path,
source: sourceText,
assumeDotNetFramework: false,
useSdkRefs: true,
useFsiAuxLib: true,
previewEnabled: true,
otherFlags: new string[] { "--targetprofile:netstandard" },
loadedTimeStamp: FSharpOption <DateTime> .None,
extraProjectInfo: FSharpOption <object> .None,
optionsStamp: FSharpOption <long> .None,
userOpName: FSharpOption <string> .None,
sdkDirOverride: FSharpOption <string> .None
);
var(options, errors) = await FSharpAsync.StartAsTask(getProjectOptions, null, token);
if (errors.Any())
{
return;
}
var performParseAndCheck = _provider.CheckerInstance.ParseAndCheckFileInProject(
filename: path,
fileVersion: 1,
sourceText: sourceText,
options: options,
userOpName: FSharpOption <string> .None
);
var(parseResults, checkAnswer) = await FSharpAsync.StartAsTask(performParseAndCheck, null, token);
if (parseResults.ParseHadErrors || checkAnswer.IsAborted)
{
return;
}
var checkResults = SqlAnalyzer.checkAnswerResult(checkAnswer).Value;
var context = new SqlAnalyzerContext(
fileName: path,
content: source.Split('\n'),
parseTree: parseResults.ParseTree.Value,
symbols: SqlAnalyzer.getSymbols(checkResults)
);
var operationBlocks = SyntacticAnalysis.findSqlOperations(context);
var loadedSchema = SqlAnalysis.databaseSchema(connectionString);
var errorMessages = new List <Message>();
if (loadedSchema.IsError)
{
foreach (var operation in operationBlocks)
{
var containsSkipAnalysis = operation.blocks.Any(block => block.IsSkipAnalysis);
foreach (var block in operation.blocks)
{
var blockRange = block.Range();
if ((block.IsQuery || block.IsTransaction) && OptionModule.IsSome(blockRange) && !containsSkipAnalysis)
{
var internalError = (loadedSchema.ErrorValue ?? "").Replace("3D000:", "").Replace("28P01:", "");
var fullError = $"Error occured while trying to connect to the database using the configured connection string in NPGSQL_FSHARP in order to perform static analysis:{internalError}";
var errorMessage = new Message(
type: "Error",
message: fullError,
code: "SQL101",
severity: Severity.Warning,
range: blockRange.Value,
fixes: Microsoft.FSharp.Collections.FSharpList <Fix> .Empty
);
errorMessages.Add(errorMessage);
}
}
}
}
else
{
var databaseSchema = loadedSchema.ResultValue;
foreach (var operation in operationBlocks)
{
foreach (var analysisOutput in SqlAnalysis.analyzeOperation(operation, connectionString, databaseSchema))
{
errorMessages.Add(analysisOutput);
}
}
}
var oldLintingErrors = this.Factory.CurrentSnapshot;
var newLintErrors = new LintingErrorsSnapshot(_document, oldLintingErrors.VersionNumber + 1);
foreach (var error in errorMessages)
{
var span = RangeToSpan(error.Range, buffer);
newLintErrors.Errors.Add(new LintError(span, error, Project));
}
await instance.JoinableTaskFactory.SwitchToMainThreadAsync();
if (token.IsCancellationRequested)
{
return;
}
UpdateLintingErrors(newLintErrors);
}
/// <summary>
/// ExecuteAsyncTask
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="task"></param>
/// <returns></returns>
static public Task <T> ExecuteAsyncTask <T>(this FSharpAsync <T> task)
{
return(FSharpAsync.StartAsTask <T>(task, FSharpOption <TaskCreationOptions> .None, FSharpOption <CancellationToken> .None));
}
// Project from the synchronized state, without the possibility of adding events that Decide(Func) admits public async Task <T> Query <T>(Func <TState, T> project) => await FSharpAsync.StartAsTask(Query(FuncConvert.FromFunc(project)), null, null);
// Execute a command, as Decide(Action) does, but also yield an outcome from the decision public async Task <T> Decide <T>(Func <Context <TEvent, TState>, T> interpret) => await FSharpAsync.StartAsTask <T>(Decide(FuncConvert.FromFunc(interpret)), null, null);
// Run the decision method, letting it decide whether or not the Command's intent should manifest as Events public async Task <Unit> Execute(Action <Context <TEvent, TState> > decide) => await FSharpAsync.StartAsTask(Decide(FuncConvert.ToFSharpFunc(decide)), null, null);
public static void TestAsync <T>(FSharpAsync <T> async, T expected) => TestTask(FSharpAsync.StartAsTask(async, null, null), expected);
public static Task <R[]> Parallel <R>(IEnumerable <Task <R> > computations) => FSharpAsync.StartAsTask(FSharpAsync.Parallel <R>(computations.Select(FSharpAsync.AwaitTask)), FSharpOption <TaskCreationOptions> .None, FSharpOption <System.Threading.CancellationToken> .None);
public static Task <T> ToTask <T>(this FSharpAsync <T> task)
{
return(FSharpAsync.StartAsTask(task, null, null));
}
public HttpResponseMessage AddToCache(
DateTime cahcedUntil,
string url = "http://www.com",
string user = null,
byte?addRequestContent = null,
byte?addResponseContent = null,
HttpMethod method = null,
Headers.CacheSettings.ExpirySettings expiry = null,
KeyValuePair <string, string[]>[] customHeaders = null)
{
expiry = expiry ?? Headers.CacheSettings.ExpirySettings.NewHardUtc(DateTime.UtcNow.AddDays(10));
cahcedUntil = new DateTime(cahcedUntil.Ticks, DateTimeKind.Utc);
var response = new HttpResponseMessage();
response.RequestMessage = new HttpRequestMessage();
if (addRequestContent != null)
{
response.RequestMessage.Content = new SingleByteContent(addRequestContent.Value);
}
if (addResponseContent != null)
{
response.Content = new SingleByteContent(addResponseContent.Value);
}
if (customHeaders != null)
{
foreach (var h in customHeaders)
{
response.Headers.Add(h.Key, h.Value);
}
}
var m = (method == null || method == HttpMethod.Get) ? "G" : null;
if (m == null)
{
throw new NotSupportedException(method?.ToString() ?? "null");
}
user = user?.Replace("$", "$$");
var key = $"{m}$:{user}$:{new Uri(url)}";
Dependencies
.Setup(x => x.Cache.Get(It.Is <string>(k => k == key)))
.Returns(Returns);
return(response);
FSharpAsync <FSharpOption <CachedValues> > Returns()
{
return(FSharpAsync.AwaitTask(ReturnsAsync()));
}
async Task <FSharpOption <CachedValues> > ReturnsAsync()
{
var resp = await FSharpAsync.StartAsTask(
CachedResponse.build(response),
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None);
return(FSharpOption <CachedValues> .Some(new CachedValues(
resp,
new Headers.CacheSettings.CacheSettings(expiry, true))));
}
}
public static Task <T> ToTask <T>(this FSharpAsync <T> item) =>
FSharpAsync.StartAsTask(
item,
FSharpOption <TaskCreationOptions> .None,
FSharpOption <CancellationToken> .None
);