"Magic" constants in C# like PHP has?

Question

I am building a logging control for a C# project and would like to be able to call it with the name of the current source code File, Line, Class, Function, etc. PHP uses "magic constants" that have all of this info: http://php.net/manual/en/language.constants.predefined.php but I don't see anything like that in the C# compiler language.

Am I looking for something that doesn't exist?

You will probably want to look into C# reflection. I don't think C# has anything like those constants, the closest you might be able to get is the C# preprocessor (and I'm not even sure about that). — FrustratedWithFormsDesigner, Jul 19 '10 at 21:25
For `__FUNCTION__`, see [C# version of `__FUNCTION__` macro](http://stackoverflow.com/questions/259536/c-version-of-function-macro). — kennytm, Jul 19 '10 at 21:32
Note that using reflection (`GetCurrentMethod` etc) will suppress inlining, resulting in a performance hit. — Pavel Minaev, Jul 19 '10 at 21:55

Hamish Grubijan · Answer 1 · 2010-07-19T21:43:01.457

2

You can ask the system for a stack trace, and you can use reflection. Details are coming.

__LINE__ 
__FILE__ 
__DIR__ 
__FUNCTION__  (does not really exist in C#) 
__CLASS__
__METHOD__
__NAMESPACE__

This is a start:

http://www.csharp-examples.net/reflection-callstack/
http://www.csharp-examples.net/reflection-calling-method-name/
Assembly.GetExecutingAssembly().FullName
System.Reflection.MethodBase.GetCurrentMethod().Name

You will get better information in Debug (non-optimized) build. PhP might always have access to all that stuff, but it ain't the fastest gun on this planet. Play with it and let me know what is missing.

edited Jul 19 '10 at 21:43

answered Jul 19 '10 at 21:25

Hamish Grubijan

10,562
23
99
147

As all others say, reflection is expensive, so ... do this in Debug Only. In Release you could just hard-code the method name because you know it :) – Hamish Grubijan Jul 20 '10 at 02:45

score 2 · Answer 2 · answered Jul 19 '10 at 21:26

2

The StackTrace/StackFrame classes will give you quite a bit of this, though they can be quite expensive to construct.

answered Jul 19 '10 at 21:26

Will Dean

39,055
11
90
118

score 2 · Accepted Answer · answered Jul 19 '10 at 22:12

Using the StackTrace/StackFrame classes, you can have your control find out where it's been called from, rather than passing it that information:

private static StringBuilder ListStack(out string sType)
{
  StringBuilder sb = new StringBuilder();
  sType = "";

  StackTrace st = new StackTrace(true);
  foreach (StackFrame f in st.GetFrames())
  {
    MethodBase m = f.GetMethod();
    if (f.GetFileName() != null)
    {
      sb.AppendLine(string.Format("{0}:{1} {2}.{3}",
        f.GetFileName(), f.GetFileLineNumber(),
        m.DeclaringType.FullName, m.Name));

      if (!string.IsNullOrEmpty(m.DeclaringType.Name))
        sType = m.DeclaringType.Name;
    }
  }

  return sb;
}

(I used this code to get the call stack of the currently executed method, so it does more than you asked for)

Calling that method to frequently could kill your application performance. — Ben Robinson, Jul 19 '10 at 22:15

score 1 · Answer 4 · answered Jul 19 '10 at 21:32

There are methods to get this type of data. It depends on what data you want.

__CLASS__ : If you want the current classname you'll need to use reflection.

__LINE__ : I'm not sure what "The current line number of the file" means, I'll take a guess and say it's how many lines in the file. That can be done by opening the file and doing a line count. This can be done via the File class, the FileInfo class may also work.

__DIR__ :Getting the directory of the file is done by using the DirectoryInfo class.

__FUNCTION__ and __METHOD__: Function name (method name), this can be retrieved via reflection.

__NAMESPACE__ :Namespace an be retrieved via reflection

re: \_\_LINE\_\_: This would be the line number in the file that the \_\_Line\_\_ call appears on. — Brian S, Jul 19 '10 at 21:34

Brian S · Answer 5 · 2010-07-19T21:39:22.683

Using Type, the best you can really do is get information about the current class. There is no means to get the file (though you should generally stick to one class per file), nor line number, nor function using Type.

Getting a type is simple, for example, this.getType(), or typeof(MyClass).

You can get the more specific details by generating a StackTrace object and retrieving a StackFrame from it, but doing so repeatedly is a bad idea.

I think a more important question is perhaps: why do you need them? For trace debugging, your output is supposedly temporary, so whether it reflects an accurate line number or not shouldn't matter (in fact, I rarely ever include a line number in trace debugging). Visual Studio is also very useful as a true step debugger. What do you really need File, Class, Function, and Line Number for?

Edit: For error checking, use exceptions like they're meant to be used: for exceptional (wrong) cases. The exception will generate a stack trace pointing you right at the problem.

score 0 · Answer 6 · answered Jul 19 '10 at 22:07

Many of the previous responders have provided excellent information; however, I just wanted to point out that accessing the StackFrame is exorbitantly expensive and probably shouldn't be done except for special cases. Those cases being an extremely chatty verbose mode for debugging corner cases or error logging and for an error you probably already have an Exception instance which provides the StackTrace. Your best performance will be as Bring S suggested by using Type. Also as another design consideration logging to the console can slow your application down by several orders of magnitude depending on the volume of data to display. So if there is a console sink having the writer operating on a worker thread helps tremendously.

"Magic" constants in C# like PHP has?

6 Answers6