[Java.Interop.Tools.Cecil] DirectoryAssemblyResolver+MemoryMappedFile (#1103)

Context: dotnet/linker#1130
Context: https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1783420

In dotnet/linker#1130, their version of `DirectoryAssemblyResolver`
was reworked to use [`MemoryMappedFile`][0] in the .NET 6 time frame.
Port these changes to Java.Interop, as we have MSBuild tasks in
xamarin/xamarin-android that use `DirectoryAssemblyResolver`.

Primarily, the [`<GenerateJavaStubs/>` MSBuild task][1] uses
`DirectoryAssemblyResolver` to iterate over types in assembly to emit
Java source code and generate `AndroidManifest.xml`.

Note: `MemoryMappedFile` can *only* be used when we are *not* opening
the assembly as `.ReadWrite`.  Trying to use `MemoryMappedFile` for
read+write scenarios would result in an `InvalidOperationException`:

	error XAGJS7009: System.InvalidOperationException: Operation is not valid due to the current state of the object.
	error XAGJS7009:    at Mono.Cecil.Cil.DefaultSymbolWriterProvider.GetSymbolWriter(ModuleDefinition module, String fileName)
	error XAGJS7009:    at Mono.Cecil.ModuleWriter.GetSymbolWriter(ModuleDefinition module, String fq_name, ISymbolWriterProvider symbol_writer_provider, WriterParameters parameters)
	error XAGJS7009:    at Mono.Cecil.ModuleWriter.Write(ModuleDefinition module, Disposable`1 stream, WriterParameters parameters)
	error XAGJS7009:    at Mono.Cecil.ModuleWriter.WriteModule(ModuleDefinition module, Disposable`1 stream, WriterParameters parameters)
	error XAGJS7009:    at Mono.Cecil.ModuleDefinition.Write(String fileName, WriterParameters parameters)
	error XAGJS7009:    at Mono.Cecil.AssemblyDefinition.Write(String fileName, WriterParameters parameters)
	error XAGJS7009:    at Xamarin.Android.Tasks.MarshalMethodsAssemblyRewriter.Rewrite(DirectoryAssemblyResolver resolver, List`1 targetAssemblyPaths, Boolean brokenExceptionTransitions)
	error XAGJS7009:    at Xamarin.Android.Tasks.GenerateJavaStubs.Run(DirectoryAssemblyResolver res, Boolean useMarshalMethods)
	error XAGJS7009:    at Xamarin.Android.Tasks.GenerateJavaStubs.RunTask()


The results of these changes in a `dotnet new maui` project,
an initial clean build:

  * Before MemoryMappedFile: GenerateJavaStubs = 1.318 s, 1 calls.
  *  After MemoryMappedFile: GenerateJavaStubs = 1.254 s, 1 calls.

Saving ~64ms or about ~5% in this example.

Note: The current version of the linker's resolver in .NET 8+ has
[moved to the dotnet/runtime repo][2].

[0]: https://learn.microsoft.com/dotnet/api/system.io.memorymappedfiles.memorymappedfile?view=net-8.0
[1]: https://github.com/xamarin/xamarin-android/blob/e694ba52a0cf5f45b213c8902bdbfb0ed348374a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateJavaStubs.cs#L131
[2]: https://github.com/dotnet/runtime/blob/cd7d006030a7feace9076fa275fb5bffc1bf4a90/src/tools/illink/src/linker/Linker/AssemblyResolver.cs

Author: jonathanpeppers

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/DirectoryAssemblyResolver.cs

@@ -32,6 +32,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.IO.MemoryMappedFiles;
 using System.Linq;
 using System.Reflection;
 
@@ -61,6 +62,7 @@ public class DirectoryAssemblyResolver : IAssemblyResolver {
 
 		public ICollection<string> SearchDirectories {get; private set;}
 
+		readonly List<MemoryMappedViewStream> viewStreams = new List<MemoryMappedViewStream> ();
 		Dictionary<string, AssemblyDefinition?> cache;
 		bool loadDebugSymbols;
 		Action<TraceLevel, string>              logger;
@@ -103,6 +105,10 @@ protected virtual void Dispose (bool disposing)
 				e.Value?.Dispose ();
 			}
 			cache.Clear ();
+			foreach (var viewStream in viewStreams) {
+				viewStream.Dispose ();
+			}
+			viewStreams.Clear ();
 		}
 
 		public Dictionary<string, AssemblyDefinition?> ToResolverCache ()
@@ -160,14 +166,41 @@ protected virtual AssemblyDefinition ReadAssembly (string file)
 				SymbolStream                    = loadReaderParameters.SymbolStream,
 			};
 			try {
-				return AssemblyDefinition.ReadAssembly (file, reader_parameters);
+				return LoadFromMemoryMappedFile (file, reader_parameters);
 			} catch (Exception ex) {
 				logger (
 						TraceLevel.Verbose,
 						$"Failed to read '{file}' with debugging symbols. Retrying to load it without it. Error details are logged below.");
 				logger (TraceLevel.Verbose, $"{ex.ToString ()}");
 				reader_parameters.ReadSymbols = false;
-				return AssemblyDefinition.ReadAssembly (file, reader_parameters);
+				return LoadFromMemoryMappedFile (file, reader_parameters);
+			}
+		}
+
+		AssemblyDefinition LoadFromMemoryMappedFile (string file, ReaderParameters options)
+		{
+			// We can't use MemoryMappedFile when ReadWrite is true
+			if (options.ReadWrite) {
+				return AssemblyDefinition.ReadAssembly (file, options);
+			}
+
+			MemoryMappedViewStream? viewStream = null;
+			try {
+				// Create stream because CreateFromFile(string, ...) uses FileShare.None which is too strict
+				using var fileStream = new FileStream (file, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false);
+				using var mappedFile = MemoryMappedFile.CreateFromFile (
+					fileStream, null, fileStream.Length, MemoryMappedFileAccess.Read, HandleInheritability.None, true);
+				viewStream = mappedFile.CreateViewStream (0, 0, MemoryMappedFileAccess.Read);
+
+				AssemblyDefinition result = ModuleDefinition.ReadModule (viewStream, options).Assembly;
+				viewStreams.Add (viewStream);
+
+				// We transferred the ownership of the viewStream to the collection.
+				viewStream = null;
+
+				return result;
+			} finally {
+				viewStream?.Dispose ();
 			}
 		}