0

我有一个有100+-公共静态方法的类，我想每次都限制一个静态调用，有没有什么技巧可以用几行代码来实现这一点？ 像一些类属性来实现这一点？

像这样：

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

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

对不起，我似乎发布了一些误导性的标题。我的真正目的是找到一种减少编码的方法，以通过在每个函数中添加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
4

3 回答 3

1

您可以将以下属性添加到每个静态方法：

[MethodImpl(MethodImplOptions.Synchronized)]

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

lock (typeof(Test))
{
    ...
}
于 2013-06-03T10:28:16.393 回答
0 
// 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 关键字），并在该静态对象上添加锁定语句在所有方法中一次执行一个

于 2013-06-03T04:04:02.243 回答
0

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

于 2013-06-03T05:59:31.140 回答