Func<TResult> Delegat

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

System.Core.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Kapselt eine Methode, die über keine Parameter verfügt und einen Wert des Typs zurückgibt, der vom TResult-Parameter angegeben wird.

C#

public delegate TResult Func<out TResult>();

C#

public delegate TResult Func<TResult>();

Typparameter

TResult

Der Typ des Rückgabewerts der Methode, die dieser Delegat kapselt.

Dieser Typparameter ist kovariant. Das bedeutet, dass Sie entweder den angegebenen Typ oder einen stärker abgeleiteten Typ verwenden können. Weitere Informationen zu Kovarianz und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generics.

Rückgabewert

TResult

Der Rückgabewert der Methode, die dieser Delegat kapselt.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie Sie eine Stellvertretung verwenden, die keine Parameter verwendet. Dieser Code erstellt eine generische Klasse mit dem Namen LazyValue "Feld des Typs Func<TResult>". Dieses Stellvertretungsfeld kann einen Verweis auf eine beliebige Funktion speichern, die einen Wert des Typs zurückgibt, der dem Typparameter des LazyValue Objekts entspricht. Der LazyValue Typ verfügt auch über eine Value Eigenschaft, die die Funktion ausführt (wenn sie noch nicht ausgeführt wurde) und den resultierenden Wert zurückgibt.

Im Beispiel werden zwei Methoden erstellt und zwei LazyValue Objekte mit Lambdaausdrucken instanziiert, die diese Methoden aufrufen. Die Lambdaausdrücke nehmen keine Parameter, da sie nur eine Methode aufrufen müssen. Wie die Ausgabe zeigt, werden die beiden Methoden nur ausgeführt, wenn der Wert jedes LazyValue Objekts abgerufen wird.

C#

using System;

static class Func1
{
   public static void Main()
   {
      // Note that each lambda expression has no parameters.
      LazyValue<int> lazyOne = new LazyValue<int>(() => ExpensiveOne());
      LazyValue<long> lazyTwo = new LazyValue<long>(() => ExpensiveTwo("apple"));

      Console.WriteLine("LazyValue objects have been created.");

      // Get the values of the LazyValue objects.
      Console.WriteLine(lazyOne.Value);
      Console.WriteLine(lazyTwo.Value);
   }

   static int ExpensiveOne()
   {
      Console.WriteLine("\nExpensiveOne() is executing.");
      return 1;
   }

   static long ExpensiveTwo(string input)
   {
      Console.WriteLine("\nExpensiveTwo() is executing.");
      return (long)input.Length;
   }
}

class LazyValue<T> where T : struct
{
   private Nullable<T> val;
   private Func<T> getValue;

   // Constructor.
   public LazyValue(Func<T> func)
   {
      val = null;
      getValue = func;
   }

   public T Value
   {
      get
      {
         if (val == null)
            // Execute the delegate.
            val = getValue();
         return (T)val;
      }
   }
}
/* The example produces the following output:

    LazyValue objects have been created.

    ExpensiveOne() is executing.
    1

    ExpensiveTwo() is executing.
    5
*/

Hinweise

Sie können diese Stellvertretung verwenden, um eine Methode darzustellen, die als Parameter übergeben werden kann, ohne explizit eine benutzerdefinierte Stellvertretung zu deklarieren. Die gekapselte Methode muss der Von diesem Stellvertretung definierten Methodensignatur entsprechen. Dies bedeutet, dass die gekapselte Methode keine Parameter aufweisen muss und einen Wert zurückgeben muss.

Hinweis

Um auf eine Methode zu verweisen, die keine Parameter enthält und void zurückgibt (in F#) (unitoder in Visual Basic, das als Sub eine anstelle Functioneiner ) deklariert wird, verwenden Sie stattdessen die Action Stellvertretung.

Wenn Sie die Func<TResult> Stellvertretung verwenden, müssen Sie keine Stellvertretung explizit definieren, die eine parameterlose Methode kapselt. Der folgende Code deklariert z. B. explizit einen Stellvertretungsnamen WriteMethod und weist eine Referenz zur OutputTarget.SendToFile Instanzmethode der Stellvertretungsinstanz zu.

C#

using System;
using System.IO;

delegate bool WriteMethod();

public class TestDelegate
{
   public static void Main()
   {
      OutputTarget output = new OutputTarget();
      WriteMethod methodCall = output.SendToFile;
      if (methodCall())
         Console.WriteLine("Success!");
      else
         Console.WriteLine("File write operation failed.");
   }
}

public class OutputTarget
{
   public bool SendToFile()
   {
      try
      {
         string fn = Path.GetTempFileName();
         StreamWriter sw = new StreamWriter(fn);
         sw.WriteLine("Hello, World!");
         sw.Close();
         return true;
      }
      catch
      {
         return false;
      }
   }
}

Im folgenden Beispiel wird dieser Code vereinfacht, indem er die Stellvertretung instanziiert Func<TResult> , anstatt eine neue Stellvertretung explizit zu definieren und einer benannten Methode zuzuweisen.

C#

using System;
using System.IO;

public class TestDelegate
{
   public static void Main()
   {
      OutputTarget output = new OutputTarget();
      Func<bool> methodCall = output.SendToFile;
      if (methodCall())
         Console.WriteLine("Success!");
      else
         Console.WriteLine("File write operation failed.");
   }
}

public class OutputTarget
{
   public bool SendToFile()
   {
      try
      {
         string fn = Path.GetTempFileName();
         StreamWriter sw = new StreamWriter(fn);
         sw.WriteLine("Hello, World!");
         sw.Close();
         return true;
      }
      catch
      {
         return false;
      }
   }
}

Sie können die Stellvertretung mit anonymen Methoden in C# verwenden, wie das Func<TResult> folgende Beispiel veranschaulicht. (Eine Einführung in anonyme Methoden finden Sie unter Anonyme Methoden.)

C#

using System;
using System.IO;

public class Anonymous
{
   public static void Main()
   {
      OutputTarget output = new OutputTarget();
      Func<bool> methodCall = delegate() { return output.SendToFile(); };
      if (methodCall())
         Console.WriteLine("Success!");
      else
         Console.WriteLine("File write operation failed.");
   }
}

public class OutputTarget
{
   public bool SendToFile()
   {
      try
      {
         string fn = Path.GetTempFileName();
         StreamWriter sw = new StreamWriter(fn);
         sw.WriteLine("Hello, World!");
         sw.Close();
         return true;
      }
      catch
      {
         return false;
      }
   }
}

Sie können auch einem Func<T,TResult> Stellvertretung einen Lambdaausdruck zuweisen, wie das folgende Beispiel veranschaulicht. (Eine Einführung in Lambda-Ausdrücke finden Sie unter Lambda-Ausdrücke (VB), Lambda-Ausdrücke (C#) und Lambda-Ausdrücke (F#).)

C#

using System;
using System.IO;

public class Anonymous
{
   public static void Main()
   {
      OutputTarget output = new OutputTarget();
      Func<bool> methodCall = () => output.SendToFile();
      if (methodCall())
         Console.WriteLine("Success!");
      else
         Console.WriteLine("File write operation failed.");
   }
}

public class OutputTarget
{
   public bool SendToFile()
   {
      try
      {
         string fn = Path.GetTempFileName();
         StreamWriter sw = new StreamWriter(fn);
         sw.WriteLine("Hello, World!");
         sw.Close();
         return true;
      }
      catch
      {
         return false;
      }
   }
}

Der zugrunde liegende Typ eines Lambdaausdrucks ist eine der generischen Func Stellvertretungen. Dadurch kann ein Lambdaausdruck als Parameter übergeben werden, ohne ihn explizit einem Stellvertretung zuzuweisen. Insbesondere, da viele Typen im System.Linq Namespace Parameter haben Func , können Sie diese Methoden einen Lambdaausdruck übergeben, ohne eine Func Stellvertretung explizit instanziieren zu müssen.

Wenn Sie über eine teure Berechnung verfügen, die Sie nur ausführen möchten, wenn das Ergebnis tatsächlich benötigt wird, können Sie die teure Funktion einem Func<TResult> Stellvertretung zuweisen. Die Ausführung der Funktion kann dann verzögert werden, bis eine Eigenschaft, die auf den Wert zugreift, in einem Ausdruck verwendet wird. Das Beispiel im nächsten Abschnitt veranschaulicht, wie Dies geschieht.

Erweiterungsmethoden

GetMethodInfo(Delegate)

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.

Gilt für

Siehe auch

• Lambda-Ausdrücke (C#-Programmierhandbuch)
• Lambda-Ausdrücke: Das fun-Schlüsselwort (F#)
• Lambda-Ausdrücke
• Delegaten (C#-Programmierhandbuch)
• Delegaten (F#)
• Stellvertretungen in Visual Basic