Include some default items in file-based apps (#49584)

jjonescz · web-flow · commit feb621b70434 · 2025-07-04T14:33:34.000+02:00
diff --git a/documentation/general/dotnet-run-file.md b/documentation/general/dotnet-run-file.md
@@ -125,6 +125,10 @@ Similarly, implicit build files like `Directory.Build.props` or `Directory.Packa
 > [!CAUTION]
 > Multi-file support is postponed for .NET 11.
 > In .NET 10, only the single file passed as the command-line argument to `dotnet run` is part of the compilation.
+> Specifically, the virtual project has properties `EnableDefaultCompileItems=false` and `EnableDefaultEmbeddedResourceItems=false`
+> (which can be customized via `#:property` directives), and a `Compile` item for the entry point file.
+> During [conversion](#grow-up), any `Content`, `None`, `Compile`, and `EmbeddedResource` items that do not have metadata `ExcludeFromFileBasedAppConversion=true`
+> and that are files inside the entry point file's directory tree are copied to the converted directory.
 
 ### Nested files
 
diff --git a/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs b/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.TemplateEngine.Cli.Commands;
@@ -32,6 +33,9 @@ public override int Execute()
         var sourceFile = VirtualProjectBuildingCommand.LoadSourceFile(file);
         var directives = VirtualProjectBuildingCommand.FindDirectives(sourceFile, reportAllErrors: !_force, errors: null);
 
+        // Find other items to copy over, e.g., default Content items like JSON files in Web apps.
+        var includeItems = FindIncludedItems().ToList();
+
         Directory.CreateDirectory(targetDirectory);
 
         var targetFile = Path.Join(targetDirectory, Path.GetFileName(file));
@@ -47,11 +51,71 @@ public override int Execute()
             File.Move(file, targetFile);
         }
 
+        // Create project file.
         string projectFile = Path.Join(targetDirectory, Path.GetFileNameWithoutExtension(file) + ".csproj");
         using var stream = File.Open(projectFile, FileMode.Create, FileAccess.Write);
         using var writer = new StreamWriter(stream, Encoding.UTF8);
         VirtualProjectBuildingCommand.WriteProjectFile(writer, directives, isVirtualProject: false);
 
+        // Copy over included items.
+        foreach (var item in includeItems)
+        {
+            string targetItemFullPath = Path.Combine(targetDirectory, item.RelativePath);
+
+            // Ignore already-copied files.
+            if (File.Exists(targetItemFullPath))
+            {
+                continue;
+            }
+
+            string targetItemDirectory = Path.GetDirectoryName(targetItemFullPath)!;
+            Directory.CreateDirectory(targetItemDirectory);
+            File.Copy(item.FullPath, targetItemFullPath);
+        }
+
         return 0;
+
+        IEnumerable<(string FullPath, string RelativePath)> FindIncludedItems()
+        {
+            string entryPointFileDirectory = PathUtility.EnsureTrailingSlash(Path.GetDirectoryName(file)!);
+            var projectCollection = new ProjectCollection();
+            var command = new VirtualProjectBuildingCommand(
+                entryPointFileFullPath: file,
+                msbuildArgs: MSBuildArgs.FromOtherArgs([]))
+            {
+                Directives = directives,
+            };
+            var projectInstance = command.CreateProjectInstance(projectCollection);
+
+            // Include only items we know are files.
+            string[] itemTypes = ["Content", "None", "Compile", "EmbeddedResource"];
+            var items = itemTypes.SelectMany(t => projectInstance.GetItems(t));
+
+            foreach (var item in items)
+            {
+                // Escape hatch - exclude items that have metadata `ExcludeFromFileBasedAppConversion` set to `true`.
+                string include = item.GetMetadataValue("ExcludeFromFileBasedAppConversion");
+                if (string.Equals(include, bool.TrueString, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                // Exclude items that are not contained within the entry point file directory.
+                string itemFullPath = Path.GetFullPath(path: item.GetMetadataValue("FullPath"), basePath: entryPointFileDirectory);
+                if (!itemFullPath.StartsWith(entryPointFileDirectory, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                // Exclude items that do not exist.
+                if (!File.Exists(itemFullPath))
+                {
+                    continue;
+                }
+
+                string itemRelativePath = Path.GetRelativePath(relativeTo: entryPointFileDirectory, path: itemFullPath);
+                yield return (FullPath: itemFullPath, RelativePath: itemRelativePath);
+            }
+        }
     }
 }
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommand.cs
@@ -94,8 +94,6 @@ public override RunApiOutput Execute()
                 CustomArtifactsPath = ArtifactsPath,
             };
 
-            buildCommand.PrepareProjectInstance();
-
             var runCommand = new RunCommand(
                 noBuild: false,
                 projectFileFullPath: null,
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -140,7 +140,7 @@ public int Execute()
             if (EntryPointFileFullPath is not null)
             {
                 Debug.Assert(!ReadCodeFromStdin);
-                projectFactory = CreateVirtualCommand().PrepareProjectInstance().CreateProjectInstance;
+                projectFactory = CreateVirtualCommand().CreateProjectInstance;
             }
         }
 
@@ -587,9 +587,13 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             }
 
             // If '-' is specified as the input file, read all text from stdin into a temporary file and use that as the entry point.
-            entryPointFilePath = Path.GetTempFileName();
+            // We create a new directory for each file so other files are not included in the compilation.
+            // We fail if the file already exists to avoid reusing the same file for multiple stdin runs (in case the random name is duplicate).
+            string directory = VirtualProjectBuildingCommand.GetTempSubdirectory(Path.GetRandomFileName());
+            VirtualProjectBuildingCommand.CreateTempSubdirectory(directory);
+            entryPointFilePath = Path.Join(directory, "app.cs");
             using (var stdinStream = Console.OpenStandardInput())
-            using (var fileStream = File.OpenWrite(entryPointFilePath))
+            using (var fileStream = new FileStream(entryPointFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))
             {
                 stdinStream.CopyTo(fileStream);
             }
diff --git a/src/Cli/dotnet/Commands/Run/VirtualProjectBuildingCommand.cs b/src/Cli/dotnet/Commands/Run/VirtualProjectBuildingCommand.cs
@@ -111,8 +111,6 @@ Override targets which don't work with project files that are not present on dis
           </Target>
         """;
 
-    private ImmutableArray<CSharpDirective> _directives;
-
     public VirtualProjectBuildingCommand(
         string entryPointFileFullPath,
         MSBuildArgs msbuildArgs)
@@ -136,6 +134,23 @@ public VirtualProjectBuildingCommand(
     /// </summary>
     public bool NoBuildMarkers { get; init; }
 
+    public ImmutableArray<CSharpDirective> Directives
+    {
+        get
+        {
+            if (field.IsDefault)
+            {
+                var sourceFile = LoadSourceFile(EntryPointFileFullPath);
+                field = FindDirectives(sourceFile, reportAllErrors: false, errors: null);
+                Debug.Assert(!field.IsDefault);
+            }
+
+            return field;
+        }
+
+        init;
+    }
+
     public override int Execute()
     {
         Debug.Assert(!(NoRestore && NoBuild));
@@ -157,8 +172,6 @@ public override int Execute()
                     Reporter.Output.WriteLine(CliCommandStrings.NoBinaryLogBecauseUpToDate.Yellow());
                 }
 
-                PrepareProjectInstance();
-
                 return 0;
             }
 
@@ -188,8 +201,6 @@ public override int Execute()
                 LogTaskInputs = binaryLoggers.Length != 0,
             };
 
-            PrepareProjectInstance();
-
             // Do a restore first (equivalent to MSBuild's "implicit restore", i.e., `/restore`).
             // See https://github.com/dotnet/msbuild/blob/a1c2e7402ef0abe36bf493e395b04dd2cb1b3540/src/MSBuild/XMake.cs#L1838
             // and https://github.com/dotnet/msbuild/issues/11519.
@@ -445,17 +456,7 @@ private void MarkBuildStart()
 
         string directory = GetArtifactsPath();
 
-        if (OperatingSystem.IsWindows())
-        {
-            Directory.CreateDirectory(directory);
-        }
-        else
-        {
-            // Ensure only the current user has access to the directory to avoid leaking the program to other users.
-            // We don't mind that permissions might be different if the directory already exists,
-            // since it's under user's local directory and its path should be unique.
-            Directory.CreateDirectory(directory, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
-        }
+        CreateTempSubdirectory(directory);
 
         File.WriteAllText(Path.Join(directory, BuildStartCacheFileName), EntryPointFileFullPath);
     }
@@ -472,19 +473,6 @@ private void MarkBuildSuccess(RunFileBuildCacheEntry cacheEntry)
         JsonSerializer.Serialize(stream, cacheEntry, RunFileJsonSerializerContext.Default.RunFileBuildCacheEntry);
     }
 
-    /// <summary>
-    /// Needs to be called before the first call to <see cref="CreateProjectInstance(ProjectCollection)"/>.
-    /// </summary>
-    public VirtualProjectBuildingCommand PrepareProjectInstance()
-    {
-        Debug.Assert(_directives.IsDefault, $"{nameof(PrepareProjectInstance)} should not be called multiple times.");
-
-        var sourceFile = LoadSourceFile(EntryPointFileFullPath);
-        _directives = FindDirectives(sourceFile, reportAllErrors: false, errors: null);
-
-        return this;
-    }
-
     public ProjectInstance CreateProjectInstance(ProjectCollection projectCollection)
     {
         return CreateProjectInstance(projectCollection, addGlobalProperties: null);
@@ -511,13 +499,11 @@ private ProjectInstance CreateProjectInstance(
 
         ProjectRootElement CreateProjectRootElement(ProjectCollection projectCollection)
         {
-            Debug.Assert(!_directives.IsDefault, $"{nameof(PrepareProjectInstance)} should have been called first.");
-
             var projectFileFullPath = Path.ChangeExtension(EntryPointFileFullPath, ".csproj");
             var projectFileWriter = new StringWriter();
             WriteProjectFile(
                 projectFileWriter,
-                _directives,
+                Directives,
                 isVirtualProject: true,
                 targetFilePath: EntryPointFileFullPath,
                 artifactsPath: GetArtifactsPath(),
@@ -534,20 +520,46 @@ ProjectRootElement CreateProjectRootElement(ProjectCollection projectCollection)
 
     private string GetArtifactsPath() => CustomArtifactsPath ?? GetArtifactsPath(EntryPointFileFullPath);
 
-    // internal for testing
-    internal static string GetArtifactsPath(string entryPointFileFullPath)
+    public static string GetArtifactsPath(string entryPointFileFullPath)
+    {
+        // Include entry point file name so the directory name is not completely opaque.
+        string fileName = Path.GetFileNameWithoutExtension(entryPointFileFullPath);
+        string hash = Sha256Hasher.HashWithNormalizedCasing(entryPointFileFullPath);
+        string directoryName = $"{fileName}-{hash}";
+
+        return GetTempSubdirectory(directoryName);
+    }
+
+    /// <summary>
+    /// Obtains a temporary subdirectory for file-based apps.
+    /// </summary>
+    public static string GetTempSubdirectory(string name)
     {
         // We want a location where permissions are expected to be restricted to the current user.
         string directory = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
             ? Path.GetTempPath()
             : Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
 
-        // Include entry point file name so the directory name is not completely opaque.
-        string fileName = Path.GetFileNameWithoutExtension(entryPointFileFullPath);
-        string hash = Sha256Hasher.HashWithNormalizedCasing(entryPointFileFullPath);
-        string directoryName = $"{fileName}-{hash}";
+        return Path.Join(directory, "dotnet", "runfile", name);
+    }
 
-        return Path.Join(directory, "dotnet", "runfile", directoryName);
+    /// <summary>
+    /// Creates a temporary subdirectory for file-based apps.
+    /// Use <see cref="GetTempSubdirectory"/> to obtain the path.
+    /// </summary>
+    public static void CreateTempSubdirectory(string path)
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            Directory.CreateDirectory(path);
+        }
+        else
+        {
+            // Ensure only the current user has access to the directory to avoid leaking the program to other users.
+            // We don't mind that permissions might be different if the directory already exists,
+            // since it's under user's local directory and its path should be unique.
+            Directory.CreateDirectory(path, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+        }
     }
 
     public static void WriteProjectFile(
@@ -648,7 +660,7 @@ public static void WriteProjectFile(
             writer.WriteLine("""
 
                   <PropertyGroup>
-                    <EnableDefaultItems>false</EnableDefaultItems>
+                    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
                   </PropertyGroup>
                 """);
         }
diff --git a/test/dotnet.Tests/CommandTests/Project/Convert/DotnetProjectConvertTests.cs b/test/dotnet.Tests/CommandTests/Project/Convert/DotnetProjectConvertTests.cs
diff --git a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ public int Execute()`
`140`	`140`	`if (EntryPointFileFullPath is not null)`
`141`	`141`	`{`
`142`	`142`	`Debug.Assert(!ReadCodeFromStdin);`
`143`		`- projectFactory = CreateVirtualCommand().PrepareProjectInstance().CreateProjectInstance;`
	`143`	`+ projectFactory = CreateVirtualCommand().CreateProjectInstance;`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`@@ -587,9 +587,13 @@ public static RunCommand FromParseResult(ParseResult parseResult)`
`587`	`587`	`}`
`588`	`588`
`589`	`589`	`// If '-' is specified as the input file, read all text from stdin into a temporary file and use that as the entry point.`
`590`		`- entryPointFilePath = Path.GetTempFileName();`
	`590`	`+ // We create a new directory for each file so other files are not included in the compilation.`
	`591`	`+ // We fail if the file already exists to avoid reusing the same file for multiple stdin runs (in case the random name is duplicate).`
	`592`	`+ string directory = VirtualProjectBuildingCommand.GetTempSubdirectory(Path.GetRandomFileName());`
	`593`	`+ VirtualProjectBuildingCommand.CreateTempSubdirectory(directory);`
	`594`	`+ entryPointFilePath = Path.Join(directory, "app.cs");`
`591`	`595`	`using (var stdinStream = Console.OpenStandardInput())`
`592`		`- using (var fileStream = File.OpenWrite(entryPointFilePath))`
	`596`	`+ using (var fileStream = new FileStream(entryPointFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.None))`
`593`	`597`	`{`
`594`	`598`	`stdinStream.CopyTo(fileStream);`
`595`	`599`	`}`