¿Cuánta computación está detrás de un HttpContext.Current call?

Question

¿Es caro?

Estoy desarrollando un HtmlHelper que la representación directamente en Response.Output con el fin de salvar a la creación innecesaria de cadena y tengo que elegir entre:

<% Validator.RenderClient(Response.Output); %> 

y

<% Validator.RenderClient(); %> 

y obtener el TextWriter de HttpContext.Current.Response

Answer 1

@Dawkins

100 carreras es demasiado pocos, es necesario ejecutar unos 10.000 veces varias veces y repetirlo y luego tomar el promedio de que para obtener un resultado fiable. El margen de error es grande en su ejemplo, pero es el camino correcto a seguir.

Esto es lo que hice:

var results1 = new List<long>(); 
var results2 = new List<long>(); 

for (int j = 0; j < 100; j++) 
{ 
    var sp = new System.Diagnostics.Stopwatch(); 

    // With HttpContext.Current: 
    sp.Start(); 
    for (int i = 0; i < 10000; i++) 
    { 
     HttpContext.Current.Response.Output.Write(i); 
    } 
    sp.Stop(); 

    results1.Add(sp.ElapsedTicks); 

    // Without: 
    TextWriter output2 = HttpContext.Current.Response.Output; 
    sp.Reset(); 

    sp.Start(); 
    for (int i = 0; i < 10000; i++) 
    { 
     output2.Write(i); 
    } 
    sp.Stop(); 

    HttpContext.Current.Response.Clear(); 

    results2.Add(sp.ElapsedTicks); 
} 

results1.Sort(); 
results2.Sort(); 

HttpContext.Current.Response.Write(string.Format("HttpContext.Current={0:0.000}ms, Local variable={1:0.000}ms, R={2:0.0%}<br/>", results1[results1.Count/2]/(double)TimeSpan.TicksPerMillisecond, results2[results2.Count/2]/(double)TimeSpan.TicksPerMillisecond, (double)results1[results1.Count/2]/(double)results2[results2.Count/2])); 

El resultado muestra que hay una diferencia de rendimiento del 18%, lo que demuestra que es más caro, pero si fuera en un 8%.

Volví a ejecutar los números varias veces y obtuve una diferencia del 10% con un margen de error inferior al 1%.

Se stablaizes en torno a:

HttpContext.Current=0,536ms, Local variable=0,486ms, R=110,2% 

De todos modos, HttpContext.Current a plantear un problema significativo el rendimiento que necesita para llamarlo el camino más de 10.000 según la petición (el costo está compuesto en gran parte por la respuesta. Escribir llamadas). Y eso probablemente no va a suceder.

Answer 2

del reflector

public static HttpContext get_Current() 
{ 
    return (ContextBase.Current as HttpContext); 
} 

llamadas ContextBase que exige

public static object HostContext 
{ 
    get 
    { 
     object hostContext = 
      Thread.CurrentThread.GetIllogicalCallContext().HostContext; 
     if (hostContext == null) 
     { 
      hostContext = GetLogicalCallContext().HostContext; 
     } 
     return hostContext; 
    } 

...

así que hay un poco de enhebrar 'cosas' pasando; el específico que realmente no sé.

Answer 3

No es intensivo en absoluto. No sé por qué no lo probé la primera vez:

 System.Diagnostics.Stopwatch sp = new System.Diagnostics.Stopwatch(); 

     // With HttpContext.Current: 
     sp.Start(); 
     for (int i = 0; i < 100; i++) 
     { 
      HttpContext.Current.Response.Output.Write(i.ToString()); 
     } 
     sp.Stop(); 
     long result1 = sp.ElapsedTicks; 

     // Without: 
     TextWriter output2 = HttpContext.Current.Response.Output; 
     sp.Reset(); 
     sp.Start(); 
     for (int i = 0; i < 100; i++) 
     { 
      output2.Write(i.ToString()); 
     } 
     sp.Stop(); 
     long result2 = sp.ElapsedTicks; 

Y mis resultados de la computadora son en torno a:

resultado1 = 395 garrapatas result2 = 332 garrapatas

Por lo tanto, es ¡muy rápido!