.Net Foundation On .NET, 19 Sep 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: This is how you get rid of null reference exceptions forever

Description

https://aka.ms/nullable-blog

In this episode, Rich sits down with Immo to explore how the new new nullable reference types feature works for library and framework developers.

[00:00] Intro
[00:54] What are nullable reference types?
[03:46] Demo time!
[07:13] What's flow analysis?
[11:48] How does Debug.Assert work?
[13:17] Nullability and generics
[19:42] What process was used to annotate the framework?
[24:17] How powerful is the compiler analysis?
[27:33] What's the philosophy on annotating interfaces and virtuals?
[31:42] How do I enable nullable reference types?

#dotnet #nullability #nullreferenceexception

A

Today, on the on.net show. we're going to be talking with immo about nullable reference types.. This is how you can get rid of all those null reference exceptions, forever.

A

Welcome to another episode of the on.net show.

A

today,, we're going to be talking with immo and we're going to be talking about nullable reference, types.

A

okay., so you've been on the show before,.

A

But how about you introduce yourself for the audience.

A

You're, more famous than me. no,, I'm not famous at all. at least,. I hope.

B

If I'm famous,, then probably for the wrong pictures., so I'm immo landwerth., I'm the program manager of the.net platform team and I specialize in anything related to api design,.

B

The base class library or bcl, as we call it,.

B

And all the fundamental types,, all the things that are fun. yeah, awesome.

A

So what are we talking about today?, so today, we're talking about a feature that you.

B

Probably have heard about many times, but we want to go a bit more into detail on how the feature works and why.

B

The feature is relevant for library, authors and what we need know about it and specifically,. The feature is called nullable reference types,, which is somewhat funny because people what they really want,.

B

Is the fact that the thing to be non-nullable,.

A

When you want to get it nullable. yes,, it's confusing. also,, so.

A

We have like 10 years ago or something like that,.

A

Nullable value types was introduced into the language.

A

So up until that point, value types could not be null.

A

right., so it's the opposite direction..

A

So are these like a meeting in the middle thing?.

B

Yeah. the interesting thing with value types is that.

B

Value types and reference types have different representations in memory., so reference types could always be nullable whether you wanted that are not.

B

for value types,. Usually the way you deal with. That is what we call sentinel values,.

B

Like you just say: zero is my null value or, like you, have an h property and you say well,.

B

If the value is zero, then it's not set.

A

That doesn't always work when.

B

Pretty much every value is a meaningful value.

B

in this case, sentinel values are hard to do., so nullable value types allow you to basically say well,.

B

Imagine you have a wrapper type that basically carries a flag that says, is the value actually present or not,, and that's basically what it is., but instead,. It has a different representation.

B

now, that the reference type is basically a feature.

B

Where the underlying memory representation is exactly the same as before., it's just that the type system is more enlightened about your intent..

B

You can say, "I, don't want this property to be null,", and then the compiler can help you figure out cases where you may accidentally have it set to null. When you didn't want to., that's basically what the feature is in a nutshell.

A

So should I think of this more as a static analysis style feature as opposed to like run-time enforcement?

A

yeah.. The run times doesn't know about this thing at all.,.

B

There is obviously artifacts that you can observe at run-time like customer attributes that are applied to apis, and we will probably also expose reflection, api's for you to inspect programs and say,.

B

"Is, this property meant to be nullable or not?".

A

So we don't have that yet?.

B

But we don't have that yet.. So the way to think about it is yeah,. It's a compiler feature.. The c# compiler has special knowledge baked in and looks at your code and says, "oh,.

B

You did an if check to say if x is not null," and then under the.

B

If we assume that x is not null because you just tested for null.", basically, that's it here.

A

So I sometimes hear this term used,.

A

So, as you know, I sit with compiler team and I hear all their conversations., so I sometimes hear this term used called flow analysis.

A

Yes., so I think that relates to this feature.

B

Yeah., that's where we look at some sample codes to make it a bit more easy to understand.

B

so basically,. What we have here is a typical program that does what you think it does.

B

It traces null reference exception., we've all seen that many times.

B

so what's happening here is you have a customer that has a first name, middle name, and last name and all we do here. We just sum them up.

B

Of course,, if middle is not set,, then we get a null reference here.. If I run this in the debugger. yeah., a lot of people can probably figure out what is going. On.

B

I'm still surprised many people don't know this.. If you look at the exception message closely,, we actually now tell you where the null reference exception came from,.

B

Because, clearly it's on this line., you know that by which of the three things is the one that was.

B

Causing the null reference, and it's the middle name,.

B

Getter that returned null., so you don't have to guess anymore,. You can hover over all of these things, where you can actually see that this is the one that's the offending thing..

B

So the feature that nullable reference types allows you to do is to say, "well,.

B

I expect this to be nullable and I don't expect these to be nullable.".

B

So now you can see this is critter here, and this critter tells you that.

B

Annotations are not available.

B

Because you haven't enabled them effectively.

B

okay.. So this is the feature you have to opt in.

A

Even if you use the latest version of c#,.

B

Existing code is the the thing as it turns out.

B

None of the existing code is a way of nullable,.

B

So that means you generally can't say that every single time I set string,, I meant non-nullable string., that's probably true, like what, 85 percent of the time maybe?, but not all the time.. That's why the feature is something you have to opt in.

B

so the way we can do this either by opting in the entire project or you can actually do it- file by file.

B

But for new code it pulling makes sense to do the entire project.

A

This was one of those like choose wisely features.

A

yes.. If you've turned on existing code, basis,.

B

Depending on how your code is,, it might be harder or easier.

A

Okay. so now, what's happening?.

B

So basically, now what we now have here is there is a few things happening right, now., so, first of all,, if we just zoom in here,.

B

If we just look at the definition of this type, here,.

B

This type is basically saying this,, "two properties,.

B

First and last, I.

B

Said they're non-nullable, but they never initialized by the constructor.", so well,. That means, if somebody just used it up,.

B

Clearly, then no.

A

Yes. so some few in the constructor.

A

Set them both to string.empty, then you would be set?.

B

Yeah, or the other thing you can do is you can just make them private setters, for example, and then just have a constructor that takes them as arguments..

B

Then the only way you can get it customized if you set first and last..

B

That would be the way to do it. but then more importantly,. We also get this guy here where we say, "well, here you're doing this thing and here's exactly that, the time where, and just the reference in the middle." we said: explicitly, "well, we expect middle, can be null".

B

now,. The component tells you that, "well,, you didn't check for that.". So to your earlier question of, I can just do this.

B

I could just say, "if customer middle is.

B

Null else,, I do this.".

B

So we would say in length.

B

Actually,, let's do this.

B

Then we just do the simple version of it.

B

Say,, if middle is null,, if middle is not null,, then we use it.

B

What you can see here is that the compiler doesn't give you a squiggle anymore, because the compiler knows that you tested this for now,.

B

And that's the flow analysis part where I didn't have.

B

To introduce a local variable that is marked non-nullable.

B

The compiler knows that in this block here,, you only execute this code. If middle is not null.

A

So how smart is the flow analysis??

A

So in that case, it's pretty straightforward, because you have an if statement, and then you just go into each of the branches, and you can know.

A

Whether middle is null in each of the branches.

A

That seems like a fairly straightforward, test?

A

yeah., I'm not a compiler guy,.

B

So I don't know what the actual technology is or the actual scientific approach,, whatever you want to call this, is being referred: to.

B

but basically,. The compiler only looks at individual variables and whatever checks you have in place.

B

So for example, I can have relatively complicated expressions here.

B

Where I have multiple variables and certain things are mutually exclusive and whatever., the compiler doesn't track them, because it's not a full theory improver where we satisfy each of the variables and conditions and figure this out..

B

It's simple in the sense that there are things like this. We detect, other things that we also detect.

B

If this is null,, you can say environment.failfast for example., you can say whatever.

B

I think that might.

B

Be because I probably have an older build where the apis here are not annotated. Yet,.

B

But basically a fail fast is annotated, that we know that this call will never return.

B

So basically, the program will terminate when you call this thing,, which now means that if middle is null,, then this code here is not reachable..

B

So the compiler in the final version [inaudible] will not get this squiggle here.

B

actually, on that note,.

A

Could you f12 that?, or maybe we're not going to see them because you're using the wrong build because-.

B

I'll go into the implementation., you can see this.

A

There's something there., I probably have an older version of the compiler that doesn't.

B

Know that attribute then.

B

what that means.

A

Yeah., so it basically.

B

Annotates this and says this method: never returns.

A

So you explained the one which does not return.

A

Can you explain what the other one means?, because it's not- this one here? -it's, not super intuitive on the face of it.

B

Yeah. this one is not what you are supposed to see.

B

That's basically one of those things where our type system doesn't allow you to actually put question marks.

B

And exclamation marks on the actual api., so you can't say: string exclamation, mark or string question mark.

B

Here, because the cli has no representation for this.

B

So the way we do it is, we just have a custom attribute that we apply to that and then that basically means that basically, this thing is nullable.

B

Okay., that's what the two means?.

A

Yes. is there a reason that an e-num wasn't used there?.

B

Because if you look at nullable context,, it has two different arguments. one is the byte, one is the byte array..

B

So if you have like an ienumerable of string, one ienumerable of the key value pair of a string and a string,.

B

The first string might be nullable,, the second one might not be., so we have [inaudible], have multiple numbers there, and it's just the most compact representation that we could have..

B

Even if you use an enum here,, especially when you have an array with four elements,.

B

You have to reflect the type in your head to actually figure this out., so the final version of the product will not show you this.

B

instead,. It will just put a question mark here., that's the end,! That's the intent. okay. we're just not there yet., but that's basically how it's being encoded, if you will, in metadata., so that's one example.

B

Another one that you can do that is very similar is you can just say,? I assert that.

B

Customer middle is not null.

A

Or you could write is object.

B

Yeah, or that; would do the same. Thing.

B

As you can see,, the squiggle disappears here because.

B

The compiler knows that this code is unreachable. If this is null.

B

Although,, don't asserts only run in debug builds?.

A

That's correct,, but if.

B

You're thinking about the feature in general,, it's not meant to be a bullet-proof system.

B

It's really meant to capture the intended [inaudible] the apis and help you write correct, code.

B

Yeah. I got you. it's totally in the spirit of the rest of it.

B

But if you look at the assert one here,, it's similar here.

B

We have a custom attribute applied to the parameter that says,.

B

''this method will not return if this condition is false.''.

B

Oh,, I see., so that's how the compiler knows that, while the condition is,.

B

This value is not null., so if the value is null,, this call would have never ever returned. yeah.. So this is starting to show.

A

The more conditional nature of the feature? yes. do you have any other favorites that are totally wacky?.

B

Yeah. so the one thing that is more on the complicated side, is,.

B

If you look at stuff like this, where you have actually concrete types,, it's all very easy.. It gets a lot more interesting when you consider generic stuff because,.

B

Well, generics are hard. so for example-.

A

Yeah,, at the best of times.

B

So we have this method here in the bcl.

B

actually,. Let me maybe change the color theme to something that is a bit more on the lighter side.

B

So basically, this method here is searching the contents of the array,.

B

And then the last,, it doesn't really matter. If you look at this one., the first-.

B

Yeah., like this. so basically, the first time you find an element where this predicate here returns: true,.

B

What we do is we return you that value for this thing.

B

But this is a generic api on an unconstrained t., so any t will work.

B

well,. That means if the array is of nullable customers,.

B

Then it can give you back a null value, just fine, because the array itself may contain null values.

B

The problem now is, what happens if you don't find a match at all?.

B

And so we return default of t..

B

So if now you mentioned the array, you pass them as a customer, array, meaning you'd say there cannot be any null values in the array.

B

Well,, it would return you a null value,, but the t is customer so that technically the well, here's your null customer,. But in fact I give you null customers back..

B

So you can't express this in generics because, as soon as I put here a question mark,, that's not correct anymore, because if t is a value type, then it's.

B

A completely different representation from if it's a non-value type., so in generics,, you can't just put a question mark., it's something you can't do.

B

I'm sure you lost half the audience there,.

A

Because I didn't follow that in completeness.

B

This is just one of those things where you as a customer, hopefully never,.

B

Unless you write generic code yourself,, you probably never have to deal with that, because when you instantiate this method, here, meaning you run it over your concrete datatype,, the compiler on the id- will do the heavy lifting to say,.

B

''yeah, this thing can return a null value.'', so it will show you in [inaudible] customer question mark when you invoke it over a customer array.

B

So what we have here is basically a custom attribute that says maybe null,, meaning it could be null,. It could be not null.

B

It depends on what the t is and whether the function succeeds or not.

A

So, what's the value of the maybe attribute, as opposed to,, say, nothing?.

A

So if we don't say anything, here,.

B

So if you do it like this,, that means the signature will show you. It gives you back a customer, and then subsequent code, when you just say, print customer dot. First name,, you don't get a squiggle in the id that tells you you may not reference, because you couldn't find the customer.

B

oh,. I see. now,. With this attribute, we say, "hold on.. We know that this method may return a null value. Here.".

B

So you actually get a squiggle in the id. If you just call find and.

B

Just start dotting into that result, though not checking it for now., I see. so in this way,.

A

We enable this method to participate in the model.

A

Yes. in a quasi useful way, as opposed to not participating at all.

A

B

That's the part that is also not necessarily over super intuitive.

B

For example, another very common example, we have is dictionary.

B

People use those constantly., so trygetvalue.

B

So same thing., you have a dictionary,, you have string and customer, and we say, give me the customer lander,.

B

And then we didn't find the customer. well, clearly,, even though, if your dictionary does not allow to contain null customers,.

B

This method has to give you back a null customer.

B

Now, that you only find because-.

A

In the case that that customer is missing from the dictionary.

B

Yes., if we can't find by the key.

B

generally speaking, you're, not very likely to extend.

B

The whole signature here, is,.

B

You're saying,, if trygetvalue, and then you only use the old variable if the method was true.

B

Yeah., so we actually encoded this as well as a convention where we say, well,.

B

We have this maybenullwhen custom attribute that says, ''well,.

B

This value here may be null if the return value of this method is false.''.

B

So same thing: here.: now we can actually,.

B

If we look at the-. I hope I have a build of the compiler that actually holds,. But let's say I have an actual dictionary here.

B

New dictionary string, customer, let's say,.

B

And let's say just "dict trygetvalue.".

B

Our var c and then let's say, "c.first.".

B

Yeah, doesn't matter. now here same thing,, I get of postal elephants because we know that this thing might be not.

B

Right., if I actually check the return value.

B

Yeah. now, this figure disappears. yeah. that magic is enabled by this customer attribute because we said, "well, the return image of the function is false,. Then this value may be null.".

B

If you think of just question marks,, it's just more expressive enough to express these conventions.

B

So we've worked really hard and we annotated the base stocks library to let the compiler have.

B

The smarts to do that and we really tried hard to avoid.

B

Cases where the compiler has to literally special case the method.

B

There are very few cases where we have, common example would be, interlocked compare exchange with a contract, is so convoluted that it will be super hard to express that.

B

But for the most part,, even environment fail fast,.

B

Or debug a certain amount of special case. They just have very simple custom attributes..

B

If you own assertion library,, you can totally apply the same customer to use and get the same behavior..

B

So what was the process that your team used,.

A

Which you've decided as a team,.

A

"We're going to go annotate all the stuff." presumably, for the first, while at least once a week,.

A

Someone would come up with, "oh,, I don't have the tools to properly annotate this..

A

We need a new descriptor of sorts.. So how was that like?".

B

Well, before we start there,, let me just serve your wholly generally thought about annotating and stuff,, because there's basically two approaches.

B

The approach that pretty much everybody normally would take us to annotate the implementation and then by annotating implementation,.

B

You also annotate your public apis.

B

people, ship, a single dll, usually where the public.

B

Api and the implementation of the same dll- that's not wholly ship.

B

We have these, what we called reference assemblies, which are basically header files,, and then we have implementation on the other hand.. So one thing we thought was, "well,.

B

Maybe we can just look at the apis and convince ourselves by question marks, should be,.

B

And then just change the reference assemblies,, because there will be much easier for us to do it to make implementation. totally makes sense, do it.. Unfortunately, now, turns out. We have never had a type system feature for nullable., so we honestly don't know what things can be null and what not.

B

So we decided early on, like that, will not work..

B

Let's actually do the pop-up.. Let's actually go implementation first.. So we took the lowest library that we have,, which is system private caller,, which is basically the risk string, leaves and end leaves.

B

yes,, the core library., it's the core library.. We basically started to annotate that entirely and we basically.

B

Just literally took what's 1,200 files and said,, you have five devs., you get these files,, you get these files,, you get files, and then for every single file. They just said "pantanal enable",.

B

And then they'll just fix the file out and then submitted prs for all of those things..

B

So as we were doing that, our goal was we will not change the code and will not add any if statements.

B

We will basically just express what the code already does.

B

We will not change the semantics of file.

B

by doing that,, we found what you just said..

B

We found all these holes, they try get value of where we really can't express with just question marks what the api does.

B

So now, that means every time not the call site uses dictionaries,.

B

You would have to suppress things.. That's the one thing we haven't talked about yet is that,.

B

I can also suppress warnings..

B

So much all. I have a question mark.. So if I say this, and I I do this,.

B

I can now get a warning here that says, "well,, you didn't check.".

B

I can just bang this and say, "no,. I know this is not now.". You may think this is now,, but I know that in my dictionary that always have a lender floating around..

B

So I know that's safe to do.

A

Right., this is the one that I sometimes called the dammit operator. yes., damn it,, I'm right.

B

So we kept track of all the cases where we used the banging operator,, because that's an indicator that either the type system is not smart, enough, or we have not enough flexibility in the type system to express ourselves.

B

or we just found bugs in the compiler as well..

B

So then we started following bugs against the compiler team and said, "well,. How do we express that?", then the compiler team,, the language designers,?

B

They went over there and the end result. Is,.

B

I can roughly show you where we are with that.

B

There's this namespace systemdiagnostics.codeanalysis.

B

There's a few things already in there like "suppressing.

B

Message, attribute" and "exclude from code coverage",, but all the other ones are just custom attributes that we came up with,. That allows us to express the liability contract like.

B

The tri-gate value or the decimal return thing for example.

B

These are the only things we ended up having to apply.

B

I think if you go through core loop,, I want to say it on the public api side,.

B

Maybe 50 applications of those attributes.

A

Okay, that's actually relatively low., maybe 100,, something in that order.

B

On the implementation side,, we have a lot of those applications.. So one of the things we do a lot in colib, is we don't just throw an exception,, because the throw statement in ils,.

B

Pretty like a lot of bytes.

A

So we have these helper functions that.

B

Basically create and throw the exception., so the compiler, of course, no longer knows that this method will never return..

B

So one of the things that we apply a lot, is that it does not return attribute on all the things that construct exceptions and fold them, for example.. That makes a lot of sense.

A

The compiler connection.

B

Understands that this will never return. or the other one that we use quite a bit in implementation is everything that is generic, where we have to use the maybe null attributes for example.

A

So, back to my flow analysis, question.

A

yeah.. If the flow analysis was more sophisticated,, then would you do not need the-- does not return attribute as much,.

A

Or that's, not the right, way?.

B

Yes and no., so you could say if the compiler could.

B

Do global program analysis when looking at every single method,, then maybe.?

B

But the problem is you have interdependencies, now, right?, because methods call other methods., so it's very hard for the compiler to have a complete picture.

B

In a sense,, the whole idea of a type system is that you don't have to do that.

B

the whole idea of a type system. Is you declare your inputs and outputs semantics, and then the compiler only has to look at each individual edge. If you will in your graph of functions.

B

You don't have to look through the whole graph., so we still can, while compilation being first.

B

We don't want to spend like an hour-, I see. for some tool to run.. Like I mean, we used to ship this thing called cloud contract,.

B

Whether it was a verifier that was a full theory improver that was more powerful.

B

You could express things like: we'll have preconditions and post conditions.. You can express, for example, that certain indices have a certain relationship and binary structure, for example.

B

the compiler could prove or the tool could prove that your code is satisfying that or not., but we don't do that..

B

We tried to keep it relatively simple,, because it also means that if you look at apis,, it's also relatively easy for you to figure out. What's correct.

A

So this feature wasn't entirely just about.

A

Like perfect correctness and.

A

How much of that we could afford on the schedule.?

A

There actually are some inherent trade offs.

B

I think the number one trade off, like I think, matt, said it really well phrased,. This thing is not designed to do enforcement.

B

Well,, the first time you use an api,.

B

You don't know what's null and what's not null.. A good example is hash. Table. hash table has this behavior where, when you index into it and the key doesn't exist,.

B

It gives you a null value versus dictionary, doesn't do that.

B

It just told an exception and says the key doesn't exist.

B

So you have to read the documentation today to know that this is the behavior..

B

The idea here is that,, because we promote these things in the type system, you get the whole experience in intellisense and documentation, and everything can tell you what about other expectations..

B

So there's a huge productivity gain in you knowing up front what the expectations are..

B

That's particularly important for things where, via, for example, interfaces and virtual methods, where, well,, there's a contract,, but it's only written in texts which nobody ever reads.

B

so it'll be just whatever they want to do.. So the idea here is that,. We tried to express the intent and we tried to keep honest people honest..

B

But if you want to cheat- and if you want to bypass things,, you can figure out a way to bypass the type checker., but the idea is that,. We don't do that..

B

Our goal is to do best effort analysis.

B

And that means minimizing false positives, also minimizing false negatives..

B

So we think we have reached a trade-off that that is pretty good,.

B

But the proof is in the pudding., so we've done a core 3.0.. The idea is that people should opt into the feature and see whether it works for them.

A

So, what's our philosophy on?, you mentioned interfaces and base classes,.

A

Because by definition,, particularly with interfaces,.

A

There's no implementation to reason: about.

A

right.. Are there any cases where you want to raise in that category?.

B

I compare is a good example.. You basically get to values, and you're supposed to compare them., I see. so there's an invader that is zero when they're the same,.

B

Negative and less when the left is smaller, and positive if the right is smaller.

B

So the idea is that you're supposed to handle the case,.

B

Where either argument is enough. yeah,, I know we were headed that direction., so the interface basically now says, "yeah, the x and the y that imposter you have to assume they are now.".

B

I see. so they're best, both marked with maybe not.

A

That makes sense, because it's inherent to satisfying that interface.

A

yes., so there's something,.

B

I quality compare it as a same thing.. If you call equals,, one side might be not..

B

There are also virtuals on base class that have a similar problem.

B

So the most common example that we argued on the team- quite a bit,- was object.tostring.

B

So object.tostring clearly I.

B

Would argue the intent has always been that you don't returning null value.

B

however,. We found internally plenty of cases that we return null.

B

Of course,, nobody writes return null,, but usually, if you return something else.

B

Like,, you have a name property or you have a field that is destruct or something.

B

I get it. while those might be uninitialized,, so you may actually get cases where tostring does return. Null.

B

Now the question is,: what should we do?? So we have two options.

B

You can either say all of the tostring is marked as not null.

B

That means not everybody who overrides it will now get a warning if they don't adhere to the contract.

B

But it also now means everybody who uses tostring no longer and gets a warning that the result might be null.

A

Yeah., that's the problem. Case.

B

Right., the alternative would be we mark it nullable., which now means everybody who uses it gets a warning and the reference that radio, which might be annoying.

B

But if you look at common cases,, we convince ourselves that that's the better angle, because people that co-opt to a tostring usually directly forward the value to other apis that generally accept nullable radios like console.writeline,.

B

Trace.Write or something like that., so you will not get spurious null warnings and.

B

Then the other thing is when you're on a derive type like stringbuilder.tostring,. Every time you have a device type,, the device type can decide to mark thing as nullable, but even at the virtual basis is nullable,.

B

The device type can say, "no,, I'm and not nullable.". That's the same thing with any other virtual method.

B

That an overwriter can always be more strict if you will,.

B

At least for the outputs you return.

B

for the arguments you take,, you can be more forgiving, but not less forgiving..

B

But that's the general idea where we looked at things and said, "okay,.

B

What can we do to make it so that people don't miss out on warnings,, but we also don't flood their arrow list with.

B

Warnings that are an actionable or that we know are very often wrong.".

B

So another common example that we have is every single time you have a struct and the struct has properties that returns a reference type.

B

strictly speaking,. There can be null because you can always have a default value of that structure where the field is uninitialized., but we said well that now means if every property and every structure is a reference type is marked as nullable,.

B

This no longer useful either because that's probably also are not true., so we said if, realistically speaking, most of the time you get.

B

The struct from a bcl api, where the thing is initialized,.

B

We mark it not nullable.. If there are cases where you constructed yourself very frequently, then we mark it nullable because we'll god knows what you're doing in you code..

B

So that's the general philosophy of guiding you.

B

Towards finding null reference exceptions earlier, rather than later., yeah.

A

So how about we transition to recapping, how you turn this on and.

A

If there were that people should look at to get a non-video format of this.

A

So there's a blog post coming.

B

That phillip carter is writing that has a very in-depth walk-through for every single customer attribute that we have.

B

Why they're there and how they work.? I think you know the url already.. I do know the url, it's aka.ms/nullable-blog.

B

Yeah., if I remember correctly., the feature is available: with.net core.

B

3.0 and.net standard 2.1 and by extension,.

B

All types implementer inside of 2.1., but you have to still opt into that..

B

You still have to say either this, sorry, null will enable or the other option that you have is you can do it by file..

B

So the other way we can do is we can say anywhere in the file.

B

It doesn't have to be in the first line..

B

It doesn't have to be the first line. in fact,. I can move this all the way to here.

B

Okay, for kicks.

A

But then it's still a whole file, scope.

A

no. oh,. No, it's everything! Below., yes, and you can also turn off again.

B

You can also say "disable".

A

But you don't have to write that if you wanted to go to the bottom.

B

Yeah., it's just to the bottom.. It doesn't carry forward to the next file.. That would be really good.

B

So. But in this case, where you've.

A

Enabled it just for the customer class,, your users of that are not using the feature. is that right?.

B

Correct., it controls both things., so there's also other directives. You can use that control analysis.

B

Versus how the type should be interpreted.

B

But the way I've written it right now it means this is considered, not null..

B

This is considered undefined,.

B

This could be null or not null., it's basically what string needs today.

B

Unenlightened? no.

B

I forgot. that was a funny word for that.

B

I wanted to say ambivalent, but don't think that was.

B

oblivious, that's what it is. okay, oblivious., because it could be null or not not., so you can think of it,. This is string bang;.

B

The non-null string- and this is the nullable string, which is the three kind of types.

B

So you could do that too, but I would rather recommend don't do that. make a decision file by file.. So what I have done usually is when I opt in existing code,.

B

I don't turn it off for the whole project.

B

I turn it on file by file, fix all the warnings,, remove all the panel enabled and enable it for the project.

A

Yeah. once you've gone through all the files.

B

If you have a large existing co-opt base, where it will take.

B

You basically multiple days,.

B

Weeks,, in our case, it was weeks, to actually enable that,. Another way you can do it is you can turn on nullable on the project. Wide,.

B

Immediately commit this change, nullable disable.

B

Okay, go the other direction.

A

Because now that means every single.

B

Time somebody adds a new file, there by default in the nullable land., so you don't accumulate more debt as you're going forward.

B

Then you just remove those guys and fix the fall out.

B

But that's the other way to make that work.

A

Okay., so this is only in visual studio, 2019?.

A

Correct. basically,, you need to follow the.net core preview.

A

So right now, basically by the time 163 when it ships,.

A

That'll be the good one. yeah,. I forgot what the version of.

B

Visual studio is but the other sounds right. yeah.. I think that's the right. One.

B

Of course, it also work in vs, code, latest version of [inaudible].. It will also work.

B

Right now, you would.

B

Expect that we have here a quick fix or something., so there's still stuff that you need to work on to provide you with a bit more of experience. But the compiler feature is done as in,.

B

We believe the flow analysis, the compilers does is correct,.

B

The way the attributes are emitted is correct..

B

The.Net platform itself is not fully annotated.

B

For.Net core 3.0, what we have done is basically we've enabled the core library which is about, I want to say, 30 percent, of what you get referenced by default in the console. App.

B

I see. so the rest will be done. In.Net 5, is that the plan?.

A

Yes, and the other thing is we.

B

Consider all annotations in preview., because, as I said, there are some elements where options are.

B

Tostring, where there really isn't a correct answer.

B

their opinions on what is more helpful for the customer, but strictly speaking, either one would be correct.. So we made some decisions,.

B

We believe they're, correct or more usable or more.

B

Useful, I guess, but we want customer feedback on those.

A

Where should they give that? sorry, what?? Where should they give that?.

B

So there's a blog post coming where philip talks about this.

B

It could be comments on the post, fall backs on github., .net/coreeffects. yeah., core effects, or it's the feedback tool here as well, would also work..

B

So the idea is consider those previews.

B

However,, if you want library authors, like if you have a nuget package,, we want you to opt into that and start annotating, your own library., because the whole video of this feature is only as big as much of the api as the customers, user, annotated.

B

That includes the framework of course, but also you can solve json,.

B

Everything else that people use. so unfortunately,, this whole ecosystem will take a while to get this., which is why they want library, authors to start basically with.net core 3.0 and.net standard 2.1..

B

Don't wait for 5.0, where everything is annotated., get ahead of the curve from and try to get it done.

A

Makes sense. okay., I think, that's pretty solid for one show.

A

Well, thanks, as always to be on the show.

A

Yeah,, this was a summary of nullable reference types.

A

With emo who's, one of the designers of this general area. thanks again.

A