Func<TResult> Temsilci

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Bütünleştirilmiş Kod:

System.Core.dll

Bütünleştirilmiş Kod:

mscorlib.dll

Bütünleştirilmiş Kod:

netstandard.dll

Parametresi olmayan bir yöntemi kapsüller ve parametresi tarafından TResult belirtilen türde bir değer döndürür.

C#

public delegate TResult Func<out TResult>();

C#

public delegate TResult Func<TResult>();

Tür Parametreleri

TResult

Bu temsilcinin kapsüllediğini yöntemin dönüş değerinin türü.

Bu genel tür parametresi kovaryanttır. Bu, kendi belirttiğiniz türü veya daha fazla türetilmiş başka bir türü kullanabileceğiniz anlamına gelir. Kovaryans ve kontravaryans hakkında daha fazla bilgi için bkz. Genel Türlerde Kovaryans ve Kontravaryans.

Dönüş Değeri

TResult

Bu temsilcinin kapsüllediğini yönteminin dönüş değeri.

Örnekler

Aşağıdaki örnekte parametre içermeyen bir temsilcinin nasıl kullanılacağı gösterilmektedir. Bu kod, türünde Func<TResult>bir alanı olan adlı LazyValue genel bir sınıf oluşturur. Bu temsilci alanı, nesnenin tür parametresine LazyValue karşılık gelen türün değerini döndüren herhangi bir işleve başvuru depolayabilir. Türün LazyValue ayrıca işlevi yürüten (henüz yürütülmediyse) ve sonuçta elde edilen değeri döndüren bir Value özelliği de vardır.

Örnek iki yöntem oluşturur ve bu yöntemleri çağıran lambda ifadeleriyle iki LazyValue nesnenin örneğini oluşturur. Lambda ifadeleri parametre almaz çünkü yalnızca bir yöntemi çağırmaları gerekir. Çıktıda gösterildiği gibi, iki yöntem yalnızca her LazyValue nesnenin değeri alındığında yürütülür.

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

Açıklamalar

Özel temsilciyi açıkça bildirmeden parametre olarak geçirilebilen bir yöntemi temsil etmek için bu temsilciyi kullanabilirsiniz. Kapsüllenen yöntem, bu temsilci tarafından tanımlanan yöntem imzasına karşılık olmalıdır. Bu, kapsüllenen yöntemin parametre içermemesi ve bir değer döndürmesi gerektiği anlamına gelir.

Not

Parametresi olmayan ve döndüren void bir yönteme başvurmak için (unitF#'ta) (veya yerine olarak Sub bildirilen Visual Basic), bunun yerine Functiontemsilciyi Action kullanın.

Temsilciyi Func<TResult> kullandığınızda, parametresiz bir yöntemi kapsülleyen bir temsilciyi açıkça tanımlamanız gerekmez. Örneğin, aşağıdaki kod adlı WriteMethod bir temsilciyi açıkça bildirir ve örnek yöntemine OutputTarget.SendToFile temsilci örneğine bir başvuru atar.

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

Aşağıdaki örnek, yeni bir temsilciyi Func<TResult> açıkça tanımlamak ve buna adlandırılmış bir yöntem atamak yerine temsilcinin örneğini oluşturarak bu kodu basitleştirir.

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

Aşağıdaki örnekte gösterildiği gibi temsilciyi Func<TResult> C# dilinde anonim yöntemlerle kullanabilirsiniz. (Anonim yöntemlere giriş için bkz . Anonim Yöntemler.)

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

Aşağıdaki örnekte gösterildiği gibi bir temsilciye lambda Func<T,TResult> ifadesi de atayabilirsiniz. (Lambda ifadelerine giriş için bkz. Lambda İfadeleri (VB), Lambda İfadeleri (C#)ve Lambda İfadeleri (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;
      }
   }
}

Lambda ifadesinin temel türü genel Func temsilcilerden biridir. Bu, bir lambda ifadesini bir temsilciye açıkça atamadan parametre olarak geçirmeyi mümkün kılar. Özellikle, ad alanında System.Linq Func birçok tür yönteminin parametreleri olduğundan, bu yöntemleri açıkça bir temsilci örneği oluşturmadan bir Func lambda ifadesi geçirebilirsiniz.

Yalnızca sonuç gerçekten gerekliyse yürütmek istediğiniz pahalı bir hesaplamanız varsa, pahalı işlevi bir Func<TResult> temsilciye atayabilirsiniz. Daha sonra işlevin yürütülmesi, değere erişen bir özellik bir ifadede kullanılana kadar geciktirilebilir. Sonraki bölümdeki örnekte bunun nasıl yapıldığını gösterilmektedir.

Uzantı Metotları

GetMethodInfo(Delegate)

Belirtilen temsilci tarafından temsil edilen yöntemi temsil eden bir nesnesi alır.

Şunlara uygulanır

Ayrıca bkz.

• Lambda İfadeleri (C# Programlama Kılavuzu)
• Lambda İfadeleri: fun Anahtar Sözcüğü (F#)
• Lambda İfadeleri
• Temsilciler (C# Programlama Kılavuzu)
• Temsilciler (F#)
• Visual Basic'deki temsilciler