Passando apenas um tipo como parâmetro em C #

Hipoteticamente, seria útil para mim fazer isso:

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

onde o método GetColumns chamará um método diferente dentro, dependendo do tipo passado.

Sim, eu poderia fazê-lo como uma bandeira booleana ou similar, apenas me perguntava se havia uma maneira de talvez passar por isso e depois perguntar:

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

Eu também poderia substituir o método, usar genéricos, etc. - eu sei que existem diferentes maneiras de fazer isso, fiquei curioso para saber se isso era possível.

Existem duas abordagens comuns. Primeiro, você pode passarSystem.Type

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

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

Isso seria chamado como: int val = (int)GetColumnValue(columnName, typeof(int));

A outra opção seria usar genéricos:

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

Isso tem a vantagem de evitar o boxe e fornecer algum tipo de segurança, e seria chamado como: int val = GetColumnValue<int>(columnName);

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

Como alternativa, você pode usar um método genérico:

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

e você poderia usá-lo como:

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

Você pode passar um tipo como argumento, mas para fazer isso, você deve usar typeof:

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

O método teria de aceitar um parâmetro com o tipo Type.

onde o método GetColumns chamará um método diferente dentro, dependendo do tipo passado.

Se você deseja esse comportamento, não deve passar o tipo como argumento, mas sim usar um parâmetro de tipo.

foo.GetColumnValues<int>(dm.mainColumn)

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

Ou usando genéricos:

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

Você pode fazer isso, apenas envolva-o typeof()

foo.GetColumnValues(typeof(int))

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

Você pode usar um argumento do tipo Type - iow, pass typeof (int). Você também pode usar genéricos para uma abordagem (provavelmente mais eficiente).

Use 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;
    }
}

E chame assim:

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