Question

我有一个带有 100 + - 公共静态方法的课程，我想每次限制一次静态调用，是否有任何使用实现此功能的技巧几行代码？ 像一些类属性来实现这个？

像这样：

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

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

对不起，我似乎发布了一些误导性的标题。我的真正目的是找到一种方法来减少编码，以便通过向每个函数添加 lock 语句来实现相同的结果。

解决

我最后通过将 lock 语句添加到每个函数来解决了这个问题，但是使用下面的宏为我做了重复工作。

''
'' 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

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

C＃每次使用100+静态方法限制一个静态调用

解决

3 个答案: