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

  • Pergunta

  • 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?

    segunda-feira, 8 de junho de 2015 12:42

Respostas

  • Boa tarde.

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

    Caso haja necessidade, favor abrir uma nova.

    Excelente tarde.

    • Marcado como Resposta Cristopher C I_ quinta-feira, 18 de junho de 2015 19:42
    quinta-feira, 18 de junho de 2015 19:42

Todas as Respostas

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

    Abraço!

    segunda-feira, 8 de junho de 2015 12:49
  • 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>();
        }
    }

    segunda-feira, 8 de junho de 2015 13:22
  • 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>();
            }
        }



    segunda-feira, 8 de junho de 2015 13:33
  • 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...

    segunda-feira, 8 de junho de 2015 14:03
  • Seria isso?

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

    segunda-feira, 8 de junho de 2015 19:26
  • 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.

    segunda-feira, 15 de junho de 2015 19:15
  • 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 ?

     

    segunda-feira, 15 de junho de 2015 19:22
  • Boa tarde.

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

    Caso haja necessidade, favor abrir uma nova.

    Excelente tarde.

    • Marcado como Resposta Cristopher C I_ quinta-feira, 18 de junho de 2015 19:42
    quinta-feira, 18 de junho de 2015 19:42
  • 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>()".

    segunda-feira, 22 de junho de 2015 15:37