What's the proper way to emulate C++ macros in C#

Question

I understand why macros were not included in the language; that they can easily become abused. However I now and again stumble upon situations where they seem desirable. Just recently I was writing a method to log image files:

public void LogImage(Bitmap image, string name)
{
    image.Save(LogRootDirectory + name + ".bmp");
}

Subsequently, I thought it clever to utilize the nameof() feature to better provide information about the image I am logging. In several places in my code I have lines very similar to this:

ImageLogger?.LogImage(processedImage, nameof(processedImage));

What bothers me is the repetitiveness of this and I would much prefer a pre-processor command similar to this:

#define LOGIMAGE(img) ImageLogger?.LogImage(img, nameof(img));

Is there a way to emulate the above macro behaviour to better streamline my code?

Note: This question differs in that the author is asking if per-processor definitions exist in C#. An assertion that I made clear from the beginning that I know that they do not. My question is in reference to techniques that I may use in substitution. Which I believe was provided to me in the marked answer.

Possible duplicate of [C# Macro definitions in Preprocessor](http://stackoverflow.com/questions/709463/c-sharp-macro-definitions-in-preprocessor) — phuzi, Dec 22 '16 at 14:29
C# doesn't support macros, closest you're going to get to is Visual Studio's snippets — phuzi, Dec 22 '16 at 14:30
in the above case could you not just provide an overloaded method void LogImage(Bitmap image) which then called LogImage(imager, nameof(image)) ? — C. Knight, Dec 22 '16 at 14:31
Knight it would not work to use an overload. Nameof(image) will always equal the string "image" and not the original variable name. — Daniel Davis, Dec 23 '16 at 15:04

score 3 · Accepted Answer · answered Dec 22 '16 at 15:22

If you're at a loss for compile-time cleverness in C#, you're just not abusing expression trees hard enough.

public void LogImage(Expression<Func<Bitmap>> b) {
    var memberExpression = b.Body as MemberExpression;
    if (memberExpression == null) throw new ArgumentException("Must be invoked with a member reference.");
    string name = memberExpression.Member.Name;
    Bitmap bitmap = b.Compile()();
    LogImage(bitmap, name);
}

Invoked as

ImageLogger?.LogImage(() => processedImage);

There is a bit of overhead associated with producing the expression tree at the call site, even if LogImage is never called, so while this is clever, it's not something to be overused. Also, this requires that your bitmap has a name (getMyProcessedImage() will not work), which is exactly the problem that you would also have with a macro, if C# supported them (nameof(getMyProcessedImage()) is invalid), except that it won't throw an exception until runtime. So it's not so hot in terms of safety either.

Personally, I'd just type the name again. I wouldn't even use nameof, really. Logging images under variable names seems like a dubious practice to me. If I did want a clear reference to the place in the source where the bitmap was produced, I'd use caller info:

public void LogImage(
    Bitmap b, 
    [CallerFilePath] string filePath = "", 
    [CallerLineNumber] int lineNumber = 0
) {
    LogImage(b, $"{Path.GetFileNameWithoutExtension(filePath)}({lineNumber})");
}

Invoke simply as

ImageLogger?.LogImage(processedImage);

Of course, this does assume you want unique bitmaps for each location, but given the name "logger" that seems an appropriate assumption.

Yup, pretty much this. Thanks. – Daniel Davis Dec 23 '16 at 14:54 — Daniel Davis, Dec 23 '16 at 14:54

score 0 · Answer 2 · answered Dec 22 '16 at 15:57

You can leverage the fact that anonymous types will have automatically generated property names. First define an overload like:

public void LogImage(object obj)
{
    var prop = obj.GetType().GetProperties()[0];
    string name = prop.Name;
    Bitmap bitmap = (Bitmap)prop.GetValue(obj);
    LogImage(bitmap, name);
}

then when you want to log an image call it using an anonymous type:

ImageLogger?.LogImage(new { processedImage });

This is an abuse of a mechanism and in production code I'd probably lean towards typing out the name twice for the sake of clarity. Also this is not exactly performant in many cases, but here we are talking about saving an image to a file, so the extra cost of allocating a small object and reflection are negligible.

What's the proper way to emulate C++ macros in C#

2 Answers2