Exporter (0) Imprimer
Développer tout
Développer Réduire
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte.
Traduction
Source

Func<TResult>, délégué

Encapsule une méthode n'ayant aucun paramètre et retournant une valeur du type spécifié par le paramètre TResult.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public delegate TResult Func<out TResult>()

Paramètres de type

out TResult

Type de la valeur de retour de la méthode encapsulée par ce délégué.

Ce paramètre de type est covariant. Autrement dit, vous pouvez utiliser le type que vous avez spécifié ou tout type plus dérivé. Pour plus d'informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

Valeur de retour

Type : TResult
Valeur de retour de la méthode encapsulée par ce délégué.

Vous pouvez utiliser ce délégué pour représenter une méthode qui peut être passée en tant que paramètre sans déclarer explicitement un délégué personnalisé. La méthode encapsulée doit correspondre à la signature de méthode définie par ce délégué. Cela signifie que la méthode encapsulée ne doit avoir aucun paramètre et doit retourner une valeur.

RemarqueRemarque

Pour référencer une méthode n'ayant aucun paramètre et retournant void (ou, en Visual Basic, qui est déclarée en tant que Sub plutôt qu'en tant que Function), utilisez à la place le délégué Action.

Lorsque vous utilisez le délégué Func<TResult>, vous n'avez pas à définir explicitement un délégué qui encapsule une méthode sans paramètre. Par exemple, le code suivant déclare explicitement un délégué nommé WriteMethod et assigne une référence à la méthode d'instance OutputTarget.SendToFile à son instance de délégué.


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;
      }
   }
}


L'exemple suivant simplifie ce code en instanciant le délégué Func<TResult> plutôt qu'en définissant explicitement un nouveau délégué avant de lui assigner une méthode nommée.


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;
      }
   }
}


Vous pouvez utiliser le délégué Func<TResult> avec les méthodes anonymes en C#, comme l'illustre l'exemple suivant. (Pour obtenir une introduction aux méthodes anonymes, consultez Méthodes anonymes (Guide de programmation 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;
      }
   }
}


Vous pouvez également assigner une expression lambda à un délégué Func<T, TResult>, comme l'illustre l'exemple suivant. (Pour obtenir une introduction aux expressions lambda, consultez Expressions lambda (Visual Basic) et Expressions lambda (Guide de programmation 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;
      }
   }
}


Le type sous-jacent d'une expression lambda est l'un des délégués génériques Func. Cela permet de passer une expression lambda en tant que paramètre sans l'assigner explicitement à un délégué. Étant donné que de nombreuses méthodes de types de l'espace de noms System.Linq disposent des paramètres Func, vous pouvez notamment passer une expression lambda à ces méthodes sans instancier explicitement un délégué Func.

Si vous souhaitez exécuter un calcul coûteux uniquement lorsque le résultat est réellement nécessaire, vous pouvez assigner la fonction coûteuse à un délégué Func<TResult>. L'exécution de la fonction peut alors être différée jusqu'à ce qu'une propriété accédant à la valeur soit utilisée dans une expression. L'exemple qui se trouve dans la section suivante montre comment procéder.

L'exemple suivant montre comment utiliser un délégué qui ne prend pas de paramètres. Ce code crée une classe générique nommée LazyValue avec un champ de type Func<TResult>. Ce champ délégué peut stocker une référence à toute fonction retournant une valeur du type qui correspond au paramètre de type de l'objet LazyValue. Le type LazyValue a également une propriété Value qui exécute la fonction (si elle ne l'a pas déjà été) et retourne la valeur résultante.

L'exemple crée deux méthodes et instancie deux objets LazyValue avec les expressions lambda qui appellent ces méthodes. Les expressions lambda ne prennent pas de paramètres car elles doivent juste appeler une méthode. Alors que la sortie s'affiche, les deux méthodes sont exécutées uniquement lorsque la valeur de chaque objet LazyValue est récupérée.


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
*/    


.NET Framework

Pris en charge dans : 4, 3.5

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft