Good things are hard to kill. One of the most useful predefined compiler macros in C/C++ were __FILE__ and __LINE__ which do expand to the compilation units file name and line number where this value is encountered by the compiler. After 4.5 versions of .NET we are on par with C/C++ again. It is of course not a simple compiler expandable macro it is an attribute but it does serve exactly the same purpose.

Now we do get

• CallerLineNumberAttribute  == __LINE__
• CallerFilePathAttribute        == __FILE__
• CallerMemberNameAttribute  == __FUNCTION__ (MSVC Extension)

 

The most important one is CallerMemberNameAttribute which is very useful to implement the INotifyPropertyChanged interface without the need to hard code the name of the property anymore. Now you can simply decorate your change method with the new CallerMemberName attribute and you get the property name as string directly inserted by the C# compiler at compile time.

 

public string UserName
{     
      get {  return _userName;     }     
      set {  _userName=value;        
             RaisePropertyChanged();  // no more RaisePropertyChanged(“UserName”)!   
          }
}

protected void RaisePropertyChanged([CallerMemberName] string member = "")
{   
    var copy = PropertyChanged; 
    if(copy != null)  
    {       
       copy(new PropertyChangedEventArgs(this, member));     
    }
}

Nice and handy. This was obviously the prime reason to implement this feature in the C# 5.0 compiler. You can repurpose this feature for tracing to get your hands on the method name of your caller along other stuff very fast now. All infos are added during compile time which is much faster than other approaches like walking the stack.

The example on MSDN shows the usage of this attribute with an example

public static void TraceMessage(string message, [CallerMemberName] string memberName = "", 
                               [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0) 
{ 
    Console.WriteLine("Hi {0} {1} {2}({3})", message, memberName, sourceFilePath, sourceLineNumber); 
}

 

When I do think of tracing I do usually want to have a API which allows me to

• Trace method enter and leave
• Trace messages with a severity like Info, Warning, Error

When I do print a trace message it is very useful to print out method and type name as well. So your API must either be able to pass the method and type name as strings or extract it automatically via walking back one Stackframe and fetch the infos from there. The first glaring deficiency is that there is no CallerTypeAttribute yet because the C# compiler team was not satisfied with its performance.

 

A usable Trace Api might therefore look like

 

    enum TraceTypes
    {

        None = 0,
        EnterLeave = 1 << 0,
        Info = 1 << 1,
        Warn = 1 << 2,
        Error = 1 << 3
    }

    class Tracer : IDisposable
    {
        string Type;
        string Method;
            
        public Tracer(string type, string method)
        {
            Type = type;
            Method = method;
            if (IsEnabled(TraceTypes.EnterLeave,Type, Method))
            {
            }
        }

        private bool IsEnabled(TraceTypes traceTypes, string Type, string Method)
        {
           // Do checking here if tracing is enabled
            return false;
        }

        public void Info(string fmt, params object[] args)
        {
        }

        public void Warn(string fmt, params object[] args)
        {
        }

        public void Error(string fmt, params object[] args)
        {
        }

        public static void Info(string type, string method, string fmt, params object[] args)
        {
        }

        public static void Warn(string type, string method, string fmt, params object[] args)
        {
        }

        public static void Error(string type, string method, string fmt, params object[] args)
        {
        }

        public void Dispose()
        {
            // trace method leave
        }
    }

This minimal trace API is very fast but hard to maintain since you need to pass in the type and method name as hard coded strings which can change from time to time. But now we have at least CallerMemberName to rid of the explicit method parameter right? Not really. Since any acceptable usable trace Api should have a method signature like Tracexxx(… string fmt, params [] object args) we not able to add additional optional parameters after the args array. If we would put it before the format string we would need to make it optional as well which would mean the compiler would need to figure out what our trace message and arguments are (not likely) or we would need to specify everything explicitly just like before .

There are ways around this by providing a myriad of overloads which in the end are routed to the very same method but that is ugly. I am not sure if nobody inside MS agrees that the above API is reasonable to have or (more likely) that the whole talk about you can use this feature for diagnostic purposes was not a core feature at all but a simple byproduct of making the life of INotifyPropertyChanged implementers easier.

A way around this would be to allow for variable argument arrays after the params keyword another set of optional arguments which are always filled by the compiler but I do not know if this is an easy one.

The thing I am missing much more is the not provided CallerType attribute. But not in the way you would think of. In the API above I did add some filtering based on method and type to stay as fast as possible for types where tracing is not enabled at all. It should be no more expensive than an additional method call and a bool variable check if tracing for this type is enabled at all. The data is tightly bound to the calling type and method and should therefore become part of the static type instance. Since extending the CLR type system for tracing is not something I do expect to happen I have come up with an alternative approach which allows me basically to attach run time data to any existing type object in super fast way. The key to success is the usage of generics.

 

    class Tracer<T> : IDisposable
    {
        string Method;

        public Tracer(string method)
        {
            if (TraceData<T>.Instance.Enabled.HasFlag(TraceTypes.EnterLeave))
            {
            }
        }

        public void Dispose()
        {
            if (TraceData<T>.Instance.Enabled.HasFlag(TraceTypes.EnterLeave))
            {
            }
        }

        public static void Info(string fmt, params object[] args)
        {
        }

        /// <summary>
        /// Every type gets its own instance with a fresh set of variables to describe the 
        /// current filter status.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        internal class TraceData<UsingType>
        {
            internal static TraceData<UsingType> Instance = new TraceData<UsingType>();

            public bool IsInitialized = false; // flag if we need to reinit the trace data in case of reconfigured trace settings at runtime
            public TraceTypes Enabled = TraceTypes.None; // Enabled trace levels for this type
        }
    }

We do not need to pass the type as string or Type object to the trace Api. Instead we define a generic Api that accepts the using type as generic parameter. Then we can create a TraceData static instance which is due to the nature of generics a fresh instance for every new type parameter. My tests on my home machine have shown that this approach is as fast as a simple bool flag check. If you have an application with many types using tracing you do not want to bring the app down by simply enabling tracing for one special rarely used type. The trace filter performance for the types which are not enabled must be therefore the fasted code path. This approach has the nice side effect that if you store the TraceData instances in one global list you can reconfigure tracing at runtime safely by simply setting the IsInitialized flag to false. A similar effect can be achieved with a global static Dictionary<Type,TraceData> object but big hash tables have random memory access semantics which is bad for cache locality and you always need to pay for the lookup which involves hash code generation, equality check and an indexed array access.

The generic version is wicked fast and allows you to add more features to your tracing Api with minimal perf overhead. But it is cumbersome to write the generic type argument always explicitly and worse if you do refactor code and move parts of it to other classes it might be that you cannot configure tracing correctly. I would like therefore to decorate my type with an attribute

    [CallerType]
    class Tracer<T> : IDisposable
    

to tell the compiler to fill in the generic type argument automatically.

    class Program
    {
        static void Main(string[] args)
        {
            using (var t = new Tracer()) // equivalent to new Tracer<Program>()
            {

That would be really useful and super fast since you do not need to pass any type object around but you do have full type infos at hand. This change would be breaking if another non generic type exists in the same namespace where now the generic counterpart would be preferred. But this is an acceptable risk in my opinion since you can today already get conflicts if two generic types of the same name are defined in different namespaces. This would be only a variation of this issue.

When you do think about this further you can add more features like to trace the exception in your Dispose method if the method is left with an exception with that little trick I did write some time ago. You can think of tracing as a super fast and configurable switch to write data to an output destination or to execute alternative actions. With such an infrastructure you can e.g.

• Reconfigure tracing at run time.
• Take a memory dump when a specific method is left with a specific exception.
• Throw an exception when a specific trace statement is hit (useful for testing error conditions).
• Execute a passed delegate which e.g. dumps additional state when enabled.
• Write data to an in memory ring buffer and dump it when specific events do occur (e.g. method is left with an exception, triggered from outside).
• Write data to an output device.
• ….

This stuff is really useful to have when your code is in production on a mission critical server and you need to find the root cause of sporadic crashes of your application. It could be a buggy graphics card driver which throws access violations into your application (ok with .NET 4 not anymore except if you enable a compatibility flag) where you would like to have a minidump or you have reached after two weeks of operation a state where you need a full memory dump at a specific point in time in the middle of an transaction.

At my older machine I do get with this super fast approach 50 million traces/s when tracing is disabled. When I do know that tracing is enabled for this type I can walk the stack by using StackFrameHelper.GetStackFramesInternal to check further if a specific action or output device is configured for this method which is about 2-3 times faster than the regular StackTrace class. Even with one String.Format I am down to 3 million traces/s so performance is not so important anymore since I do want to do something now.

The CallerMemberName feature of the C# 5 compiler is nice but I would have preferred to get direct access to the MethodHandle and not to the stringified version of it. But I really would like to see a CallerType attribute implemented to fill in the generic type argument of the call site to augment the static CLR type data with run time data.