¿Cuándo es mejor utilizar funciones estáticas en ASP.NET?

Question

Me he estado preguntando, cuándo utilizar funciones estáticas, y cuándo no en ASP.NET?

¿Cuáles son las ventajas y desventajas en el uso de ellos, en varios aspectos como el rendimiento, siguiendo las buenas prácticas, etc (y muchos más, lo que se siente es relevante).

Answer 1

Contras:

• problemas de threads (funciones estáticas no requieren una instancia a ser llamado, por lo que es fácil de invocar a ellos desde diferentes partes del código y si leen / escritura a un estado compartido este estado podrían estar dañados en un multi ambiente -enhebrado tales como ASP.NET)
• difícil de prueba de la unidad (como funciones estáticas no requieren una instancia de objeto, inyección constructor es significado imposible que la única manera de inyectar dependencias es pasando como argumentos de la función en sí)

Pros:

• Rendimiento (esto es cuestionable - en la mayoría de las ganancias de rendimiento casos serán completamente insignificante en comparación con otras partes del código)

Answer 2

Definitivamente, hay situaciones en las estático es la solución adecuada, al igual que con cualquier aplicación. Cada vez que haya algún objeto que debe vivir en el ámbito de aplicación, y no en el ámbito de la petición, debe ser estática y se debe utilizar métodos estáticos para acceder y manipular a él.

A modo de ejemplo, he aquí un fragmento de código que he escrito recientemente para una aplicación ASP.NET, que es esencialmente una memoria caché serializador. Serializadores son caros para crear y podemos volver a utilizar la misma según el tipo durante el tiempo que la vida de la aplicación, así que no hay necesidad de perder tiempo en cada hilo solicitud de ellos:

( Nota: esto ha sido simplificada para demostrar los 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

La única desventaja importante de un método estático es que es casi en su totalidad no unidad comprobable. Los usuarios del método tienen que unirse al método concreto y no se pueden unir a una abstracción, con lo que la falsificación o burlarse difícil, si no imposible.

Esto puede o no puede ser un problema, dependiendo del código, sin embargo.

La otra cosa que desee tener en cuenta es que los datos estática es universal en todas las peticiones al servidor.