Comparteix a través de


Converter<TInput,TOutput> Delegado

Definición

Representa un método que convierte un tipo de objeto a otro tipo.

generic <typename TInput, typename TOutput>
public delegate TOutput Converter(TInput input);
public delegate TOutput Converter<in TInput,out TOutput>(TInput input);
public delegate TOutput Converter<TInput,TOutput>(TInput input);
type Converter<'Input, 'Output> = delegate of 'Input -> 'Output
Public Delegate Function Converter(Of In TInput, Out TOutput)(input As TInput) As TOutput 
Public Delegate Function Converter(Of TInput, TOutput)(input As TInput) As TOutput 

Parámetros de tipo

TInput

Tipo de objeto que se va a convertir.

Este parámetro de tipo es contravariante, es decir, puede usar el tipo que haya especificado o cualquier tipo menos derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.
TOutput

Tipo al que se va a convertir el objeto de entrada.

Este parámetro de tipo es covariante, es decir, puede usar el tipo que haya especificado o cualquier tipo más derivado. Si desea obtener más información sobre la covarianza y la contravarianza, consulte Covarianza y contravarianza en genéricos.

Parámetros

input
TInput

Objeto que se va a convertir.

Valor devuelto

TOutput

TOutput que representa el TInput convertido.

Ejemplos

Esta sección contiene dos ejemplos de código. La primera muestra el Converter<TInput,TOutput> delegado con el ConvertAll método de la Array clase y el segundo muestra el delegado con el ConvertAll método de la List<T> clase genérica.

Ejemplo 1

En el ejemplo de código siguiente se define un método denominado PointFToPoint que convierte una PointF estructura en una Point estructura. A continuación, el ejemplo crea una matriz de PointF estructuras, crea un Converter<PointF, Point> delegado (Converter(Of PointF, Point) en Visual Basic) para representar el PointFToPoint método y pasa el delegado al ConvertAll método . El ConvertAll método pasa cada elemento de la lista de entrada al PointFToPoint método y coloca los elementos convertidos en una nueva lista de Point estructuras. Se muestran ambas listas.

#using <System.Drawing.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Collections::Generic;

Point PointFToPoint(PointF pf)
{
    return Point((int) pf.X, (int) pf.Y);
};

void main()
{
    // Create an array of PointF objects.
    array<PointF>^ apf = {
        PointF(27.8F, 32.62F),
        PointF(99.3F, 147.273F),
        PointF(7.5F, 1412.2F) };


    // Display each element in the PointF array.
    Console::WriteLine();
    for each(PointF p in apf)
    {
        Console::WriteLine(p);
    }

    // Convert each PointF element to a Point object.
    array<Point>^ ap = 
        Array::ConvertAll(apf, 
            gcnew Converter<PointF, Point>(PointFToPoint)
        );

    // Display each element in the Point array.
    Console::WriteLine();
    for each(Point p in ap)
    {
        Console::WriteLine(p);
    }
}

/* This code example produces the following output:

{X=27.8, Y=32.62}
{X=99.3, Y=147.273}
{X=7.5, Y=1412.2}

{X=27,Y=32}
{X=99,Y=147}
{X=7,Y=1412}
 */
using System;
using System.Drawing;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create an array of PointF objects.
        PointF[] apf = {
            new PointF(27.8F, 32.62F),
            new PointF(99.3F, 147.273F),
            new PointF(7.5F, 1412.2F) };

        // Display each element in the PointF array.
        Console.WriteLine();
        foreach( PointF p in apf )
            Console.WriteLine(p);

        // Convert each PointF element to a Point object.
        Point[] ap = Array.ConvertAll(apf,
            new Converter<PointF, Point>(PointFToPoint));

        // Display each element in the Point array.
        Console.WriteLine();
        foreach( Point p in ap )
        {
            Console.WriteLine(p);
        }
    }

    public static Point PointFToPoint(PointF pf)
    {
        return new Point(((int) pf.X), ((int) pf.Y));
    }
}

/* This code example produces the following output:

{X=27.8, Y=32.62}
{X=99.3, Y=147.273}
{X=7.5, Y=1412.2}

{X=27,Y=32}
{X=99,Y=147}
{X=7,Y=1412}
 */
Imports System.Drawing
Imports System.Collections.Generic

Public Class Example
    Public Shared Sub Main()
        ' Create an array of PointF objects.
        Dim apf() As PointF = { _
            New PointF(27.8, 32.62), _
            New PointF(99.3, 147.273), _
            New PointF(7.5, 1412.2)  }

        ' Display each element in the PointF array.
        Console.WriteLine()
        For Each p As PointF In apf
            Console.WriteLine(p)
        Next
        
        ' Convert each PointF element to a Point object.
        Dim ap() As Point = Array.ConvertAll(apf, _
            New Converter(Of PointF, Point)(AddressOf PointFToPoint))

        ' Display each element in the Point array.
        Console.WriteLine()
        For Each p As Point In ap
            Console.WriteLine(p)
        Next
    End Sub

    Public Shared Function PointFToPoint(ByVal pf As PointF) _
        As Point

        Return New Point(CInt(pf.X), CInt(pf.Y))
    End Function
End Class
' The example produces the following output:
'       {X=27.8, Y=32.62}
'       {X=99.3, Y=147.273}
'       {X=7.5, Y=1412.2}
'       
'       {X=28,Y=33}
'       {X=99,Y=147}
'       {X=8,Y=1412}

Ejemplo 2

En el ejemplo de código siguiente se define un método denominado PointFToPoint que convierte una PointF estructura en una Point estructura. A continuación, en el ejemplo se crea un List<T> objeto de PointF estructuras, se crea un Converter\<PointF, Point> delegado (Converter(Of PointF, Point) en Visual Basic) para representar el PointFToPoint método y se pasa el delegado al ConvertAll método . El ConvertAll método pasa cada elemento de la lista de entrada al PointFToPoint método y coloca los elementos convertidos en una nueva lista de Point estructuras. Se muestran ambas listas.

#using <System.Drawing.dll>

using namespace System;
using namespace System::Drawing;
using namespace System::Collections::Generic;

Point PointFToPoint(PointF pf)
{
    return Point((int) pf.X, (int) pf.Y);
};

void main()
{
    List<PointF>^ lpf = gcnew List<PointF>();

    lpf->Add(PointF(27.8F, 32.62F));
    lpf->Add(PointF(99.3F, 147.273F));
    lpf->Add(PointF(7.5F, 1412.2F));

    Console::WriteLine();
    for each(PointF p in lpf)
    {
        Console::WriteLine(p);
    }

    List<Point>^ lp = 
        lpf->ConvertAll<Point>(
            gcnew Converter<PointF, Point>(PointFToPoint)
        );

    Console::WriteLine();
    for each(Point p in lp)
    {
        Console::WriteLine(p);
    }
}

/* This code example produces the following output:

{X=27.8, Y=32.62}
{X=99.3, Y=147.273}
{X=7.5, Y=1412.2}

{X=27,Y=32}
{X=99,Y=147}
{X=7,Y=1412}
 */
using System;
using System.Drawing;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<PointF> lpf = new List<PointF>();

        lpf.Add(new PointF(27.8F, 32.62F));
        lpf.Add(new PointF(99.3F, 147.273F));
        lpf.Add(new PointF(7.5F, 1412.2F));

        Console.WriteLine();
        foreach( PointF p in lpf )
        {
            Console.WriteLine(p);
        }

        List<Point> lp = lpf.ConvertAll(
            new Converter<PointF, Point>(PointFToPoint));

        Console.WriteLine();
        foreach( Point p in lp )
        {
            Console.WriteLine(p);
        }
    }

    public static Point PointFToPoint(PointF pf)
    {
        return new Point(((int) pf.X), ((int) pf.Y));
    }
}

/* This code example produces the following output:

{X=27.8, Y=32.62}
{X=99.3, Y=147.273}
{X=7.5, Y=1412.2}

{X=27,Y=32}
{X=99,Y=147}
{X=7,Y=1412}
 */
Imports System.Drawing
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim lpf As New List(Of PointF)

        lpf.Add(New PointF(27.8, 32.62))
        lpf.Add(New PointF(99.3, 147.273))
        lpf.Add(New PointF(7.5, 1412.2))

        Console.WriteLine()
        For Each p As PointF In lpf
            Console.WriteLine(p)
        Next

        Dim lp As List(Of Point) = lpf.ConvertAll( _
            New Converter(Of PointF, Point)(AddressOf PointFToPoint))

        Console.WriteLine()
        For Each p As Point In lp
            Console.WriteLine(p)
        Next

    End Sub

    Public Shared Function PointFToPoint(ByVal pf As PointF) _
        As Point

        Return New Point(CInt(pf.X), CInt(pf.Y))
    End Function
End Class

' This code example produces the following output:
'
'{X=27.8, Y=32.62}
'{X=99.3, Y=147.273}
'{X=7.5, Y=1412.2}
'
'{X=28,Y=33}
'{X=99,Y=147}
'{X=8,Y=1412}

Comentarios

Este delegado lo usa el ConvertAll método de la Array clase y el ConvertAll método de la List<T> clase para convertir cada elemento de la colección de un tipo a otro.

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.

Se aplica a