RootHidden = When you have a class that implements an IEnumerable and delegates it’s job to other enumerable, which it wraps.

Since you mentioned debugger step through is niche - One thing I used it for is when you create a castle dynamicproxy, and apply interceptors to the object. Otherwise when you try to step into your object methods, it would always jump into the interceptors first, so I `DebuggerStepThough` the interceptors - So it looks like you're directly stepping into the methods (as expected)

In VS debugger and in remedybg, I use the watch window a lot, it gives a little better over view if you need to see many variables interact and change values. In the watch window you can also write some code like calling trivial methods or functions or operators. But I think these annotations can be used in combination in a nice way too, or if you dont have watch windows then they seem great!

You can also add the DebuggerDisplayAttribute as an assembly attribute. If you *really* hate yourself and your coworkers you can do for example this: using System.Diagnostics; [assembly: DebuggerDisplay( "420", Target = typeof(int), Type="Something..dunno..")] int x = 69; int y = 80085; int z = 1337; If you hover over one of the ints or look at them in locals or a watch window, it'll say the value is 420. And since it's an assembly attribute, it'll do that for every single int in your project. Happily it doesn't seem to be a way to "inherit" the attributes, so there's that. (until somebody sneaks a code generator into a nuget package to terminate their trustworthiness forever) Of course this can be used for good too. If a BCL type or type from a package has a poor debugging experience, you can fix it yourself. Visual Studio has a bunch of assembly level DDAs in a file called "autoexp" (cs file, but can't type it or YT will think it's a link). The filename is also a terrific search term on Google or whatever 🙂

I've recently been debugging something using lists of largish objects and I've only been interested in one single property. Was becoming painful expanding it everytime. Cheers!

I use [DebuggerNonUserCode] in my library code, which combines DebuggerHidden and DebuggerStepThrough and can be applied to classes and structs.

I’m so used to Nick’s constants being some variant of 69 or 420, that seeing 13 and 37 makes me wonder what I’m missing.

Good debugging tips always pay dividends, especially when it comes to tweaks in setup and annotation so I'll definitely have to have a play around with these in my toy projects. Ever since I found that you could debug individual unit tests in VS2019/2022 (which was a massive boon to my workflow), I've been a convert to the benefits of debugger tricks.

Immediate window. The most beneficial debugging tool ever.

Make it easier: you can expand object props and press on the icon next to property. It will turn to flag and will be displayed like with [DebuggerDisplay] attribute. Visual Studio has something like this also if I remember correctly

I remember using the proxy types at several places in a former job where I had to debug through some very complex types, with loads of properties, sub-arrays of objects, etc., with only a couple of useful ones. It was way much clearer to only see what I needed while debugging than browsing through a complex tree. And for DebuggerStepThrough, I use it on small easy to understand extension methods that I know how they work and don't want to pass through them while debugging because it's most of time irrelevant.

RootHidden sounds super useful for classes implementing IEnumerable to collapse inner collection. Proxy seems useful for debugging classes, for which you don't have source to access.

I use DebuggerStepThrough on a lot of simple constructors, and DebuggerDisplay often. Makes things better.

Note on DebuggerBrowsableAttribute that is also has a side effect that hidden things won't show up in intellisense anymore (though might depend on the IDE I guess)

DebuggerStepThrough very useful in libraries that manage your code. For example, like Promise when using multiple Then and passing lambdas. Stepping through your code using F11 is much more convenient.

I think you got your point across! Alright I'll see myself out...

Great video, thanks. I use the DebuggerStepThrough when I'm debugging a winforms app, I mainly put it on events that fire, like mouse_move, or form_refresh. Though I tend to not leave it there, just add it in when I'm debuiging.

“You don’t need to debug when you don’t have bugs.” 😂

[DebuggerHidden] on a function with a "System.Diagnostics.Debugger.Break();" will break where that function is called. Useful for functions like VerifyDateFormat(string date){a without it stopping inside the checker function.

The video title sounded uninteresting, but I watch all of your non-AWS videos. It ended up being interesting, empowering, and at one point I laughed out loud. "Why would you want to do this...? I don't know, but you can!"

I've been rocking a $70 asrock board for 3 years now.

I wish there was a way to apply these to a class, that you can't edit yourself(external dll or whatever). Would be really nice to be able to make stuff I care about appear at the top of the properties list. Instead of having to search the name. (specifically for unity monobehavoirs, since they have A LOT of fields/props.)

All these attributes are new to me, but DebuggerDisplay seems usefull, except there are no variable name validation.

that sneaky 1337 @6:55

Pin property in "quickwatch" is very helpful. It will do the similar thing you've just shown. Unfortunately, in order to filter properties, I have to copy the "quickwatch" output with the table separation, put it to the google spreadsheet and then filter by something.

Could you make a circular reference with the DebugggerTypeProxy attribute ?

Do a video on Debugger Visualizers...

Are these attributes polymorphic (different views for different subclasses), or will the debugger consider only the type of the variable?

Thanks for the content

Thank you

Is there an attribute to allow you to skip exceptions in certain method? I mean to prevent VS from stopping at exception and continue executing catch clause silently?

Which visual studio extensions are you using for that debug value view?

Hi bro. Is there a way to get a discount for one of your courses for someone who’s is starting with testing in Net Core? Much love

What a twist it would be to have x = 105 and x = 4, then x*y = 420

I hate it when VS won't let you see into Dictionary internals like the hash table and entries

Hi! How do you circle with red rectangle to show smth?

How to debug library functions

These attributes kind of break the separation of concerns

Yes, but it`s a pity that rider or resharper cannot fix the necessary attribytes of the object how VS does it

Instead of breakpoint on line 3 and stepping over, why don't you just put the breakpoint on line 5?

Hi just out of curiosity, why do you always use the numbers 69 and 420 in allllll your videos? is that a easter egg or something, hahahahahah I love your videos btw.

Why do you use Rider instead of Visual Studio?

Very nice!

What program do you use to draw on the screen ? I’ve tried ZoomIt, but that zooms in, and I don’t see a way to disable the zooming.

What are the operating system and the program those you use for the video man? Is that Visual Studio 2022 in a Linux distrubition? Thanks for the video.

We more debugging attributes!!!

i just output to a textfile

🔥

Hey Nick. You looked somewhat tired in this video. Are you taking proper rest and some time for yourself mate?

Hi nick

DebuggerBrowsable is pure evil. It's only there to annoy your colleagues

Great video, but these features are unnecessary IMO, they are OK but do we really need them?

For performance reasons i always make a private GetDebuggerDisplay() method so the method evaluator doesn't have to evaluate multiple properties, only the one call in [DebuggerDisplay("GetDebuggerDisplay(),nq")] the method gets optimized away in Release by the compiler

Nick))) Could you talk a bit slowly. Please.

Nothing really useful mentinoned in this video.Comments have much useful suggestions.

Debuggers are evil. Don't use them. Implement excellent logging instead.

Can you stop with all these shit calle programming, you cant program anything without bugs and problèms with each line of code

Fantastic !!