Task.FromResult<TResult>(TResult) Method

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<TResult> ^ FromResult(TResult result);

public static System.Threading.Tasks.Task<TResult> FromResult<TResult>(TResult result);

static member FromResult : 'Result -> System.Threading.Tasks.Task<'Result>

Public Shared Function FromResult(Of TResult) (result As TResult) As Task(Of TResult)

Type Parameters

Parameters

Returns

The successfully completed task.

Examples

The following example is a command-line utility that calculates the number of bytes in the files in each directory whose name is passed as a command-line argument. Rather than executing a longer code path that instantiates a FileStream object and retrieves the value of its FileStream.Length property for each file in the directory, the example simply calls the FromResult method to create a task whose Task<TResult>.Result property is zero (0) if a directory has no files.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
 public static void Main()
 {
 string[] args = Environment.GetCommandLineArgs();
 if (args.Length > 1) {
 List<Task<long>> tasks = new List<Task<long>>();
 for (int ctr = 1; ctr < args.Length; ctr++)
 tasks.Add(GetFileLengthsAsync(args[ctr]));

 try {
 Task.WaitAll(tasks.ToArray());
 }
 // Ignore exceptions here.
 catch (AggregateException) {}

 for (int ctr = 0 ; ctr < tasks.Count; ctr++) {
 if (tasks[ctr].Status == TaskStatus.Faulted)
 Console.WriteLine("{0} does not exist", args[ctr + 1]);
 else
 Console.WriteLine("{0:N0} bytes in files in '{1}'",
 tasks[ctr].Result, args[ctr + 1]);
 }
 }
 else {
 Console.WriteLine("Syntax error: Include one or more file paths.");
 }
 }

 private static Task<long> GetFileLengthsAsync(string filePath)
 {
 if (!Directory.Exists(filePath)) {
 return Task.FromException<long>(
 new DirectoryNotFoundException("Invalid directory name."));
 }
 else {
 string[] files = Directory.GetFiles(filePath);
 if (files.Length == 0)
 return Task.FromResult(0L);
 else
 return Task.Run( () => { long total = 0;
 Parallel.ForEach(files, (fileName) => {
 var fs = new FileStream(fileName, FileMode.Open,
 FileAccess.Read, FileShare.ReadWrite,
 256, true);
 long length = fs.Length;
 Interlocked.Add(ref total, length);
 fs.Close(); } );
 return total;
 } );
 }
 }
}
// When launched with the following command line arguments:
// subdir . newsubdir
// the example displays output like the following:
// 0 bytes in files in 'subdir'
// 2,059 bytes in files in '.'
// newsubdir does not exist

open System
open System.IO
open System.Threading
open System.Threading.Tasks

let getFileLengthsAsync filePath =
 if Directory.Exists filePath |> not then
 DirectoryNotFoundException "Invalid directory name."
 |> Task.FromException<int64>

 else
 let files = Directory.GetFiles filePath

 if files.Length = 0 then
 Task.FromResult 0L
 else
 Task.Run(fun () ->
 let mutable total = 0L

 Parallel.ForEach(
 files,
 fun fileName ->
 use fs =
 new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 256, true)

 Interlocked.Add(ref total, fs.Length) |> ignore
 )
 |> ignore

 total)

let args = Environment.GetCommandLineArgs()[1..]

if args.Length > 0 then
 let tasks = Array.map getFileLengthsAsync args

 try
 Seq.cast tasks |> Seq.toArray |> Task.WaitAll

 // Ignore exceptions here.
 with :? AggregateException ->
 ()

 for i = 0 to tasks.Length - 1 do
 if tasks[i].Status = TaskStatus.Faulted then
 printfn $"{args[i + 1]} does not exist"
 else
 printfn $"{tasks[i].Result:N0} bytes in files in '{args[i + 1]}'"
else
 printfn "Syntax error: Include one or more file paths."

// When launched with the following command line arguments:
// subdir . newsubdir
// the example displays output like the following:
// 0 bytes in files in 'subdir'
// 2,059 bytes in files in '.'
// newsubdir does not exist

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks

Module Example
 Public Sub Main()
 Dim args() As String = Environment.GetCommandLineArgs()
 If args.Length > 1 Then
 Dim tasks As New List(Of Task(Of Long))
 For ctr = 1 To args.Length - 1
 tasks.Add(GetFileLengthsAsync(args(ctr)))
 Next
 Try
 Task.WaitAll(tasks.ToArray())
 ' Ignore exceptions here.
 Catch e As AggregateException
 End Try

 For ctr As Integer = 0 To tasks.Count - 1
 If tasks(ctr).Status = TaskStatus.Faulted Then
 Console.WriteLine("{0} does not exist", args(ctr + 1))
 Else
 Console.WriteLine("{0:N0} bytes in files in '{1}'",
 tasks(ctr).Result, args(ctr + 1))
 End If
 Next
 Else
 Console.WriteLine("Syntax error: Include one or more file paths.")
 End If
 End Sub
 
 Private Function GetFileLengthsAsync(filePath As String) As Task(Of Long)
 If Not Directory.Exists(filePath) Then
 Return Task.FromException(Of Long)(
 New DirectoryNotFoundException("Invalid directory name."))
 Else
 Dim files As String() = Directory.GetFiles(filePath)
 If files.Length = 0 Then
 Return Task.FromResult(0L)
 Else
 Return Task.Run( Function()
 Dim total As Long = 0
 Dim lockObj As New Object
 Parallel.ForEach(files, Sub(fileName)
 Dim fs As New FileStream(fileName, FileMode.Open,
 FileAccess.Read, FileShare.ReadWrite,
 256, True)
 Dim length As Long = fs.Length
 Interlocked.Add(total, length)
 fs.Close()
 End Sub)
 Return total
 End Function )
 End If
 End If
 End Function
End Module
' When launched with the following command line arguments:
' subdir . newsubdir
' the example displays output like the following:
' 0 bytes in files in 'subdir'
' 2,059 bytes in files in '.'
' newsubdir does not exist

Remarks

This method creates a Task<TResult> object whose Task<TResult>.Result property is result and whose Status property is RanToCompletion. The method is commonly used when the return value of a task is immediately known without executing a longer code path. The example provides an illustration.

To create a Task object that does not return a value, retrieve the Task object from the CompletedTask property.

Starting in .NET 6, for some TResult types and some result values, this method may return a cached singleton object rather than allocating a new object.

See also

• CompletedTask