C#使用100+静态方法限制类中每次静态调用一次

Question

我有一个使用100+-公共静态方法的类，我想每次限制一个静态调用，有什么技巧可以用来实现吗？类似于类属性来实现这一点？

如下所示：

public class Test
{
    public static void A() { }
    public static void B() { }
    public static void C() { }
    public static void D() { }
}

一次只能访问一个静态方法调用。当方法B调用时，必须阻止对其他方法的调用，直到方法B返回为止；

很抱歉，我好像发布了一些误导的标题。我的真正目的是找到一种减少编码的方法，以获得与向每个函数添加锁语句相同的结果。

解出

最后，我通过向每个函数添加锁状态来解决这个问题，但是使用下面的宏为我做了重复的工作。

''
'' edit from Code outlining sample.
''
Sub LoopFunction()
    Dim i As Integer
    Dim fileCM As FileCodeModel
    Dim elts As EnvDTE.CodeElements
    Dim elt As EnvDTE.CodeElement

    fileCM = DTE.ActiveDocument.ProjectItem.FileCodeModel
    elts = fileCM.CodeElements
    For i = 1 To elts.Count
        elt = elts.Item(i)
        EditFunction(elt)
    Next
End Sub

Sub EditFunction(ByVal elt As EnvDTE.CodeElement)

    If (elt.Kind = EnvDTE.vsCMElement.vsCMElementNamespace) Then
        Dim i As Integer
        Dim mems As EnvDTE.CodeElements

        mems = elt.Members
        For i = 1 To mems.Count
            EditFunction(mems.Item(i))
        Next
    ElseIf (elt.Kind = vsCMElement.vsCMElementClass) Then
        Dim i As Integer
        Dim mems As EnvDTE.CodeElements

        mems = elt.Members
        For i = 1 To mems.Count
            EditFunction(mems.Item(i))
        Next
    ElseIf (elt.Kind = vsCMElement.vsCMElementFunction) Then
        Dim epStart As EnvDTE.EditPoint
        Dim epEnd As EnvDTE.EditPoint
        Dim textSelection As EnvDTE.TextSelection

        epStart = elt.GetStartPoint(vsCMPart.vsCMPartBody).CreateEditPoint()
        epEnd = elt.GetEndPoint(vsCMPart.vsCMPartBody).CreateEditPoint()
        textSelection = DTE.ActiveDocument.Selection
        textSelection.MoveToPoint(epEnd)
        textSelection.Insert(NewLine & "}" & NewLine)
        textSelection.MoveToPoint(epStart)
        textSelection.Insert(NewLine & "lock(lockTest){" & NewLine)

    End If

End Sub

Answer 1

可以向每个静态方法添加以下属性：

[MethodImpl(MethodImplOptions.Synchronized)]

对于静态方法，这相当于在每个静态方法中放置以下构造：

lock (typeof(Test))
{
    ...
}

Answer 2

// Static object that can only be instantiated once per class
private readonly static lockObj = new object();

 public static void A() {
     lock(lockObj){
       //.. your code here
     }
    }

 public static void B() {
     lock(lockObj){
       //.. your code here
     }
    }

  public static void C() {
     lock(lockObj){
       //.. your code here
     }
    }

  public static void D() {
     lock(lockObj){
       //.. your code here
     }
    }

其思想是创建一个只能实例化一次的静态对象(通过readonly关键字)，并在每次只执行一次的所有方法中添加该静态对象的锁语句。

Answer 3

这个问题可以归结为一个简单的关键区段问题，其中每个静态函数都有关键代码，一次只能运行一个函数。现在，您可以像信号量一样使用任何标准方法来解决这个问题。在执行函数之前获取锁，在执行后释放锁，以便正在等待的其他函数可以执行。在您的情况下，二进制信号量将完成这项工作。