Use PayloadReader in System.Resources.Extensions

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.IParseState.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.BinaryFormat;
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+internal sealed partial class BinaryFormattedObject
+{
+    /// <summary>
+    ///  Parsing state.
+    /// </summary>
+    internal interface IParseState
+    {
+        BinaryReader Reader { get; }
+        IReadOnlyDictionary<int, SerializationRecord> RecordMap { get; }
+        Options Options { get; }
+        ITypeResolver TypeResolver { get; }
+    }
+}

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.ITypeResolver.cs

@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection.Metadata;
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+internal sealed partial class BinaryFormattedObject
+{
+    /// <summary>
+    ///  Resolver for types.
+    /// </summary>
+    internal interface ITypeResolver
+    {
+        /// <summary>
+        ///  Resolves the given type name against the specified library.
+        /// </summary>
+        [RequiresUnreferencedCode("Calls System.Reflection.Assembly.GetType(String)")]
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+        Type GetType(TypeName typeName);
+    }
+}

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.Options.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters;
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+#pragma warning disable SYSLIB0050 // Type or member is obsolete
+
+internal sealed partial class BinaryFormattedObject
+{
+    internal sealed class Options
+    {
+        /// <summary>
+        ///  How exactly assembly names need to match for deserialization.
+        /// </summary>
+
+        public FormatterAssemblyStyle AssemblyMatching { get; set; } = FormatterAssemblyStyle.Simple;
+
+        /// <summary>
+        ///  Type name binder.
+        /// </summary>
+        public SerializationBinder? Binder { get; set; }
+
+        /// <summary>
+        ///  Optional type <see cref="ISerializationSurrogate"/> provider.
+        /// </summary>
+        public ISurrogateSelector? SurrogateSelector { get; set; }
+
+        /// <summary>
+        ///  Streaming context.
+        /// </summary>
+        public StreamingContext StreamingContext { get; set; } = new(StreamingContextStates.All);
+    }
+}
+
+#pragma warning restore SYSLIB0050 // Type or member is obsolete

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.ParseState.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.BinaryFormat;
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+internal sealed partial class BinaryFormattedObject
+{
+    /// <summary>
+    ///  Parsing state for <see cref="BinaryFormattedObject"/>.
+    /// </summary>
+    internal sealed class ParseState : IParseState
+    {
+        private readonly BinaryFormattedObject _format;
+
+        public ParseState(BinaryReader reader, BinaryFormattedObject format)
+        {
+            Reader = reader;
+            _format = format;
+        }
+
+        public BinaryReader Reader { get; }
+        public IReadOnlyDictionary<int, SerializationRecord> RecordMap => _format.RecordMap;
+        public Options Options => _format._options;
+        public ITypeResolver TypeResolver => _format.TypeResolver;
+    }
+}

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.TypeResolver.cs

@@ -0,0 +1,139 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters;
+
+#pragma warning disable SYSLIB0050 // Type or member is obsolete
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+internal sealed partial class BinaryFormattedObject
+{
+    internal sealed class DefaultTypeResolver : ITypeResolver
+    {
+        private readonly FormatterAssemblyStyle _assemblyMatching;
+        private readonly SerializationBinder? _binder;
+
+        private readonly Dictionary<string, Assembly> _assemblies = [];
+        private readonly Dictionary<string, Type> _types = [];
+
+        internal DefaultTypeResolver(Options options)
+        {
+            _assemblyMatching = options.AssemblyMatching;
+            _binder = options.Binder;
+        }
+
+        /// <summary>
+        ///  Resolves the given type name against the specified library.
+        /// </summary>
+        [RequiresUnreferencedCode("Calls System.Reflection.Assembly.GetType(String)")]
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+        Type ITypeResolver.GetType(TypeName typeName)
+        {
+            Debug.Assert(typeName.AssemblyName is not null);
+
+            if (_types.TryGetValue(typeName.AssemblyQualifiedName, out Type? cachedType))
+            {
+                return cachedType;
+            }
+
+            if (_binder?.BindToType(typeName.AssemblyName.FullName, typeName.FullName) is Type binderType)
+            {
+                // BinaryFormatter is inconsistent about what caching behavior you get with binders.
+                // It would always cache the last item from the binder, but wouldn't put the result
+                // in the type cache. This could lead to inconsistent results if the binder didn't
+                // always return the same result for a given set of strings. Choosing to always cache
+                // for performance.
+
+                _types[typeName.AssemblyQualifiedName] = binderType;
+                return binderType;
+            }
+
+            if (!_assemblies.TryGetValue(typeName.AssemblyName.FullName, out Assembly? assembly))
+            {
+                AssemblyName assemblyName = typeName.AssemblyName.ToAssemblyName();
+                try
+                {
+                    assembly = Assembly.Load(assemblyName);
+                }
+                catch
+                {
+                    if (_assemblyMatching != FormatterAssemblyStyle.Simple)
+                    {
+                        throw;
+                    }
+
+                    assembly = Assembly.Load(assemblyName.Name!);
+                }
+
+                _assemblies.Add(typeName.AssemblyName.FullName, assembly);
+            }
+
+            Type? type = _assemblyMatching != FormatterAssemblyStyle.Simple
+                ? assembly.GetType(typeName.FullName)
+                : GetSimplyNamedTypeFromAssembly(assembly, typeName);
+
+            _types[typeName.AssemblyQualifiedName] = type ?? throw new SerializationException($"Could not find type '{typeName}'.");
+            return type;
+        }
+
+        [RequiresUnreferencedCode("Calls System.Reflection.Assembly.GetType(String, Boolean, Boolean)")]
+        private static Type? GetSimplyNamedTypeFromAssembly(Assembly assembly, TypeName typeName)
+        {
+            // Catching any exceptions that could be thrown from a failure on assembly load
+            // This is necessary, for example, if there are generic parameters that are qualified
+            // with a version of the assembly that predates the one available.
+
+            try
+            {
+                return assembly.GetType(typeName.FullName, throwOnError: false, ignoreCase: false);
+            }
+            catch (TypeLoadException) { }
+            catch (FileNotFoundException) { }
+            catch (FileLoadException) { }
+            catch (BadImageFormatException) { }
+
+            return Type.GetType(typeName.FullName, ResolveSimpleAssemblyName, new TopLevelAssemblyTypeResolver(assembly).ResolveType, throwOnError: false);
+
+            static Assembly? ResolveSimpleAssemblyName(AssemblyName assemblyName)
+            {
+                try
+                {
+                    return Assembly.Load(assemblyName);
+                }
+                catch { }
+
+                try
+                {
+                    return Assembly.Load(assemblyName.Name!);
+                }
+                catch { }
+
+                return null;
+            }
+        }
+
+        private sealed class TopLevelAssemblyTypeResolver
+        {
+            private readonly Assembly _topLevelAssembly;
+
+            public TopLevelAssemblyTypeResolver(Assembly topLevelAssembly) => _topLevelAssembly = topLevelAssembly;
+
+            [RequiresUnreferencedCode("Calls System.Reflection.Assembly.GetType(String, Boolean, Boolean)")]
+            public Type? ResolveType(Assembly? assembly, string simpleTypeName, bool ignoreCase)
+            {
+                assembly ??= _topLevelAssembly;
+                return assembly.GetType(simpleTypeName, throwOnError: false, ignoreCase);
+            }
+        }
+    }
+}
+
+#pragma warning restore SYSLIB0050 // Type or member is obsolete

src/libraries/System.Resources.Extensions/src/BinaryFormat/BinaryFormattedObject.cs

@@ -0,0 +1,91 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Reflection;
+using System.Runtime.ExceptionServices;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.BinaryFormat;
+
+namespace System.Resources.Extensions.BinaryFormat;
+
+/// <summary>
+///  Object model for the binary format put out by BinaryFormatter. It parses and creates a model but does not
+///  instantiate any reference types outside of string.
+/// </summary>
+/// <remarks>
+///  <para>
+///   This is useful for explicitly controlling the rehydration of binary formatted data.
+///  </para>
+/// </remarks>
+internal sealed partial class BinaryFormattedObject
+{
+#pragma warning disable SYSLIB0050 // Type or member is obsolete
+    internal static FormatterConverter DefaultConverter { get; } = new();
+#pragma warning restore SYSLIB0050
+
+    private static readonly Options s_defaultOptions = new();
+    private readonly Options _options;
+
+    private ITypeResolver? _typeResolver;
+    private ITypeResolver TypeResolver => _typeResolver ??= new DefaultTypeResolver(_options);
+
+    /// <summary>
+    ///  Creates <see cref="BinaryFormattedObject"/> by parsing <paramref name="stream"/>.
+    /// </summary>
+    public BinaryFormattedObject(Stream stream, Options? options = null)
+    {
+        _options = options ?? s_defaultOptions;
+
+        try
+        {
+            RootRecord = PayloadReader.Read(stream, out var readonlyRecordMap, leaveOpen: true);
+            RecordMap = readonlyRecordMap;
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidCastException or ArithmeticException or IOException)
+        {
+            // Make the exception easier to catch, but retain the original stack trace.
+            throw ex.ConvertToSerializationException();
+        }
+        catch (TargetInvocationException ex)
+        {
+            throw ExceptionDispatchInfo.Capture(ex.InnerException!).SourceException.ConvertToSerializationException();
+        }
+    }
+
+    /// <summary>
+    ///  Deserializes the <see cref="BinaryFormattedObject"/> back to an object.
+    /// </summary>
+    [RequiresUnreferencedCode("Ultimately calls Assembly.GetType for type names in the data.")]
+    public object Deserialize()
+    {
+        try
+        {
+            return Deserializer.Deserializer.Deserialize(RootRecord.ObjectId, RecordMap, TypeResolver, _options);
+        }
+        catch (Exception ex) when (ex is ArgumentException or InvalidCastException or ArithmeticException or IOException)
+        {
+            // Make the exception easier to catch, but retain the original stack trace.
+            throw ex.ConvertToSerializationException();
+        }
+        catch (TargetInvocationException ex)
+        {
+            throw ExceptionDispatchInfo.Capture(ex.InnerException!).SourceException.ConvertToSerializationException();
+        }
+    }
+
+    /// <summary>
+    ///  The Id of the root record of the object graph.
+    /// </summary>
+    public SerializationRecord RootRecord { get; }
+
+    /// <summary>
+    ///  Gets a record by it's identifier. Not all records have identifiers, only ones that
+    ///  can be referenced by other records.
+    /// </summary>
+    public SerializationRecord this[Id id] => RecordMap[id];
+
+    public IReadOnlyDictionary<int, SerializationRecord> RecordMap { get; }
+}