variable - interface where t class c#

¿Hay una etiqueta genérica "anónima" en C#, como ''?'' en Java?

Question

En Java, uno puede declarar una variable parametrizada por un tipo genérico "desconocido", que se ve así:

Foo<?> x;

¿Hay una construcción equivalente a este signo de interrogación, en C #?

Answer 1

AFAIK no puedes hacer eso en C #. Lo que hace el BCL y hay una gran cantidad de ejemplos para crear una clase que no sea genérica y luego crear una clase genérica que hereda el comportamiento base del anterior. Vea el ejemplo a continuación.

class Foo
{
}

class Foo<T> : Foo
{
}

El puedes escribir algo como esto:

Foo t = new Foo<int>();

Answer 2

No hay una sintaxis equivalente en C #.

Answer 3

No, no hay realmente el mismo concepto en C #. Tendrías que consultar una clase base de Foo (quizás un Foo no genérico), o hacer que el método en el que trabajas sea genérico en sí mismo (para que puedas referirte a Foo y dejar que el que llama de tu método determine qué T es).

Espero que ayude.

Answer 4

Si bien es cierto que no es el enfoque limpio, el uso de Foo<object> x también puede ser adecuado.

Answer 5

La respuesta corta es no. No hay una característica equivalente en C #.

Una solución, desde C # desde la perspectiva de un desarrollador de Java por Dare Obasanjo:

En ciertos casos, se puede necesitar crear un método que pueda operar en estructuras de datos que contengan cualquier tipo, en oposición a las que contienen un tipo específico (por ejemplo, un método para imprimir todos los objetos en una estructura de datos) mientras se aprovechan los beneficios de tipificación fuerte en genéricos. El mecanismo para especificar esto en C # es a través de una función llamada inferencia de tipo genérico, mientras que en Java esto se hace usando tipos de comodines. Los siguientes ejemplos de código muestran cómo ambos enfoques conducen al mismo resultado.

C # Code

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

class Test{

    //Prints the contents of any generic Stack by 
    //using generic type inference 
    public static void PrintStackContents<T>(Stack<T> s){
        while(s.Count != 0){
            Console.WriteLine(s.Pop()); 
        } 
    }

    public static void Main(String[] args){

    Stack<int> s2 = new Stack<int>(); 
    s2.Push(4); 
    s2.Push(5); 
    s2.Push(6); 

    PrintStackContents(s2);     

    Stack<string> s1 = new Stack<string>(); 
    s1.Push("One"); 
    s1.Push("Two"); 
    s1.Push("Three"); 

    PrintStackContents(s1); 
    }
}

Código Java

import java.util.*; 

class Test{

    //Prints the contents of any generic Stack by 
    //specifying wildcard type 
    public static void PrintStackContents(Stack<?> s){
        while(!s.empty()){
            System.out.println(s.pop()); 
        }
    }

    public static void main(String[] args){

    Stack <Integer> s2 = new Stack <Integer>(); 
    s2.push(4); 
    s2.push(5); 
    s2.push(6); 

    PrintStackContents(s2);     

    Stack<String> s1 = new Stack<String>(); 
    s1.push("One"); 
    s1.push("Two"); 
    s1.push("Three");   

    PrintStackContents(s1); 
    }
}

Answer 6

No es (bastante) cierto que no hay equivalente en C #. No existe un equivalente estático que pueda usar como tipo, o invocar métodos, lo suficientemente cierto. Para eso, usa la respuesta de Jorge .

Por otro lado, a veces necesitas la idea equivalente para la reflexión, y hay un equivalente allí. Si usted tiene:

interface IFoo<T>
{
  T Bar(T t, int n);
}

puede obtener un Type que represente IFoo<int> utilizando typeof(IFoo<int>) . Menos conocido, y una respuesta parcial a su pregunta, es que también puede obtener un Type que representa IFoo<T> utilizando typeof(IFoo<>) .

Esto es útil cuando quiere utilizar IFoo<T> para algunos T través de la reflexión y no conocerá T hasta el tiempo de ejecución.

Type theInterface = typeof(IFoo<>);
Type theSpecificInterface = theInterface.MakeGenericType(typeof(string));

// theSpecificInterface now holds IFoo<string> even though we may not have known we wanted to use string until runtime

// proceed with reflection as normal, make late bound calls / constructions, emit DynamicMethod code, etc.