Code aliases through header-style files

[TheWhiteGuardian]

Edit: ignore for now, see comments. This is pending a massive review because currently it is unsuitable for implementation.

---

One feature that I keep wishing C# would support is the ability to add code aliases: defining a specific keyword that, on compilation, would be replaced with a predefined bit of replacement code.

I've done some research as to why this isn't in C#, and found a few key problems that such a solution would have to solve, and I hope that my proposal does so pretty well.

Firstly, consider this bit of example code.

public sealed class MyClass
{
    [OnEvent]
    private void OnEvent()
    {
        // Do Something.
    }
}

In this case, the OnEvent method is a handler for some event that gets called via reflection. The code analyzer doesn't know this though, and so it presents a warning message. We can disable this via an additional attribute:

public sealed class MyClass
{
    [OnEvent]
    [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0051:Remove unused private members", Justification = "Not unused, reflection handles this.")]
    private void OnEvent()
    {
        // Do Something.
    }
}

However, this would require a lengthy attribute for each event handler. To solve this, I propose the addition of 'c# header files' if you will, which could look like this:

namespace Aliases
{
    // Acts like field assignments. Alias left, value right.
    EventHandler = OnEvent,
        System.Diagnostics.CodeAnalysis.SuppressMessage(
            "CodeQuality", "IDE0051:Remove unused private members",
            Justification = "Not unused, reflection handles this."
    );
}

These files would serve as centralized definitions for code aliases, bound to a certain namespace just like types are, but present in separate, dedicated files such that they can be collected in a fast and straightforward manner.

The above file would then, in my proposal, add a definition for an alias (the icon I have in mind for these would be akin to an opera mask icon, which I can produce if necessary).

With the inclusion of this header file, the code can be simplified to this:

using Aliases;

public sealed class MyClass
{
    [EventHandler] // alias definition imported from the Aliases namespace.
    private void OnEvent()
    {
        // Do Something.
    }
}

The benefits:

1. Repetitive tasks or frequently written code can be shortened up through an alias definition.
2. The centralized location of aliases would make it manageable to maintain a database in memory of imported aliases in code editors, for intellisense purposes (akin to the 'expands to' overlay when viewing a C macro in VSCode)
3. For many good reasons it is impossible to 'merge' attributes. A possible replacement though is creating an alias for a group of attributes, to avoid having to write out the attributes separately.
4. Usage of specific files for aliases simplifies work for developers: one needn't search much to find where a certain alias is defined, as there are only a handful of files wherein it could be. Binding aliases to namespaces further simplifies this, since files defining code artifacts that belong to the same namespace are often grouped together.
5. By design aliases are meant to be replaced prior to compilation (through, for example, a Visual Studio build event) so their impact on program performance should be unnoticeable.

Accessibility modifiers would present a possible problem here: what prevents someone from using a restricted object through an alias? A possible solution would be to replace the aliases prior to intellisense analysis, which would then notice that an inaccessible object is being used.

I'd love to hear everyone's feedback on my idea. I absolutely love C# so I'm thrilled to have the opportunity to try and contribute to it.

[HaloFour]

Your proposal implies that it would work as a general purpose macro but the example given seems more specialized. How would the compiler know that this EventHandler "alias" had anything to do with attributes? What would happen if you used that elsewhere? Can you define more general purpose macros, and if so, what would they look like? Can they contain control blocks like if or while given that they cannot be assigned as an expression today? What happens if you have public event EventHandler MyEvent; somewhere in your code and the namespace in which that alias is defined is imported?

[TheWhiteGuardian]

"How would the compiler know that this EventHandler "alias" had anything to do with attributes?"
Same issue as with type accessibility: replace the aliases with the code that they define prior to compilation. If the code between the attribute brackets isn't an attribute then the code won't compile, right?

"What would happen if you used that elsewhere?"
Well, something like this. Prior to alias replacement:

private void Test()
{
    EventHandler handler = new EventHandler();
}

After alias replacement, which is what the compiler will receive:

private void Test()
{
    OnEvent,
        System.Diagnostics.CodeAnalysis.SuppressMessage(
            "CodeQuality", "IDE0051:Remove unused private members",
            Justification = "Not unused, reflection handles this."
    ) handler = new OnEvent,
        System.Diagnostics.CodeAnalysis.SuppressMessage(
            "CodeQuality", "IDE0051:Remove unused private members",
            Justification = "Not unused, reflection handles this."
    )();
}

Which, of course, is gibberish, so the compiler will reject it. It used as an attribute though:

[EventHandler]
private void Test()
{
    // Do something.
}

Becomes:

[OnEvent,
        System.Diagnostics.CodeAnalysis.SuppressMessage(
            "CodeQuality", "IDE0051:Remove unused private members",
            Justification = "Not unused, reflection handles this."
    )]
private void Test()
{
    // Do something.
}

Which is valid, since multiple attributes can be defined in-between the same brackets, if separated by a comma.

"Can you define more general purpose macros, and if so, what would they look like? Can they contain control blocks like if or while given that they cannot be assigned as an expression today?"
Sure. Aliases are literal, it's up to the end user to make sure that when an alias is used, the code that that alias will be replaced with is valid. Currently in my proposal aliases are limited to one-line statements though, ended with a semicolon.

If the statement assigned to the alias is bunkum, then it'll result in compiler errors when attempting to use the alias.

"What happens if you have public event EventHandler MyEvent; somewhere in your code and the namespace in which that alias is defined is imported?"
Ideally the same thing that would happen if you were to have some type called EventHandler in a namespace and import it: you would have to specify by using the namespace name.

Good point though, I hadn't thought of that. Clearly then the alias processor/intellisense would have to be taught to recognize that two different EventHandlers are being used and provide ambiguity warnings where applicable, which would make things more difficult. That's a nasty problem indeed.

[HaloFour]

So this is text replacement and shares all of the same problems as C macros.

[TheWhiteGuardian]

After giving it a lot more thought, I see what you mean, as well as discovered another problem: lambdas. That's going to be messy. Clearly this proposal needs a lot more thought on my part so I'll be closing this, for now at least.