Your phrasing could confuse readers: MSBuild happened to historically have XMake as a codename but is entirely unrelated to the build system known as XMake.
Clarified my comment a bit, thanks
Readit Newsjanjones commented on Xmake: A cross-platform build utility based on Lua xmake.io/... · Posted by u/phmx
janjones commented on Xmake: A cross-platform build utility based on Lua xmake.io/... · Posted by u/phmx
At my work we use MSBuild and vcpkg. What would a transition from that to XMake be like?
Then you are already using XMake (albeit a different one than OP), it's the original codename for MSBuild, still present in the code: https://github.com/dotnet/msbuild/blob/main/src/MSBuild/XMak... :)
janjones commented on Decompiling the New C# 14 field Keyword blog.ivankahl.com/decompi... · Posted by u/ivankahl
How does C# the language or C# the language standard evolution process accommodate a new keyword with such a generic name? Is it context-dependent?
Yes, it's contextual. There is more details in this section of the article: Naming Conflicts with Existing Class Members
C# playground (compiler explorer) which runs entirely in a browser (via WebAssembly). Started as an alternative to SharpLab which is not maintained anymore. But it can also do some other stuff that I wanted like downloading any compiler version, and compiling Razor. Recently I've added some "IntelliSense" features to improve the editing experience.
janjones commented on Run a C# file directly using dotnet run app.cs devblogs.microsoft.com/do... · Posted by u/soheilpro
> we don't want to create a new C# scripting dialect hence it isn't possible to "import" other files (that's not how C# works)
This statement is a bit confusing. From a user perspective, "dotnet run" does add a new scripting dialect. I would like to rewrite all my csx utilities to use this.
I've been using dotnet-script for several years for both unit testing code and for creating small utilities. Being able to load scripts (with "#load - see below) from other scripts is a core feature for keeping my code DRY. It would be a knock against "dotnet run" if a comparable syntax was not available. It's just a preprocessor - not a change to the C# syntax. Just like the other '#:' preprocessors being added.
I propose "#:load file.cs"
https://github.com/dotnet-script/dotnet-script#consuming-a-s...
> From a user perspective, "dotnet run" does add a new scripting dialect.
By dialect I mean that in CSX, the C# language has subtle differences in behavior compared to CS files (e.g., top-level methods are compiled differently). In 'dotnet run app.cs', the C# is exactly the same, hence it can be converted to a project (and we have a command for that - 'dotnet project convert').
> It's just a preprocessor - not a change to the C# syntax.
Should #:load work in normal C# files as well then? If yes, we would have two ways to include files - the normal way (include them in the project) or via #:load. If not, how would 'dotnet project convert' work? (It could paste the text but that's not very DRY if it's imported at multiple places.)
That's in short why #:load doesn't play very nicely with existing C# (it's a different paradigm of including other files). So the current proposal is to just make files in the same folder visible (just like they would be for a .csproj), because that's consistent with current C#, 'dotnet project convert' works, etc. But this proposal is not final yet, there are other options including what you suggest - see https://github.com/dotnet/sdk/issues/49193.
janjones commented on Run a C# file directly using dotnet run app.cs devblogs.microsoft.com/do... · Posted by u/soheilpro
>referencing DLLs which is discouraged in modern .NET
You can't do much of anything in .NET without referencing Nuget assemblies.
> opaquely named directives like `#r` seems counter-productive
Then why is it the existing standard?
Agreeing with others, '#r "nuget:' should at least be an option. And otherwise (but I guess regarless if you stick with this syntax) you will have to add another tab to Nuget called "dotnet run". "Script & Interactive" is already present in Nuget and shows the #r syntax for a reference.
> You can't do much of anything in .NET without referencing Nuget assemblies.
And referencing NuGet assemblies is of course supported via the #:package directive. It's just that referencing DLLs directly is not a common scenario, hence it's not supported for now (but can be added later).
> Agreeing with others, '#r "nuget:' should at least be an option.
Thanks, we hear you and plan to add support for it, see https://github.com/dotnet/sdk/issues/49199
> And otherwise (but I guess regarless if you stick with this syntax) you will have to add another tab to Nuget called "dotnet run". "Script & Interactive" is already present in Nuget and shows the #r syntax for a reference.
Agree but also note that the ".NET CLI" tab which tells you to run "dotnet add package" should also work in near future, see https://github.com/dotnet/sdk/issues/49200.
janjones commented on Run a C# file directly using dotnet run app.cs devblogs.microsoft.com/do... · Posted by u/soheilpro
That doesn't explain why standard C# had to deviate further from the script dialect just for import directives. These directives don't interfere with the rest of the grammar.
Is #:package <pkg> really so much nicer than #r "nuget: <pkg>" as to deserve deviating from .NET Interactive, F# and the existing NuGet picker? (It could be, if properly argued!) Has there been any effort to have the rest of .NET adopt this new syntax or share concerns?
On that note, is any language other than C# supported for `dotnet run`? Is the machinery at least documented for other MSBuild SDKs to use? Considering how dotnet watch keeps breaking for F#, I suspect not.
> Is #:package <pkg> really so much nicer than #r "nuget: <pkg>" as to deserve deviating from .NET Interactive, F# and the existing NuGet picker? (It could be, if properly argued!)
Yes, we believe so. There is not much to be gained from reusing the syntax (it's not like you can import cs from csx or vice versa). We are also adding other directives, e.g., `#:property` - it would not make sense to reuse `#r` for that. `#r` is short for "reference", because it was originally meant for referencing DLLs which is discouraged in modern .NET. The main motivation for file-based programs is to lower the entry barrier, and having opaquely named directives like `#r` seems counter-productive.
> On that note, is any language other than C# supported for `dotnet run`?
File-based programs are for C# only. F# already has `dotnet fsi`. VB support seems unlikely per the language strategy: https://learn.microsoft.com/en-us/dotnet/fundamentals/langua...
> Is the machinery at least documented for other MSBuild SDKs to use?
There is really not much special machinery, an in-memory csproj file is created and built via MSBuild just like an on-disk csproj would. Any MSBuild SDK can be used via the `#:sdk` directive.