The Magic of Breaking Down Your Types in C#

Check out my courses on Dometrain: dometrain.com
Become a Patreon and get special perks: / nickchapsas
Hello, everybody, I'm Nick, and in this video, I will introduce you to a C# feature called deconstruction. It is a really cool feature that can help you write better code.
Workshops: bit.ly/nickworkshops
Don't forget to comment, like and subscribe :)
Social Media:
Follow me on GitHub: github.com/Elfocrash
Follow me on Twitter: / nickchapsas
Connect on LinkedIn: / nick-chapsas
Keep coding merch: keepcoding.shop
#csharp #dotnet

[@DeserdiVerimas]

You can also nest deconstructions. So, for example, you can change that DateTime example to ```var (date, (hours, minutes, seconds)) = DateTime.Now;```, which makes things a lot more descriptive than many parameters, imo

[@local9]

you what... o.O

[@alexisfibonacci]

Wicked

[@jamesbennett5421]

The example of KeyValuePair deconstruction on the “foreach” makes this whole video worth it!

[@pdebie1982]

But why? Which problem does it solve? It isn't a lot of work or hard to writeout objectName.Key or objectName.Value.

[@MatinDevs]

4:25 "couple of random numbers" is the biggest lie you've ever told in your life 😂

[@martink.7497]

Nah, he just has really bad seed generator.

[@Andrew90046zero]

heh! He does that all the time :P

[@Velociapcior]

@@martink.7497 I mean his SEED is in his... you know where

[@kp_xcess]

@@martink.7497 Very clever one, I like it. Also within the context of this video there's actually a second joke hidden in there too. Not sure if you already intended that or not :)

[@martink.7497]

​@@kp_xcess Not sure if we think the same thing, but he always has some joke in the video ;)

[@aderitosilvachannel]

I remember the announcement of deconstructors, when they first came out, but I forgot they even exist. I think they're cool, actually, but I guess I didn't pay enough attention to them, maybe because I haven't seen many examples myself where they could be useful. Now that you brought them to my attention, I think I will start paying more attention on where I could be using them more. Thanks! Great video!

[@lordmetzgermeister]

Deconstructing DateTime can be really handy, I didn't know about it. Also a note - both Visual Studio and Rider have quick actions for generating deconstructors, so we don't have to remember the exact duck typing syntax for this.

[@path_selector]

awesome video. love these short and focused videos

[@nikolayrogchev9628]

Awesome stuff, every time I learn something from you, keep up the good work

[@Fred-yq3fs]

interesting. I use deconstruction on tuples, but did not know the other usages and features. I'll try to use it more.

[@osr2004snd]

Really useful to replace complex DTOs.

[@charles_kuperus]

Nick, I definitely think that the Deconstruct method is not often enough used and I hope this video would give other developers the option of using this feature more.

[@jfpinero]

Here's one dev that will start using this feature more!

[@joshpatton757]

Yeah, this was a completely new one to me, I had no awareness of it, but I see quite a few opportunities here.

[@klausbjornjensen]

Thanks for sharing... nice to know.

[@der.Schtefan]

a great deconstruction is overloading string arrays. That way you can access the results of a string.Split operation

[@t-moty]

What about a non-predetermined splitting character?

[@der.Schtefan]

@@t-moty the thing would read var (a,b,c) = "xxx".Split(",") with "," being the default. a,b,c, woudl be stirngs, you can do something else for "the rest" if you want, but in most cases i'd just stuff the rest into c unsplit (since that would be an error)

[@alexisfibonacci]

@@der.Schtefan I think we have the new spread operator for that?

[@vyrp]

I think it's improbable the .NET team will ever add array deconstruction, because the number of elements is unknown at compile time. In the example above, `a` will be "xxx", but will `b` and `c` be? Instead of deconstruction, you can use pattern matching: ``` string numElements = "xxx".Split(',') switch { [] => "0", [var a] => "1", [var a, var b] => "2", [var a, var b, .. var rest] => "3 or more", }; ```

[@g3ff01]

this works, but just for fix number of parameters: public static class StringDeconstructExtensions { public static void Deconstruct(this string ext, out string a, out string b, out string c) { string[] split = ext.Split(','); a = split[0]; b = split[1]; c = split[2]; } }

[@kevman2296]

Records are awsome. I use them a lot for DTOs but this use case is also amazing

[@wyattcallister2388]

Wow wow wow! That is cool!

[@fakhrulhilal]

Amazing. I know deconstruction magic since record introduced. But creating from extension method is new for me.

[@sanderqc]

Content as allways great. 🎉 Why first random int is exact 69 for You? 😅

[@88spaces]

I'll use the dictionary for each example. That's helpful. Thanks, Nick.

[@fifty-plus]

Use it quite a bit, it's very useful, not just in loops but to save dotting into the variable later in a method. Makes code a lot cleaner.

[@s.hosseinhosseini8330]

Good one.

[@jamienordmeyer4345]

I love that you can do this... but I REALLY wish that they would have just made it a part of the syntax, and have it look closer to JavaScript (I LOVE the way that JavaScript/TypeScript supports deconstruction). So maybe a syntax like this where I can just pull the fields I need without defining a specific Deconstruct method: var { FirstName, LastName, birthdate: Birthdate } = person; -- or -- var {FirstName, LastName, Birthdate as birthdate } = person; Syntactical sugar, of course. The compiler would just compile it to: var FirstName = person.FirstName; var LastName = person.LastName; var birthdate = person.Birthdate; But I'll take what I can get, and having this at all in C# is still super nice!

[@ayoko5161]

It is weird to have a method with a specific name 'Deconstruct' on an object, that translates the object directly without the declaration of a tuple. For instance, if I declare a method that is named 'Deconstruct' when I work on a 3d application, then this method name might be ambigous with object deconstruction. In my opinion, this feature leads to mentally overhead you need to remember, but you would not expect. Therefore I think it does not support code to be clean, if it is used wrong. To use this feature in a good way, it should be really obvious like in the example with key-value-pairs. Best way would be to use a method, which returns the tuple.

[@AlexxXRecorD]

Nice feature, but I think, necessity to use it appear not often. Thanks for video!!!

[@d3vil5oldier]

I did know about this but never used. I liked the datetime example that will help on my current project. Many thanks.

[@itaylorm]

Thanks is awesome, thank you

[@xRealHackerx]

That mustache says a lot about your favorite number 😁

[@Spid88PL]

Mmm, interesting thing :) Thanks

[@RockTheCage55]

cool i do this in javascript all the time. I didn't know this was possible in c#

[@AvenDonn]

The JS thing is different and definitely more powerful. Deconstruction in C# is nice but it's not JS

[@RagtaouiIssam-yb1nc]

Hi I need some help. I am listening to a socket for stock data, but sometimes when the data is very fast I get a lot of queueing and delay. I am using c#, I think the size of my buffer is very small. Do you have some suggestions on how to increase the size of the buffer? And thank you very much for all your videos.

[@x0rld159]

I always use the Dictionnary deconstructions to named properly my key/value

[@MixturaLife]

What I don't like about this object deconstruction is that it deconstructs based on the position of parameters in the Deconstruct method. It could be error-prone in cases when parameters share the same type. Pity that there is no option to specify parameter names similar to how I would have done it in methods/constructors.

[@idk_just_will]

I’ve used deconstruction for JS for a long time, pretty stoked to learn it’s available in C# too! I feel like KVP and custom records seem ideal. Maybe also some larger classes like Request would be nice to strip off just relevant pieces like Host and Query Params, but it doesn’t seem like you can just take what you want like JS, unless there’s a way to do it like a named parameter.

[@kabal911]

Indeed, how this works on JS objects is super useful and nice, and can be used everywhere, even as function parameters.

[@user-tk2jy8xr8b]

I wish there was some support for sum types, i.e. multiple Deconstruct_s returning bool. Having that functionality one could possibly switch on an Option type like `value switch { (var value) => TransformSome(value), () => TransformNone() }` provided a 1-tuple and 0-tuple deconstructions are made possible. Still not good enough to deconstruct an Either type though.

[@stxnw]

reasons why i don’t use this is because my codebase linter disallow using var and unpacking in c# looks terrible. i usually use it in a foreach loop where it looks a lot more readable

[@billy65bob]

I remember having to add my own Deconstruct method for the dictionary's KVP. Was such a massive oversight... and I think that's still the case if you're stuck with .NET 4.x.

[@alexisfibonacci]

As an extension method?

[@billy65bob]

@@alexisfibonacci Yes.

[@voidmice1669]

Can you use deconstructors in switch expressions especially for custom classes?

[@realtimberstalker]

I don’t know, but it’s unnecessary as you can already switch over a type’s properties with pattern matching.

[@figloalds]

Not many things in my day-to-day have obvious de-constructions, and when they do I don't even write a Type, I just straight up use tuples

[@andreaskarz]

Very cool, the excample with the dates are super

[@badderborroda4972]

What is an actual use for deconstruction though? I don't personally think (year, month, day) is cleaner than just using date.Year, date.Month, date.Day, and presumably deconstructing is doing more under the hood than just referencing the variable on the class so it will be marginally slower? For me it's worse readability and even if negligible worse performance

[@QuAzI_NODE]

Maybe it would be useful for some HttpResponse where you need to check the status before getting result

[@longvungoc260]

how to access view deconstructor method like Nick, I want to know its keyboard shortcut

[@musichobbylife]

It would be great if you could scope the variables e.g. var (date, time ) = new DateTime() { // code here can access date time } // code here does not see date or time. This makes it really easy to both review the code and free unused variables. I am aware this could be done by wrapping the block itself in { }.

[@softwaretechnologyengineering]

What happens to the reference of the class with the deconstructor if the deconstructor returns an object and the class with the deconstructor goes out of scope but the object remains in scope? Will the original be garbage collected or will it remain in memory?

[@louisfrancisco2171]

Garbage collection does not care about what is in scope or not. The garbage collector creates a graph of every reachable object starting at the roots (static fields, local variables...) and following each reference. Only objects that are not in that graph are considered unreachable and candidates for memory release. In your example, the original object could be collected if the object returned by the deconstructor doesn't hold a reference to the original.

[@kp_xcess]

It's probably because I haven't had a clear use case for deconstructors to date, but I don't really see where using them is an advantage over simply using a class' members. Also, when deconstructing them into local variables, does that not cause additional allocations on the stack or even heap?

[@pdebie1982]

I'm also not sure which problem is being solved with deconstruction.

[@g3ff01]

I've just measured it. It's the same. Forgive my stupid example, but: [MemoryDiagnoser] public class DeconstructionBenchmarks { private readonly Dictionary keyValuePairs = new() { { "Key", "Value" }, { "ki", "value" } }; [Benchmark(Baseline = true)] public string NonDeci() { string build = ""; foreach (var pair in keyValuePairs) { build += pair.Key; build += pair.Value; } return build; } [Benchmark] public string Deci() { string build = ""; foreach (var (key, value) in keyValuePairs) { build += key; build += value; } return build; } } | Method | Mean | Error | StdDev | Ratio | RatioSD | Gen0 | Allocated | Alloc Ratio | |-------- |---------:|---------:|---------:|------:|--------:|-------:|----------:|------------:| | NonDeci | 24.39 ns | 0.427 ns | 0.379 ns | 1.00 | 0.00 | 0.0172 | 144 B | 1.00 | | Deci | 24.60 ns | 0.530 ns | 1.163 ns | 1.02 | 0.03 | 0.0172 | 144 B | 1.00 |

[@mirkogeffken2290]

Deconstructors are only good with folks that use good variable names. It’s why I love var. Help those after you are gone to comprehend what you left.

[@pdebie1982]

Still not sure why you should use object Deconstruction. What problem is it trying to solve? I mean, it isn't complex to write out Point2D.X or keyvaluepair.Value.

[@foxred2380]

Hello, can you make demonstration video about SAST pls

[@MichaelBattaglia]

Can you add deconstructors to sealed classes?

[@vyrp]

Yes, as extension methods, like Nick showed in the video.

[@meisamhashemi4363]

muscle memory typed that number

[@olyazhulanova8028]

nice

[@BernhardMillauer]

Dear Chapsas, I really appreciate your work and engagement to bring knowledge to the people. May I ask you very politely to add warnings to the extensions you teach? Like the Task the foreach-range extension some time ago which is kind of "clever" but hard to grasp if you're new. In addition to the "hidden" dept you introduce with such code, refactorings with tools like resharper break at some point because these tools just don't know how "clever" you were with your code extensions. So please, keep going with these interesting ways to use c# and show what's behind the curtain, yet add a warning to your fellow viewers that, if you leave the standard-path, you chose to travel at your own risk. Thank you very much!

[@inzyster]

That’s super useful. Is the duck typing magic all compiler or is there some kind of performance penalty for using this?

[@AvenDonn]

It's not duck typing in that sense. There's a Deconstruct method behind this. You're just calling the method. If I misunderstood the question, then the answer is "yes it's all compiler magic" The only penalty is on the scale of doing the deconstruction into separate variables, but you're already paying that cost in general. The only time it matters is when you Deconstruct to only access one or two properties out of hundreds. Good luck even having a Deconstruct method in a type like that

[@inzyster]

Thanks, that’s exactly what I was curious about 🙂

[@garcipat]

I would like if deconstruction would work for linq expressions of objects. Like keyValuePairs.Select((key,value) => ....). Sadly it doesnt

[@funkwurm]

With your syntax the compiler can't know whether you mean to deconstruct or whether you want the index of the item in the keyValuePairs into the value parameter. But yes you could imagine a syntax like keyValuePairs.Select(((key, value), index) => $"Item at {index} has key {key} and value {value}");

[@garcipat]

@@funkwurm you are right. Maybe that even already works, didny try that yet

[@jessebitch6227]

Nick we are waiting for .NET Roadmap 2024. :D Cheers

[@body_web_life8497]

Hi Nick! Great video. I have a question , if you can add aliases in the deconstructive parameters. If yes how this implemented. Thanks in advanice , Keep it up 🙌🙌🙌

[@PublicVoidFoo]

You can name your deconstructed variables as you like. They don't need to match the parameter names of the Deconstruct method. It matches based on position. For example: var (myKey, myValue) = new KeyValuePair("foo", 420);

[@body_web_life8497]

@@PublicVoidFoo Ok thanks !! But if we are talking about a class DateTime that have properties day etc. If i want to set an alias currentDay how the Deconstruction understand that I refer to day property?

[@stephenyork7318]

Why are they getting away from interfaces? For something to be usable in a foreach you need the class to have an interface method implemented. For disposable you need to implement disposable. I would have thought a feature like you’re showing would require the interface to implement IDeconstructible. I noticed that middleware classes also don’t implement an interface. Shirley it’s less efficient for the language to have to reflect the instance to see if they have the expected method?

[@necrokora7688]

It is not reflected but lowered

[@JamieTwells]

Because the signature of the interface would limit the types and number of parameters you can deconstruct. He only shows deconstructing two parameters here but you can do three or any number (more than 1).

[@klaxxon__]

It's annoying how you can't deconstruct on the left side of a lambda arrow (eg. a Select over enumerable of KeyvaluePairs would let you take key and value on the left side of the arrow). I use that in Typescript all the time. You also can't deconstruct in the inline variable declaration when taking a value from an out parameter of a function you are calling.

[@Sander-Brilman]

I initialy thought you were talking about the destructor. but this is also very cool

[@fifty-plus]

I think you meant destructor, no?

[@Sander-Brilman]

@@fifty-plus yea i mean that, i always get them confused 😅

[@boxacuva]

The one issue i have with this is that deconstruction for DateTime is culture specific.

[@kenbrady119]

Isn't this just an implicit cast operator?

[@garcipat]

Sadly i rarly found any usecase for this.

[@gavinlangley8411]

Async functions cannot access functions with out parameters, doesn't that limit the use-cases for this quite a lot?

[@AvenDonn]

Why would your Deconstruct method need to be async? That implies you're doing far more than deconstructing

[@gavinlangley8411]

@@AvenDonn The point is that the deconstruction cannot be used within a function which is async. If the question is why should a function be async then that's a technique for server resource utilisation. It's quite a big limitation.

[@kp_xcess]

This is not true. Methods that are async themselves can perfectly use other methods containing out parameters.

[@AvenDonn]

@@gavinlangley8411 what are you on about? Yes it can Source: *I've literally done it* Async functions *cannot themselves* have out or ref parameters. They can most certainly call and use methods that use those.

[@grozoff]

Hello Python

[@AddictOfLearning]

I think this is neat, but I can't think of any real world use that I would use this for.

[@ravikumarmistry]

69 is your favorite I think

[@anar.bastanov]

Hello

[@zagoskintoto]

I feel no one gives you enough credit for the commitment to use 69 everywhere, even when initializing your Point2d. So here it goes. Nice

[@PublicVoidFoo]

420 didn't make an appearance this episode 🍀

[@ILICH1980]

Nick 69 - oh my ;-)

[@Namynnuz]

Finally, well welcomed TypeScript feature implemented in C#.

[@evancombs5159]

Deconstructors have been around for a bit at this point, coming in with C# 7

[@ralmslb]

One issue I worry about deconstruction, is the added GC pressure vs accessing the values directly.

[@ara849]

Why would it add additional pressure to GC?

[@diadetediotedio6918]

It has no added GC pressure because the tuples it uses for deconstruction are structs, they are (in this case) allocated on the stack. *** Correction, I totally forgot about this *** It does not use value tuples either, it is just a method that uses a bunch of 'out' params, so you will not be allocating nothing either way.

[@ralmslb]

​@@diadetediotedio6918I would say it depends on the parameter type. Because if I use for example a custom object or any other ref type, I would expect an allocation from the out parameter, even if just to have an object that has the memory address of the data it contains. Which still forces GC to clean it up eventually. I highly doubt that this acts the same way as for example stackalloc. I guess I will need to run some tests to be sure.

[@diadetediotedio6918]

​@@ralmslb No, not really. This do not depends upon the parameter type, because the practical difference between a reference type and a value type in this context is merely how it is represented in the stack. If you out a struct, it will be copied entirely by the processor into the out param (assuming no optimizations), and if you out a class it will just copy the 8 byte pointer into the out param (assuming a x64 architecture), no heap allocations would be made in this context. Heap allocations (the matter of GC) occur only when you create a new class instance or box a struct, otherwise it is just overwritting memory everywhere around.

[@ralmslb]

@@diadetediotedio6918 You're right, I did some benchmarks, isolating the base Class to just have the decomposition and it causes no GC (params were an int and a String). I was confused thinking that even if you are copying the reference, that an object with that reference would be created, that would result in GC allocations, which even if it's happening, it's being cleaned out when existing the method context and not by GC.

[@MatinDevs]

this number is cursed 😂

[@asteinerd]

Honestly it's kinda pointless unless you have the additional flexibility of the spread operator putting "the rest" of the object into subset type like Typescript does. The heap/stack could create a ref just hides class members that have already been implicitly referenced; make it something akin to a read-only struct to avoid recreating the object every time a local variable is created using decontruction. When C# get Pick and Omit capabilities than it will be a powerhouse of simplicitiy allowing ultraportable type-ref libraries akin to what we see in TypScript.

[@diadetediotedio6918]

I don't see how it does not having what you like make it 'pointless', it is pretty useful in some scenarios for clarity even without this resource you are mentioning. It with it, but it does not render the actual implementation .

[@asteinerd]

​@@diadetediotedio6918 it's a half-baked syntax-sugar feature that's relatively unessesary in a language that supports tuples and delegates outright that can accomplish very similar things. Plus I don't really see C# using it anywhere other than data-type structs with values that are expressed at invoke; versus classes that could potentially compute and mutate after intialization and during run-time, meaning "out" would need to be switched out with "ref" to stop the stack/heap from replicating the object every time the variable/local is used. It's a really cool feature as-is; but I don't see a point to it. It doesn't make coding faster, it doesn't optomize the code doing it this way, it's not cleaner or legible that adding a dot and variable name on the next line. ---- I'm sure I'll come around to liking it once it's fully implemented and non-scripting use-cases are provided for it. But I stand by my 'pointless' opinion of it.

[@oislek34]

Get to the point man, stop counting seconds for $$$