Quando é melhor usar funções estáticas em ASP.NET?

Question

Eu estive pensando, quando usar funções estáticas, e quando não em ASP.NET?

Quais são as vantagens e desvantagens em usá-los, em vários aspectos, como desempenho, seguindo as boas práticas etc (e muitos mais, o que você sente é relevante).

Answer 1

Contras:

• enfiar questões (funções estáticas não necessitam de uma instância para ser chamado, por isso é fácil de invocá-los a partir de diferentes partes do código e se eles leitura / gravação para um estado compartilhado este estado pode estar corrompido em um multi ambiente Threaded tais como ASP.NET)
• difícil de teste de unidade (como funções estáticas não necessitam de uma instância de objeto, injeção de construtor é significado impossível que a única maneira de dependências Inject é por passá-los como argumentos para a função em si)

Pros:

• desempenho (isto é questionável - na maioria dos casos os ganhos de desempenho será completamente insignificante em comparação com outras partes do código)

Answer 2

Há definitivamente situações onde estática é a solução adequada, como acontece com qualquer aplicativo. Toda vez que você tem algum objeto que deve viver no escopo do aplicativo, e não no escopo da solicitação, deve ser estático e você deve usar métodos estáticos para acesso e manipulá-lo.

Como um exemplo, aqui está um trecho de código que eu escrevi recentemente para uma aplicação ASP.NET, que é essencialmente um cache serializer. Serializers são caros para criar e podemos reutilizar o mesmo por tipo para contanto que nossas vidas aplicação, por isso não há necessidade de perder tempo em cada thread de solicitação para eles:

( Nota: este foi simplificada para demonstrar os aspectos estáticos)

public class XmlSerializerUtility
{
    private static Dictionary<Type, XmlSerializer> serializers = new Dictionary<Type, XmlSerializer>();
    private static object sync = new object();

    public static T Deserialize<T>(string input)
    {
       XmlSerializer xs = GetSerializer(typeof(T));
        using (StringReader sr = new StringReader(input))
        {
            return (T)xs.Deserialize(sr);
        }
    }

    public static XmlDocument Serialize(object input)
    {
        XmlDocument doc = new XmlDocument();
        XmlSerializer xs = GetSerializer(input.GetType());
        using (MemoryStream stream = new MemoryStream())
        {
            xs.Serialize(stream, input);
            stream.Position = 0;
            doc.Load(stream);
        }
        return doc;
    }

    private static XmlSerializer GetSerializer(Type type)
    {
        lock (sync)
        {
            XmlSerializer xs = null;
            if (!serializers.ContainsKey(type))
            {
                xs = new XmlSerializer(type);
                serializers.Add(type, xs);
            }
            else
            {
                xs = serializers[type];
            }
            return xs;
        }
    }
}

Answer 3

A única grande desvantagem para um método estático é que é quase totalmente não-unidade testável. Usuários do método tem que se ligam ao método concreto e não pode vincular a uma abstração, tornando assim fingindo ou zombando difícil, se não impossível.

Esta pode ou não ser um problema, dependendo do código, no entanto.

A outra coisa que você quer observar é que os dados estáticos é universal em todas as solicitações para o servidor.