Esporta (0) Stampa
Espandi tutto
Espandi Riduci a icona
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Delegato Func<TResult>

Incapsula un metodo privo di parametri e restituisce un valore del tipo specificato dal parametro TResult.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

public delegate TResult Func<out TResult>()

Parametri di tipo

out TResult

Il tipo del valore restituito del metodo che questo delegato incapsula.

Il parametro di questo tipo è covariante. Ciò significa che è possibile utilizzare il tipo specificato o qualsiasi tipo più derivato. Per ulteriori informazioni sulla covarianza e la controvarianza, vedere Covarianza e controvarianza nei generics.

Valore restituito

Tipo: TResult
Il valore restituito del metodo che questo delegato incapsula.

È possibile utilizzare questo delegato per rappresentare un metodo che può essere passato come parametro senza dichiarare in modo esplicito un delegato personalizzato. Il metodo incapsulato deve corrispondere alla firma del metodo che viene definita da questo delegato. Ciò significa che il metodo incapsulate non deve avere parametri e restituire un valore.

NotaNota

Per fare riferimento a un metodo privo di parametri e restituisce void (o in Visual Basic, che viene dichiarato come classe Sub anziché come oggetto Function), utilizzare Action delegato anziché.

Quando si utilizzano Func<TResult> delegato, non è necessario definire in modo esplicito un delegato che incapsula un metodo senza parametri. Ad esempio, il codice seguente in modo esplicito dichiara un delegato denominato WriteMethod e assegna un riferimento a OutputTarget.SendToFile metodo di istanza alla relativa istanza del delegato.


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'esempio seguente consente di semplificare questo codice consente di creare un'istanza Func<TResult> delegato anziché in modo esplicito la definizione del delegato nuovo e assegnando un metodo denominato.


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


È possibile utilizzare Func<TResult> il delegato a metodi anonimi in c#, come nell'esempio seguente. (Per un'introduzione ai metodi anonimi, vedere Metodi anonimi (Guida per programmatori 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;
      }
   }
}


È anche possibile assegnare un'espressione lambda a un oggetto Func<T, TResult> il delegato, come nell'esempio seguente. (Per un'introduzione alle espressioni lambda, vedere Espressioni lambda (Visual Basic) e Espressioni lambda (Guida per programmatori 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;
      }
   }
}


Il tipo sottostante dell'espressione lambda è uno dei generici Func delegati. Ciò consente di passare un'espressione lambda come parametro senza in modo esplicito assegnarlo a un delegato. In particolare, poiché molti metodi dei tipi in System.Linq lo spazio dei nomi presentano Func parametri, è possibile passare a questi metodi un'espressione lambda senza creare esplicitamente istanze di un oggetto Func delegato.

Se si dispone di calcoli dispendiosi che si desidera eseguire solo se il risultato è effettivamente necessario, è possibile assegnare una funzione dispendiosa a un oggetto Func<TResult> delegato. L'esecuzione della funzione può quindi essere ritardata fino a quando non viene utilizzata una proprietà che accede al valore in un'espressione. Esempio nella sezione successiva viene illustrato come procedere.

Nell'esempio seguente viene illustrato come utilizzare un delegato che non accetta parametri. questo codice crea una classe generica denominata LazyValue che include un campo di tipo Func<TResult>. Questo campo del delegato può memorizzare un riferimento a qualsiasi funzione che restituisce un valore del tipo che corrisponde al parametro di tipo LazyValue oggetto. LazyValue il tipo dispone anche di un oggetto Value proprietà che esegue la funzione (se non è già stata eseguita) e restituisce il valore risultante.

Nell'esempio vengono creati due metodi e di creazione di due LazyValue oggetti con le espressioni lambda che chiamano questi metodi. Le espressioni lambda non accettano parametri in quanto è sufficiente chiamare un metodo. Come illustrato nell'output, i due metodi vengono eseguite solo quando il valore di ogni LazyValue l'oggetto viene recuperato.


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

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2015 Microsoft