.Net Foundation Design Reviews, 7 Apr 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: .NET Design Review: GitHub Quick Reviews

Description

00:00:00 - Approved: Consider exposing Socket(SafeSocketHandle fd) constructor https://github.com/dotnet/runtime/issues/862#issuecomment-610520669
00:26:35 - Approved: MemoryMappedFile constructor https://github.com/dotnet/runtime/issues/33206#issuecomment-610526663
00:38:26 - Approved: Implement IAsyncDisposable for XmlWriter and XmlReader https://github.com/dotnet/runtime/issues/33618#issuecomment-610535975
00:57:13 - Needs Work: Provide opt-in for custom converters to handle null https://github.com/dotnet/runtime/issues/34439#issuecomment-610556104
01:39:35 - Approved: JsonSerializer support for non-public accessors and fields https://github.com/dotnet/runtime/issues/34558#issuecomment-610571471

A

He um every day, for the past few weeks, he's been joining me for meetings. I, don't really know why, but I'm not gonna complain. Well. Cats are social beings. They also want to be in the meeting very.

B

Surprised, mine hasn't because for some reason he always knows when a camera's running and then he just runs into the room and sits in front of it.

A

Once I bring the turtles on camera, then you know that I have a problem. I need help. Oh the turtles.

A

It's a wonderful mix, alright,.

C

So Steven I think this is yours. Are you sharing your screen? Well, I'm, not sure my screen. Okay, then let me show my screen, which yeah.

D

Are we screaming yeah.

C

We are, let me actually share the other screen.

C

This is the one, so the Newton I can already see what you can't see, but now I should also be able to see it. So.

E

Basically, ignore everything and that's threats at the very top, which is Annette core, 3 I, think it was maybe two one we exposed a safe handle for socket, but you kind of can't do anything with it other than you know, pass it around, maybe extract the file descriptor or handled from it and P invoke with it.

E

If you get a handle from somewhere else, such as, if you P invoke to something like socket pair or you, P invoke to socket and on Linux thing you know pass in, create your own socket for some Linux specific protocol. You have no way to then use the rest of the socket class and infrastructure with that. So this is just adding a constructor to socket that takes an existing handle.

E

There are, for the most part, everything works, as you would expect it to there are you know the some expected oddities and some unexpected oddities, obviously an expected oddity, which happens anywhere else. We deal with handles if someone were to pass in. You know a bad one, for example, one that was already closed. Someone was you know, working with the raw handle or file descriptor closed.

E

It had been passed it in here you might have handle recycling and all that kind of stuff, but that's just the nature of handles the slight oddities are specific to the public.

E

Api is on the socket class, where, if you take, for example, there's a property socket blocking which on socket defaults to true on Windows, there's no way to query whether a socket has been put into non blocking mode, at least not as far as I'm aware, whereas there is on linux, and so, if someone passed in a handle that they had made non blocking, we're still gonna reflect it as suck at socket up blocking equals. True on windows, because we just have no way to get the actual value.

E

You can work around that if you know you're in that situation by toggling, it yourself and then it'll kind of you know snap back into the right thing, but there'll be a few things like that, where we just, we lack the ability to grab the exact data too. If you have you created, you know in a certain way to fully round-trip the information, but all the API is like right, send and receive all just work.

C

So that begs the question whether we should make blocking a parameter to that man, so that constructor they'll write to tell the person like sorry. We can't reduce this years to tell us. We.

E

Could there's a variety of properties like that, where we can't necessarily infer it on all platforms like on Mac on Windows and Linux, we can infer the protocol type, but we can't always or generally we can't on Mac. So would we also take the protocol type it and what happens if we you know on on Linux, we can infer it. What happens if you pass in a different one from the one that we inferred, do we throw, but we wouldn't do that on Windows, because we couldn't infer it.

E

So my default was: let's just do the best we can and it leave it to Docs. If people think we should try and have people pass in all the parameters, and then we sort of do something else, we could consider it I just don't know what that something else would be yeah.

C

I mean the one thing that it's like giving they be no investing, as my question would be. How could we help people right? So if we down in a dedicated API, it would be fill it'll be hard for us to detect. Oh you on Windows, but you you'll see you pass in a socket handle but you're not setting blocking.

C

F

Socket right the or have constructors that, if you want to for given family, you can't read sockets. So this is only for a special cases where, for example, you pass descriptors between processes or you try to work with unsupported address family that all that stuff is kind of advanced. And if you want to just use normal constructor, you can right.

F

D

Connect the properties through if someone tries to get them, and we don't know what they're.

F

I'm sure we could for the others, families we already have unknown so I think that's default, that if you do not know you just get address family, unknown, I think the blocking is the only one real case and it's only one window. So.

C

So maybe I'm misunderstanding is the problem. Only that you can't ask the socket instance or is the problem that the behavior of the socket instance isn't what you want it to be for the given angle.

E

We see way if you, if you access, socket, get blocking, we don't know what to return so like by default. If you would do that, we don't actually query the underlying file descriptor a handle. We just know that I'm sorry I'm a backup if you create a socket just using the socket win32 function or the POSIX API, it defaults to being a blocking mode.

E

We know that in the socket implementation- and so we maintain our own shadow copy of that information of fields that says whether it's blocking mode or not, which defaults the truth. So if you just call get blocking, is going to return true, if you have set it to false, then we'll not only make the assist, call to move it into a non blocking mode, but we'll set our property. You know our field to false and then next time you access it.

E

You'll get the value of the field, which is false if you construct it from an arbitrary file descriptor or handle, and we lack the ability to ask the operating system. Is this blocking or non blocking? We kind of have no other option but to assume it's the default, and so we leave our field set to true. If it's, if we do have the ability, then we can query the operating system and set the field appropriately.

E

Now, even then, it's a little weird because on linux, where we do have the ability to query or on unix in general, where we have the ability to query.

E

We actually send we. The way we implement asynchrony for sockets is by putting the underlying file descriptor into a non-blocking mode and then layering on sort of the asynchrony ourselves via trying the operation getting an e woodblock and using a pole to wait for the operation in the scalable way. That means that the we actually on purpose diverge the state that we maintain and socket for socket dot blocking from the underlying file descriptor.

E

So if, even if you were to take one socket put it into non-blocking, you know say: create a socket on linux and just make an asynchronous method. Call on that socket socket up locking for that socket will return true, but the underlying fire of the file descriptor will be non-blocking. If you were to then take that safe, socket handle and use it to create another socket instance.

E

When we query the underlying file descriptor we'll find out that it's not walking so we'll say that socket dot blocking is false, even though the original instance on which it was created had it is true, so there's kind of no perfect answer.

E

F

Anyway, setting it after you create the socket, it's not much worse than doing constructor with a bunch of parameters right. This is really the most real property and again I. Think, as you suggested see, if I think we can document that yeah.

D

It is an advanced use, API, so expecting people to understand and read documentation, I think is okay, yeah.

C

I mean because advanced or not, people really read, documentation and stuff doesn't work right. The problem is that stuff only doesn't work on certain operating systems right, which is the whole point that we tried to design API is that they work across as much as we can by default. Right I mean this, of course, always got Russ and you're always expected to test stuff, but in practice people don't test an operating systems all the time right, so that so so my question was basically like.

C

If we have cases like this, how can we at least provide an analyzer that would tell you that this stuff is no longer portable, because you didn't do something correctly right, I mean we could I mean if you make a constructive of, let's say, inaudible parameters at least we can detect it. Oh yeah, you said no, which means you know we inferred. If we can see if we can, if he can't then too bad, then we can tell people like. So. Are you past it now here? Probably that code is long, affordable to Windows?

C

So think about that or you did this thing? Maybe it's not portable to make to the other thing right, but.

E

To the Tomatis point like, how would that be different from just if someone wanted to avoid an issue with such an analyzer? Just have the very first thing they do after creating the socket meet us at blocking equals. True, oh.

C

It doesn't, but at least you I mean it is something gave you the the information that, if you don't set it, we we have no way of knowing. If you set eclis, know the values to them, but all means that it's a true right. Okay, that that's that's domain knowledge that we just can't have right. Let.

E

Me rephrase my question: are you suggesting that? Because there is an optional parameter to the constructor, that that would inform someone that there might be something that's happening? Well,.

C

Not that is optional right in conjunction with an analyzer right, so, like the implies, it would tell you that or you call this API, you pause and also this. That code is no longer portable. If you want the code to be portable pausing, the correct leader for this parameter, I did so. This will be the message we give people, but.

E

But how is I was so, let's say: I, don't I'd, say I passed in a true or false to that parameter. How is that different from saying after the constructor socket?

E

C

Not that I'm saying to me the question is: what's easier for generalized ID, they give you a different property, can be easily call it that information. A lot I.

D

Suppose we can, in terms of analyzers I, would expect this to be very, very key. So I don't know if we should go into this, assuming there will be one.

E

Yeah I'm, honestly I'm not I, bring it up in full disclosure I'm, not particularly.

B

So from like, if it's just a reporting problem, which is what it sounds like it is for Windows, then I can kind of decide that I don't care and that we could fix it in the future. But if this is, if you have a socket on Linux and you grab the handle and then you open a new one from that handle and it changes behavior, then we shouldn't add the API either it becomes a mandatory parameter of you have to say: if you want it in blocking mode or not, or we just don't add it.

B

I, don't think I agree because diagnostically lying is one thing, because I don't think people are really gonna, read the property back and care, but if you've, if you get, if non-blocking is maintained on Windows and Mac or is maintained on Windows, then they're gonna expect that it's maintained. Like you tested a sink, it looks a sink everything's happy then different things happen when you go to linux. Like that, to me is worse, I don't think I don't think would change behavior.

E

Would it Steve the the socket won't change? Well, it could change behavior. So if I, if I kept the socket 1 on Linux and I, make an asynchronous actually okay. So here I'm gonna first answer the question and then make a suggestion: um if I have socket one that I make an asynchronous operation, call on its socket blocking is gonna be true. The underlying file descriptor will be non-blocking.

E

If I make a sync. If I then make a synchronous call on that socket, we will respect the socket deblocking equals true and will simulate the synchrony. Even though the file descriptor is non-blocking, so we'll still make the operation complete synchronously and successfully, even though the underlap now non-blocking. If you then just make a read, call on it, it's going to fail with IE would block, because its socket blocking property is going to be false rather than true. If assuming we query, the underlying file descriptor.

E

So one solution to that is to just say: we always create the socket with a blocking equals. True in our sort of managed view of the world, we still query to understand whether the underlying socket is non-blocking or not, and regardless of OS. When you, then you know, construct this thing from their socket. You're gonna get socket top locking equals true, and if the underlying socket was a sync on Linux, then it'll will simulate the blocking there.

D

E

Still corner cases but.

B

Then existent and Austin sees good.

E

But not I mean they're there. There are still some inconsistencies that we can't do anything about like if you on Windows, if you socket want made it socket dot blocking equals false and then use that safe, socket hail to create a second socket. We have no way of knowing what the underlying socket is, so we're shooting in the dark as to whether it's blocking or not so you could set it to blocking.

E

I have a suppo to say yeah, you can always say to Blokland in word: we're actually mutating the underlying handle yeah, so I don't think we want to do that either, but I understand the concerns Jeremy. At the same time, I think the benefits of such an API outweigh the concerns. So saying we're just not gonna. Add it because there are some oddities I, don't think it's the right answer. I.

B

Think I just felt like I, just my maybe it's like crypto stuff. If you only actually have like seven customers and they don't all, read the docs and understand it, and it's fine I, just I feel that I can't load the state machine here in my head and therefore I. Don't think that the average caller could either well the average caller.

E

Isn't gonna access the relevant properties, but even if they couldn't the only other answer, is you need to write platform-specific code for every platform you want to target in order to P invoke and re-implement the entire system? Net sockets infrastructure to be able to use arbitrary, socket file? Descriptors you get and.

B

I guess I guess really: there's not much scenario in you have a socket instance so you're in dotnet and you get the handle and then you then you make a new one. No.

E

I mean there's also deducted in same instance, right there's, almost no reason to take the safe socket handle from one socket and use it to create another. The the primary scenario here is you do something the P invoke or native code that gives you a handle or file descriptor, and you use it to construct the socket right.

B

And in that case, I guess it makes more sense. I just started with your premise of we exposed this, and then there was nothing you could do with it, and so now I was just picturing. You have a socket and you're cloning, the socket by hand right, but that's actually bad, because modifying one will modify the other in ways that we still can't express right.

E

Like one thing you might do with it is, you know, send it across a UNIX domain socket or something to some other process or use this on Windows with duplicate or whatever that API is, but the primary use cases for this are I'm P, invoking or in some native code I'm creating I'm calling some API. That gives me back a socket file, descriptor or handle, and now I want to use the manage socket class to wrap it. Okay,.

B

When the handle class is publicly constructible, yes,.

E

Okay, for example, as part of another bug, fix that caused me to look at this I'm 90% sure we're going to change this process start to use socket pair instead of pipe to create the connection to the new process that you start and it'd be really nice. If we could then create a socket for the client to communicate over rather than not.

B

Okay, so, given that the scenario is you've you've already done, some P invokes to build the handle yourself and now you're. Turning it into socket semantics, then then I'd say it makes a lot more sense than what I was originally thinking and then I would recommend, because.

E

I think it's reasonable to say that whenever you create a managed socket instance socket that blocking returns. True on Linux and Mac, we can detect whether the underlying one is async and do the right thing. The only oddity there will be on Windows and we just have no way of knowing could.

B

You figure it out on like is that if you call the synchronous, one it'll give an error and then you could. The property would flip. Essentially, the first time you call read and it figures out it needs to go to the other mode. Yes,.

E

Except the problem is that any operation we perform on the socket has the potential to change state. So if we, the only way to know would be, for example, to do a a read or a write, yeah.

B

I'm saying like put read so, if read and write are in, like I'm waiting to figure out what state the socket was actually in mode and then it figures out: oh crap, it's it's actually non-blocking I need I'll, flip the property and my behavior right.

E

But in order to do that, we'd have to actually read which would take data off the socket right.

B

I mean wait until somebody actually calls read like oh and.

E

Then and then well, even if the data was already available, it will still return successfully, even if it was a non-blocking.

B

Fair enough, okay, my recommendation would be if you can get eventually consistent. Do that we.

E

Certainly, could we could event we could opportunistically do so. It would require tracking things that mushroom would be worth it like. We'd have to not only track whether we, whether like the property, has changed in the interim. The way, though, maybe someone said it, I, don't look at it.

C

So that, but it still sounds to me like if you would make the constructor parameters your basic tenant, the person you tell us what motored is it right because you created the the handle, you would know.

B

Well but then there's I mean there's two ways of interpreting that you know it's which mode should I just think it's in or which mode should it go into, because setting the property is enter, this mode change, the underlying socket to be right, and if it's just tell me what mode do you think it's in then that is weird and in that case I'd say that the way that it's proposed is better well.

C

Because the basically controls behavior I mean it's not just for the diagnostic API, it's basically what mode of interacting with this socket did you give an student and all.

E

The api's will respect that, with the exception of the one that reports. What motors.

C

Yesterday, I guess that maybe is still under census. Api works like like it sounded to me like, based on what they blocking is on or off. You have different behavior of when you call it methods on our socket. Yes,.

E

So, generally, a developer will put the socket into a specific mode, and then all subsequent operations perform a certain way in response to that. So, if I call Reid and the socket is in blocking mode, Reid will block until it can perform the read successfully if I call Reid and it's a non-blocking mode Reid, and we can't successfully return immediately. I'll return, an error would block the socket class will continue to correctly behave exactly in that way.

E

Based on what the underlying the mode of the underlying socket it's just that socket dot blocking, may not be accurate.

C

It's okay. Next time is purely a reporting issue that not a behaviors you right.

E

I mean the kissing reporting, slash behavior for the sock and blocking API, but it's just reporting for the rest right.

C

Then I'm fine with the.

E

Api as it is proposed and we'll just add lots of documentation to say you know be careful of the following things:.

C

Because I'm sure that for people who read it will really appreciate this.

B

Alright, so that was a fun full.

G

B

Conversation, thank you for the journey. Steve you're.

E

Welcome. Thank you for humoring me.

C

Patted him down.

C

Let me just post a comment as well, so just so we have everything documented alright. So then I can close this guy here.

H

Carlos, are you I'm here great good.

C

H

You want a minute to read this summary: either wall works, okay, so I realized. This is a kind of similar to the previous API. We need to make an existing constructor public, one that receives memory-mapped file handle, and we want to also pass an existing file trim by disposable object.

H

The reason why we need this constructor is because we're courting methods from framework and in net core these new methods are being added as extensions in a different assembly. So there's no way to access the private constructor that already exists.

H

We don't want to make the internal visible because it will expose all internals. We also want to avoid making reflection, calls so the best ways to make the constructor public, but with this structure that we see here and.

E

Can I ask the question on those premises for a second? What what about refactoring to just move the types downs that are no longer in a different Assembly.

H

Refactoring to move to different assembly, you need movie, you mean movie memory, mapped file to then be.

E

Assembly, where we are adding those extensions, no I mean moving memory.

B

Mat file Akal down to memory in that file. We can one of the apples in a different assembly because they don't work on Windows systems. That's.

E

Fine, they don't have to be undone on Windows I mean that these eight, these, the public api's, wouldn't work on those systems anyway, right so maybe they'd be throwing a platform not supported this exception. On those platforms.

B

Right I think we were I feel like we were trying to keep the whole package as like only reference. You should only reference this if you hope that you're working on Windows no.

E

No, you you, you would we we would do the whole, like the same thing, that we do with pipes right and pipes. Don't we have the Apple types and the base assembly and we have a separate assembly that a separate ref assembly that just exposes the relevant ApS? Okay,.

B

So to type for wording in the implementation, assemblies and yeah making the refs lie. Okay,.

H

H

Guess I can try to see if it's possible.

H

Yeah I can look into this cool.

E

H

C

You repeat what you would you I.

E

Was asking so Mike? It's I mean I interrupted Carlo rudely before he got to actually talk about the API, so I apologize for that, but yeah. If this was just a public constructor that took memory map file handle like I'd, have no concerns about that, but taking this other AI disposable thing, that is this other additional thing to dispose of when the memory map file is disposed as an implementation detail.

E

So it's weird to me that we're adding a constructor for that, if it's the only way, okay but I'm, hoping we find another way and the other way I'm suggesting is rather than have that. The reason this needs to exist is because the implementation that needs to use this, as in another assembly, I'm suggesting move that implementation down to the same assembly and just expose it from the original one did the higher-level one with type codes, I.

C

Think that would make sense to me: I mean I, don't know nothing about the details, but it seems like that super and we have used elsewhere. The only thing with that is, it's freaking machinery with the reference assembly. That's right, but it's just the way things are in corvex, I guess so.

E

I think my suggestion is: we continue reviewing this as a backup in case that doesn't work or we don't want to do that. But it'd be great if we could find something that didn't expose kind of our dirty laundry.

C

You know I mean I, agree with everything you said like to me. The handle one would be very unpopular mattock. That's like a very pattern. We happen to be seeing almost everywhere, but you can construct a managed object over the underlying native one. The filestream one seems more in the realm of plumbing right, where it really doesn't make sense anybody to call this it's just there, because infrastructure needs to call it well.

D

C

D

Thing with this is in Linux. Our safe handle already has a reference to the file stream. We could just do the same thing on Windows so that you don't have to pass in this eye disposable.

B

Right smuggle the disposable thing via the safe handle. You.

E

Know if that works, I'm happier without even.

C

All because we didn't have a puppy, then under the safe memory-mapped file handle.

D

Not a property, at least on linux- it it's just set up so that when you call dispose on the file handle, it will dispose the file stream as well yeah.

B

I mean you have to be a little careful with that to make sure that you didn't wash the handle through a peon VOC and lose this secondary properties on it. But as long as you're maintaining referential integrity, then then that should work.

B

But I don't know how where we would be able to like yeah. So it would be interesting to see if there's a place that we can already hide it because, like how? How is the Akal assembly going to be able to set it because, presumably word unless we have a constructor that expands it from file stream them, which case that would be easy. We just saved the reference.

E

And then I think you know if those two all don't work out, I think my third would be I. Don't is safe memory mapped file, handle sealed if no, presumably, the accolade P is, could just derive their own internal version of it and include the file stream on the handle, if not I'd, almost rather unseal safe memory map file handle so that that could be done rather than add. This API Steve wants something to be unsealed, no I don't want it to be, but I'd rather.

A

E

Rather, that and allow people to attach arbitrary, I disposables to memory in that file right.

B

Because previously this was a filestream object and we had objected that there because it was only being used for disposed. We didn't like that. There was a lot of ambiguity of what, if you pass some unrelated file stream. What's that mean- and it just raised too many questions.

H

Right so we're using the most is obstruction.

H

Okay, so the first suggestion is to try to bring those extension methods into the same assembly. Member in my file. Second suggestion is what Cory said: do what we're doing in Linux of having their. Let me see if I understood that having a file stream already pretty safe, so we can dispose it.

H

What do you say again that it's being saved in Linux? It's.

D

Being saved inside the handle, it's not exposed at a property, it's only there so that when you call dispose on the handle, it will dispose the file stream as well. Okay,.

H

In the handle and the third one.

H

B

So the third, the third suggestion- was to derive safe memory, mapped file handle if there's not a place that you can do. The second one then use a use, a derived type so that you can okay and personally.

E

My order, for you know, figuring out which ones of those would work or preference would be quarries, so number two, then the unsealing so number three then the first, which is the combining assemblies and then the last would be the one that's proposed. I. Think: okay,.

C

Sorry, like I, think I think I got lost by what I was typing, the node so option, one that I had written right now is moved. Implementation from the higher-level assembly to the assembly, contain memory, mapped file, vomiting and the breakfast assembly split that we currently have. Then that was the option with the smuggling. The data is in the safe memory, mapped file, handle I, guess that is the option of having a field and then there's the other option of deriving format is that is that is that fair yep yeah?

C

So this option, like option 2a an option to be kind of thing.

B

Yeah and to see is if safe memory mapped file handle is currently a sealed type, unseal it and then do to be.

C

And the order is filled and then I'm sealing right.

H

E

Now, at the end of the day like this is so you know such a corner of the framework that if, if the proposed solution is the only one we can do, then okay, so I think I still think we should review it so that we don't have to kind of come back through this discussion. I would.

B

Call it parent.

B

The filestream parameter, I would name it parent.

E

It also needs to be nullable.

C

Yes, yeah I mean I'm, okay was saying approved, feedback I mean.

E

The other thing to look at would be, and I haven't investigated this whole issue and what's driving it so I could be totally off base, but whether it would make more sense for the safe memory mat file handle constructor to take the file stream rather than memory. Matlab.

E

But that ties in with it having a field and all that kind of stuff. So probably some investigation to be done in that part and then, if we can do it via field and safe memory, map file handle, there's a whole lot of options to explore about how best to expose that ok, reasonable Carl's, yeah.

C

Right so then, when it's done.

C

We are under control.

I

Yep so trees. We have several bugs related to this issue and pretty much XML reader and writer missing, dispose async implementation and because of that, acing calls are calling sink disposed method and this caching issue for a second listings.

D

So XML writer need to write some final bytes when you close it is that good.

E

Yeah anything that's still left in it that hasn't been flushed and.

D

Xml reader shouldn't need that with this just.

J

D

I

Some of reader I haven't really got to look similar there, but we having a similar but so I think there is also need that I mean.

B

If you had a custom stream like if you had a stream that was, you know, sending a thin style close across the network, then you would want it to call close. They sink instead of closed sink yep. So it's probably.

J

D

B

Data, but it might be acknowledging that it's done reading data right.

D

B

D

I think is I know that none of our XML API is passing a cancellation token, but should we consider starting that here, with close eight close async at least we've.

E

Generally hesitated to do that because these are used on you know if you're using this in a using or something right, and you cancel the operation, you don't actually want to cancel the cleanup, slash, closing yeah.

D

We I mean disposed async. We not have cancelable I agree there, Oh God emo, we've done something bad, but suppose I think I think would be the happy path that you could enable cancellation through and.

B

Why you're tired of waiting on the ACTU, the Finn yeah.

E

Yeah, but it also I mean, if someone's, if we expose the cancellation token, there then seems like it's going to push people towards just using that close a sync in place. If disposed, they sink, and then it's gonna having the same problem as if to suppose they sink took a token no I.

D

Mean there's always a risk. If someone decides that in their exceptional path, they want to support cancellation still that they would use it. I, don't know. I.

E

Guess they're not deciding that like they just look. It takes a cancellation token. Let me pass one in right back working, we're talking about analyzers that again, I warn.

D

E

That they're not.

D

Yeah I guess there's this kind of just goes back to the problem with having both disposed and close, and what are the differences I.

B

Mean what did we do on stream? There.

E

Is no close, they think.

C

What's funny is that I just looked at text reader text writer, so text writer is icing disposable text reader is not I.

A

Was going to ask, why do we need the reader to be to be disposable here or a sick disposable, because there's no fin on the reader.

B

You don't know what the stream does.

B

Writing the if you're.

J

B

Sips or Samba, it's gonna send to the server I'm done with this handle released, they'll release any exclusivity.

A

Yeah but generally that would take place just in the background in which are in synchronous life, because you don't need to wait for the app Jam.

D

So an example with HTTP 3, you don't have that nice, you know having all the things flush. In the background feature you actually do need to perform some IO when you close out a stream. If you want to make sure it's all acknowledged, so this could come in handy there. So.

A

What would the implementation of this be check to see if the underlying stream is isync disposable? If so, call dispose async, otherwise fall back to dispose o-hall.

D

Streams support our async disposable. Now they just wrap dispose of not implemented I.

A

Thought we just said they didn't okay right.

B

But if, if streams don't have a closed async that takes a cancellation token, then there's nothing that this close. They think it could do with a cancellation token. Well.

D

If it's calling stream that flush async, it could pass the cancellation token to that. So.

A

The right, / async will fail on a read-only stream yeah.

B

So for XML writer, closed async taking one could call flush async with the cancellation token, but on the reader it couldn't because I mean it. We could put it in the API it just literally can't do anything with it.

A

So a related question Steve like what happens if say that the implementation of writer dot closed async is it calls underlying stream, dot, flesch a sink and then underlying stream disposed? If flush async throws an exception? Is the dispose? Oh, you think method also supposed to throw an exception.

E

Because it might happen as part of the using well.

A

Because the if this is implemented as a flush fault, a flush and then it disposed right.

D

A

The flush throws, because maybe the underlying connection disappeared and does the overall dispose async transition to a faulted state or a finished state. So.

E

It's in conservation specific, some of our streams do one thing, some of them to other things. Most of them will are hard smart enough and will just try and flush again.

B

Dispose is allowed to throw exceptions. Finalized errs are not yeah really yeah.

E

That's third, it's discouraged, but pretty much every stream we have can throw from its disposal, okay, with the exception of a big memory stream, and that might be.

B

E

B

Mean it can, whatever the CLR does, whenever pointers jump in the wrong place, seh exception.

E

E

Don't know I'd encourage someone to use once a sink with a cancellation token, rather than close I think with one okay.

D

Does XML writer have a fleshie sink? Alright thanks.

E

A little writer, yes, okay,.

D

In that case, can we just not have these close async api's encourage people to use dispose well.

B

The XML writers, an abstract class somebody has to write, dispose somehow well.

E

No I think Corey's, suggesting this pose a safety virtual yeah.

D

Essentially, the same bottle: we've decided on for her stream. What.

E

Does that do? Does it just call close.

B

Dispose a sink is supposed to be non virtual.

E

B

Do you say that cuz you approve that guideline? We wrote a book because if you make it virtual, then somebody's gonna forget to call suppress finalize this, which they're supposed to do is if regular dispose was called.

B

So we we wrote the the.

B

The basic dispose async pattern effectively, which is like the basic dispose pattern disposed as non-virtual, but.

E

Suppose this virtual on stream, yeah.

B

We got it wrong, we.

E

B

Yeah because we added dispose a sink before we came up with the guidelines for dispose, they sink, and then we shipped it. Then we came up with the guidelines.

E

I feel like we got it wrong in the book, but maybe you and I should sing.

A

Anything that encourages people to propagate the dispose pattern, in my opinion, is just wrong, but whatever yeah.

B

I mean like emo and I, drew this out on on a board trying to figure out if for the degenerate case, where you're disposed async and have a finalizar, which yes should not happen, but it's disposed disposed. Async should be non-virtual should call your dispose. A sink core then should call dispose false and then should call sorry should dispose a sink or suppress finalized dispose false to make sure that you got anything that needed to run in the in the full absolute shutdown case.

C

B

I mean I, remember, discussion.

C

And I think I think what we landed was. The details might be worthwhile just thinking about this at some point and next seen the flow chart again but I mean my other question is more basic, actually so the XML reader writer we have these create methods, these factory methods that we told everybody to use, and so you can construct a reader and a writer over a text reader in the text.

C

Writer, so text writer is a sink too is in disposable, but text reader is not so what does it not mean if you rep Lex and all reader over an excimer over a text reader that is Mathias and disposable, because I suppose we do I think it means we wait until we have scenarios.

E

For XML, weird, to be honest, I think disposable before we do it. Okay,.

C

So yeah so then, basically we only make the writer I seem disposable, and then we do it in whatever mechanism we we concluded the right way of doing it right, because what we said, what.

B

We wrote in the book is that it should be assuming that close, a sink is only here as the implementation of dispose a sink. That is virtual. It should be public value, task, dispose, I, say, protected virtual value tasks dispose a sink or.

E

Our is XML reader. Does it have a public concern?

E

It has a public constructor holy, protect everybody.

C

E

Protect your concern, in other words, someone.

K

Else, besides brain work and derive from it.

C

Yes believe that it's true, let me double check this o.

B

Versus internal only constructors, so well, it's polymorphic. It's close to polymorphic yeah.

C

Yes, the reader has a protected one. My things are lighter as well.

C

E

Well, we should do whatever the pattern is that we want to have Jeremy reconvince me offline, that the pattern you just espouse is the right one.

E

C

Can you repeat slowly what you said earlier, sorry would you would say this post a Singh is non virtual right and then we would have protected, dispose, async or.

B

I'm pulling up the book.

B

It would be terrible if we wrote one thing and then did a completely completely different one.

B

Yes, protected virtual.

B

Protected virtual value tasks dispose async core which takes no parameters and is equivalent to dispose true.

B

And what does this pose? Aysen to a weight, dispose async or dispose false GC suppress finalize this.

C

Yeah good sounds right, but.

C

Don't because the chance of somebody getting dead right doesn't seem very high.

B

Because the the belief was, if dispose async is equivalent to dispose, then it should remove it from the final wiser queue if it was registered for finalization. So we have to put that call somewhere. So we said continuing the the pattern that we already have of the dispose itself is not virtual means that there's a definite place to put it.

I

So we don't need clothes I. Think anymore, is this I said that.

B

That becomes well cozy, a sink becomes protected, dispose a sink or yeah.

I

C

Guess I mean it did me also say like if you want clothes acing, but you should do, is flush acing and then dispose right.

B

That's why it's protected I cancel.

D

Closer, you think you should call Felicity yeah yeah.

E

Jeremy, why didn't we like virtual dispose? They think that would just delegate to its base and the base would suppress finalize.

B

E

Okay, well, it's not symmetric either way.

B

Like I know that this involved a lot of doodling things on a whiteboard back when humans were all out to be near each other and that all I did was in the end, write down what was remaining on the board and and then my my tech editor signed off on it. So.

E

For anyone listening that was me.

C

He was probably busy optimizing magics, and so it's right now, alright, so.

C

Which is impossible virtual spell closed acing.

C

Should call so flush already takes and cancellation token.

I

Know any of them not taking any consolation. I.

C

D

There was a separate discussion to be a dove, should all the other api's be made. Cancelable I think the Loess cancellation was more just preventing users from calling their own thing.

C

Yeah, what was the reasoning again to say the cancellation should be on flush? Is it not close, I think so.

L

E

In any kind of structured exception, handling solution, whether using using or try finally, you're gonna be closing this thing on the way out and closing this is gonna, be cleaning up resources. You want to clean up resources, even if you were cancelled, you generally have one cancellation token, which is what triggered cancellation. If you also pass that into the thing that supposed to clean up your resources and it prevents you from cleaning up your resources, it's not good. That's.

M

B

Because, then the dispose async is going to throw canceled and then the finalize is gonna run, which is what you were trying to avoid.

E

Well, that and you're not gonna. You know close your file or close your socket or write whatever yeah.

D

I think that the usage pattern, I would imagine, is a weight using xml writer and then calling doc close a sink with a cancellation token right before the scope closes, so that your success case would get cancellation.

E

Yeah, if that was me sure you could do that, my concern is someone says, oh well, why am I doing both the weight and the clothes I'll just do a try? Finally, another close yeah.

C

All right, so that leaves me with this. Let me copy and paste this in.

B

And scroll, so we can see what your roof.

C

Almost like keep going.

E

Yeah by not having clothes, I think now at least leave the door open for the future. If we decide that I'm wrong.

C

Wrong with such a strong word, misguided.

E

To quarantined.

C

Yeah, what say, there's a bunch of quarantine in there somewhere.

A

Yeah- and here you, you explicitly left the dispose async off of XML Reader. It looks like yeah.

B

That's the first bullet yeah.

C

A

See the word reader wasn't highlighted like everything else, so I just skip over.

C

C

Alright, so then this one.

L

Lay on your own, yes, okay! So this issues about allowing custom converters down to know today serialize that so this budget, since here is it so series are only passes not to custom converters if there are value types, structs, okay, some good start of one week. So when we do not, so we don't pass not to custom converters for reference types, so instead we return all on this realization or four different types and a serialization. We write know directly so.

K

L

Is primarily for performance always keep an extra quality converter, and only on during these discussions. For the converter feature, I mean the resolutions that we didn't want people to have to check for no I, just a very direct method over it.

L

Yeah, so so we don't pass not to reference types, but for value types we do personal and it is to support internal logic for DC, arises in Jason element, inaudible of T, where no is valid token. So what is meant? We return a jason element with a value kind, no, and for not above t and obviously just coming off. So we supported so.

L

Not just a value for sale are tips, so knowledge notify is valid value for value types. So we hand over know to value types of decisions.

D

Agent, well not syrian, because.

L

Those coming off, but it's basically to see converter, determine what to do with this invalid, not open, so this, which are provides a way for converters to obtain to handle in all, regardless of whether they convert value of reference types. So this will have to be obtained because previous behavior, that I just described series might want to Hunton, offer various scenarios or situations for validation or replacing, in all token, with something else, some default value, so that, if you know Stack Overflow people brought this up.

L

We didn't have a tracking issue kind of tracking this internally, but I open this issue a few days ago to bring it for API use again. So we have some partners who are requesting for this. So API proposed out here, decent converter, also before I move on any sort of question about the premise or.

E

Can you just share where you would want.

L

Okay, so I have like so before, okay, so the usage examples you have like profile, you are a just some random example where in T, Jason comes as no for whatever is in in P load, but you don't want to store null in you're like a context that runtime, because you wanted value to be this weekend's.

E

I mean email, could you scroll down so I can see what he's talking about sorry.

C

It's calling on my screen ever.

L

Imagine, like he user profile, account for some app every first name last name and we link to their profile page. So Jason comes back and then, for some reason it doesn't have. You know I mean doesn't so you want to replace that no token, with some value on this realization the read method there and on for writing.

L

For some reason, all you want to write out some default value, so you today, you can't do this because this year, that will not pass you to no token and a bunch of people have various scenarios where they want to do this.

L

So we already have existing logic to pass a law to comfort us for decision because, as I mentioned above listener elementary districts, and we need to disguise that and pass it. No well. Let's eat know that knowledge trying to beat this realized and also for another good types as well. So this infrastructure exists internally right.

B

And this is only going to invoke it when you see the null token, it's not going to fire an artificial null token when the property was missing. No.

L

B

L

B

Get null profile, you are eyes if they didn't transmit it. That's right.

L

When this also applies for serialization as well, because this 0 type can be no, so you want to do something else once you realizing so okay, so that's already gone over it like API usage, so I'm not sure if every so everybody saw the EPA proposal, because that's what country? So you, if you can't just scroll up.

L

Decent Court of T existed here right now, so we're putting proposing a virtual brilliant get only because you just have to return true or false, where they want 200. No, so default value for value types will be true, because that's the behavior to be country inter cuz, they'll, be breaking and because I think it makes sense. But for reference types value before.

L

So, of course, any converter can see trough also the behavior. So if you're is value, type opt out of handling. No, then we will likely return a default value. When we see no and you decided not to handle it, then of course, if you reference type any opt-in, then you and whatever you want to get, and you think that's about yeah. Sorry.

E

Guys, I'm not know, did you consider an alternate design where the there is a like? This is a method that takes the T and returns a T, or it's here that that gives back the T that should be used for null.

K

L

This is a relative feature. It's where we see like either no came in then I want to replace no with this value, or there was no decent and I want to put this file instead. So that's related to like default value, handian, um that's something else which people have asked for, but and it could solve this scenario, but specifically people want to be able to handle all in their comforter so well. That is something which could support them. Maybe should I, don't think it directly solves this problem. I mean it's also dependent on you know.

L

If you are just trying to. Please know something else, but if you just want know to be in your convert and that's what you're asking for it, then then that doesn't satisfy the requirement. Sorry.

E

I'm not entirely understand it. Can you give me an example: I had to clear I'm, not suggesting we do that instead I'm just trying to understand the trade-offs. What if I had a use? You know method, that's called and it hands back the T for null. Well, wouldn't that handle that this proposal does.

E

Well, I guess handle your example right. Cuz your example was replace null with HCP whack-whack, my company comm, or something right.

L

Well, it does yeah well, it does satisfy the scenario. I guess, I'm saying: that's not what people are asking for, but it I guess I mean I, think this proposal satisfies what people are asking for and what they used to come from be soft.

L

What this also does provide multiple which to do it, including something like what you've described boy. If we decided to see he does approach you want to take instead, I think it's valid as long as they can't get to do what they want to I. Don't.

E

Know the trade-offs I'm just trying.

N

To understand what options the option with like getting a tea for the valued like you have to have a not everything to write like. Why are you given a now? You have to construct the tea out of it, so it is a very common pattern by real users want to see string not empty instead of a null value, so you like it just adds more api's, as opposed to like this one, where you get one API for both civilization. Ninety serialization right.

B

But again it you know, it requires that what was explicitly sent on the wire was the token null it doesn't handle like if it was transmitted using the current version of the serializer with ignored null or whatever the name of the property is, then the null string would not have been written on the wire, the properties just not set, and then you're still going to get null back, because this doesn't fire on properties that were not present.

B

So I'm not sure this is act like people may say this is what they want. I'm, not sure it is. What they want is a little bit of a question, and then how does this on when serializing does handle null returning? True beat the serializer being in ignore null mode?

B

L

Told us to ignore um so, if ignored no value will not fire here, because we see that the value changes here is no and then this doesn't from that and I. Don't think it should I mean.

B

Like it just now, there are two conflicting things saying what to do for null and I'm, just making sure it split. We know what it's supposed to do and we've we've we've decided what it's supposed to do and we write that down and we test it because.

L

Yeah, this is to mean, if so, I mean my definition, for this would be if we're not ignoring no I can't handle. No, it's so describe this behavior. If.

A

You round tripping so say that you have a client server and your round tripping some kind of structure, and if the structure has an empty string property, because that's what you expected in the first place, when would you ever get an OLE on the wire in that scenario, like your server will never send mult of the client in that scenario, that I just described so this property theoretically will never even get called in such a scenario. I.

L

Mean in that scenario perhaps, but the veers I mean going through all the scenarios that could possibly happen, that Jason could come out of no way might not. That should be in your own ship scenario. Do we we typically think about when we design these features? um Somebody might just happen to have no, and then they want to be able to determine what to do it when they see it in their pillow right.

A

And I I get that I I recognize that there's a scenario where you're reading from some third party, the third party has put it all on the wire you're consuming it. But in that case we would say that the Jason converters handle no property is telling you. How do you want me to deserialize know what I'm having trouble wrapping my mind around is, if we say this property is also controlling serialization at that point. Generally, is the scenario not round-tripping, because if your serializing presumably are also deserializing.

L

Great, so if you have serialize and you've handled null, then that means typically when your DC realizing you're not going to handle you need two hundred no-cost I would never like Peno. Is that what you're that.

A

Right and that's what I'm trying to figure out is whether we actually need two different properties for that, because I don't necessarily see how that you will ever be both how the two will ever both be relevant. At the same time,.

L

Okay, so if we.

A

L

A

Overthinking, this all.

L

Right I'm, just thinking if we split it up like with it, so you have Handl retinal or read no um without that. Would there ever be case where one is used and today is not used.

L

M

J

Ultimately, that's that's all this thing does is called existing, read and write methods, not on you know, serialization deserialization, so you can do whatever you want in that you can not do anything or you can. You know, add some logic. So I, don't I, don't think we need two rules here, because you still have control over them.

J

A

Does this property need to be on the json converter based class, rather than the jason converter up to you derived class, because right now can convert type is on the days class.

L

um So the reason I put it so yeah, okay, so that's a good point that some other method that determines whether the converter is it's called, is on the piece type. But for me like read and write out on this type and the only time you would want to ask whether you want to handle all is when you're about to read or write. So I thought to put it here: okay, yeah!

L

Well, I don't know I mean without that sort of breaking the parity with some other.

A

Well, no, if you're saying that this is a sibling api to read and write, then it makes sense right. Yeah,.

L

This tells my thinking.

C

So maybe I missed is like we, we said earlier that we will not call this api when I was playing. We said earlier, if the property is entirely missing in the tail of a bond called the the converter and all I'd be only call them and.

F

There's a there's.

C

An actual video at the payload and if you were to call the converter even if the property, sorry, the property, is missing. Wouldn't that address effectively also.

L

So if we, which we call the converter, even when the properties machinima jason, yes,.

C

Because then, it's implicitly not affect the playwright. Well,.

A

Doesn't that break patch scenarios.

L

What do you, what.

A

Do you mean you have an existing object and you're deserializing a dip into the object, Oh.

L

Y-Yeah I think we need another little feature to see.

L

My thing was missing: I want to what do you do when not nope? No Jason came from this table which Newton's of hearts I think they have so they have default value handling, which says no populate with this value. If there's nothing new Jason, so I, don't think that I.

L

Don't think that would mean also if we implement similar sort of feature I, don't think the override to behavior that we have here or in influence it in any negative way.

C

That's the thing that we should Poli validate I mean like to me. It seems I grieve. You think it probably is two different features and you may bond one, but not the other, but we should make sure that the design is not you know this is the design will work for both of them and it looks like they were both designed it not like accidentally, stitched together right, so I stitch together. You know what I mean like solar, for example.

C

If you know no way of doing it is I, don't know like to to have a different pool here, or maybe just have a different kind of mechanism and all these stuff is being registered, but you just feel consistent between the two scenarios. I guess is what I'm saying.

L

Yeah I mean doing interaction is if the future says. If this thing is no, then replacing with this value, then that would so. The only interaction is that would then mean that we wouldn't call the converter or this method if, if the feature goes, if my magician is missing or if null is, if null is the value or my know, for this token, then, whatever wouldn't even check this just value on this handle no we'll just be replacing it with a default value um weighted right, yeah,.

C

But and I don't, but that seems to kind of suggest that we wouldn't expose the boolean here at that seems to suggest we just have two options on the on the Jason's settings, and it would say you know default belief or missing. Property is one setting and then before value from a property is a different setting right right.

D

Looking at the stack overflow issues linked I think those users should probably be very confused by trying to use this and unspecified properties showing up as null instead of empty string. Right.

B

Yeah, that's that's my biggest concern for confusion. Is that the especially given the ignore nulls serializing option that that it was no, and you thought you registered a thing to handle that on deserialize, but it's not firing and it's because what you wanted was a default value and the two are gonna. Have an interesting, intermix, I, agree and I. Think that's the the biggest concern we're having is, if you haven't actually finished designing what you would want to do for default values that this may be premature.

L

Okay, um yep I will yeah that make sense. I will I do I, don't think that yeah, ok, so I'll come back to this when I when I design, something for default for replacing nose or empty strings I, don't think need to self. Does it for nose, um but yeah I'll confirm my circle back here.

J

And, and just as an overview of Connor or recap, what happened in the past is that, as mentioned on the very top, we don't call the read and write for nulls I mean we could have elected to call it that have a slight / fit a bigger /, fit back in the original implementation, and then also we thought people would forget to put the first line of code at the top of every read and write method.

J

But assuming we didn't make that decision, what we would have done is, you know you just have to handle token type of null on deserialize and then check for null I'm see realized if you want different behavior, so I mean this is just saying: hey ignore our special logic. We have and call the normal method you would expect, which is read and write so I, don't think it. Overlaps with defaulting I mean I. Think that's completely separate.

J

You know missing values um because you could have their default values implemented, um not within the converter, I mean just for attributes, etc. But anyway, I mean I, I'm, fine with the guidance to say, go and think about defaulting, but I, don't think the over around I.

D

Think if this is going to be looked at as a completely separate thing, then we should have some concrete examples and the issue of what this will solve.

B

D

B

They wouldn't be confusing for users if the property was completely missing, as opposed to the property was specified as the literal null yeah.

D

The current scenarios, it seems like this proposal would not be intended to solve any of those yeah.

J

This has nothing to do with default values.

B

Right but it it has a little bit to do with user confusion once you turn this on, because if the places that people are asking about it, it feels like what they're asking about is default values. Then then they think that the to intermix, I and and just for.

J

Clarity here that this only is set to true by the actual implementation of a converter, not from the consumer right so I only person that would be confused as the guy who owns the converter and.

B

To solve their problem and then their problem didn't get solved. Yeah.

J

Yeah I mean with a little test and it figure it out so they'd be confused for, like.

B

I think that, from from the feature as proposed that the shape looks reasonable for what's described but as the bigger scenario problem I think it's potentially missing the scenario and potentially is going to interact poorly with the bigger scenario, and so my specific concern is make sure that we understand the big picture before we talk about the tiny detail.

B

L

But then my question is: how then do you allow people to handle all in their converters? Is that not something that should be I, think.

B

That, instead of like that, because you've mentioned default and you said default or null and if default takes default or null now, you have to understand how all this is. Gonna interact, ignore a null handle null default or null like you. You now have three different interpretations of what null means and can you write a consistent users? There's only one interpretation of no.

L

In this scenario, Oh knowledge is Jason token type. Now, when you read it and the value when you see realize it so what.

D

Would we expect so.

F

Maybe they read.

D

Know what? What is a valid value that it would give for know whatever.

L

I want to give I, don't mean on this realization. You.

D

L

The point to say we did implement.

D

This what example like what scenario would you want murder to do this like? Is there a sentinel null value for something where an axle.

F

D

Appropriate or like it is there a scenario that this tackles, because the three listed are not that yeah.

L

So I kind of so there's again as I mentioned the partners that request this and have to write custom converters to handle.

L

To handle it the entire wrapping type because they can't handle no, for they can't specify what should be pleased to know value is so I think when it comes to converters, but in general user should have no leeway to do what they want and by not providing a way to Angelo and converter is not complete a sense, because the commodity give you users, which completely take control of digitization isolation. I.

J

Mean the canonical example, I think is a string. So if you, if you see a annul on your property during serialization, you want to write empty string out. If you see a null coming in, maybe because it's not your values from you know some for their third party, then you want to set your property to empty string instead of known.

B

Exact ANSI it in the in the in the you know, limited scope that this is presenting it as, but that it feels like the people who are using it. Don't understand that in the scope is presented and if default is, if the default proposal comes along and it is not going to intermix the notion of I'm reading null and that means I should do the default instead of null.

B

Then that's fine and you've drawn a clear separation and the two things don't interact, but when you say things like default or null as a phrase, then that muddies the situation and now you it's less clear what things are supposed to do and it's less clear that we have a coherent story for a scenario.

B

Where do you see the default terminal terminal? Iommi said it.

L

Okay, so yet I mean replace know with some some default values. What I might have said to see you have no and then no, you don't want to replace it with something else or just hand rule not generally, regardless of whether you consider it to be too forward right.

B

But when when the default values proposal gets looked at and designed and whatever, if anybody during the time that you're looking at that says, oh and maybe we should say that the default value should be returned. If we see the null token coming in now, you have two conflicting interpreting is reasonable to see in that case, that.

L

The default value hanging would apply if there's no Jason, for when your dissertation I think. That is how it applies in.

B

Soft as well right and if it says no, that means no. Unless the converter changes it like I, think that that's a reasonable interpretation. You just need to have decided that for defaults before we can really say that this makes sense for converters, I've been hesitant to prematurely.

L

See that during this Eclair review but I think that's the direction which you go, that if we do the default value, handling wait, that would only apply if Jason is missing and then we'll. You know, since we already have a solution for that and and generally so, this I think we have to. Definitely we have to do this, and one thing is we do generally don't want to have too many ways to do the same thing and within the library which I think is a problem. We need to stop Jason.

L

um So if we go down this matrix for for didn't Hanley, not then replacing missing Jason with with a default value, wouldn't interact yeah because we limit it to only if there's no Jason coming in.

L

So in that, like that, I mean I think unless there is any objection, otherwise I think is readable to to move forward with this I.

D

I would like to see an a user, an actual scenario, that this solves, that the user is asking for. I haven't seen that today, I.

J

Didn't yeah I mean I, haven't clicked on all of these, but I'm assuming there's, say: I want to serialize empty strings instead of null strings just from the link.

D

J

D

But it it only partially solves it because, as a user I would assume that a property not existing is identical to a big null.

D

Maybe that's an incorrect assumption, but it's what I would have make and would have made and have made using various REST API. So I don't know if this is the right place to handle that.

J

Yeah I mean I think people might want to handle in all different lengths differently than default values. So I I mean I'm. Okay with saying hey, we should look at null. Values are sort of default handling in conjunction with this I. Don't even know, however, if default handling is on the radar for file, I mean Leoni. Is it its back? Look.

L

This is important for I'm. Just trying to look up for queries scenario, there's actual in the cosmos database I mean could be a scenario buddy. Do we please in all ways from default value for their class.

J

So for default handling today you have to set your field or your property in the constructor, so you know you can you can kind of do it today? It's clunky, there's no callbacks or anything like that. So we definitely have a gap with the default value handling and we purposely scoped it out interview one but I. If we don't do it, we will need something like this I think for final yeah. This is backlog.

L

For five, just under two priorities, I mean default value and your name yeah.

A

I have a related question. We had talked about whether there should be a difference between null literally being on the wire versus a property not existing on the wire. Do we have evidence about how commonly that difference occurs in practice like do we have evidence that that services actually write out literal moles, rather than just on lighting the property entirely.

L

I mean grab everything that exists, but I'm not sure what the statistics are. Unlike how common one is versus the other.

C

Right, if you, if you returned data from the server, then we lighting probably make sense. If you send data for updates, then you might not delight them, because you want to explicitly know them all rather than not modifying them, as you suggested earlier right right. Well,.

A

Does this gets to what what was being mentioned earlier about you know? Maybe we really do need a strong difference between this versus something didn't exist at all. I know, that's something I think Stevie were pushing it just a few minutes ago. So is that and it sounds like that's something you want to keep as a separate proposal rather than rolling into this. It does seem very much related I.

L

Mean if we draw the line between there was nothing missing in Jason, I mean those. This property was in presidency Jason and something was present, which is know, then just don't know it they're not related, because the converter is saying I'm sis realized something which exists, whether indigestion or or from the CLR type. They are realizing, so the converter can interact with anything where there's no Jason.

L

So again just so, we don't have multiple ways to do. The same thing wait to see. Okay, we have no and then now you want to issue something. We could start to go down that path if we have not default value hands in interact with the converters and interact with this 100 no feature I mean.

C

The one thing that we have said in the past is that we see the converters as the old, a patch right and like originally. We also had this idea of callbacks, whether you're the Conde civilization, where you basically get the instance after deceleration, make a mess of it afterwards right.

C

But we haven't done that because we said the converter will handle all these cases right, but it seems like we discover more more cases with the converter.

C

Either is insufficient or doesn't have enough information to make a decision right, which seems you should probably think about that I mean another option, would be another virtual message to Jason and on missing the video or something right, but I'm wondering like how far we can do this before we realize that you really need a generic or UCLA's method or something that allows you to inspect the object after deceleration and do some additional stuff with it right. Please please, please, please know.

L

B

Where all the accurate bugs come from.

C

But then the question is: what's you know, what's the alternative to that design right.

B

Like I mean the converter, should the converter can handle whatever something's missing because it like it's, but it needs to pop up a level. It needs to look at the bigger type, not at the individual property value. It is the.

C

Difference in further I can handle it. Yeah I mean the converter. I mean it's it's the seal as it has to I mean this is the party of deciding that right, but then it can follow the information to the converter and say, like oh, the property that I that you're, the type of was missing. The payload. No give me more everybody. You want to give me right because.

B

The string scenario on this one I mean assuming that I understand how the API works, which may be wrong. If you wanted to normalize the null value for Strings to the empty string, you would register adjacent converter of string like, but if you only wanted, then the null value for a string to be the empty string on profile. You would register something for profile, handle all the properties individually for profile and then say: oh, you never gave me a profile URL or you gave me a null profile.addlocation.

B

Uhl's, it's D. It's handling an entire complex payload yeah.

C

You said the two options you have I mean they make sense to me. That's why I'm saying if you do it in the converter, you would handle it for every single property that is of that type right, which might be useful right because you may not want to do that for every single object in your payload, whether you just want to turn the type once and for all right, maybe.

B

But registering adjacent converter during that turns all null strings into the empty string seems heavy-handed I.

C

Mean I mean any for primitive types. It is but like for your own custom times. It doesn't seem like it right because you know if you have your own schema I mean that's the rules in your schema right. They will probably apply to all instances at that time. Okay, again.

B

That's that's the the Corey's question of what's the scenario, because if it's turned an empty string or the null string into the empty string, I, don't think we really want people registering Jason, Converter of string that like instead, they would be registering a converter for their custom type. That says that when it's, this property on this type do something different, which is sort of kind of the same as the artists always call back, except with less you didn't pay attention to what properties actually got set security bugs as.

O

Far as it's in to protect our property, I mean I said that's what this one is for the for the property like well they're, free all.

L

Right so it's Noble and.

J

And today you can do all of this just without the null right. So just because we added this quirk, almost you can call it, and v1 is the only reason why we're having this discussion. Otherwise you know on. Do you realize you know you can have a string property map to an int, you know Jason and you just check hey as a token type. Int. Okay, well, you know, call int 2 string and set the string or return the string, so so having another token type of null.

J

You know it's completely normal I think coming in for deserialize I'm going out it's the same thing. Normally you get every single value of your object. However, we thought the serta Lizer would just remove. You know the possibility bugs and then the perfect things will we. This is a case basically where we limit the capability of the converter, because it's not called I think is the only.

B

Reason I mean if you have like a 90% confidence that default values. If it's ever added isn't going to interact poorly with this, then I I can think that that's fine just. It feels like from a scenario level they're really really to a user they're almost indistinguishable.

C

Yeah, how about this I mean I, agree with you on that one and I I don't want to block the feature for much longer, but it seems like at least I would like to see us being confident about that, and it seems based on the discussion that David on really seemed to know how we would handle that case. Right.

D

Can we look at the default values, API and then decide where to go on this once we have that one I think.

C

Yeah I, don't necessarily ask for like a full design where that consists. Like you know, if somebody can't describe to me how this would work roughly and then say this is why I believe it doesn't interview this feature, this exposes: is the bool is totally fine, I'm totally fine with it. I just wanna make sure that we have that level of confidence, and this discussion doesn't necessarily inspire the confidence.

C

It seems like there's still a lot of discussion on how this could work and and there's a difference between a full design of the feature and just as Jeremy said just having that confidence that we're not shipping a feature that immediately after post 500, we add another feature and all we have and.

B

If you no way o me Steve, if you guys are willing to say because we've shipped this feature, we know that we can't make default and all interact then sure like. But we.

C

Need a common statement.

B

L

Not to say that that default handling feature before if Jason is missing and not for if Jason is no because convert attribute and no in my opinion should be to do anything with whatever Jason is there. So if we decide that that's the way that no can be replaced, then I I would say that I wouldn't propose default value hand in the handle. The case, where did the Jason is known.

D

So if I'm, a user and a property is not specified or it could be null in order to get a string dot empty replacement behavior on both of those I would need to use two separate api's.

B

Or just register a full converter for your type, because.

D

It feels like the overwhelmingly common case would be null and unspecified are identical from the user perspective. It seems like a much more rare thing. That null would mean something special and unspecified would mean something different.

L

L

Yeah, it's just yeah, it's mean okay, I'll bring this.

A

L

Jessie, if we're talking about no and missing I, think there'll be a case of one feature trumping over the other one. So it's a stretch to say you have to like use a converter for this case and the priority well, no use is too bad to see if you want to handle. You know, if you think is know, then you know use the converter zip into entity and because that feature they already exist. So most people already have logic in the converters down to this.

L

If you have to do it and then for default value hanging, no puts it to default value attribute to specify what well you want to replace things with, and then, if Jason is missing would use that values. So in that way, I think that's a pretty I. Don't think it has to be ceremonious where it's a big problem where we, you have to do poor things, and maybe people generally use converter to handle.

D

All cases but I mean gonna.

L

D

A converter can return the status of. Maybe it doesn't have to be boolean. Maybe it can be used default ordinal or something like that. I communicate that the default value should be used if it's seasonal. In some cases and in other cases it can return special value.

C

Yeah so Magda's deeds work like if, if you feel like you have a high confidence plan during the week and it's just a minor modification of what you have, you can also do it over ma. I don't have to wait for a full week if you, if you need to make it forward, but you know give me the only a 50 minutes left. So we should look at the next issue that you have the support for non-public exercise. Thank you, yep yeah, this make. Hopefully this is easy.

L

Okay, so there are two issues these so future part is one separate issue and non public access or support is another issue. Do so so I proposed out I, just both of them since, like I'm, proposing similar API 202 scenario, um so starting with so non-public, accesses, serialization and deserialization? So so this is not talking about non public properties.

L

So this talk about proper public properties which have the primary. You know the predominant cases it has a public Gator and it non public cetera.

L

So right now we do not use the non-public sector for this realization, but it can be serialized and people want away to as part of the public contract. So people want able to me to deserialize it and then, although non-public data is not common and also not really requested, I include support for this, because Newton's off has parity and it's chipped, implement and test and I. Don't think we need to further complicate the API to support this in the future.

L

I think by just opting in in the way of describe issue way to handle both non-public, Gator and non-public, cetera to test non-public accesses. So few supports there's no way to see lies and easily using the serializer. We scoped out of t1, so just note that, according to guidelines that Jerry now recommended, but the net itself uses these types, I'm use these fields, thankfully tuples so dis, which all support well.

E

So what assuming we went ahead with this? How are we thinking about responding to a customer when, in the next release they say, hey I was serializing system, dot, foo and you changed its internal structure and now my code is broken.

L

So systems the food wasn't see it was see as an empty like value give well this week and it's a breaking change, which.

B

It looks Steve, like you have to slap an attribute on the field that you want serialize, so it's not reaching in to CLR types. People have to paint it themselves all.

E

Right, I only see what's currently on the screen, which doesn't include.

J

L

A Google option, so things like I, mean things like value like value. Tuples are not with theorised I'm empty now, which for many people is a problem and I think doesn't make sense and I think we reasonable to make a breaking change actually can take civilize those contents I.

C

Honestly would say my line in the sand is: if you want to civilize fields, for whatever reason or private fields, you have to mark the type like I think like we don't want to be in a world where people can globally turn it on for any random type, but to Stevens Point. It's not a breaking change. If we changed internals of the type, that's a completely compatible change right. It's just that.

C

We go out of our way to provide a feature that can turn private implementation changes to breaking changes, which, I think is will be don't want. This.

L

Will not happen because we're not going to be this doesn't support private fields, it's just going to be public field and then for built-in types like value to pools which people want, including partners.

L

C

Alright, so they, so the global option is only for public fields only for public field. If you need non-public access, then you have to use the Jays in order to be actually.

L

So this wound support this dude. So down will not support non-public fields. You only be for public shoot, so someone can reserve the right to say hey. You are not serializing, my huge before don't serialize them know. This is what this would provide, but this doesn't provide support for big ships. Yeah.

A

I think Steve to your question. The line in the sand is, if you, if you require the payload to be consistent across versions of the framework, don't serialize types that are not under your complete control.

C

It's just that if we combine the feature where you accidentally or intentionally, it's your less private state that that doesn't work right, because people always use member types and their public types yeah. It's like stringing, a list of three or something like yeah yeah. That's that's I, think why we need to be careful that we don't design a feature with people either intentionally unintentionally. You can see all that's private state, all fabric types right.

A

That large wasn't started. Sorry Coco I.

D

Think I can, by the usage pattern of just marking, forcing people to mark the fields that they would want, including private fields, perhaps and not having a global option to do that.

L

So then, do we support built-in types like well, you explicitly I think.

D

We would convert order.

G

Yeah, because we want to support.

B

So how is so I guess so public fields I, can understand right public fields, as public things can can work, but for the non public, accessor x'.

B

Wouldn't a OT like a OT just can't do this wait.

L

That's something something we'll have to communicate, because if you look at I mean people wanted and I think we just have to document, it's not super clear what the implication will be just yet because we don't know if we're going to be generated. If we do generalizes, we might generate them on T type themselves when another design, so that might not be a problem. um Otherwise that would be a problem. So I think tell Vic is what we communicate, that certain like non public usage can force.

L

You can either know how we design you can either just not be supported and or we let you know that we will go down if using existing parts. That would use the.

A

Reflection what you could say what you could say right now is: if you want, like some kind of ahead of time like cogent serializer thing, you support, pocos and that's it like pokers have to have get set, properties have to have public fields like they're, just.

B

Like if there's, if it's the thing that has to be put explicitly on the object, then you'll get warnings of that level. But because I guess I, don't see, include fields suggested as adjacent serializer option. But so maybe I'm just conflating state.

A

What about read-only fields, I,.

B

D

B

L

A

L

A

They get serialized what you can't do, serialize them just like with read-only properties,.

L

Right um actually can lead DCM, like reflection, not.

A

Not necessarily because, depending on what run time, you're on the run, time might actually throw an exception. Just like.

L

A very fiction features that we use down, or you need differently.

G

A

The the run time has gotten a lot stricter lately about being able to write to things that are marked as read-only. For instance, if you try using reflection to overwrite the property of a static read-only field, we may have already cogent the value of that and burned the value into various call sites. At that point, reflection will actually throw an exception. Saying like I've, already gone, the sorry I can't do anything for you. You can imagine in the future, that being extended, to instance, properties or instance, fields as well, bunch of static fields, yeah.

B

I think they would have to use the or other feature of.

J

Constructor matching: it's definitely something we have to test for it, especially if we do the I/o emit options for sending field.

L

Yes same as read-only property,.

B

So is our JSON object attribute that is on the screen right now. Is that a completely new attribute? Yes, this.

L

Is newly proposed.

J

I

A

J

Object, meaning there's two options here also on the other. One does not have this attribute. So if that's offensive, then maybe option two well.

B

I was trying to understand the riad in prop room like the difference between adding a new attribute that has properties on it or adding properties to an existing attribute right.

C

L

C

It's also, we already have adjacent property name attribute. It seems a bit odd to have Jason property as a concept and then everything called adjacent member like.

L

You know I mean I referred to Jason property name, as the thing like representing what the fear are. I would be written as Jason or what you look for when weight is really where such is member means. This is the member and a poco that we should include during serialization deserialization yeah.

C

What it means, but it seems, the terminology that we choose is property right.

J

We could have said Jason object, serializable or something like that. I mean it, um but it only is applied to classes and strokes. I.

M

Think he means for de jason member. It seems to me, like we.

C

Couldn't merge them, I mean first example like it seems odd to me to apply the the the they attribute to the whole type. It seems much more in line with saying you need to apply them to the individual members. You want to be civilized and then you can have just Jason property attribute, and then you know, for example, have additional settings and that one to say what do you want to do with non-public accessories right if you apply to a field that doesn't apply, but if you apply the property back to the appliance right so.

A

One benefit to applying it to the type rather than to the individual members is. If you have a code, if you have a source generated partial class, you can apply the attribute to a dummy, partial declaration that that's similar to how data annotation juice to work way back in full framework. You can't necessarily easily do that at the property or member level.

A

B

Right because you can only declare void private.

D

B

D

C

It's like because I mean it seems to me when you want to include like it makes it. What this indicates, this whole hold fields or non-public. Things are being treated on that tire, but that still seems like it's probably a local decision, not a global decision I mean is so I think.

L

Is no acknowledging that is another member. This is another actually being proposed that actually does provide that look cool like opt-in,.

L

C

I think I would encourage us to to avoid too many switches that are overlapping, because that eventually results in a complicated stage. Reason about like what we know about takes precedence and what doesn't. But it generally seems to me that if we believe that fields are somewhat rare and if we generally believe that that you know non-public accessories are kind of rare, then I think it makes more sense to me that you apply and it's similar to rename. So he said renaming happens at the member level.

C

You put the attribute on the member you want to rename and because this is somewhat rare scenario and for the global things that are common, that I tested Kate's may have a global setting right, so I can buy the global. You know, please include public fields because, as Jeremy said, public field streams generally fine, but anything that involves non private store and that's a non public state should be an opt-in for a member, in my opinion, because it seems to be somewhat rare and yeah.

C

That's what you have to express your intentions, because otherwise, if we apply this today today, you happen to have two private things that you want to do and then tomorrow and a third one did you really meant to expose it? Maybe, but maybe not I.

B

Mean and in the JSON object, attribute type right now like right now, there are two things and you're like fine. If you specify that you probably wanted them both to be included, so there ignore to change the default that anything future would have to have a the opposite state for a default, because it would be behavior preserving. So it would need to be written the other way anyway, but yeah I think that we should get rid of the type level one in just just the member level. One and.

A

We would have a global include fields on the serializer, as is proposed here, which.

C

Only mean college should probably just call this public because it can't be protected right. It needs to be truly public if.

A

I, don't necessarily know if we need to include that technically, because there, if you have include fields and you put Jason member on a private field like it'll, get serialized right, like the two of them behind allow private, even.

C

If the global one is fault, if you put Jason member on a field that should be in cooler no matter what the law was sitting is right, because it's a trait yes.

A

Yes, fair enough yeah.

L

But I mean right now: I, don't nobody is asking for private fields and I, don't think I mean I, don't know it's up to security perspective. Whether we should include support for that.

B

N

B

An attribute on something they've that is the maximum amount of opting in that you can do like I, don't care what happens as long as somebody is explicit. Yeah.

L

um What about so the same thing with like to non-public prophecies all right.

B

Yes, but all of these, you then have to ask the question of, as we start being trying to be more inclusive of äôt environments like what of this is going to start randomly failing when you start doing a target specific äôt single file distribution like the does the entire serialize or stack fall on the floor, like you, just we're adding a lot of things in the same release, and it seems like this isn't interacting. Well with other things. We want to add.

C

Yeah you did that or the way I understood comment was that one way to do civilization is that we generate the the the code written sterilizer as part of a member of the types themselves, in which case they can clearly see their own privates right. It would just mean that if you can't do that, then you know what happens if you take we've also generator you take a random assembly and try to use it on iOS. What it just means you fall back to reflection and.

L

C

No soap yeah it for that. Take yeah, that's the thing we should avoid, though, because these are kind of the landmines. Two people really dislike right because it's it's hard to reason about behavior changes that are like cross-cutting, like you know, äôt, on safety off, but it kind of makes sense for things that you know you generate cold weather. Think people can understand that reflection. It doesn't work on an iPhone right, but it's very hard to reason about all the features that happen to use reflection and its implementation right.

B

I mean like the notion of so. If you have to put the properties on every individual member and then then yeah you had to control the type to do it, generating it inside the same type works and there's no weird external state. That's going to rewrite what all that's doing, and so so it that makes more sense than some bigger level options. Doesn't.

A

The Jason serializer right now allow you to specify like as a sidecar option. Oh this property didn't actually have this attribute on it, but pretend it did as far as the serializer options are concerned. Doesn't that ability exist I.

C

C

A

I thought you could I thought you could associate a converter with a specific property, even if you didn't control the actual type that the property was too clear.

J

No, you can. We did discuss the husband where you could add quote-unquote attributes at runtime, although.

F

J

About that for a long time, but eventually we decides not to do that. But okay, because.

A

If we did that, this would obviously play with that system. Yeah.

L

C

Let me just summarize what we have and then we can look at this in the window, because I think it will be hard. Otherwise it's a API surface to reason about so what I heard is nobody has an objection with the global setting right so long. It only applies to public correct. Is that a fair summary correct.

A

C

Default so this will be off because.

M

Otherwise, you see, as more said right, okay.

J

So then, this is primarily useful: the global option, when you don't own the type, if you own the ties yeah, you could just plop on the attribute on you. Every field.

L

All right, great, the reason why I mean if somebody has included fuse on, but somebody who doesn't want you included even I, have to like put Jason ignore and everything on there. No, no their fields for it touch with it, which is just like something top-level saying, hey, don't include any of my fields but I guess that's fine!.

J

It's possible, depending on the whole set of types you use. You know it's gonna break you're out, but people have to understand that if you enable global, you know public feels.

B

Like I get JSON object as a attribute, it just doesn't scale with the were you're opting in to ignore, because any future additions would have to be opted in to include, and so then the argument of it lets you avoid jason. Ignore is limited to exactly this release and doesn't stretch beyond so I. Think, there's having a consistent story going forward is better than having a convenience in this release and we can always totally optional drink.

L

C

So I just removed the comments. This is what I currently have. So if we remove the JSON object, what are we doing with the accessory? Should that be a say on the Jason member attribute then, or how would that work.

L

The access, so, if you put it on, if you put Jason member and something that has private exercise, that would also work the same way you would use to fund public access. Oh.

C

Yeah, well, we need it at all like if I put on the property and the accessor happens to be private, you can work this.

L

We don't need that property, I.

L

B

That's the point by just putting the attribute on the property at all, you said: make call both together and cetera. I, don't care what their declared access level was right. So yeah.

L

And then, just so now, I wasn't including private, like non-public fields or properties. So now these mental attributes also apply to those.

C

L

C

See so you would only apply to properties and fields right and so.

F

C

Field to visualize that would put the attribute on it yeah. The only thing you can't express right now is: if this setting is on I can't suppress the field, I guess I can.

B

Yeah, which presumably right now doesn't say it applies to field, so we need to update its attribute usage. Yes, wind.

L

Field supported I did it. I did.

A

This seems this whole seems reasonable. Yeah.

J

Okay, just to clarify, though, the original proposal only applied to properties, if they, if the property itself was public and then of course, the setter and getter can have either one of one of them, and we could have you know internal or private. So we're saying that on now we're gonna loosen that up, and it applies no matter what the property is declared is as long.

B

As it has to be declared with the type prior to compilation, then I don't care what you do.

J

For private and getters, it's normally I'm, just a setter. You know internal or private I mean.

M

I think so I don't think we need.

J

M

J

But I don't know if we can change the behavior in the future or not I haven't thought about it. I.

A

C

Compile if both setters, if the property was public in both setters other, both accessor as a private I, think it's out to compile no.

L

That's not at least one.

C

F

Of them has this.

C

Match the the the visibility? Yes, that's that's correct! So what do we do this today? For it only properties have a basis utilizing them on, but we don't do like them right. That's right!.

L

C

That's, and so, if you, if you know want to see lies, you would just put chase number on the property I don't know it would just realize. No I would also DC authorized it by that's the way it would work. Yeah.

L

I mean very duly to touch him and get only what to do soon. So if it doesn't have a get it get that, then this one provides support because I mean there's no there's no set that you use even use the parameter, constructor feature or there's like a feature. Maybe post file where we see like object, handing object, object, region, Christian, Hanlon, where we can reuse the the instance. If it's already instantiated.

C

So if you have a property that is read-only right, so it has it, but it has a private setter right today. Be would only see Eliza, but we wouldn't deserialize it nope I've wanted diesel. Is it I only have to put this Jason member had to be on it, and that would work right. Yes, that's right. I told you asking about if you didn't have a set at all, so if it doesn't have a setter at all, then I think it would.

C

It would basically do nothing by Jason would still see Liza, but it wouldn't do lies it right, because there's no way for us to call the court and.

B

The only thing that I think you couldn't do easily easily is, if you had an internal property that you wanted to serialize, but not deserialize, and then the answer is make another internal property. That only has the get calls the get of the pretty that you care about and put Jason number on that and and Jason property name like you can work around it at that point and I. Don't think we need to say. Oh, this was a non-public get, but I want you to now.

B

Do the the read-only property scenario like you again, there's a workaround, so so I don't think that's important yeah.

C

So my question: now it should be renamed this edge to be it though, because really it feels like Jason include.

B

C

Yes, I think that seems exactly what I understand. Yeah the.

L

C

Just seems as odd choice because we don't talk about members, but in Jason it's called a property in member seems to be that concept to be invalid.

J

I think it was because it was called away because we had a one that was called class, so two different Jason included that only applies to fields and properties, make sense right.

L

So would it should be valid to have Jason included and Jason ignore like right now, Jason ignore wins over everything, so you should read actively check for that and throw if you have.

C

You know we should we should. We should just use Jason exclude so Jason ignore them, because if you put both of them, I would say it's probably a bug on the developer side, but that I would probably strip of an analyzer if we cared enough, but at one time I would just say: if Jason ignore specify you, don't you don't utilize it all.

J

Over or throw an exception but yeah we do throw in velvet operation exception and other cases like this, where we detect misuse attributes are.

B

You think Jason property named Knowle.

L

Yep just an extension theater, multiple I.

B

Think it's you can either go with ignore or ignore wins or throw whatever, whatever makes you happier, but include, should lose. Then I always wins.

B

L

Probably pray through one.

B

And emo don't forget the note that we need to update the attribute usage on Jason, ignore.

J

Properties and fields on this.

B

Seems like that's what you wanted.

J

I mean in the sense of fields had to be public, and you had to have the public property declared as being public the setter and getter one of them. Oh I see what you're saying no so.

C

This maybe I'm, maybe I, read too strong because it says non public access was in fields, so I kind of assumed. You meant. Oh.

B

C

Feel yes, give.

G

C

B

At non-public accessories.

C

Okay, so maybe if there's no needs to support privates, then I'm also capable, but.

D

B

C

Is well one person actually but yeah.

B

I mean you can choose to you know, throw in the case where you see it applied to a thing that you didn't feel like writing down thing.

B

D

B

Shouldn't like, if you decide you don't want to serialize private fields, even if they put Jason include, then you need to throw, because if you silently ignore it, you can't change your mind later.

L

B

Said include this and then say: fine I'll include it or throw yeah.

J

Definitely lay only what are the other serialize errs on support for private. Do.

L

They use you can use different property for an instance of to support this.

L

That's what I know for you to soft I think either it's a fate Jason or brings you to veggies, and that allows you to include to use non private members as well as.

B

Long as there's not a type level directive that ops things in as long as it has to be on each individual member like I, if you want it to include privates I, don't have an objection. It's weird, but I don't have an objection. I.

L

Mean there's one or two people. That would be very happy if we do this one and you.

B

Do you make sure you include tests with fields that are declared read-only and understand what yeah.

L

B

You're going to do around that because yeah, if the because I feel, like instance, fields already we're block and get blocked for set value if they were to acquired redoubling, but I could be I thought it was universal, but Levi says is contextual, so trust him I.

A

Think it was more people than me said that.

C

Yeah well, I would not make it contextual, I would just and I say like the way we should treat with only a few. That's like get only properties right, yeah.

A

There's no sense whatsoever, yeah.

B

So so just make sure that we include a test that does that and that we've codified the behavior and yada yada yada.

L

Yes, for the non-public stuff, I defer to Steve um Steve. Do you think we should.

J

Shed non public members, I mean my only concern with non public is, was the äôt scenarios as Jeremy brought up already um I mean.

K

J

Whether they're, private or internal really doesn't matter, but if it becomes a common pattern- and you know everyone starts doing it this way, then we've very constrained by what we can do for the cogeneration I mean basically the the cogeneration converter has to live on that type, but by opening up into none public setters anyway, you kind of have the same problem, but it's just not gonna, be as pervasive, I think. But as long as there's no security concerns, um I thought there was a.

B

Man, if somebody's explicitly slapping yet you Don things- that's like that says, write this on the payload and I'm willing to accept that going on the wire, because that's that's exactly what they it's the same as I'm writing the converter and doing it manually sure.

L

Okay, I think for now through, if you put the attribute on non public member and then if at least a 2-liter versus I, get it a difficult spot now mm-hmm, it's just depend on how many and we've wanted.

J

Element behavior um for four privates I'm, assuming it's not gonna, be difficult. You know, assuming we can do it. Fine! It's just concern there.

B

Because if the aisle Amit is dropping a assembly on the side, normal assembly load, rule say if, if you had a field that was public and then you change it to private somebody who was already calling the setter will get in a CLR exception like it'll smack down and terminate the process.

B

So you may, you may have trouble with. You may not be able to recommend the fallback to reflection.

J

Only right so I guess that's a concern for perf anyway, um but I guess, if somebody's doing that they probably have a good reason to do it. I mean making private setters and getters and feels amazing didn't get more perfect. That.

B

As long as it's not silently, if writing Jason include on a private field is not silently ignored, then you have expansion, room yep, but if you silently ignore it in this release, then that's the behavior for her. Oh.

L

Yeah there's only purpose of I like this one better anyway. So if this looks good and.

C

Cool we're happy it so I just put it on the screen. What I had written? Nobody greets of that- and this is it for today- we're 20 minutes over my only review for issues.

C

Pressing there's easily do all the blocking ones I like.

C

Alright, guys and I say goodbye and see you next week. Thank.

L