Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Func<T1, T2, T3, T4, TResult>-Delegat

 

Veröffentlicht: Oktober 2016

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

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(
	T1 arg1,
	T2 arg2,
	T3 arg3,
	T4 arg4
)

Parameter

arg1
Type: T1

Der erste Parameter der Methode, die dieser Delegat kapselt.

arg2
Type: T2

Der zweite Parameter der Methode, die dieser Delegat kapselt.

arg3
Type: T3

Der dritte Parameter der Methode, die dieser Delegat kapselt.

arg4
Type: T4

Der vierte Parameter der Methode, die dieser Delegat kapselt.

Rückgabewert

Type: TResult

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

Typparameter

inT1

Der Typ des ersten Parameters der Methode, die dieser Delegat kapselt.

inT2

Der Typ des zweiten Parameters der Methode, die dieser Delegat kapselt.

inT3

Der Typ des dritten Parameters der Methode, die dieser Delegat kapselt.

inT4

Der Typ des vierten Parameters der Methode, die dieser Delegat kapselt.

outTResult

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

Sie können diesen Delegaten verwenden, um eine Methode darzustellen, die als Parameter übergeben werden kann, ohne explizit einen benutzerdefinierten Delegaten zu deklarieren. Der gekapselte Methode muss der Methodensignatur entsprechen, die von diesem Delegaten definiert ist. Dies bedeutet, dass der gekapselte Methode vier Parameter verfügen muss, von die jeder Wert übergeben wird, und einen Wert zurückgegeben werden muss.

System_CAPS_noteHinweis

Um eine Methode zu verweisen, die über vier Parameter verfügt und gibt void (oder in Visual Basic deklariert wird als eine Sub sondern als eine Function), verwenden Sie die generischen Action<T1, T2, T3, T4> stattdessen delegieren.

Bei Verwendung der Func<T1, T2, T3, T4, TResult> Delegaten, Sie müssen nicht explizit einen Delegaten definieren, der eine Methode mit vier Parametern kapselt. Der folgende Code deklariert beispielsweise explizit einen generischen Delegaten mit dem Namen Searcher und weist einen Verweis auf die IndexOf Methode, um eine Delegatinstanz.

using System;

delegate int Searcher(string searchString, int start, int count, 
                         StringComparison type);

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Searcher finder = title.IndexOf;
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters, 
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.", 
                              position, title);
         }
      } while (position > 0);
   }
}

Im folgende Beispiel wird dieser Code vereinfacht, durch die Instanziierung der Func<T1, T2, T3, T4, TResult> Delegaten nicht explizit einen neuen Delegaten definieren und eine benannte Methode zugewiesen wird.

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder = title.IndexOf;
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters, 
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.", 
                              position, title);
         }
      } while (position > 0);
   }
}

Sie können die Func<T1, T2, T3, T4, TResult> -Delegaten mit anonymen Methoden in c#, wie im folgenden Beispiel veranschaulicht. (Eine Einführung in anonyme Methoden finden Sie unter Anonyme Methoden (C#-Programmierhandbuch).)

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder = 
           delegate(string s, int pos, int chars, StringComparison type) 
           { return title.IndexOf(s, pos, chars, type); };
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters, 
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.", 
                              position, title);
         }
      } while (position > 0);
   }
}

Sie können auch einen Lambda-Ausdruck zuweisen einer Func<T1, T2, T3, T4, TResult> zu delegieren, wie im folgenden Beispiel veranschaulicht. (Eine Einführung in Lambda-Ausdrücke finden Sie unter Lambda Expressions (Visual Basic) und Lambda-Ausdrücke (C#-Programmierhandbuch).)

using System;

public class DelegateExample
{
   public static void Main()
   {
      string title = "The House of the Seven Gables";
      int position = 0;
      Func<string, int, int, StringComparison, int> finder = 
           (s, pos, chars, type) => title.IndexOf(s, pos, chars, type); 
      do
      {
         int characters = title.Length - position;
         position = finder("the", position, characters, 
                         StringComparison.InvariantCultureIgnoreCase);
         if (position >= 0)
         {
            position++;
            Console.WriteLine("'The' found at position {0} in {1}.", 
                              position, title);
         }
      } while (position > 0);
   }
}

Der zugrunde liegende Typ eines Lambda-Ausdrucks ist einer der generischen Func Delegaten. Dadurch können einen Lambda-Ausdruck als Parameter zu übergeben, ohne explizit einen Delegaten zugewiesen werden. Insbesondere, da viele Methoden von Typen in der System.Linq -Namespace haben Func Parameter können übergeben dieser Methoden einen Lambda-Ausdruck ohne explizit zu instanziieren einer Func delegieren.

Im folgenden Beispiel wird veranschaulicht, wie deklarieren und Verwenden einer Func<T1, T2, TResult> delegieren. Dieses Beispiel deklariert eine Func<T1, T2, TResult> Variable und weist sie einen Lambda-Ausdruck, der verwendet ein String Wert und einen Int32 Wert als Parameter. Der Lambda-Ausdruck gibt true Wenn die Länge des der String Parameter ist gleich dem Wert von der Int32 Parameter. Der Delegat, der diese Methode kapselt, wird anschließend in einer Abfrage zum Filtern von Zeichenfolgen in einem Array von Zeichenfolgen verwendet.

using System;
using System.Collections.Generic;
using System.Linq;

public class Func3Example
{
   public static void Main()
   {
      Func<String, int, bool> predicate = (str, index) => str.Length == index;

      String[] words = { "orange", "apple", "Article", "elephant", "star", "and" };
      IEnumerable<String> aWords = words.Where(predicate).Select(str => str);

      foreach (String word in aWords)
         Console.WriteLine(word);
   }
}

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 3.5
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: