Func<TResult> Temsilci

Tanım

generic <typename TResult>
public delegate TResult Func();

public delegate TResult Func<out TResult>();

public delegate TResult Func<TResult>();

type Func<'Result> = delegate of unit -> 'Result

Public Delegate Function Func(Of Out TResult)() As TResult 

Public Delegate Function Func(Of TResult)() As TResult 

Tür Parametreleri

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.

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

open System

type LazyValue<'T>(func: Func<'T>) =
    let mutable value = ValueNone

    member _.Value =
        match value with
        | ValueSome v -> v
        | ValueNone ->
            // Execute the delegate.
            let v = func.Invoke()
            value <- ValueSome v
            v

let expensiveOne () =
    printfn "\nExpensiveOne() is executing."
    1

let expensiveTwo (input: string) =
    printfn "\nExpensiveTwo() is executing."
    int64 input.Length

// Note that each lambda expression has no parameters.
let lazyOne = LazyValue(fun () -> expensiveOne ())
let lazyTwo = LazyValue(fun () -> expensiveTwo "apple")

printfn "LazyValue objects have been created."

// Get the values of the LazyValue objects.
printfn $"{lazyOne.Value}"
printfn $"{lazyTwo.Value}"


// The example produces the following output:
//     LazyValue objects have been created.
//
//     ExpensiveOne() is executing.
//     1
//
//     ExpensiveTwo() is executing.
//     5

Public Module Func
   Public Sub Main()
      ' Note that each lambda expression has no parameters.
      Dim lazyOne As New LazyValue(Of Integer)(Function() ExpensiveOne())
      Dim lazyTwo As New LazyValue(Of Long)(Function() ExpensiveTwo("apple")) 

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

      ' Get the values of the LazyValue objects.
      Console.WriteLine(lazyOne.Value)
      Console.WriteLine(lazyTwo.Value)
   End Sub

   Public Function ExpensiveOne() As Integer
      Console.WriteLine()
      Console.WriteLine("ExpensiveOne() is executing.")
      Return 1
   End Function

   Public Function ExpensiveTwo(input As String) As Long
      Console.WriteLine() 
      Console.WriteLine("ExpensiveTwo() is executing.")
      Return input.Length
   End Function
End Module

Public Class LazyValue(Of T As Structure)
   Private val As Nullable(Of T)
   Private getValue As Func(Of T)

   ' Constructor.
   Public Sub New(func As Func(Of T))
      Me.val = Nothing
      Me.getValue = func
   End Sub

   Public ReadOnly Property Value() As T
      Get
         If Me.val Is Nothing Then
            ' Execute the delegate.
            Me.val = Me.getValue()
         End If   
         Return CType(val, T)
      End Get
   End Property
End Class

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.

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.

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

open System.IO

type WriteMethod = delegate of unit -> bool

type OutputTarget() =
    member _.SendToFile() =
        try
            let fn = Path.GetTempFileName()
            use sw = new StreamWriter(fn)
            sw.WriteLine "Hello, World!"
            true
        with _ ->
            false

let output = new OutputTarget()
let methodCall = WriteMethod output.SendToFile
if methodCall.Invoke() then
    printfn "Success!"
else
    printfn "File write operation failed."

Imports System.IO

Delegate Function WriteMethod As Boolean

Module TestDelegate
   Public Sub Main()
      Dim output As New OutputTarget()
      Dim methodCall As WriteMethod = AddressOf output.SendToFile
      If methodCall() Then 
         Console.WriteLine("Success!")
      Else
         Console.WriteLine("File write operation failed.")
      End If      
   End Sub
End Module

Public Class OutputTarget
   Public Function SendToFile() As Boolean
      Try
         Dim fn As String = Path.GetTempFileName
         Dim sw As StreamWriter = New StreamWriter(fn)
         sw.WriteLine("Hello, World!")
         sw.Close      
         Return True
      Catch
         Return False
      End Try
   End Function
End Class

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.

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

open System
open System.IO

type OutputTarget() =
    member _.SendToFile() =
        try
            let fn = Path.GetTempFileName()
            use sw = new StreamWriter(fn)
            sw.WriteLine "Hello, World!"
            true
        with _ ->
            false

let output = OutputTarget()
let methodCall = Func<bool> output.SendToFile
if methodCall.Invoke() then
    printfn "Success!"
else
    printfn "File write operation failed."

Imports System.IO

Module TestDelegate
   Public Sub Main()
      Dim output As New OutputTarget()
      Dim methodCall As Func(Of Boolean) = AddressOf output.SendToFile
      If methodCall() Then 
         Console.WriteLine("Success!")
      Else
         Console.WriteLine("File write operation failed.")
      End If      
   End Sub
End Module

Public Class OutputTarget
   Public Function SendToFile() As Boolean
      Try
         Dim fn As String = Path.GetTempFileName
         Dim sw As StreamWriter = New StreamWriter(fn)
         sw.WriteLine("Hello, World!")
         sw.Close      
         Return True
      Catch
         Return False
      End Try
   End Function
End Class

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.)

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#).)

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

open System
open System.IO

type OutputTarget() =
    member _.SendToFile() =
        try
            let fn = Path.GetTempFileName()
            use sw = new StreamWriter(fn)
            sw.WriteLine "Hello, World!"
            true
        with _ ->
            false

let output = OutputTarget()
let methodCall = Func<bool>(fun () -> output.SendToFile())
if methodCall.Invoke() then
    printfn "Success!"
else
    printfn "File write operation failed."

Imports System.IO

Module TestDelegate
   Public Sub Main()
      Dim output As New OutputTarget()
      Dim methodCall As Func(Of Boolean) = Function() output.SendToFile()
      If methodCall() Then 
         Console.WriteLine("Success!")
      Else
         Console.WriteLine("File write operation failed.")
      End If      
   End Sub
End Module

Public Class OutputTarget
   Public Function SendToFile() As Boolean
      Try
         Dim fn As String = Path.GetTempFileName
         Dim sw As StreamWriter = New StreamWriter(fn)
         sw.WriteLine("Hello, World!")
         sw.Close      
         Return True
      Catch
         Return False
      End Try
   End Function
End Class

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ı

Ş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