A Visual Studio extension to quickly switch startup class

Vanderlei Adriano Morais — Wed, 09 Apr 2025 15:11:57 +0000

Have you ever wanted to set multiple entry points in a C# project to quickly switch between different programs? Well, it's not so simple—that's why I developed a Visual Studio Extension to help with that.

"Change Startup Object" is a lightweight extension that adds a new "Set as Startup Object" command to context menus. With it, you can easily change which class serves as the entry point of your project.

This command is similar to "Set as Startup Project" but is designed for setting a class as an entry point at the project level, allowing multiple Main methods across different .cs files.

How It Works

When the command is executed, the selected class is set in the respective project as the <StartupObject>. This is a compiler option that specifies the entry point of the application.

Shortcut

Use Alt+F5 to set the active file OR the selected file in Solution Explorer as the Startup Object.

Use Cases

When you don't want to create multiple projects just to have different entry points, such as small POCs and benchmarks using Console Applications.
A quick solution for CS0017 that eliminates the need to compile with the /main option.

Limitations

Doesn't work with top-level statements, since there is a limitation of only one top-level file per application.
The selected class must have a Main method.

Download and install

Get it in Visual Studio Marketplace.
Run and install the VSIX file.

Improving String Manipulation in .NET

Vanderlei Adriano Morais — Wed, 25 Sep 2024 03:08:20 +0000

One thing so trivial as transforming a string could have considerable impact in the performance depending on how is implemented. Let's check an example of a simple requirement that I had to work some time ago.

The Requirement

Given a "CPF" (Brazilian National ID) stored as string with only numeric digits, add some standard separators (“.” and “-”) to display it in a more user-friendly format, pretty straightforward as:

> Input: “12345678909”  
> Output: “123.456.789–09”

Initial Solution: Stack Overflow

Like a good developer I google it for a quick solution and, of course, I ended up in Stack Overflow. In the best voted answer, I found this implementation:

public string Format(string cpf)
{
    return Convert.ToUInt64(cpf).ToString(@"000\.000\.000\-00");
}

Looks like a good solution, right? To use the number format string - that allows defining a mask for a number in the ToString method - the string was converted to UInt64.

Pretty clever, huh? Not much...

My Solution

I had doubts about the performance of the solution found, especially because the conversion part, so I tried to implement my own solution in a very simple way:

public string Format(string cpf)
{      
    return $"{cpf.Substring(0, 3)}.{cpf.Substring(3, 3)}.{cpf.Substring(6, 3)}-{cpf.Substring(9, 2)}";
}

Basically, I just used Substring to split the CPF into four parts, inserting the corresponding separators.

Then, to compare the approaches I used Benchmark.DotNet, here are the results:

Method	Mean	Ratio
FormatCpfConvert	301.97 ns	baseline
FormatCpfSubstring	127.54 ns	-56%

My solution was 50% faster than the Stack Overflow one!

Final Solution

Even that my solution was an acceptable implementation I felt it could still be improved, the problem is that using Substring for extracting the CPF sections generates new allocations in the memory for each part of the string.

To make this process efficiently instead of creating new substrings we ideally could just pick slices of the original input and add the required separators. Here is where the power of Span and Slice can be used.

The Span<T> type provides a way to point to a specific part of an object in the memory by using the Slice method, for manipulating strings this can be very helpful in scenarios where parts of the existing string can be used to produce the desired result.

So, by just applying the extension method AsSpan into the string and using Slice I implemented this new solution:

        public string Format(string cpf)
        {
            var cpfAsSpan = cpf.AsSpan();

            return $"{cpfAsSpan.Slice(0, 3)}.{cpfAsSpan.Slice(3, 3)}.{cpfAsSpan.Slice(6, 3)}-{cpfAsSpan.Slice(9, 2)}";
        }

After running the benchmark again, we have:

Method	Mean	Ratio
FormatCpfConvert	301.97 ns	baseline
FormatCpfSubstring	127.54 ns	-56%
FormatCpfAsSpan	75.94 ns	-74%

Final solution is almost 75% faster than the initial one!

Conclusion

I hope this gives you an idea of Span type and its benefits regarding performance. Although this type was introduced a few years ago is not common to see it being used or explained.

Also, this experience reinforced practices that I recommend and try to follow every day:

Stay up to date about the features of the programming language/framework that you are working with, you never know when you can find something useful to apply in your day-to-day activities
Make it work, then make it better/faster
Don't blindly rely on solutions from the internet

Links:

DEV Community: Vanderlei Adriano Morais