Me gustaría enviar un genérico de tipo convertidor de función a un método, pero no puedo averiguar cómo hacerlo.

Aquí la sintaxis no válida que explique lo que me gustaría lograr, el problema es que no sé cómo especificar el tipo genérico junto con mi func:

public void SomeUtility(Func<T><object,T> converter)
{
    var myType = converter<MyType>("foo");
}

Editar (ver también mi discusión en los comentarios con Lawrence) : Por «genérico del convertidor del tipo» quiero decir que me gustaría pasar un convertidor que puede convertir a cualquier tipo fuerte <T> (no objeto), por lo que la siguiente línea en el método podría ser:

var myOtherType = converter<MyOtherType>("foo");

El delegado me gusta pasar como parámetro sería algo como esto:

private delegate TOutput myConverterDelegate<TOutput>(object objectToConvert);

Esto es más una sintaxis /C# la exploración de ahora, para hacer las cosas, probablemente voy a utilizar una interfaz en lugar de eso, pero espero que esto es posible de lograr con una func/delegado.

  • Es el hecho de que usted haya especificado un tipo dentro del cuerpo del método significativo? Eres lo que implica este método puede necesitar para hacer las conversiones en contra de varios tipos, en lugar de un tipo específico definido por la persona que llama?
  • Sí, eso fue lo que traté de expresar como un «tipo genérico converter» así que la próxima línea podría ser var myOtherType = converter<MyOtherType>(«foo»);
  • Ok – entonces creo que voy a encontrar mi respuesta útil 🙂
InformationsquelleAutor joeriks | 2012-09-25

4 Comentarios

  1. 23

    Usted no puede tener instancias de funciones genéricas o acciones – todo tipo de parámetros se definen por adelantado y no puede ser redefinido por el autor de la llamada.

    Una manera fácil sería evitar el polimorfismo totalmente por depender de abajo-casting:

    public void SomeUtility(Func<Type, object, object> converter)
    {
        var myType = (MyType)converter(typeof(MyType), "foo");
    }

    Si quieres que tipo de seguridad, es necesario diferir la definición de los parámetros de tipo para la persona que llama. Usted puede hacer esto mediante la composición de un método genérico dentro de una interfaz:

    public void SomeUtility(IConverter converter)
    {
        var myType = converter.Convert<MyType>("foo");
    }
    
    interface IConverter
    {
       T Convert<T>(object obj);
    }

    Edición:

    Si el «tipo de convertidor» que se conoce en la convocatoria el lugar, y sólo este tipo se utiliza en el método de utilidad, a continuación, puede definir un tipo genérico sobre el método y el uso que, al igual que otros carteles han sugerido.

    • Ok gracias, sí, yo probablemente sólo tiene que utilizar una interfaz, gracias por señalarme a esa dirección. Pero, fuera de interés, no un delegado / a func ser capaz de pasar de un tipo genérico? Descrito como un delegado supongo que me gustaría escribir como : privado delegado TOutput myConverterDelegate<TOutput>(objeto objectToConvert); pero cuando trato de usar que como un parámetro, aparece el mensaje «requiere 1 tipo de argumentos»
    • Sin duda se puede definir el genérico de los delegados, después de todo, eso es exactamente lo que Func y la Acción. Ellos son tratados como genérico definiciones, como genérico de interfaces y clases. Sin embargo, usted no puede utilizar genérico definiciones en el método de firmas, sólo con parámetros tipos genéricos. Simplemente no puede hacer lo que usted está tratando de lograr con un delegado por sí solo.
  2. 16
    public void SomeUtility<T>(Func<object, T> converter)
    {
        var myType = converter("foo");
    }

    y luego:

    SomeUtility(arg => new MyType());

    El tipo genérico de inferencia funcionará en este caso.

    • este debería ser aceptado
  3. 7

    Que usted necesita para hacer SomeUtility genérico así. Haciendo esto y la fijación de la sintaxis da:

    public void SomeUtility<T>(Func<object,T> converter)
    {
        var myType = converter("foo");
    }
  4. 3

    Usted tiene que saber la T de tipo en tiempo de compilación para usarlo. El T puede ser especificado a nivel de clase o a nivel de método.

    class SomeClass<T> {
        public void SomeUtility(Func<object, T> converter) {
            var myType = converter("foo"); //Already is the T-type that you specified.
        }
    }

    o

    public void SomeUtility<T>(Func<object, T> converter) {
        var myType = converter("foo"); //Already is the T-type that you specified.
    }

Dejar respuesta

Please enter your comment!
Please enter your name here