Могу ли я добавить атрибут к функции, чтобы предотвратить повторный вход?

Предопределенного такого атрибута нет. Вы можете создавать новые атрибуты, но это вам не поможет. Проблема в том, что настраиваемый атрибут предотвращает повторный вызов метода, что я не думаю, что это выполнимо.

Оператор блокировки - это не то, что вам нужно, поскольку это приведет к блокировке вызовов и ожиданию, а не к немедленному возврату.

PS: используйте блок try ... finally в приведенном выше примере. В противном случае, если в середине функции возникнет исключение, inFunction1 останется истинным, и все вызовы вернутся немедленно.

Например :

if (inFunction1) 
   return;

try
{
  inFunction1 = true;

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

Я не думаю, что это будет возможно.

Ближайшим будет атрибут «Синхронизировано», но он заблокирует все последующие вызовы.

Вы можете обнаружить, что для этого можно использовать PostSharp - вместе с предложениями Энтони об использовании try / finally. Хотя, скорее всего, это будет неаккуратно. Также подумайте, хотите ли вы, чтобы повторный вход был для каждого потока или для каждого экземпляра. (Могут ли несколько потоков вызывать метод для начала или нет?)

В самом фреймворке ничего подобного нет.

Если это сделано для безопасности потоков, будьте осторожны с этой переменной.

Возможно, другой поток может войти в функцию и пройти проверку до того, как первый поток установит переменную.

Убедитесь, что он помечен как изменчивый:

private volatile bool inFunction1 = false;

Без переписывания сборки и IL вы не сможете создать настраиваемый атрибут, который изменяет код описанным вами способом.

Я предлагаю вместо этого использовать подход, основанный на делегатах, например для функций с одним аргументом:

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

Этот метод принимает функцию для переноса (при условии, что она соответствует Func <TArg, T> - вы можете написать другие варианты или полностью универсальную версию с дополнительными усилиями) и альтернативную функцию для вызова в случае повторного входа. (Альтернативная функция может генерировать исключение или немедленно возвращать и т. д.) Затем во всем коде, где вы обычно вызываете переданный метод, вместо этого вы вызываете делегат, возвращаемый WrapAgainstReentry ().

Вместо того, чтобы использовать bool и устанавливать его напрямую, попробуйте использовать long и 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
}

Это сделает проверку потокобезопасной.

Вы можете создать атрибут PostSharp, чтобы проверить, находится ли имя метода в текущей трассировке стека.

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

Эта тема немного устарела, но я подумал, что стоит перенести ее в 2012 год, потому что эта проблема все еще существует (более или менее). Мне удалось решить эту проблему, используя прокси-объекты, созданные с помощью Reflection.Emit (в частности, с использованием LinFu.DynamicProxy). Статья LinFu старше этой статьи, поэтому я предполагаю, что все, что в ней обсуждается, было актуальным, когда ее спрашивали (и все же почему-то все еще остается сегодня).

Я использовал LinFu, потому что я уже использовал его для других целей, но я уверен, что некоторые из других доступных фреймворков DynamicProxy подойдут вам (например, Castle.DynamicProxy), или вы можете использовать свои собственные на основе Reflection.Emit (не для тех со слабым нравом). Они предоставляют механизм, который выполняет большую часть роли АОП, сохраняя при этом контроль над кодом.

Возможно, вы захотите избежать повторного входа, изменив свой дизайн так, чтобы он никогда не вызывал function1 () до завершения предыдущего вызова. Мне кажется, что сверху не хватает слоя function1 ().