![\"Expression](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/4\/2019\/06\/Gem1-Expression-Evaluator-Format-Specifiers-Refresh.png\" "\\"Expression")
<\/a><\/p>\nHowever, you can use the \u2018ac\u2019 (always calculate) format specifier to force evaluation on every step.<\/p>\n
I also find the \u2018h\u2019 (hexadecimal) format specifier useful. You can leave the global display of the debugger alone, but update a single watch item to report in hex by using \u2018value,h\u2019.<\/p>\n You can read about all of the different format specifiers for both C++<\/a> and C#\/VB<\/a>.<\/p>\n The measure of a modern debugger is its ability to display runtime object data in a simple and meaningful way. As such, when the debugger displays this information, it needs to show the most interesting values prominently. Unfortunately, it is difficult for the debugger to analyze arbitrary objects and figure out what is \u2018most important\u2019. The only generic solution is for you<\/i> to control what the debugger displays; which leads us quite nicely into attributed debugging.<\/p>\n Attributed debugging gives the author of the type the ability to specify what it looks like when being debugged. The simplest form of this is the DebuggerDisplayAttribute. Imagine debugging the following code:<\/p>\n If you set a breakpoint on the closing brace of Main, and examine presidents, you\u2019ll see something like this:<\/p>\n If you want to examine the properties of James Madison, then you must know that he was the 4th<\/sup> president. You could override ToString in Person; the EE will call ToString if it\u2019s overridden. However, that causes a function evaluation, which can be hundreds of times slower than normal data inspection, and it may be that the debug \u2018view\u2019 of the data should be different than the ToString view. For those cases you can use DebuggerDisplay as follows:<\/p>\n This updates the display, to the more scannable:<\/p>\n You can include format specifiers in the expression to evaluate. In this case \u2018nq\u2019 means \u2018no quotes\u2019 when displaying the string.<\/p>\n We now have an easier time finding James Madison without expanding every node; however, after we expand, we see the following view:<\/p>\n This shows a lot of duplicative information, and in this case, we don\u2019t really need it. Not only that, but it consumes 3 full rows of the watch window, where vertical space is precious. Since we know how FullName is calculated we\u2019re comfortable never seeing FirstName or LastName when a Person is expanded. This is achieved through the DebuggerBrowsableAttribute. For example, if we add the following attributes:<\/p>\n Our view updates to:<\/p>\n You can learn more about attributes that control the debugger data window views here<\/a>. There are several other attributes that can control the behavior and look of the debugger, that we\u2019ll likely talk about in future posts!<\/p>\n You may not always control the source for the types that you\u2019d like to make easier to view. Imagine you have the following:<\/p>\n It sure would be nice if IPHostEntry showed the HostName property in the value column, without having to expand it.<\/p>\n The DebuggerDisplayAttribute has an optional parameter for TargetType. This can be used in conjunction with setting the DebuggerDisplayAttribute at the assembly level, to customize types even when you cannot modify their source.<\/p>\n Visual Studio ships with a file called autoexp.cs & autoexp.dll (auto expand) in <visual studio install location>\\Common7\\Packages\\Debugger\\Visualizers\\Original. This file already has several DebuggerDisplay attributes that customize common framework types. We can modify it from an elevated command prompt and add the following: We then compile it, again from an elevated developer command prompt, with the command line \u201ccsc \/t:library autoexp.cs\u201d. The next time we debug our program, we\u2019ll now see:<\/p>\n This allows for powerful, time-saving, customizations of your own types, frameworks you ship to others, and any code on which you depend.<\/p>\n Although the examples above focus on managed code, similar customizations can be made to the C++ debugging experience, including global view modifications via autoexp.dat, as documented here<\/a>.<\/p>\n The tips above are focused on debugging code that\u2019s already been written. What about when you need to pump out new code quickly? I expect many of you may already be familiar with the built-in Code Snippets, but it\u2019s worth mentioning that Snippets are extensible. There are default directories that are registered where you can store your own code snippets. For example, for C#, that location is %userprofile%\\Documents\\Visual Studio 2017\\Code Snippets\\Visual C#\\My Code Snippets.<\/p>\n In 2005, when Snippets were first introduced, a common demo of adding a new snippet for C# was to create a \u2018dim\u2019 snippet, so that you wouldn\u2019t have to enter the type name twice when instantiating a type in C#. The introduction of implicitly typed local variables via \u2018var\u2019 somewhat eliminated the need for such a snippet; however, some coding guidelines preclude using var as it can impact readability. So, let\u2019s introduce a new \u2018var\u2019 snippet, called var.snippet, of the following form:<\/p>\n Now if we type var in a C# file, and hit <tab><tab>, the following will be inserted:<\/p>\n We can tab through the literals, and as we update the type name, any other reference to that same literal will be updated!<\/p>\n Code snippets are supported in many Visual Studio languages including Visual Basic, C#, CSS, HTML, JavaScript, TSQL, TypeScript, Visual C++, XAML and XML. You can read more about that support here<\/a>.<\/p>\n In some cases, when exploring a codebase, it\u2019s useful to be able to see all the types that derive from a base class. This can be particularly true for large, heavily factored frameworks, like Universal Windows or the .NET Framework. It\u2019s possible to use Object Browser to do this for you!<\/p>\n Object Browser is extensible, by creating a library manager. This is important for this tip because different library managers support different functionality. The C# Library Manager does not support locating Derived Types, so if you use the \u2018My Solution\u2019 component set, then you will not see this option. The \u2018My Solution\u2019 component set is the default, but you can change it by the drop-down that appears at the top of the Object Browser (there are many options). Let\u2019s select the .NET Framework 4.6.1:<\/p>\n Now, if you want to locate all the derived types of System.IO.Stream, you simply navigate to the type and expand the \u2018Derived Types\u2019 folder. This is an expensive operation, so expect to wait a fair bit of time for the result to come back.<\/p>\n This works for any assembly or framework; however, to use it for items that you have referenced in your solution, you must first add them to a separate \u2018custom component set\u2019 (the \u2026 next to the drop-down), so that the correct library manager is used.<\/p>\n There is a little-known toolbar combobox called \u2018Find\u2019. It\u2019s on the standard toolbar, but in most settings files its hidden by default. You can show it by clicking on the drop-down of the standard toolbar, the down arrow at the far right of the toolbar that has the back and forward buttons on it, and selecting Add or Remove Buttons and then the Find option.<\/p>\n<\/a><\/p>\nGem #2 – Controlling the value column of the debugger<\/h2>\n
class Person\r\n{\r\n public string FirstName;\r\n public string LastName;\r\n\r\n public Person(string first, string last)\r\n {\r\n this.FirstName = first;\r\n this.LastName = last;\r\n }\r\n\r\n public string FullName { get => $\"{LastName}, {FirstName}\"; }\r\n}\r\n\r\n\r\nclass Program\r\n{\r\n static void Main(string[] args)\r\n {\r\n List<Person> presidents = new List<Person>\r\n {\r\n new Person(\"George\", \"Washington\"),\r\n new Person(\"John\", \"Adams\"),\r\n new Person(\"Thomas\", \"Jefferson\"),\r\n new Person(\"James\", \"Madison\"),\r\n new Person(\"James\", \"Monroe\")\r\n };\r\n }\r\n}<\/pre>\n<\/a><\/p>\n[DebuggerDisplay(\"Name: {FullName,nq}\")]\r\nclassPerson<\/pre>\n<\/a><\/p>\nGem #3 – Showing important values when an object is expanded<\/h2>\n
<\/a><\/p>\n[DebuggerBrowsable(DebuggerBrowsableState.Never)] \r\npublic string FirstName; \r\n[DebuggerBrowsable(DebuggerBrowsableState.Never)] \r\npublic string LastName;<\/pre>\n
<\/a><\/p>\nGem #4 \u2013 Applying view customizations to framework types<\/h2>\n
class Program\r\n{\r\n static void Main(string[] args)\r\n {\r\n IPHostEntry hostEntry = Dns.GetHostEntry(\"bing.com\");\r\n }\r\n}<\/pre>\n<\/a><\/p>\n<\/code><\/p>\n[assembly: DebuggerDisplay(\"Host: {HostName}\", Target = typeof(IPHostEntry))]<\/pre>\n<\/a><\/p>\nGem #5 \u2013 Snippets<\/h2>\n
<?xml version=\"1.0\" encoding=\"utf-8\" ?> \r\n<CodeSnippets xmlns=\"http:\/\/schemas.microsoft.com\/VisualStudio\/2005\/CodeSnippet\"> \r\n <CodeSnippet Format=\"1.0.0\"> \r\n <Header> \r\n <Title>Var<\/Title> \r\n <Shortcut>var<\/Shortcut> \r\n <Description>Code snippet for instantiating an object with full type info<\/Description> \r\n <Author>Anson Horton<\/Author> \r\n <SnippetTypes> \r\n <SnippetType>Expansion<\/SnippetType> \r\n <\/SnippetTypes> \r\n <\/Header> \r\n <Snippet> \r\n <Declarations> \r\n <Literal> \r\n <ID>type<\/ID> \r\n <Default>Example<\/Default> \r\n <ToolTip>The type to construct<\/ToolTip> \r\n <\/Literal> \r\n <Literal> \r\n <ID>variable<\/ID> \r\n <Default>example<\/Default> \r\n <ToolTip>The variable name<\/ToolTip> \r\n <\/Literal> \r\n <Literal> \r\n <ID>args<\/ID> \r\n <Default><\/Default> \r\n <ToolTip>The constructor arguments<\/ToolTip> \r\n <\/Literal> \r\n <\/Declarations> \r\n <Code Language=\"csharp\"> \r\n <![CDATA[$type$ $variable$ = new $type$($args$);$end$]]> \r\n <\/Code> \r\n <\/Snippet> \r\n <\/CodeSnippet> \r\n<\/CodeSnippets><\/pre>\n
<\/a><\/p>\nGem #6 \u2013 Derived types<\/h2>\n
<\/a><\/p>\n<\/a><\/p>\nGem #7 \u2013 Find combo<\/h2>\n