Can I add an attribute to a function to prevent reentry?

前端 未结 9 2323
梦谈多话
梦谈多话 2021-02-15 12:26

At the moment, I have some functions which look like this:

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


        
相关标签:
9条回答
  • 2021-02-15 12:55

    Instead of using a bool and setting it directly, try using a long and the Interlocked class:

    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
    }
    

    This will make the check thread safe.

    0 讨论(0)
  • 2021-02-15 12:55

    Without assembly and IL rewriting, there's no way for you to create a custom attribute that modifies the code in the way you describe.

    I suggest that you use a delegate-based approach instead, e.g. for functions of a single argument:

    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;
            }
        };
    }
    

    This method takes the function to wrap (assuming it matches Func<TArg,T> - you can write other variants, or a totally generic version with more effort) and an alternate function to call in cases of reentry. (The alternate function could throw an exception, or return immediately, etc.) Then, throughout your code where you would normally be calling the passed method, you call the delegate returned by WrapAgainstReentry() instead.

    0 讨论(0)
  • 2021-02-15 12:56

    There is no such attribute predefined. You can make new attributes, but that won't help you. The issue is making the custom attribute prevent the method being called again, which I don't think is doable.

    The lock statement is not what you want, since that will cause calls to block and wait, not return immediately.

    PS: use a try ... finally block in the above sample. Otherwise, if an exception is thrown in the middle of the function, inFunction1 will be left true and all calls will return immediately.

    e.g. :

    if (inFunction1) 
       return;
    
    try
    {
      inFunction1 = true;
    
      // do stuff which might cause function1 to get called
      ...
    }
    finally 
    {
      inFunction1 = false;
    }
    
    0 讨论(0)
  • 2021-02-15 12:56

    If this is for Thread safety you have to be careful with that variable.

    It's possible another thread could come into the function and pass the check before the first thread has set the variable.

    Make sure it's marked volatile like so:

    private volatile bool inFunction1 = false;
    
    0 讨论(0)
  • 2021-02-15 12:58

    You could build a PostSharp attribute to check to see if the name of the method is in the current stack trace

        [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;
        }
    
    0 讨论(0)
  • 2021-02-15 12:59

    This thread is a bit old but I figured it'd be worth bring it into 2012 because this problem still exists (more or less). I was able to solve this problem using proxy objects generated using Reflection.Emit (specifically using LinFu.DynamicProxy). The LinFu article is older than this article so I assume everything it discusses was relevant when it was asked (and yet somehow still today).

    I used LinFu because I was already using it for other purposes, but I'm sure some of the other DynamicProxy frameworks available would work for you (e.g. Castle.DynamicProxy) or you could roll your own based on Reflection.Emit (not for those with weak dispositions). They provide a mechanism that fills a large part of AOP's role while keeping you in control of your code.

    0 讨论(0)
提交回复
热议问题