Pasar solo un tipo como parámetro en C #

Hipotéticamente sería útil para mí hacer esto:

foo.GetColumnValues(dm.mainColumn, int)
foo.GetColumnValues(dm.mainColumn, string)

donde el método GetColumns llamará a un método diferente dentro dependiendo del tipo pasado.

Sí, podría hacerlo como una bandera booleana o similar, solo me preguntaba si había una forma de pasar esto, y luego preguntar:

typeof (arg [1]) o similar ...

También podría anular el método, usar genéricos, etc. Sé que hay diferentes formas de hacerlo, tenía curiosidad por saber si esto era posible.

Hay dos enfoques comunes. Primero, puedes pasarSystem.Type

object GetColumnValue(string columnName, Type type)
{
    // Here, you can check specific types, as needed:

    if (type == typeof(int)) { // ...

Esto se llamaría así: int val = (int)GetColumnValue(columnName, typeof(int));

La otra opción sería usar genéricos:

T GetColumnValue<T>(string columnName)
{
    // If you need the type, you can use typeof(T)...

Esto tiene la ventaja de evitar el boxeo y proporcionar algún tipo de seguridad, y se llamaría así: int val = GetColumnValue<int>(columnName);

foo.GetColumnValues(dm.mainColumn, typeof(string))

Alternativamente, podría usar un método genérico:

public void GetColumnValues<T>(object mainColumn)
{
    GetColumnValues(mainColumn, typeof(T));
}

y luego puedes usarlo como:

foo.GetColumnValues<string>(dm.mainColumn);

Puede pasar un tipo como argumento, pero para hacerlo debe usar typeof:

foo.GetColumnValues(dm.mainColumn, typeof(int))

El método debería aceptar un parámetro con tipo Type .

donde el método GetColumns llamará a un método diferente dentro dependiendo del tipo pasado.

Si desea este comportamiento, no debe pasar el tipo como argumento, sino utilizar un parámetro de tipo.

foo.GetColumnValues<int>(dm.mainColumn)

foo.GetColumnValues(dm.mainColumn, typeof(int));
foo.GetColumnValues(dm.mainColumn, typeof(string));

O usando genéricos:

foo.GetColumnValues<int>(dm.mainColumn);
foo.GetColumnValues<string>(dm.mainColumn);

Puedes hacer esto, solo envuélvelo typeof()

foo.GetColumnValues(typeof(int))

public void GetColumnValues(Type type)
{
    //logic
}

Puede usar un argumento de tipo Type - iow, pass typeof (int). También puede usar genéricos para un enfoque (probablemente más eficiente).

¡Usa tipos genéricos!

  class DataExtraction<T>
{
    DateRangeReport dateRange;
    List<Predicate> predicates;
    List<string> cids;

    public DataExtraction( DateRangeReport dateRange,
                           List<Predicate> predicates,
                           List<string> cids)            

    {
        this.dateRange = dateRange;
        this.predicates = predicates;
        this.cids = cids;
    }
}

Y llámalo así:

  DataExtraction<AdPerformanceRow> extractor = new DataExtraction<AdPerformanceRow>(dates, predicates , cids);