有没有办法确定哪个类在.NET中称为静态方法

Question

We have a central STATIC method that get's called from many different locations of our ASP.NET application.

I need to add some conditional logic to the static method that needs to run only if the method was called from a specific class. One approach would be to add an additional parameter to the static method's signature -- some kind of enum that would represent which class called this static method, but I was hoping .NET offered a more elegant approach.

EDIT: See Sample Code below

I am trying to modify how exceptions are handled. Currently, if we are processing 1000 checks, and there is an exception inside the loop at check 500, checks 500 - 1000 will not be processed.

We have several screens on our website that calls this central method. One of them called Check Creation Wizard, another called ACH Creation Wizard, etc. Well for the ACH Creation Wizard, we want to handle exceptions by simply skipping a failed check, and move on to the rest of the checks. However, for all other wizards, we want to continue failing the remaining batch of checks if one fails.

public static string GenerateChecks(List<CheckJob> checkJobs)
{
    foreach (CheckJob check in checkJobs)
    {
        try
        {
            bool didGenerate = DoGenerate(check);
            if(didGenerate)
            {
                Account acct = LoadAccount(check.GetParent());
                ModifyAccount(acct);
                SaveAcct(acct);
            }
        }           
        catch (Exception ex)
        {
            if (Transaction.IsInTransaction)
            {
                Transaction.Rollback();
            }

            throw;
        }
    }
}

Answer 1

This all smells from afar. You can have this in many ways, but detecting the calling class is the wrong way.

Either make a different static method for this specific other class, or have an additional argument.

If you insist on detecting the caller, this can be done in several ways:

1. Use the stack trace:

    var stackFrame = new StackFrame(1); var callerMethod = stackFrame.GetMethod(); var callingClass = callerMethod.DeclaringType; // <-- this should be your calling class if(callingClass == typeof(myClass)) { // do whatever } 

2. If you use .NET 4.5, you can have caller information. Not specifically the class, but you can get the caller name and source file at the time of compilation. Add a parameter with a default value decorated with [CallerMemberName] or [CallerFilePath] , for example:

    static MyMethod([CallerFilePath]string callerFile = "") { if(callerFile != "") { var callerFilename = Path.GetFileName(callerFile); if(callerFilename == "myClass.cs") { // do whatever } } } 

3. Simply use an additional parameter with a default value (or any kind of different signature)

Note that 1 is very slow, and 2 is just awful... so for the better yet: use a different method if you need a different process

Update

---

After watching your code, it's even more clear that you want to have either two different methods or an argument... for example:

public static string GenerateChecks(List<CheckJob> checkJobs, bool throwOnError = true)
{
    //...
    catch (Exception ex)
    {
      if(throwOnError)
      {
        if (Transaction.IsInTransaction)
        {
           Transaction.Rollback();
        }
        throw;
      }
    }
}

And then pass false to that when you want to keep going

Answer 2

You never make a decision on what to do based on who called you. You allow the caller to make that decision by providing a feature .

You want a single method to do two different things on error. So either (1) write two methods, and have the caller decide which one to call, or (2) make the method take a Boolean that changes its behaviour, and have the caller decide which Boolean to pass, true or false.

Answer 3

Adding a parameter is definitely more "elegant". Make the parameter optional (by providing a default value, eg bool and false ) and only execute the special code if the parameter is explicitly set to true.

The alternative, though not as "elegant" as you can read from the comments, would be to search the StackTrace for the calling code.

Answer 4

我想，你可以使用StackTrace类，但这种逻辑并不是很好

Answer 5

You can use StackTrace like this

 static void Main(string[] args)
{
    Do();
}

static void Do()
{
    DosomethingElse();
}

private static void DosomethingElse()
{
    StackTrace stackTrace = new StackTrace();
    foreach (StackFrame Frame in stackTrace.GetFrames())
    {
        Console.WriteLine(Frame);
    }
}

and this would be the output

{DosomethingElse at offset 77 in file:line:column <filename unknown>:0:0}
{Do at offset 37 in file:line:column <filename unknown>:0:0}
{Main at offset 40 in file:line:column <filename unknown>:0:0}
....