Is it possible to replicate ASP.NET RouteAttribute functionality in a non-WebAPI project?

To make this work, you would have to write your own custom middleware that intercepts a request and matches route patterns.

Yes, you can not pass interpolated strings to attributes, but you could pass a template string and use regex or a simple parsing technique to match incoming request route to the endpoint route.

for example, you would need to define attribute like this: [MyRoute("myFunc/{param}")], then, when processing a request, you can take route of the request and match it to this template.

you could define a method in your attribute class that performs route matching. Keep in mind, this custom middleware would also need to check for similar template definitions, because you may only define a single unique route.

[AttributeUsage(AttributeTargets.Method)]
public class MyRouteAttribute : Attribute
{
    public string Template { get; }

    public MyRouteAttribute(string template)
    {
        Template = template;
    }

    public bool Matches(string requestRoute)
    {
        var templateSegments = Template.Split('/');
        var routeSegments = requestRoute.Split('/');

        if (templateSegments.Length != routeSegments.Length)
            return false;

        for (int i = 0; i < templateSegments.Length; i++)
        {
            if (templateSegments[i].StartsWith("{") && templateSegments[i].EndsWith("}"))
                continue; // Placeholder matches any segment but this can be enhanced with further type checking if specified in template like: "{param:int}"
            if (!string.Equals(templateSegments[i], routeSegments[i], StringComparison.OrdinalIgnoreCase))
                return false; // Segments must match exactly, without case, I suppose
        }

        return true;
    }
}

You could also specify a type of param like {param:int} and perform further type checking in Matches method, just like asp.net does.

This can also be done with regex but I am too lazy to study regex for this, I'm sure ChatGPT will spit it out in seconds.

As for suggestions and highlights, you would have to dig into source generators and analyzers to make that work.

For any one who wonders whats the solution imma provide below code for that.

Steps to follow:

• Install package for VS Extensions.
• Create project from project template - VSIX Project
• Add new Item - Editor Classifier

After that u should get 4 new classes. a. nameof your EditorClassifierItem + .cs later called Classifer b. ClassiferClassificationDefinition.cs c. ClassiferFormat.cs d. ClassiferProvider.cs

After so only two of them will be needed - Classifer.cs and ClassiferClassificationDefinition.cs

In ClassiferClassificationDefinition.cs you have to define your classification colors.

 internal static class EditorClassifier1ClassificationDefinition
    {
        // This disables "The field is never used" compiler's warning. Justification: the field is used by MEF.
#pragma warning disable 169

        /// <summary>
        /// Defines the "EditorClassifier1" classification type.
        /// </summary>
        [Export(typeof(ClassificationTypeDefinition))]
        [Name("EditorClassifier1")]
        private static ClassificationTypeDefinition typeDefinition;

        [Export(typeof(ClassificationTypeDefinition))]
        [Name("BlueRouteText")]
        private static ClassificationTypeDefinition blueType;

        [Export(typeof(ClassificationTypeDefinition))]
        [Name("GrayRouteParam")]
        private static ClassificationTypeDefinition grayType;


#pragma warning restore 169
    }

    [Export(typeof(EditorFormatDefinition))]
    [ClassificationType(ClassificationTypeNames = "BlueRouteText")]
    [Name("BlueRouteText")]
    [UserVisible(true)]
    [Order(After = Priority.Default)]
    internal sealed class BlueRouteTextFormat : ClassificationFormatDefinition
    {
        public BlueRouteTextFormat()
        {
            this.DisplayName = "Blue Route Text";
            this.ForegroundColor = Color.FromRgb(30, 101, 255);
        }
    }

    [Export(typeof(EditorFormatDefinition))]
    [ClassificationType(ClassificationTypeNames = "GrayRouteParam")]
    [Name("GrayRouteParam")]
    [UserVisible(true)]
    [Order(After = Priority.Default)]
    internal sealed class GrayRouteParamFormat : ClassificationFormatDefinition
    {
        public GrayRouteParamFormat()
        {
            this.DisplayName = "Gray Route Param";
            this.ForegroundColor = Colors.LightGray;
        }
    }

and in Classifer.cs you basically write a logic for the highlighting.

internal class EditorClassifier1 : IClassifier
{
    private readonly IClassificationType _blueTextType;
    private readonly IClassificationType _grayParamType;

    public event EventHandler<ClassificationChangedEventArgs> ClassificationChanged;

    public EditorClassifier1(IClassificationTypeRegistryService registry)
    {
        _blueTextType = registry.GetClassificationType("BlueRouteText");
        _grayParamType = registry.GetClassificationType("GrayRouteParam");
    }

    public IList<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
    {
        var result = new List<ClassificationSpan>();

        string text = span.GetText();

        foreach (Match attrMatch in Regex.Matches(text, @"\[Route\s*\(\s*""([^""]+)""\s*\)\s*\]"))
        {
            string routeContent = attrMatch.Groups[1].Value;
            int routeStart = attrMatch.Groups[1].Index;

            foreach (Match segment in Regex.Matches(routeContent, @"\{([^{}]+)\}"))
            {
                int braceOpenIndex = routeContent.IndexOf("{" + segment.Groups[1].Value + "}");
                if (braceOpenIndex < 0)
                    continue;

                int globalOpen = span.Start + routeStart + braceOpenIndex;
                int paramLength = segment.Groups[1].Value.Length;

                var snapshot = span.Snapshot;

                // { – czerwony
                result.Add(new ClassificationSpan(
                    new SnapshotSpan(snapshot, new Span(globalOpen, 1)),
                    _blueTextType));

                // środek – szary
                result.Add(new ClassificationSpan(
                    new SnapshotSpan(snapshot, new Span(globalOpen + 1, paramLength)),
                    _grayParamType));

                // } – czerwony
                result.Add(new ClassificationSpan(
                    new SnapshotSpan(snapshot, new Span(globalOpen + 1 + paramLength, 1)),
                    _blueTextType));
            }
        }

        return result;
    }
}

before: before vsix

results: after vsix