So You Think You Know C#? ValueTuples & Deconstruction

what's up youtube in today's video we're going to be looking at value tuples primarily and this is a new feature since c sharp 7.2 or something but we're also going to be looking at anonymous types which have been around since link has been around and tuples which are the older version of value tuples but focusing on value tuples and focusing on going under the hood so this is a so you think you know c sharp series so you can imagine there's lots of surprises here waiting for you so if you don't know how some of the stuff works under the hood then this is the video for you with regards to value tuples and even anonymous types maybe some people use them they don't quite understand like what's going on and that's the point of these series the c sharp so you think you know c sharp cities focusing on value tuples first we need to understand where we use them then understand what they are and then go under the hood and try and understand even better or even deeper what they are while we do that we might also be looking at anonymous types because there is some similarity to some extent just again from an interest point of view you know the do you know think you know c sharp perspective understand what anonymous types are contrast them with value tuples because they kind of seem the same similar and also the old tuple types which also sort of satisfied the same need that value tuples do today and in many ways the tuple type the old tuple type is considered a mistake now of course you know 2020 hindsight so first just let's look at where would we use value tuples right so first of all value tuples they're called value tuples because they're value types they're not reference size the tuple type which has been around for many more years is a reference type but otherwise they all both of them look kind of the same the difference is one's value type one the reference type now it's a struct the value type double the destruct and typically in c sharp the guidance is their value type should always be immutable and even now you decide design your own structs your own value types please make sure they're always immutable as in they are not mutable however value tuples are mutable and that's something to be careful about there's probably a reason for why they're mutable but as a result you need to understand that they are still value types they are not reference types and value types mutating value types has a different behavior from what i think most people are used to when they mutate reference types all right so having said that when would you use these tuples value doubles essentially when you wanted to return more than one argument more than one variable from a method so typically methods have one return type sometimes you want to return two return three return types and the tuple type in c sharp has been the sort of the stand in for that and of course there are some issues with the double time and i'll discuss those and as a result nobody ever used them so the value tuple looks similar to the tuple type so what's so special about them well that's what we're going to find out today so here i'm going to design a method that i would like to be able to return multiple types so we'll leave that let's call this compute aggregates let's see and the aggregates i want to compute are things like sum average and max let's say so i want to return multiple types i'm going to do that let's do this with the tuples first the older tuples so we had a tuple so some let's say i'll keep them as double some average also double and let's say max isn't it just as an artificial argument's sake all right okay so if you were to return this some type from here then you would have to say you know return and i believe tuples have a factory dot create so you can use this you know create factory method and you can specify the different types or you could just simply if you know them them to be doubles and you could say let's say count let's say 20 d to double and then they have let's say 13d and the max is let's say 35 as an example right so i can return this i'm returning an instance of a tuple this is not the value table this is the tuple type and over here let's say we were looking at using this return compute aggregates right you would have something like that and when you look at the aggregates type you'll see there are properties it's called item one item two one item three is not called sum average and max so that was the problem with the tuple type that even though we could conceptually return multiple values from a method rather than you defining your own type this double thing kind of made it quick and simple or easy convenient to define a thing literally kind of on the fly without having to specify your own type right the problem was that item one item to item they didn't make sense on the call side and you kind of lost that usability if you will personally and for even with people i know personally we hardly ever used doubles in fact never right i tried it once literally and i gave it up i said okay this is it i don't like this item one item two thing i'm just going to define my own types one would wonder then so what's the real problem so you can define your types and i'm never believe me i'm never concerned with defining extra types i'm really not but i do get concerned when the extra types really don't have any meaning to my business you know what i mean like if i define a type that has the sum average and count like it doesn't necessarily mean anything to me it's not i can't give it a name it's not a sort of basic you know domain entity in that sense it's just the thing so now i start questioning do i want to define things like that you know that have min max and count and average some that i can't actually name at the business level do what i do with this stuff right it's like i'm defining things that don't really hold a whole lot more in meaning than what they just are and that's when i would wish i could use the tuples but i didn't want to use double because i don't want it to item three thing so if you find yourselves wanting to return a domain specific thing or that in your mind could be considered part of your business your domain the system that you're building then don't use value tuples right just use them for these kind of things that are a grouping of certain values that you would like to return from your math i mean it makes sense right you've got a collection of you know information with one iteration through this collection you can calculate the sum you can calculate the average you can clear the min you can calculate the max it makes sense that you can do all of these things in this one method at this at the same time and what if you could just return them right now you can do that today without and breath modifiers but as for the guidance don't use outer depth modifiers and so we would resort to defining our own types okay so let's look at what else can we do with the double let's say we use value tuple here instead of this type and you say okay then uh early tuple also has a sort of a factory method if you will it does that and now what's the difference here let's see that what's the difference here oh well this is the same thing item one item two item three so like where's the benefit what's the value what's the value of value tuples it doesn't seem to be a value but it gets better now so now that you understand through the use case and some other problems with the tuple type i'm going to introduce to you the value tuples and we're going to look at how best to use them so with the value tuples this is not the syntax you would use you would actually use something like this so there's a lot of convenient syntax when it comes to value tuples so you would do that and you're saying hey but that's great what i mean how much did that save us well it gets better you can actually also do this right and so what you're doing is you're saying here's the definition at the time of defining the method signature you're saying this method returns a double double int and and then it returns this as a single thing and then it seems to have put them all together here now you can't remove these parentheses the parentheses are required for a reason and i'll show you why what that reason is once we look at what's going on under the hood it's just going to make sense on the call side then what's the difference let's look at the the difference on the call side we're still stuck with item one item to item three so we're getting a little better the definition of the method is a bit improved the return type is a bit improved you have to specify the new value type and value type and all that over here so why do you double i mean so was this what's so special there are a couple of things one i'm gonna now even though for the sake of this exercise i felt it's easier to work with something more meaningful rather than abstract like some average and count like they all just normally doesn't really make a lot of sense so for the sake of explanation only i'm going to use a vehicle dto vehicle you know dto because it's got like a make model here and then it just has a little more meaning but don't do that in your systems if that's your business as in a vehicle has a meaning then define a type called vehicle don't use it as a tuple or a value tuple right so i'm going to have this changes method called you know get vehicle and the make would be a string the model also will be a string and let's say the year is in it okay it was already in it all right so here let's see the makers mercedes the model is amg slc 43 who likes this car oh my gosh this is the 2020 model oops 2020 model okay so we have a mercedes here and we do that so i'm just bringing it back to the way it was before except now with vehicles instead of aggregates all right so so far we're not seeing any difference we're still seeing the item one item to item three that's great all right so where's the value of value tuples what are we really getting as a benefit and what's going on under the hood right one value is you can do that you can do that how cool is that what it really means is the first return type will be assigned to this local variable here the second return type over here the third return type over here and of course if you were to look at the values you will see let's say if i just did you know i print out the make over here yeah we should see mercedes as the first return type here and his email series right okay so this idea or this ability to split up the return type on the call site into multiple variables is called deconstruction and it's also a feature of tuples we'd be looking at that it's not sorry what i meant is it's not only a feature of tuples so you'll be looking at deconstruction for other types that you might have in the system as well because a very powerful and very cool feature of course everything cool ends up getting abused and then i fear every time i show you something the next thing you know it's going to get abused so please use them wisely but this is the idea of deconstruction and we'll be looking at so this is using deconstruction it's able to take a return type like this or multiple return types and allow you to deconstruct it like that right there's another way you can do that the var is of course type inference based on the return types here so it's inferring the type right so now you might be wondering in some cases what's the difference between the tuples then and anonymous types they'd seem to be this similar if you've used anonymous types you're wondering like that's almost like an honors type right here's what a normal status look like so you could have um something let's say wiggle and you could say new good to make omg sl43 2020 all right and then here you could get access to the properties to make model and the year right with the with anonymous types and well the value types you can just say we didn't call this method i could do this with value types value tuples are mainly value types value doubles so here i could say mercedes amg sl43 2020 so now they start to look very similar these two so let's look at anonymous types just for a bit that thing i don't spend a whole lot of time on it but there's some magic happening with almost types as well under the hood since this is again hey so you think you know c sharp series is worth it digging in a little bit under the hood to see what the heck is going on with anonymous types right i'm going to remove this part for now and remove that as well so i just want to show you this part what happens with this all right i'm going to go i've compiled this application i'm going to go into i'll spy i've already hooked up the the xz2 value to i'll spy so i'm going to keep doing this over and over and here we shall see some magic all right what the heck is that do you see this what do you think that looks like this looks pretty weird but really this looks like the type name that's a generic type so now this is a closed generic type it's called vah and they're saying new of that close unit type and then it's got our data here so even though we wrote just this code see this with new curly braces and all that it is basically lowered if you remember the c sharp lowering if you haven't if you don't know what c sharp lowering is please take a look at my video here i talk about c blurring is very interesting feature if you are wanting to understand how the ceo compiler works what's going on under the hood stuff like that that'll be an interesting video to watch this is c sharp lowering what it's doing really is this taking the code b right here which is like a it's like a convenience feature and it translates that to normal c sharp which is it has to new it up and stuff like that but what the heck is that if you look this at this one it is an internal c class that's called this funky name and look at the names of these things holy my gosh goodness thank god you don't write code like that if any one of you guys go like that i tell you you know i'll look for you i will find you okay the thing is this is better c sharp code we are not able to write code like this the compiler will block us from naming our variables with open angle brackets and underscores and stuff but it is not it's still valid c-sharp we're just not allowed to use that and so as a result when we whenever these compiler generates c-sharp code on its own it uses this naming kind of thing because it knows there'll never be a collision right unless we free of collision from its own code that it generates as well as from any code that we might have written in our application so that's the name of the class all of that and then there's this this part here and then these are generic type arguments the names of the generator type like t1 t2 so that's they give these weird names to them and then you have read only members that have the you know funky names again and the type so that's the name of the nested type and then that's the name make model here so it's using the previous exist previously existing names but adding some other stuff to it to kind of make it you know unique and then it's got properties defined and then a constructor that takes those arguments and so on so forth it also overrides the equals and get hash codes so with the value tuples so this anonymous types with anonymous types they are value semantics they use value semantics for equality or value equality not reference equality so because they've already in the equals and get hash code methods and of course the two string implementation all that's done for you but this is a type it creates on the fly it didn't exist there's no base class there's no base class here it's not descending from something it just manufactured this type all on his own it's pretty cool but it's a reference type which means anytime you use value types you're creating a reference you're creating a new instance allocation in on the heap so you'll be worried about that if you're using this in link when you especially when you use you know select and you project some type that's not doesn't exist if you do that a lot you might just define the type yourself right it's not adding any value to do this sort of thing on your own but here's another thing let's say i might have a different i define this multiple times not just in the like one next to each other but elsewhere in my application like anywhere else right if i defined i made the same declaration here same property names whatever model the values are different with the property names and the types are the same then at compile time the compiler will not generate another type for the same for this one if they match you'll just use the same type it's a type definition why would it define another type that's exactly the same as this one so it finds that the type definition already exists it won't define a new type definition and a new type and so you'll benefit to some extent where you know you're using on almost anonymous types all right so far it's just been anonymous twice but i'm gonna i'm done with anonymous types going to go back to the value tuples all right okay so going back to battery doubles okay so we had this thing here and you're wondering like okay but what's the deal with this what if i did that right you could also do this and if you're defining the thing here you could do you know make something available use syntax yep if you're defining something on the fly and this one makes sense but that's not how it normally works so now when you do vehicle dot you'll see the make model in here going on here which is cool so this is very important right you don't know this ahead of time it's not normally is coming from a method here so let's go back to these method type signatures and how would you define these method name method signatures all right so now we just remove that put this here all right at this point here we're still stuck with the item one item two one item three and we are looking at going to look at now how to improve on this so one way to do that as i showed you earlier was you can deconstruct it here and you can do that this so you're doing the deconstruction and apparently you use the caller that method seems to know what the different types are the string string into like which was the first string what's the second string what's the third string you now have to look at implementation of the method right you can't discern this from the outside so you have to look at the implementation to understand what's the first thing what's the second string what's the third string that's okay but i don't recommend that so what you can do also you could have when you define this method you could say the string is the make and then this is the model and that's the year now notice the casing is not like the sort of argument casing right in arguments we and c-sharp would normally name them as camel cased this is more pascal cased the return type reason is when i see it over here now even if i did this right if i did something like that i could look at and see that there now has the make model and here properties and they're the casing here the way i'm seeing them is because the way it's been defined over here and if i define this in in camel casing then that's what i'm going to get so i'll leave it up to you to decide whether you want to make these as camel cased or pascal case one i think it might make a it might make it easier this doesn't look like method arguments the return types so maybe that would be a benefit the disambiguam ambiguity the inputs and the outputs okay so on this side now you're going to see this as uh pascal case so you've got to make model in here that sort of seems it looks weird so i would actually prefer to do that right you can still deconstruct it here so you don't have to know that this is more from the the way you define the method signature i'm talking about that as a perspective of for the sake of understanding the methods in nature in and of itself that's how you should do it right you should always define the type and the name of the argument so that people from the outside of the method don't look at the inside the implementation to understand what is that first argument what's the second argument what's the third argument the other thing is don't use these this feature for methods that require to return more than three i think three is the max three is already i think in some cases too much one and two one of course we already had two is when you start to use value tuples and three is kind of the limit i think if you start using many tuples for more than that it gets really complicated and hairy to understand what is going on but also you know readability i mean if you especially when you're using generic types right iron renewable law or task of this financial or something else and that one argument is that long and then like by the time you finish two arguments or three arguments you've gone past your width of the screen just in the the output arguments you've already defined the method name and the input arguments so but i think if you go beyond two or three look at do you want to just define your own type right again the type i have sometimes have an issue with defining types that are not quite meaningful to my business side they're simply placeholders or a way to combine multiple values but you know if it means that readability would improve then i would certainly look at defining a type that's named you know somehow correctly for the thing i'm trying to do here and then use that instead of multiple more than three return types in a method i think that three is like kind of a limit right okay so the other option is as i said over here you could still go back and define it be more explicit and you could do that and you could define a variable over here which you can't normally do if you don't specify the types if you use bar you can't define a variable in other words if i let me just copy this over and i'll keep writing this over and over if i did that then i won't be able to define a separate variable on on top of this right this doesn't work at this point it doesn't like this i have to remove this type here and now it works right so you can do this define your your variable local variable like this or instead of using var you specify the types of the arguments and the names and then on top of that you can also specify a singular variable so that your singular variables properties will be equal to what you've defined so now overrides is lowercase maker it overrides what is coming from the method so this is the thing with the magic as i said value tables under the hood are simply oh we haven't seen what's going on under the hood right let's look at what's going on under the hood with value doubles all right so now i've built it let me compile that's already refreshed this assembly here reload it and let's try it again and look at the we look at main that looks different but it's understandable if we're saying it's the type value double or string string int call it a vehicle and then look at this so the way we written the code with the assignment as make more earlier it gets rewritten to that defines it as a vehicle of double string string and but then it assigns local variables with the names and push them in there right now at compile time what happens to the this method here now in the methods this is the one aspect of value tuples is there is a concept called type eraser type razor is typically associated with genetics for example in java the genetics is implemented using type eraser which means once it's compiled you lose information about the type right the the constraints that you're limited with are only for compile time as in at the time of you writing the code and compile time once the thing has been compiled those constraints have been removed in other words there are features in languages that prevent users language people writing code in that language from doing certain things yet the language itself doesn't have a constraint and so type erasure is this idea where like in java genetics you have certain constraints when you're writing the code but once it's compiled those constraints disappear there so the type information if you will disappears it's not actually required for runtime but it is required at the time of compiling c generics of course does not use type erasure it uses another the opposite of typewriter called reification i think it's pronounced uh spelled as r e i re re-refification i don't know how you say that but that's what it is and that's the way c-sub-generations are implemented in value tuples we have a notion or a semblance of type ratio whereas certain information that we had at compile time disappears at the after compilation and that's what it is over here we've lost that information about the names and so what they've done is they've introduced by name i mean like if you look at here we have given the names for the return types and so what they've done is they've introduced another attribute here called tuple element names for the return types and just names so if you were reflective would reflect upon this assembly here it's not going to be simple for you to reconstruct if you will the idea that these things were called these names but it's possible and so with the help of the attribute that type eraser is restated if you will but for all practical purposes the diaper is has taken place and you don't actually know what the thing is this value doubles all right so behind the scenes just to recap here the method signature changes to still go back to value doubles the implementation is still saying new value double blah blah and now you understand why that signature wants us to have to write this score here because this is the way to create a new instance of a value double where that's the first argument that's the second argument this third argument i wonder if this would work i guess it does what does that do what if i didn't specify this doesn't like it so as long as this is the match it's good with that yeah i don't know the name matches is good with that so basically that declaring it twice doesn't have any meaning then okay and these guys think about everything don't they okay and because these things are value types be careful about something like this let's say i have you know this is so and so and i want to go back to declaring this with the types we have i'll need that variable all right and let's call this okay so when you do this this is a copy it looks like this is an assignment like you know you assign reference types to each other this is not the kind of assignment this is a copy right so there's a new instance of this value tuple being created here as a value type and so you're making another copy of it these two are not the same right so if you then modify the properties of the one that's copied or the original one they have there's no connection between these two things they don't share the same reference so keep in mind even though it looks like you know reference types is something you want to do so of course when you are using value tuples personally you know if something comes back to you from a method you shouldn't be changing it so similarly when a method receives something you should be changing it so if you program like that it's not odd or unusual for you to not touch it i know a lot of people kind of don't like to declare the variables they start modifying the variables that came back from methods or sent into methods being changed by the method so don't do that but if you are doing that sort of thing then be careful of these being valid value types and not reference types and i said this that these are value types and they're also mutable meaning i can actually change the property so let's say make true something else let's say i said uh you know that's allowed it will allow me to do that it's not going to create a whole new copy it's the same copy same same instance of this value type whose property make has been changed from mercedes to toyota and it's not a new copy so it's immutable i'm not sure why it had to be mutable you know but yeah be careful of that too in case you're used to it being things being immutable i am and these things can be mutated then just be you know careful of how you use that as well the other thing that may not been have been apparent here is when you look at the the value types they implement the equals and they get hash code methods here so which means that these value types value tuples are you are able to compare them using value comparison with a value semantics or so not like reference semantics and reference types so that's also a key thing to keep in mind that you can compare these as y equals b meaning all the property names and values are the same they're not the same then you they're not equal if not they are the same right structural slash value equality the fact that they implement get hash code [Music] of their own as an order gives you the ability to use these things in dictionaries as keys equals with the equals method allows you to compare using value comparison or value equality and the same goes actually for anonymous types as well they also implement the equals method in the anonymous types you know the generic that class they define on the fly has that implemented and also as the two string also is implemented in that class and so is get hash code so even anonymous types can be used in dictionaries as keys can be equated or you know compared with the value equality semantics using the equals method and so on so then the last point is deconstruction okay so deconstruction is how this stuff works all this stuff to be able to do here is deconstruction but what if you want to be able to do this for your own types yes you can you can also do this for types that you don't own using intent extension methods right i personally would suggest it but again it's a cool feature so if you have your own types you could do that so let's see how that would work for our own types right so i'm going to define my own type here let's call it vehicle and let's call this and [Music] this is the string hmm okay so this is just an immutable type so i have my own type here it's just something i'm going to call a vehicle and i want to be able to use it so let's say i want to say how do you have vehicle there's a v is equal to new vehicle and let's say over here i'll say [Music] mmg 43 2020 right but let's say i get return a vehicle type from another method and this is this vehicle because we scored three probability but let's say this type had a whole lot of properties however most times when people use your type on the call site even though they'll have a need for all the other values they typically use they say two or three of these values of for the most times right so you could say okay i'm going to have a deconstruction deconstruct method you can have multiple by the way not just one in the same class you can have multiple deconstruct methods by the same name deconstruct and that's even know what that is how does that work just because i could define a method with the deconstruct name like how does that happen duct typing yes so cjrc has some duck typing in that regard as well if you looked at my i forget which video i talk about you know with four or four each also this duck typing and so on so the duck typing kind of finding his way in different parts in c-sharp as well it's not necessary that we used our tabbing but the compiler and runtime could possibly use it all right so i'm going to go here and in my vehicle class this is my own class but i'm going to define a public method oops this is the void returning method but it's got um out types so this is out modifier out string make because this big camel case now our string model camera case now doesn't have to be but i'd rather stick to the convention that we have in c sharp which is arguments are calcased okay and here you implement it so you have to actually implement it let's say over here we'll say you know make um however you implemented independence like at some point you'll have to assign the values before the method leaves so on the call side now that i have a deconstruct method here on the call site i could basically do the same thing i could just say var make model and here and that works it works because of the fact that this class has a deconstruct method on it right as i said you can have multiple deconstruct methods in a class you got to be careful about the ambiguity aspect even though c does not determine whether a method is the same or not based on return types the ambiguity on the call side can occur based on the types of the values returning so be careful about not careful something may not work the way you expect because the compiler might on the call side might complain about certain things and the other thing is that you can define on using extension methods deconstruct methods on types that are not yours so you know if you feel like you're using this one type that you have in your system a lot it's not your class it's coming from some other library you could define a deconstruction deconstruct method on on it for yourselves and you can use them with the one or two arguments to use normally and that's kind of like a convenience way of doing it the other aspect about these types is that let's say in this particular case i'm not interested in the year so you don't even have to define the your parameter argument here you can use the discard and the discard is sort of showing intent you're saying okay in this particular case i'm only interested in the make and the model i don't care for the error so no need to declare the variable year just not to use it just don't use it declare so it's discard it's called a discardency sharp and of course they can all be discarded if that's what you wanted so i'm saying in this case in this particular case let's say i'm calling this method and it returns to me a vehicle i'm only testing the make here maybe someone else i'm interested in all three but in this case i'm only interested in the year right so i'm discarding or using the discard type in c sharp to discard and that's not you can't do that if i want to discard something like from a return type i can also discard it as a singular but that doesn't make sense if i discard it like that like oops sorry where am i i'll go there okay so if that's the case then like what's the point like you know what if you don't need it [Music] you're really saying i've created a new wake up i'm not interested in using it like saying what but this is not the discard this is actually defining a variable that's called underscore a discard would mean that that so you can't borrow it you can't define it as a var so you know the other compiler is happy so the discard type is a little weird if you never used it before but it's very convenient of course and but you can't say var to it if you say water that's a variable you can actually have a variable by just the name underscore so that's what is happening here so basically what the excluding i'm saying i think here was saying that you're not using this thing right yeah remove this unused local variable it's not a local variable discard so don't don't make it local variable use it without the bar so going back to this case if i didn't want the make accuracy okay that's i don't care for the make but i do need the model i'm interested in the model and i'm invested in the year so you could do that right so you're discarding the things you're not interested in to show intent and of course you need the bar on this end you know let's look at the implementation of this deconstruct method right we got this out arguments here how does it actually deconstruct it let's look at that so i'm just going to um build make sure this application builds i'm going to copy the code all of this code now let's go into shoplab.io and paste all this here let's look at the you see here this is our code and we write the code like this and it gets deconstructed to these three different variables here what's really happening is calling the deconstruct method for you and it's declaring our variables here i think language design if you're good at that would be really cool right to come to think of think of the syntax arriving at of course these days the c-sharp the design not done in isolation is the you know if you're interested you should participate as well since it's open source i just think it's interesting the way they say okay i wish we had a feature like this and then you kind of you kind of go back into it right you you backwards to figure out how am i going to implement it you know into at the compile time from a programming from a coding perspective what should it look like and what should happen you know compile time what happens after compilation like diaper asia and stuff like that so here what they've done is they've declared three variables they use them as the out arguments here for the art modifier for this method and of course it comes back and then they just declare the the values have been assigned here so that's cool and everything else goes on as usual so this one line here translates to that internally and this is the other beauty with c sharp and maybe other languages as well where the in this case because the c sharp lowering feature the actual runtime is can still be an older runtime one of the things you should look at here is for example in uh yeah see i normally set this to c sharp two here because if i did the same thing let's see the loading idea of c sharp loading is to lower the code down to a lower version of c sharp and because all the new features are for the most part are simply compiler magic synthetic sugar at compile time it goes back to being the way it used to be c sharp two so if you look at here if you get this value doubles thing maybe it's not going to be visible but if you look at if you convert this to this is c sharp eight or something it'll be very different right so in c way it becomes like that the and this still won't make sense to a whole lot this is what we've seen before but in older versions of c sharp it actually becomes like this so let's do the wrong method again yeah anyway all i'm saying is that these tools depending on what version they're sort of decompiling reverse engineering it from and back to the output might be different so you might want to play around with to see like how it all looks but that's the sort of the point i was trying to make is that all c-sharp loading is trying to do is lower your higher level newer version c-sharp to a lower version c-sharp and then compile it right so it's not like the compiler has to learn new tricks but the compilers already have the runtime and the jitters don't right so the c team can work independently of the runtime team not acquiring the runtime team to support a new feature in c sharp since all it really is is compiler magic so that's all i have for today i hope you've enjoyed yourselves if you have please give me a thumbs up if you haven't liked my videos please give me a like and i will see you next time

Channel: Shiv Kumar

Views: 1,287

Keywords: ValueTuples, Tuples, Anonymous Types, Deconstruction, C#, .NET, OOD, OOP, .NET Core, ASP.NET, ASP.NET Core, Programming with Intent, Value Types, Reference Types

Id: x3At5Pq2__I

Length: 46min 27sec (2787 seconds)

Published: Sun Aug 02 2020