Métodos Estáticos Genéricos Inteligentes - Que identifiquem a classe que chama como o tipo genérico

Question

Olá, eu escrevi um código aonde uma classe possui métodos estáticos. Eu quero que, quando eu derivar a classe eu possa chamar estes métodos sem passar o atributo do TIPO, pois deverá assumir o tipo como a classe que chama o método.

Exemplo:

public class BaseClass<T> where T, new()
{
    public static h method<h>() where h : BaseClass<T>, new() { /* RETURN SOMETHING */ }
}

public class Child : BaseClass<decimal> { }

public class ABC : Child
{
    public void Test()
    {
        var iABC = ABC.method();
        //ao invés de: var iABC = ABC.method<ABC>();
    }
}

Como faço isso?

Answer 1

Olá, pelo que eu entendi você quer que o método estático retorne uma instancia da classe "BaseClass<T>"?

Abraço!

Answer 2

Não. O que o método faz na BaseClass eu já escrevi e funciona. Eu quero "camuflar" a chamada genérica nas classes filhas, não precisando informar o tipo, pois ele será a própria classe que chama o método.

Veja, um exemplo real seria:

public class Rec
{
    public string Name { get; set; }
    public override string ToString() { return this.Name; }

    public virtual void Load() { /* HERE IT READS A TEXT FILE AND LOAD THE NAME */ }
}

public class BaseClass<T> : Rec
{
    public T Argument { get; set; }
    public override void Load() { /* NOW IT LOADS ALSO THE ARGUMENT */ }

    public static H Method<H>() where H : Rec, new()
    {
        H iH = new H();
        iH.Load();
        iH.Name += " " + iH.Argument.ToString();
        return iH;
    }
}

public class Child : BaseClass<string> { }

public class SomeOtherClass
{
    public void Test()
    {
        Child i = Child.Method();
        //instead of Child.Method<Child>();
    }
}

Answer 3

Da uma olhada se é isso que tu precisa.

 public class BaseClass<T, H> : Rec where H : Rec, new()
    {
        public T Argument { get; set; }
        public override void Load() { /* NOW IT LOADS ALSO THE ARGUMENT */ }

        public virtual static H Method()
        {
            H iH = new H();
            iH.Load();
            iH.Name += " " + iH.Argument.ToString();
            return iH;
        }
    }

    public class Child : BaseClass<string, TIPODESEJADO>
    {
        public static override TIPODESEJADO Method()
        {
            return base.Method();
        }
    }

    public class SomeOtherClass
    {
        public void Test()
        {
            var i = Child.Method();
            //instead of Child.Method<Child>();
        }
    }

Answer 4

O Bruno, obrigado pela resposta.

É isso, mas eu não posso usar esta solução. Essa classe foi um exemplo, a real tem pra mais de 200 métodos, quase tudo genérico... rsrsrs

A minha ideia foi justamente usar uma classe básica abstrata com vários métodos genéricos, para que as classes filhas apenas os derivem...

Answer 5

Seria isso?

http://blog.caelum.com.br/parametros-opcionais-e-nomeados-do-c/

Answer 6

Helder, obrigado - mas não... não é isso.

Isso que está descrito no blog eu já faço sim, mas não soluciona esse ponto.

Answer 7

Helder, obrigado - mas não... não é isso.

Isso que está descrito no blog eu já faço sim, mas não soluciona esse ponto.

 Olá Sammuel tudo bem,

 confesso que li seu post várias vezes, não entendi muito bem o que necessita, vamos lá você possui uma classe com varios métodos e deseja que ao criar a instância de uma classe qualquer que ela herde todos os metodos de uma classe genérica ? Ou seja essa classe contenha métodos de extensão ?

 

Answer 8

Boa tarde.

Por falta de retorno do usuário, esta thread será encerrada.

Caso haja necessidade, favor abrir uma nova.

Excelente tarde.

Answer 9

Não precisa herdar Daniel (obrigado por responder de novo).

O que eu quero é que, na classe "ABC" do meu exemplo eu possa chamar o método usando "ABC.method()", ao invés de precisar chamar "ABC.method<ABC>()". O método tem um argumento genérico, que quero omitir, de forma que o argumento genérico seja sempre a classe que está chamando.

Faça o seguinte, pegue o exemplo que escrevi no post, coloque-o - exatamente como está - no Visual Studio e tente compilar. Você receberá um erro dizendo para passar um Tipo para o método ("ABC.method<AQUI!!!>()"). Eu quero evitar este erro. Se chamei "ABC.Method()" ele deve entender que é "ABC.method<ABC>()", se eu chamar uma classe derivada qualquer como "CDE.Method()", ele deve entender que é "CDE.method<CDE>()".