Question

假设我有两个功能：

OnlyCalledOnce

是否可以调用DoesNothing并且它实际上运行void DoesNothing(){} void OnlyCalledOnce(){ //lines of code OnlyCalledOnce = DoesNothing; }？我想像这样：

OnlyCalledOnce

最后一行之后，每当我调用DoesNothing时，它将运行df1 <- data.frame(df1 = c("A","B"), col1 = c(0,0), col2 = c(0,0)) source col1 col2 1 A 0 0 2 B 0 0 > df2 <- data.frame(df2 = c("C","D"), col1 = c(0,0), col2 = c(0,0)) index col1 col2 1 C 0 0 2 D 0 0。

有可能吗？

Answer 1

您可以像这样在OnlyCalledOnce中提前返回：（假设您的DoesNothing示例实际上没有任何作用-不需要）

bool initialized = false;

void OnlyCalledOnce()
{
    if (initialized) return;

    // firsttimecode
    initialized = true;
}

initialized变量将在首次运行后为true。

Answer 2

您可以解决此问题的另一种方法是维护代表已调用方法的字符串列表。字符串甚至不必是方法名称，它们只需要对每个方法唯一。

然后，您可以使用一个名为ShouldIRun的辅助方法，该方法接受函数的唯一字符串并检查其是否存在于列表中。如果是这样，则该方法返回false，如果不是，则该方法将字符串添加到列表中并返回true。

这里的好处是，您不必维护一堆状态变量，可以根据需要使用任意数量的方法，并且方法本身不需要任何复杂的逻辑-他们只需询问他们是否应该运行的帮助者！

public class Program
{
    private static List<string> CalledMethods = new List<string>();

    static bool ShouldIRun(string methodName)
    {
        if (CalledMethods.Contains(methodName)) return false;
        CalledMethods.Add(methodName);
        return true;
    }

    // Now this method can use method above to return early (do nothing) if it's already ran
    static void OnlyCalledOnce()
    {
        if (!ShouldIRun("OnlyCalledOnce")) return;

        Console.WriteLine("You should only see this once.");
    }

    // Let's test it out
    private static void Main()
    {
        OnlyCalledOnce();
        OnlyCalledOnce();
        OnlyCalledOnce();

        GetKeyFromUser("\nDone! Press any key to exit...");
    }
}

输出

Answer 3

您尝试使用委托吗？

class Program
{
    private static Action Call = OnlyCalledOnce;

    public static void Main(string[] args)
    {
        Call();
        Call();
        Call();
        Console.ReadKey();
    }

    static void DoesNothing()
    {
        Console.WriteLine("DoesNothing");
    }

    static void OnlyCalledOnce()
    {
        Console.WriteLine("OnlyCalledOnce");
        Call = DoesNothing;
    }
}

Answer 4

如前所述，您可以使用：

private bool isExecuted = false;

void DoesNothing(){}

void OnlyCalledOnce(){
    if (!isExecuted)
    {   
        isExecuted = true;
        //lines of code
        DoesNothing();
    }
}

如果有多个线程等，则可以做一个lock（object）..

Answer 5

您对此有何疑问？

void DoesNothing()
{
}

void OnlyCalledOnce()
{
    DoesNothing();
}

一旦运行OnlyCalledOnce（），它将运行DoesNothing（）

将功能指向另一个

5 个答案: