.Net, Visual Studio, VS2017

VS 2017 Structure Visualizer

After installation of Visual Studio 2017, you probably noticed some vertical dotted lines.  Many people find them annoying and want to remove them.  At the end at this article I’ll show you how you can disable this feature but first I’d like to tell you how this new feature can be beneficial to you.

It’s not hard to figure out that these lines are lining up with structured code blocks.  It allows you quickly figure out the code scopes.  The biggest benefit you get when you hover over the line.  It allows you easily see namespace, class, method, and other code blocks without the need to scroll.  I’ve been using a lot Ctrl+] to jump between difference braces in Visual Studio.  Now I just need to hover over the line and see the scope of the code at a glance.


If you think you like this feature but don’t use VS 2017 yet, you can install Productivity Power Tools for VS 2015 or VS 2013.

Ideally, you write your code in such manner that each code block can be easily seen on a single screen.  Even if you succeed to write the code nice and concise, the need to read someone else code will arise in your career and this feature might be helpful you.

Disable this feature.

If you still believe that this new feature is not going to help you, then you can disable it by going to Tools > Options > Text Editor and uncheck “Show structure guide lines”.

Disable structure guilde lines

In case you like this feature but you want the guide lines to be less or more prominent you can go Tools > Options > Environment > Fonts and Colors.  In “Display items” select box choose “Structure Guide Lines” option and pick the color that suits you best.

Modify structure guilde lines

I hope you find this article and this new feature useful.

.Net, C#, C# 7

Out Parameters

I’m so happy to see this new, very simple improvement in C# 7.  You probably have to write the code similar to the one below many times:

   int outNum;
   var tryParse = int.TryParse("5", out outNum);

In C# 6 and earlier versions, we had to use two statements.  One to declare a variable and then to call int..TryParse method.  I take pride of having my classes and methods as small as possible. I can save a line with this new feature, no need to declare a variable.

   var tryParse = int.TryParse("5", out int outNum);

In some cases you don’t care about the out variable at all. You just want to know if you can parse string to int or not. In this case, use a single underscore instead the variable name to create a discard.

   if (int.TryParse("5", out _))
      // Some logic

Because we don’t need the declaration of the variable, we can implement a method with an expression body:

   static int ParseOrMyDefalt(string text) =>
      int.TryParse(text, out int value) ? value : 5;

That’s basically it about new out parameter feature. Once again I’m very happy that I don’t need to deal with annoying variable declaration statement.

.Net, C#, C# 7

Underscore Separators

Another new feature of C# 7 is underscore separators.  Now you can put underscore anywhere inside any numeric literal to make long numbers more readable.  And I mean any, you can put it inside regular integer, binary, hex, decimal and many other numeric literal.

In the statement bellow it’s hard to see how many millions / billions the numeric value has.

int milesFromEarthToSun = 92960000;

We can improve it by putting some separators.

int milesFromEarthToSun = 92_960_000;

With new syntax we can clearly see how many million miles from Earth to Sun.

However, you also can misuse this feature and make code less readable. Unfortunately this example is valid:

int loooooongTen = 1___________0;

This new feature plays nicely with another C# 7 feature (binary literal)

   int readableBits = 0b0010_1111_0000_1111;

When using this feature, you need to be aware of some restrictions.  All examples below are invalid:

  • You can’t prepend the literal with an underscore
    int invalidNumber = _2;
  • You can’t add an underscore to the end of the literal
    int invalidNumber = 2_;
  • You can’t insert an underscore before or after the period in a floating point literal
   float invalidFloatNumber = 23_.15f;
   decimal invalidDecimalNumber = 23._15m;
  • You can’t put an underscore after the base specifier (0x or 0b) or before the literal suffix
   byte invalidHexByte = 0x_A;
   byte invalidBitByte = 0b_1010;
   decimal invalidDecimalNumber = 23.15_m;

I disagree that we are not allowed to put underscore after the base specifier. I wish I could use something like this:

   int whishToBeValidBits = 0b_0010_1111_0000_1111;
.Net, C#, C# 7

Binary Literals

One of the new feature that comes with C# 7 is binary literals.  We had hex digit literal for a long time 0x or 0X prefix.

int hexNum = 0xA; // Prints 10

With C# 7 we now can represent a number in binary format.  To represent number in binary (bit) format you just need to prefix it with 0b or 0B.

int bitNum = 0b1010; // Prints 10

So why do need to know about this syntactic sugar?

  • If you read a code where this syntax is used, you need to understand it.
  • For bitmasks.
  • When implementing protocol with specific bit patterns.

We also can use it in enum.  Some people might agree that it’s more readable. Before C#7 our enum Colors would looks something like that:

enum Colors
   Black = 1,
   Red = 2,
   Blue = 4,
   Green = 128

That’s how it looks using binary literals:

enum Colors
   Black = 0b0001,
   Red = 0b0010,
   Blue = 0b0100,
   Green = 0b10000000

I myself probably would use binary literals only if I have to work with bitmask. However, it’s nice to have an extra option.

byte decByte = 60;
byte hexByte = 0x3C;
byte bitByte = 0b00111100;

The last thing I want to mention is that using binary literals doesn’t affect performance at all.


Capitalize only first character. (C#)

Once in a while, you may need need to capitalize only the first character of a word. Like everything else in programming, there’s more than one way to solve this problem. In this post, I’m going to explore three different ways to capitalize the first letter of a word, and then let you know which one I prefer.

1. String manipulation solution.
private string UpperFirst(string text)
return char.ToUpper(text[0]) +
((text.Length > 1) ? text.Substring(1).ToLower() : string.Empty);


This solution is straightforward. First, capitalize the initial character of the text, and then append the rest. Next, we test if our text has more than 1 character. If this is text with multiple characters, we convert the rest of the text to lowercase, in case there are any uppercase letters.

2. LINQ solution.
private string UpperFirst(string format)
return format.First().ToString().ToUpper() +
String.Join("", format.Skip(1)).ToLower();


LINQ solution is also easy to follow and understand. We get the first character, and then we convert it to String (because the char type doesn’t have instance implementation of ToUpper()). Then, like in the previous solution, we append the rest of text.

3. TextInfo.ToTitleCase solution.
private string UpperFirst(string text)
return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text.ToLower());


This solution is taking advantage of the ToTitleCase method. It looks simple, but it’s not exactly like our two previous solutions. The problem with this solution is that it’s going to capitalize every word in the text.  For example: if your text has the value “hello world”, the result of this solution will be “Hello World” and not “Hello world” as in the two earlier examples. If you need to capitalize every word in your text, use this solution. Otherwise, use one of the earlier solutions.

The best solution for me.

Personally, the 1st solution looks the best. There are two reasons why I think solution #1 is the best:

  1. I believe it’s easier to read, but readability is very subjective.
  2. It performs better. I iterated each solution 1,000,000 times, and the first solution performed the fastest.

Below is the table of my performance test, in case you’re interested. It shows the time in milliseconds for 1,000,000 iterations.

Solution Time
String manipulation







Please let me know if you can think up other implementations for capitalizing letters.

Technorati Tags: ,,,

Corrected problem with SystemWrapper in NuGet gallery.

Yesterday, I told the world that SystemWrapper is in NuGet gallery.  However, I didn’t realized that I publish the wrong version that does absolutely nothing.

I just want to let you know that I re-publish the correct version and everything should work fine. 

I originally tested the package on my local machine but I’ve never tested the published one.  It taught me AGAIN that I should not to assume anything.

I hope you’ll forgive for this embarrassing, rookie mistake.