¿Puedo agregar un atributo a una función para evitar el reingreso?

Question

Por el momento, tengo algunas funciones que tener este aspecto:

private bool inFunction1 = false; 
public void function1() 
{ 
    if (inFunction1) return; 
    inFunction1 = true; 

    // do stuff which might cause function1 to get called 
    ... 

    inFunction1 = false; 
} 

Me gustaría ser capaz de declarar como esto:

[NoReEntry] 
public void function1() 
{ 
    // do stuff which might cause function1 to get called 
    ... 
} 

¿Hay un atributo que puedo añadir a una función para evitar la reentrada? Si no, ¿cómo podría hacer una? He oído acerca de los atributos AOP que se pueden usar para agregar código antes y después de las llamadas a funciones; Serían adecuados?

Answer 1

No existe dicho atributo predefinido. Puedes crear nuevos atributos, pero eso no te ayudará. El problema es hacer que el atributo personalizado impida que se vuelva a llamar al método, lo que no creo posible.

La instrucción de bloqueo no es lo que desea, ya que eso hará que las llamadas se bloqueen y esperen, no se devolverán de inmediato.

PD: use un intento ... finalmente bloquear en la muestra anterior. De lo contrario, si se lanza una excepción en el medio de la función, inFunction1 se dejará en verdadero y todas las llamadas volverán inmediatamente.

p. Ej. :

if (inFunction1) 
    return; 

try 
{ 
    inFunction1 = true; 

    // do stuff which might cause function1 to get called 
    ... 
} 
finally 
{ 
    inFunction1 = false; 
} 

Answer 2

No creo que sea posible.

Lo más cercano será el atributo 'Sincronizado', pero eso bloqueará todas las llamadas posteriores.

Answer 3

Puede encontrar que puede usar PostSharp para lograr esto, junto con las sugerencias de Anthony sobre el uso de try/finally. Sin embargo, es probable que sea complicado. También considere si desea que la reentrada sea por subproceso o por instancia. (¿Pueden varios hilos llamar al método para comenzar, o no?)

No hay nada como esto en el marco mismo.

Answer 4

Si esto es por la seguridad del subproceso, debe tener cuidado con esa variable.

Es posible que otro hilo pueda entrar en la función y pasar la verificación antes de que el primer hilo haya establecido la variable.

asegurarse de que es volátil marcada así:

private volatile bool inFunction1 = false; 

Answer 5

sin montaje e IL volver a escribir, no hay manera para que usted pueda crear un atributo personalizado que modifica el código en la forma en que usted describe.

Sugiero que utilice un enfoque basado en delegado, por ejemplo, para las funciones de un solo argumento:

static Func<TArg,T> WrapAgainstReentry<TArg,T>(Func<TArg,T> code, Func<TArg,T> onReentry) 
{ 
    bool entered = false; 
    return x => 
    { 
     if (entered) 
      return onReentry(x); 
     entered = true; 
     try 
     { 
      return code(x); 
     } 
     finally 
     { 
      entered = false; 
     } 
    }; 
} 

Este método tiene la función de envolver (suponiendo que coincide Func < Targ, T> - puede escribir otras variantes, o una versión totalmente genérico con más esfuerzo) y un suplente función para llamar en casos de reingreso. (La función alternativa podría arrojar una excepción, o regresar inmediatamente, etc.) Luego, a lo largo de su código, donde normalmente estaría llamando al método aprobado, llame al delegado devuelto por WrapAgainstReentry() en su lugar.

Answer 6

En lugar de utilizar un bool y se establece directamente, trate de usar un largo y la clase Interlocked:

long m_InFunction=0; 

if(Interlocked.CompareExchange(ref m_InFunction,1,0)==0) 
{ 
    // We're not in the function 
    try 
    { 
    } 
    finally 
    { 
    m_InFunction=0; 
    } 
} 
else 
{ 
    // We're already in the function 
} 

Esto hará que el hilo de verificación seguro.

Answer 7

Se puede construir un atributo PostSharp comprobar para ver si el nombre del método es en el seguimiento de la pila actual

[MethodImpl(MethodImplOptions.NoInlining)] 
    private static bool IsReEntry() { 
     StackTrace stack = new StackTrace(); 
     StackFrame[] frames = stack.GetFrames(); 

     if (frames.Length < 2) 
      return false; 

     string currentMethod = frames[1].GetMethod().Name; 

     for (int i = 2; i < frames.Length; i++) { 
      if (frames[i].GetMethod().Name == currentMethod) { 
       return true; 
      } 
     } 

     return false; 
    } 

Answer 8

Este hilo es un poco viejo pero pensé que valdría la pena ponerla en 2012 porque este problema todavía existe (más o menos). Pude resolver este problema usando objetos proxy generados usando Reflection.Emit (específicamente usando LinFu.DynamicProxy). El artículo de LinFu es anterior a este artículo, por lo que supongo que todo lo que se discutió fue relevante cuando se lo preguntaron (y aún de alguna manera todavía hoy).

Utilicé LinFu porque ya lo estaba utilizando para otros fines, pero estoy seguro de que algunos de los otros frameworks DynamicProxy disponibles funcionarían para usted (por ejemplo, Castle.DynamicProxy) o podría hacer los suyos propios basados ​​en Reflection.Emit (no para aquellos con disposiciones débiles). Proporcionan un mecanismo que ocupa una gran parte de la función de AOP mientras te mantiene en control de tu código.

Answer 9

Es posible que desee considerar evitar la reentrada modificando su diseño para que nunca llame a function1() antes de que se complete su invocación anterior. Para mí, parece que falta una capa desde arriba function1().