wpf | NET Core UI framework for building Windows desktop

Looks like you have resolved the embedding part of your question and are left with just the deletion of the extracted DLLs.

Because the DLL is inuse but your own process, unless you are able to uload the DLL successfully, I dont think you will be able to delete the DLL.

1st Potential Option

One thing you could try and do is schedule the deletion of the file after reboot. This SO post explains how to do that using P/Invoke and MoveFileEx.

The example they give is as follows:

This seems to be a known bug in .net 6.0.2

see: https://github.com/dotnet/core/issues/7172#issuecomment-1034105137

for a workaround you could try this: https://github.com/dotnet/winforms/issues/6663#issuecomment-1034371295

Or just use the sdk:6.0.101-windowsservercore-ltsc2022 image till a fixed version is released

This is part of the syntax of a XAML file, you can read all the gory details here

Markup Extensions

XAML defines a markup extension programming entity that enables an escape from the normal XAML processor handling of string attribute values or object elements, and defers the processing to a backing class. The character that identifies a markup extension to a XAML processor when using attribute syntax is the opening curly brace ({), followed by any character other than a closing curly brace (}). The first string following the opening curly brace must reference the class that provides the particular extension behavior, where the reference may omit the substring "Extension" if that substring is part of the true class name. Thereafter, a single space may appear, and then each succeeding character is used as input by the extension implementation, up until the closing curly brace is encountered.

More information here

Overview of markup extensions for XAML

Also another good link tendered by @Charlieface

Basic Markup Extension Syntax

A markup extension can be implemented to provide values for properties in an attribute usage, properties in a property element usage, or both.

When used to provide an attribute value, the syntax that distinguishes a markup extension sequence to a XAML processor is the presence of the opening and closing curly braces ({ and }). The type of markup extension is then identified by the string token immediately following the opening curly brace.

When used in property element syntax, a markup extension is visually the same as any other element used to provide a property element value: a XAML element declaration that references the markup extension class as an element, enclosed within angle brackets (<>).

This answer explains how, in Elmish.WPF, progress updates to the user interface can be done from an async.

I have created an example on GitHub that demoes this. The example also demoes another way to call async functions and receive results. And it also demoes how to use mkProgram instead of mkSimple. The demo can be used as a starting template for your Elmish.WPF applications.

This snippet from the demo show the essential code involved in updating a user interface from an async.

Both techniques are based on code from the Elmish Book. You will find a lot of code there that is useful also in Elmish.WPF.

I haven't tried to update a progress bar here, only a status text box, but from this you'll very easily figure out what to do to update anything.

I managed to solve this by doing the following:

I made a property; public static string PreviewedInvoice { get; set; } in the ViewModel of the parent window. In my method that opens the child window (where the preview invoices are to be displayed) I bind it to LicenseHolderID of the rows that have a checked CheckBox, via foreach loop, like such:

It all comes down to your requirements really. There is no silver bullet to this.

I must admit I didn't really know the settings (designer) file that you mentioned. I can tell that that's not a thing (as far as I know) in Xamarin or .NET MAUI. Probably also because there is the concept of a sandbox in mobile apps that is less a thing on desktop apps. So the location where things are saved are a bit more important.

In the comments there are already a couple of great suggestions to get you started. If your requirement is to just save simple types (string, bool, int, etc.) then the Essentials Preferences API should work just fine. I think under the hood that just serializes to a json file and stores it somewhere. Essentials is indeed already part of .NET MAUI at this time.

Xamarin.Forms used to have their own Properties, which is I think a more common concept in .NET applications, but I think the Essentials way is better.

If you want to save more complex things you might want to consider using a local database like SQLite or just roll your own and serialize your settings and save that somewhere, preferably with the Essentials FileSystem Helpers.

One thing to note here, and that is where the value of these libraries come in, is where you save the settings. Do you want the settings to be backed up to a cloud service so if survives a reinstall of the app? Or even an install of the same app on a new phone? Or do you then just want to reset the whole state and don't care about it.

If you figure that out, the rest is up to you! Hope this helps.

Try to remove the following line from the project (.csproj) file and then build again:

As it correctly pointed in comment it will work without async, with async you need to do it on the applicaton's thread. The key is, that CultureInfo.CurrentCulture set the value for current thread and as it's a thread pool you doesn't see it in async event handler, or I suppose you can have it occasionally, if you will get the same thread.

The UpdateLayout call is totally redundant. Modifying the Width will automatically trigger a layout pass. Additionally, both iterations should be merged into a single iteration in order to improve the performance.
The complete implementation is very questionable in terms of user experience: in case the user adjusts the column's width, you would override and reset his customizations, which provides a poor experience. Also the grid would potentially resize itself constantly, which looks and feels odd too. You should at least set DataGrid.CanUserResizeColumns to false.
I believe that adding a column filter, that allows the user to hide particular columns in order to compact the view, has a higher value.

From the code you have posted, it's not possible to tell exactly what is going on or what could cause the issue. The actual layout configuration of your DataGrid control and its context is apparently undisclosed.

However, the issue could be related to how the DataGrid is calculating the width for each column, in case you give the DataGrid a fixed Width and this value would cause the content to exceed the available viewport width (the ScrollViewer would appear in this case):

a) In case of each column width is set to Auto, the DataGrid would simply give each column the required minimum width.

b) In case a column's width is set to star * size, the assigned width is calculated relative to the available remaining space.
In order to calculate a reasonable value, the algorithm would use the effective size of the DataGrid.
The point is, that when using a ScrollViewer, the virtual width would be infinite. Now, if the algorithm would set the last column's width to infinite, you would get a very tiny scroll bar. Therefore, infinite is not a reasonable value. In effect, the final width can not be calculated. That's why the algorithm falls back to use the effective width of the DataGrid, which is the ScrollViewer.ViewportWidth. The result is that all columns must be sqeezed into the available viewport space, causing columns to clip their headers and cell content.

I can provide two solutions.

The first solution is to use a fixed Width for the last column like 1000 DIPs.
This solution does scale very bad. The last column would have either a too small width or a too extreme width that does not make much sense (that's why a reasonable width for the last column can't be calculated - what is reasonable in this context?).

The second and better solution would try to detect if the ScrollViewer can scroll: in this case the last column would be at least partially out of view. This results in a reasonable Width for the last column of Auto: the minimal required space.
The other case, when the ScrollViewer can't scroll, is when all columns are visible in the viewport. This results in a reasonable Width of * in order to allow the last column to fill the remaining space: