.Net Foundation Design Reviews, 26 Mar 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: .NET Design Review: AssemblyLoadContext improvements

Description

-17:-02:-08 - Approved: API proposal AssemblyLoadContext.ActiveForContextSensitiveReflection https://github.com/dotnet/corefx/issues/36236#issuecomment-476796579
00:42:56 - Approved: AssemblyLoadContext .NET Core 3.0 improvements https://github.com/dotnet/corefx/issues/34791#issuecomment-476796715

A

Right so I know your life is a proposal from Steve. Do you want to walk us.

B

Sure this is a kit, because I can't see the whole thing. We can open it on my screen. This is sort of a basic proposal for some.

B

Simple additions to the assembly load context to sort of make it more function and complete we're. At a we tried, there was a desire to simplify usage in the creation of plug-in context to make this a concrete type instead of a abstract type, so we're proposing adding a default load implementation which simply returns null.

B

This is actually the implementation that's used in to our internal Hales assembly load context as well. When you return all that method implies, try to load it from the default first, and so that's sort of a logical default implementation. It says if you, if I'm missing a dependency, go, try to load it from my default context and then come back and call my resolving event for me to get a second chance if I to find it assembly.

B

So if you it for assembly load context, usage which which would prefer late binding of assemblies as opposed to early like it, wants a second chance for somebody's that are not found in the default. This is sort of a logical default, so we've used it in a couple of our internal invitations and it it feels natural for plugins. At a couple places, the second sort of feature is adding a name just so that the assembly load context. When you query them in a debugger or you want to print them, they have some sort of identity.

B

That's human, readable part of that name proposal is some assembly load context, get created automatically in the assembly load methods Loadstar at methods, some of those actually create or something about context automatically. So the proposal includes is what that those will assign a name to the the automatically created assembly hood context as well, and it override the to string method for similar reasons and then we're adding a set of an enumerable to return the the context.

B

So someone can iterate through all these existing assembly about context and an Assemblies property, the iterate to the Assemblies contained in the assembly hood context. Both of those innumerable properties are snapshotted so that they represent a set of talk in a specific time for.

C

The context property, what the expected use- Kay, there's I'm iterating through it, to look for a context that I want to load my assembly into.

B

Most of this was driven by Diagnostics as people try to understand problems with loading assemblies and they're getting loaded in wrong context. I was my intent was so that you could create a graph of context and the assemblies they contain, and you make it relatively easy to to make that map I.

C

Use case would basically just be a double nested loop loop over all the context for each assembly load contact loop over all the assemblies and help put it out in some fashion right.

B

C

I think in the.

B

Discussion it may other people may have thought of uses for it, but not seeing it.

A

Point because I mean everybody who does that? Like that's probably the first thing you try to get right, it's like getting understanding what's loaded and what's already, and they should. You know, load your stuff into just doing this Linda burger and just seeing what's what's there it's a thing super useful yeah.

A

Let's see that discussion that we had as like coders. So what ends up happening when you said they're immutable snapshots at the time you, but you would feed the property they're a snapshot. Yeah.

B

Well, and if you, if you anything, we redid it again, it would get three snapshot ring I. Think that's! The way in numerable works right when you, basically that you start the enumeration iterate through it, then you reset it, and so, when you start an enumeration, it would snapshot it. And when you didn't read it again, it would rese not John. So.

A

When does that probably happen back in together or when you actually pull on the numerator for the first time, it.

B

Should happen when you pull on the enumerator at the first time it certainly the intent is for it. When you use context in a for each loop or D, it would be snapshot of the instance. You called it I believe that is the way it works.

D

What is this bake by and if I snapshot you mean that if I save the innumerable and I numerated again later, I get the same answer.

B

Know it snap chatted for the duration of the enumerable, so basically, if someone inserts creates another context, while your enumerator, it won't give it that new context won't appear.

E

B

C

I make sense every time you tear off in a numerator it you're, getting the current snapshot all right.

A

I think that sounds to me, like my biggest concern, is that you have you know threading issues where somebody you know you know as you. It is it all that you just try to create a graph and I'd say you like in the loop you're, instantiating I, don't know the XML reader, which happens to go through this path and as a side effect, creates another context and suddenly or for each loop, goes in, but an operation exception, because the collection change where you numerated it right.

A

Also, the kind of things like that, you know I think snapshotting seems reasonable to me, because I mean that's the best you can do. My concern of snapshotting or originally was is like the naive way of doing it would just say every time you create the property, you basically, you know, do a two array or something and then property a basic accessory locates every single time, and that would be pretty bad, in which case you want to make the method. If you do it. Basically, on the first time the Corbitt enumerator, it's fine, I think.

F

And all the all assembly load contacts that were created, get put in this list, even ones that I derive Andrew it myself, yes and.

B

The default one would be in the list who you know just have a name of default sort of logical.

B

What named is my assembly load context kit, so that so we did add a constructor to allow you to name them. If you have, if the the existing code wouldn't obviously use that constructor so right now, the name would be null, but the two string would include the type name. So your my assembly load context would show up in the two string at least are.

D

D

B

Yes, I'm trying to abstract the class with this change to certain.

C

Concerns, or is this like the desirable that I can basically walk up now to I, can find any assembly little context in my entire process and load and assembly into it.

C

I mean there's no secure right now. Some of those contacts are not providing any securities yeah actually didn't mean from a security. Boundary meant more from an expectation like if it is anyone like if someone was creating their own assembly load context than one area. The process is what I was doing, the other. Would it mess up anyone's assumptions about how their some of the context works for arbitrary assemblies to sort of be shoved into it?.

B

Fine I am I, mean they're. Still they already exist backdoors to do this so right now on app domain you can call get assemblies and for each assembly you can call get assembly vote contacts to find the Assembly of context. So these are sort of to some extent convenient safety. Is that we've kind of vetted for making them performant and make it easy to use in a debugger? So I don't think it's not really exposing new functionality, except for the name.

F

Is assemblies in my in my assembly little context, the Assembly's property gets filled up automatically as well. Yes,.

F

B

How sorry so, right now, it's implemented by calling abdomen get assemblies and filtering based on the ones that are in this assembly, though context as we iterate, and if this becomes important there may be performance improvements that we you know under the covers the implementations and would be internal and said that some of them contacts me carry that list itself.

B

B

What are the open issues?

B

There was a a suggestion that context should be called all contexts, because some people felt like it was felt like a better semantics in a four for each kind of reading. I.

A

Know I said no context, not context which is kind of weird yeah. You could just call it all.

A

I'd make the footage group a little bit easy to me.

F

You scroll down, emo I, see the open issues. Oh okay, that was it sorry. We were missing that list. Sorry, there was one thing in the list: yeah.

A

A

The thing I asked this question on the thing that I don't exist. We call the answer entirely. So the idea is that, if you can you up in assembly local context now right and then I can say, load will fin assembly name over the past right like the path. One completely makes sense to me because you call they detect.

A

You know you just point to an assembly, but then, as as this assembly is basically being used, other loads are being triggered by a name right and then this guy will just return now and I think you said that the basically, if you returned off from this method, it just means that some default policy is being applied. Is that correct right.

B

So currently null when you worded returns and all the search continues in the default assembly context to look through the trusted platform assemblies and if that fails, then this assembly load context resolve I, get the names mixed up, but the result effectively, the resolving event will get fired.

B

Giving this assembly low-context a chance to load that so one of the other API extensions we did for 300 was the assembly dependency resolver right in in the sample code, one of the primary ways that uses attach that assembly defense, your resolver to the similar context, resolving event gotcha.

A

So the primary way to customize that effectively moving forward is not to override the method but just instantiate any context and subscribing to the event which basically makes it open-ended yeah.

B

I mean there's still, there's still sometimes a motivation if you want an assembly to be able to be loaded both in a custom assembly context and the default, and you want to make sure it's loaded in your some of the context before the default. Well, then, you'd have to over light this method, but that's a fairly against use case. What.

A

Is this, so is there any way for me to run the default policy to resolve it to an assembly or is the way you go to semi local context or default or load by name.

B

Right now, the normal ways return null I think you can also. You can also say, assembly, low-context default load with I, don't know exact same, but there is a load. There's a method on the some of the context to do that right, so it maybe it's look. You can certainly see load from path, I think think. There's a load by assembly name to which effectively triggers this scenario.

B

A

The side-effect of those sapiens is that they also load the assembly, but if I just want to say, can you resolve this guy I have no way of doing that right. Right.

B

It is certainly a desire. The problem is with our current design with the callbacks. We can't predict what the callbacks will do, because the callbacks all actually do the load.

G

B

We'd really like to this port would be a data structure, kind of thing. Like here's, the list of assemblies I know about and we'll load. We just write with an existing design. That's not feasible.

G

C

55, how does this relate to the the collectible assembly stuffs? Icd is collectible equals false at the top, if I'm holding on to an assembly load of context, just like the reference to this code instance did that keep alive everything inside it, it I believe it soon.

B

C

Okay, so with the with the content, with the all context thing if I were holding on to that enumerate or I would basically be preventing anything from being collected right.

B

I think that a numerator wins implement right now, I snapshot the week references, so those are offenses are not holding it open and, as you iterate through it I check to see if the weak reference is valid before returning it. So it's not actually a.

C

Snapshot in that I could I could start a numerating, the ALC could be collected, and then it could show up as a you know, no weak reference then go in you as I'm a numerating. It won't be there anymore right. So.

B

It's that seems the best solution for me. That's what I chose to do. We could yeah I'm going to could hold it. Yeah I think that's the best.

A

Yeah I think that's reasonable right, because, basically you you don't expose to race conditions to the customers. Right I mean the race condition. I mean there is a race condition, but you don't quite know when it happens, but it's also not relevant y-you. Just you basically I think the API shape is nice because it doesn't expose a big reference concept right. It just means that whenever you pull on the assemblies, we give you what's still alive and that might be less.

C

Again reasonable, it does mean that someone who's enumerated me Elsie's. If they were to then hold on to the ALC there, then preventing it from being collected, but that's on them well,.

A

My listening is that they don't write because they're. What Steven just said is that they've hold onto the big reference in the numerator right.

B

A

B

Could go put it in a container right.

C

Yeah I think under the covers, there's a weak reference around the assembly load context. This is unwrapping that weak reference and handing back the ALC as long as they can't hang on to that ALC. It won't be collected as minders.

D

Oh I see the thing yeah. Yes,.

D

Called getenumerator manually advanced at once as long as that of numerator stays alive, and still that has a strong reference property they're, always accidentally.

H

Yeah I think that's fine I just want to make sure I understood how this works.

A

It's su that anything holds it alive. I did I just hold on to the assembly. Able to I would hold up the context of law right right, so yeah.

A

And that's the thing with collectible stuff: are you gonna hold on to it.

A

Alright I think that's all the questions that I had I think there were a few that I asked and I got answers for already and.

B

The there was a more controversial change that we forked off into a separate review and I at least would like to look at that, which one was that um it's. If you look at the bottom, it's three six, two three six!

B

E

Bottom, with one of.

B

The last late comments near the bottom on the thread.

B

Eeeh two three six, two three, six yep that one.

B

Okay, this is really long right up, so the.

A

B

Guys near the bottom.

B

That's part of it. It's it's repeated it. Each fragments repeated as I go through the document.

A

Oh, can you give us a.

B

Basic the weave there's as we try to implement plugins xunit and WPF we've seen problems with the current set of the current api's were originally designed to take advantage of the ambient. After being current domain and as we've moved from app domains into assembly load context, we don't have that ambient property anymore and so code that was intended to run within an app domain, suddenly becomes ambiguous and so we're trying to infer the assembly load context from an assembly and they're. Not it's not a one-to-one mapping.

B

It's a one to many mapping so in the right up here that plug-in dependency can be used in one assembly, the context but loaded in another, and so what we're trying to infer where it's being used from in a place where we can infer it, and so this is proposing adding an ambient property for this reflection case to sort of correspond to the current app domain property that we lost.

B

It's unfortunate, it's very difficult to understand to the right of these long, hopefully readable so I'm, proposing adding a read-only property which is active for consequence of reflection and I'm, proposing two methods that return I, dispose of all activate for context. Sense of reflection to basically set this property in a using block and to clear when you leave the using block so.

A

Basically I'm so big lost like how am I like was setting it and who was using it as.

B

I was designing it, the intent. The idea that I had was that the person that was create loading, the plugin, the plugin loader, would set the property as it entered the plugin, basically saying I'm executing I'm. Turning over this thread of execution to this plug-in I expect the api's behave as the plugins.

B

The current active context.

B

And so as you as the plug-in loads that plug-in it would call a using block before it called to enter the code in the plug-in and so and right. Now, this the proposals is for to be an async local property so that it follows the in synchronous, sort of control.

A

So what does it know mean that everything that is basically you request, an assembly load context or default is actually returning the other one, or does it just mean that every time you know trigger and load by default? It goes into that guy. You.

B

Can if you scroll down, there's a set of affected api's right now the sets fairly limited, so it is assembly load. This is activator, create instance, cases where there's an assembly name which effectively triggers a load.

B

There's these assembly load cases which are triggering loads and then there's a few more and like type get type which are triggering loads when the type name is fully quality qualified, not necessarily fully qualified.

A

Is what I call any of these API? They would basically ask for the active for context.

E

Of the trip, reflection context and would put stuff into that.

B

Right using the using the the fallback methodology that assembling the context has determined effectively so some assembly, those assembler contacts, sometimes resolve assemblies in other assembly hood context, but it would follow that assembly load contacts, all back out were them and.

G

A

G

Until it said right.

A

And then then it's now you just loaded into default. I suppose.

B

Right now, the current behavior is right. Now the current behavior these api's is they look at their callers assembly and figure out what this n with no context it's loaded into, and so that's the cantos emily load context that's being used right now. The problem is only when you have a stack of assemblies and one of them is in like a framework, that's sort of required to be loaded in default, but really wants to be loaded in the plug-in context.

D

So that is the active one, a stack.

B

It is a using stack so each when they call use against creating an object that preserves the previous one, that when you leave the using block it restores the previous and.

D

What happens if somebody doesn't disposable.

B

I get set till it's disposed, I mean when the object is collected. It was clear it okay,.

D

Well, it cleared or well, we teach them to fix their code by just fail fasting. The process.

B

Right now it's clearing and I mean Isis I, don't know right now. It's clearing, so the destructor right now is calling the dispose. It's possible. I could throw an exception or maybe in debug code it should throw an exception.

D

I'm just here because, but it seems like letting one of these dangle would be very weird yeah, which others doesn't expect everyone to fit me using. But if they want to do something, weird I feel that you know they should understand what happened. But maybe it's not. According this asking.

B

Yeah, it would seem a little weird for someone to say: I, disposable, equals ALC, activate context, sensitive for reflection, but I. Suppose someone could you could easily do it. It would be problematic.

D

That we expect people this should be fairly rare right, yeah.

B

I expect plug-in framework people would developers who implement this and use this. We probably use it in our test cases, so X unit is hit. This issue are two test. Cases for WPF have hit this issue so.

D

B

Fairly advanced scenario, it's fairly should be fairly rare. The.

D

Question I was building up to should, instead of being opaque, I disposable, should it be a struck disposable? So it doesn't. We can stack Alec and not GC, but if, if it's a rare.

B

D

B

In the context of that, so there was a note in the review of this that the I disposable would heap allocate, and one of the recommendations was to put it on a struct to to minimize that I was.

D

B

Boxing would still have to so.

D

The way that the using statement works if it's provably a value type, is direct dispatches the call to dispose and it never boxes it.

B

Oh so yeah we should definitely we all definitely make a struct.

I

Yeah, there's also another option to not create the helper for disposing at all and make it just a property that you just set and clear, and you kind of are in control. You know what what what you want to do it in tight. Oh, you have the caller used to try finally block on the road yeah, for example I, except even today. I the number of kind of good chance with these that you can kind of not tell to stack properly and forget to dispose it or you know so.

A

It's certainly easier in the sense is only one API. Instead of soon.

D

But I mean if we expect that the average process never does this in the average plug-in hosting process. Does this once then out of the boxes.

I

It's it and you know that the plug-in process, depending on the kind of debugging architecture I you can imagine some plugins- might want to kind of generate or some plug-in infrastructures might want to generate a proxies between our plugins and then they would set and clear this property each way through this proxy right.

A

So what are they setting that then, every single time they they'll they go across the proxy yeah.

I

You can imagine if somebody here they wanted to mimic what happens with top domains right up domains been busy. You go from one up domain to other after mine. You always go through a proxy that base, which is the current up domain, and you know like Marsh's the argument and whatnot right. So if somebody wanted to mimic this kind of behavior, they would busy want to auto-generate the proxies for all the communication, and they would always want it to set and clear this property in that proxy.

A

Then at that point don't like, if you set the property, you have to remember the old video right. Otherwise bad things will happen. Sure yeah, it's like.

I

No different from the up domain transitions right after my transition service also remember the phone value. So when you go back, you kind of.

D

That is disposable that handles the remembering to remember the previous value, in the put it back.

I

Yeah I mean so so this another powder is proposal. If you know the proposal is to flow it with async. That kind of makes it kind of more interesting. That means with box.

I

That means that you do, it would come participate. Indeed, you know the async local think.

A

I mean this will be a song right. It's just the property itself, it's stored in a single right. It doesn't necessarily mean that the caller of their using is an amazing context. Well,.

D

The right that, if the using.

B

Threats would stick if the ace-king threat escape the using block that would remain set on that easing thread, which is I, think the correct behavior.

B

A

Well, then, you put a different light like depending on again. If you want to evolve the behavior here like today, you say: oh, we don't do anything local tomorrow, you do it in a single I. Don't know, like you, remember the video you get some other photos. If you want to apply, if you make it a method, returns and basically and I disposable, and you expose what what the only way we'd only you get to deplete.

A

You basically calculate that policy right as soon as you say, it's a it's, a property, that's together and a setter. Everybody has to follow the ceremony correctly. Then, what you better, never change! That ceremony.

B

Sort of you can't mandate, it.

I

The property like I, don't think this trucks give you any extra. The kind of safety like in part of you for the async case, I, don't think the property prepares of struck makes any difference we have. For example. Today we have culture in photocurrent, culture that also flows with a sink and people just set and create, or you know, do what I'm going to take one a minute. I.

D

Think you most comment is: if right now, it's one property that you set in the new setback and a finally, but then you know next release it becomes two or three, but if it's encapsulated in the push the state pop the state with a disposable than the API does its own housekeeping.

D

Instead of making everybody go, find all the places they did this and update all of them and then make sure they didn't update. All of the pushes and then forget to update all of the pops.

A

Yeah like to insert about safety, it's more about, if you ever want to change the ceremony of going from one context to the other like, if you sure it's only going to be a single property and you just restore the old value, I think it's pretty much the same about modern lines of code. Everybody has to write. It just means you better. Never change that.

D

But if all that's flowing with the async context is the oneness and we load contacts, then the struck disposable. When you push in it, assigns it when you pop out it the lasing state snapped it. So you don't care, but then the serie. The synchronous flow now has the restored correct value, so it seems to still magic the disposable pattern.

A

Yeah I'm fine, either way. Honestly, like it's more of a function of you know, it's a very advanced API I'm, not sure the name makes sense to most people. To me, it's not clear what it is. I would have to read the entire right up in order to make sense of it, but maybe that's kind of what you want.

C

To be to be current on, you had some object that you stored, and then you cleared it out by clearing that object. That was the wrapper for.

B

It, but this one I think thread finishes its: it doesn't need to be restored because its threads basically gone now. That thread gets reused.

I

For a net next work item well.

C

It would flow into it so for that in general, unless you're doing something complicated by default like if you did task dot run or you did thread, people accuse a work item or something and the async local is only going to exist for the batch scoped delegate or whatever that you passed and then the underlying infrastructure is going to clear it out. But if you did execution context, capture you're, basically holding on to that indefinitely until you drop that context.

C

But if so, if we cared about that and if we wanted to force it to be cleared effectively from everywhere, when you did dispose, then the thing that you stored in the async local you'd want it to be like a strongbox of tea rather than a tea, and then we undisposed. We would know out that the strongbox value I don't know if that's what we want, but that's how you could probably do it again right now,.

B

I had thinking that the pattern would would not want that.

D

Should the current, hmm but the current value be exposed as a static property anywhere, or is that not useful? It.

B

Is the proposal includes that, above that this.

C

B

A is these are partial, fragments that the summary proposals at the bottom, but as I, walk through each of these guys. So there is a property. That's active just above this.

D

B

D

Current context-sensitive context and then the instead of activate just called you know, make contact sensitive or something out of them there again there. These are off in the week, so it doesn't matter so much, but I feel that most of the places that we have the static things like this, the the static is called current. Okay.

J

I, don't you could just call it current on.

E

Sensitive reflection, contracts right, yeah,.

A

Yeah, it seems like a name that you can actually say laughing alone right and.

D

Then figure out what.

A

G

D

Methods is whether it's stacked, evader said, or you could even just use I feel like use the logic argument.

A

Well, you could say they start context-sensitive objection right, yeah,.

A

Or beginning I guess begin start.

J

K

Deposit, your the of.

J

The oldest of the ACA.

A

Fair enough.

G

A

K

Context actually.

A

Enter kind of implies that there's own there's no corresponding end method, which is nice, so I just write this up. So what did we say? Current.

E

Sensitive in context.

E

E

Context-Sensitive reflection.

B

Did you want the context on that one too, or no.

E

A

I mean put your contacts in there, because this the I mean whatever you closed on aesthetic, so there's already context in there somewhere.

A

A

A

You know you call it context in the trip reflection land, which is not nothing because here the context, toys.

K

Region, sensitive.

E

B

Said current sensitive reflection context, which is seems reasonable, yeah.

A

They did works for the book, one that they wouldn't want is they enter. Sensitive reflection seems a bit weird. The.

D

Trouble is what I saw and I was like sensitive like this is a security boundary, but it's just context sensitive. That context doesn't mean context in this. You.

B

Get rid of the word sensitive.

B

Dynaroo internal reflection, context, yeah contextual, maybe yeah.

A

Clint actual I think isn't actual.

D

Reflection context.

K

Correct contextual reflection, companies.

A

Yeah I think that's readable I mean still not like it's. It's not.

E

Never going to be pretty.

B

Ugly or ambiguous.

G

B

If it's fun make.

L

D

We're gonna make replace hi disposable with some sort of a layup, a cropped, Lutz's they're, making a little peak yeah, making a problem that doesn't necessarily expose any of the fields. Just says: I'm a struct that I'm disposable.

B

Yeah, the struct name could just be something like the same as the property name. Almost.

B

Does it being a map expert could opt escape the docks, I guess I, guess in the docks you just have to say that it is a struct or do you specify the inheritance of the pig struct, so that includes.

L

I disposable I really would say that it's our disposable cook. But if it's.

D

No because if the return type is I, just turn type has to return. I have.

E

A quick update agenda yeah, of course they did.

K

Just contextual reflection leads funny.

A

Guess what that the other proposals didn't have that bonus too right.

K

Yeah I mean the.

D

K

The start yes yeah I think it should be visible in textual reflection context. Well,.

E

But it's not the context. It's alright well,.

D

But it's a different kind of context. It's the context that when it goes away in context, it should.

B

Be scoped so that.

J

Works, contextual reflection, scope, yeah. There are serious.

A

And finally, do we, like the nest, instruct I think it makes sense, because nobody will care for this thing yeah. Nobody.

K

Should be saving it yeah, you just fix the return type again.

A

And it rolls it would never be okay with that sure.

D

I mean again nobody when they're looking at a symbol in context and they hit thought they want to see the useful statics that the other poses that are not this one yeah right.

A

All right, then: let's do this.

A

Let me approve this: one exhibit.

L

A

So this one or they.

C

Forgot using good and.

A

Then the other one years well like it just me putting paste some notes in here. What did you do.

E

And then we have the same thing here and then we're done.

A

All right that was easy.

K

G

All right, sorry, Steven for all the delay, but like Steve sorry, it took us about to get to the backlog. You.

B

Know yeah I'm sure. Thank you very much. Absolutely.

G

A

All right now, I have to clear various things by guys online.