Chamar métodos virtuais descendentes de método estático

Question

Primeiro vamos estabelecer isso.

Eu tenho

public abstract class Foo
{
  public static void StaticMethod()
  {
  }
}
public class Bar : Foo
{
}

é válido para chamar

Bar.StaticMethod();

???

Se assim for, vamos expandir exemplo anterior:

public abstract class Foo
{
  public static void StaticMethod()
  {
  }
  public abstract void VirtualMethod();
}
public class Bar : Foo
{
  public override void VirtualMethod()
  {
     Trace.WriteLine("virtual from static!!!!");
  }
}

Como devo construir StaticMethod na classe base para que eu possa usar VirtualMethod de classes derivadas? Parece que eu tinha muito pouca / muita cafeína hoje e nada me vem à mente aqui.

Hm, eu sei que eu não pode invocar método de instância de método estático. Portanto, a questão é esta:

Posso criar instância da classe derivada de método estático da classe base. Ao usar algo como:

  public static void StaticMethod()
  {
    derived d=new derived();
    d.VirtualMethod();
  }

Eu inventei nova palavra-chave, derivada, com o propósito de ilustração.

BTW, eu irá favorecer não-reflexão solução baseada aqui!

Answer 1

Para chamar um método não estático de um método estático, você tem que fornecer uma instância como o método estático não é obrigado a this

Em seguida, após a sua edição, sua pergunta me fez pensar na curiosamente recorrente template padrão em C ++.

Eu nunca me tentou usá-lo em C #, mas você tem ter um olhar aqui , que lhe daria algo como:

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication3
{
  public abstract class Foo<T> where T : Foo<T>, new()
  {
    public static void StaticMethod()
    {
      T t = new T();
      t.VirtualMethod();
    }

    public abstract void VirtualMethod();
  }

  public class Bar : Foo<Bar>
  {
    public override void VirtualMethod()
    {
      System.Console.WriteLine("virtual from static!!!!");
    }
  }
  class Program
  {
    static void Main(string[] args)
    {
      Bar.StaticMethod();
    }
  }
}

e imprime a mensagem "virtual from static!!!!" destina no console.

Answer 2

é válido para chamar Bar.StaticMethod (); ???

Sim, chamando Bar.StaticMethod é legal, e simplesmente se comporta como se você chamou Foo.StaticMethod.

Posso criar instância da classe derivada de método estático da classe base.

OK, eu acho que entendo o que você quer. Você deseja chamar um método estático e tê-lo criar uma instância de uma classe ARBITRÁRIO derivada, e, em seguida, chamar um método em que a classe, sim?

Use genéricos.

abstract class Foo 
{
    public static void DoBlah<T>() where T : Foo, new()
    {
        T t = new T();
        t.Blah();
    }
    public abstract void Blah();
}
class Bar : Foo
{ 
    public Bar() {}
    public override void Blah() {}
}
...
Foo.DoBlah<Bar>();

Sim?