Skip to content

Instantly share code, notes, and snippets.

@ahsonkhan

ahsonkhan/ref-api-diff.md

Last active February 22, 2019 08:44
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ahsonkhan/9172948674eb7fb8d98e84438509b9b0 to your computer and use it in GitHub Desktop.
Save ahsonkhan/9172948674eb7fb8d98e84438509b9b0 to your computer and use it in GitHub Desktop.
Download ZIP
Difference in reference assemblies between .NET Core 3.0 master and .NET Core 3.0 UpdateRefs branch
Raw
ref-api-diff.md

API Difference

Microsoft.Private.CoreFx.NETCoreApp-master\ref\netcoreapp3.0 vs Microsoft.Private.CoreFx.NETCoreApp-branch\ref\netcoreapp3.0

API listing follows standard diff formatting. Lines preceded by a '+' are additions and a '-' indicates removal.

Microsoft.VisualBasic

 namespace Microsoft.VisualBasic {
     public sealed class Strings {
-        public static int InStr(int StartPos, string String1, string String2, CompareMethod Compare = CompareMethod.Binary);
+        public static int InStr(int Start, string String1, string String2, CompareMethod Compare = CompareMethod.Binary);
     }
 }

System

 namespace System {
     public sealed class AppDomain : MarshalByRefObject {
+        public IPrincipal GetThreadPrincipal();
     }
     public static class StringNormalizationExtensions {
-        public static bool IsNormalized(this string value);
+        public static bool IsNormalized(this string strInput);
-        public static bool IsNormalized(this string value, NormalizationForm normalizationForm);
+        public static bool IsNormalized(this string strInput, NormalizationForm normalizationForm);
-        public static string Normalize(this string value);
+        public static string Normalize(this string strInput);
-        public static string Normalize(this string value, NormalizationForm normalizationForm);
+        public static string Normalize(this string strInput, NormalizationForm normalizationForm);
     }
 }

System.Collections.Generic

 namespace System.Collections.Generic {
     public class SortedList<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
-        void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
     }
 }

System.Collections.Immutable

 namespace System.Collections.Immutable {
     public static class ImmutableSortedDictionary {
-        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder source);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder);
     }
 }

System.ComponentModel

 namespace System.ComponentModel {
     public sealed class ParenthesizePropertyNameAttribute : Attribute {
-        public override bool Equals(object o);
+        public override bool Equals(object obj);
     }
     public sealed class RefreshPropertiesAttribute : Attribute {
-        public override bool Equals(object value);
+        public override bool Equals(object obj);
     }
 }

System.ComponentModel.DataAnnotations

 namespace System.ComponentModel.DataAnnotations {
     public sealed class CustomValidationAttribute : ValidationAttribute {
+        public override bool RequiresValidationContext { get; }
     }
 }

System.Diagnostics

 namespace System.Diagnostics {
-    public class Process : Component
+    public class Process : Component, IDisposable
     public abstract class Switch {
-        protected virtual string[] GetSupportedAttributes();
+        protected internal virtual string[] GetSupportedAttributes();
     }
     public abstract class TraceListener : MarshalByRefObject, IDisposable {
-        protected virtual string[] GetSupportedAttributes();
+        protected internal virtual string[] GetSupportedAttributes();
     }
     public class TraceSource {
-        protected virtual string[] GetSupportedAttributes();
+        protected internal virtual string[] GetSupportedAttributes();
     }
 }

System.IO

 namespace System.IO {
     public sealed class BufferedStream : Stream {
+        public override void CopyTo(Stream destination, int bufferSize);
+        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
+        public override int Read(Span<byte> destination);
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
+        public override void Write(ReadOnlySpan<byte> buffer);
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken));
     }
     public class StringWriter : TextWriter {
+        public override void Write(StringBuilder value);
+        public override Task WriteAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
+        public override void WriteLine(StringBuilder value);
+        public override Task WriteLineAsync(StringBuilder value, CancellationToken cancellationToken = default(CancellationToken));
     }
 }

System.IO.Compression

 namespace System.IO.Compression {
     public struct BrotliEncoder : IDisposable {
-        public static int GetMaxCompressedLength(int inputSize);
+        public static int GetMaxCompressedLength(int length);
     }
     public sealed class BrotliStream : Stream {
+        public override int ReadByte();
+        public override void WriteByte(byte value);
     }
 }

System.IO.Enumeration

 namespace System.IO.Enumeration {
     public abstract class FileSystemEnumerator<TResult> : CriticalFinalizerObject, IDisposable, IEnumerator, IEnumerator<TResult> {
+        ~FileSystemEnumerator();
     }
 }

System.IO.IsolatedStorage

 namespace System.IO.IsolatedStorage {
-    public class IsolatedStorageException : Exception
+    public class IsolatedStorageException : Exception, ISerializable
     public sealed class IsolatedStorageFile : IsolatedStorage, IDisposable {
-        ~IsolatedStorageFile();

     }
     public class IsolatedStorageFileStream : FileStream {
-        public override IAsyncResult BeginRead(byte[] buffer, int offset, int numBytes, AsyncCallback userCallback, object stateObject);
+        public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject);
-        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int numBytes, AsyncCallback userCallback, object stateObject);
+        public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback userCallback, object stateObject);
     }
 }

System.IO.Pipes

 namespace System.IO.Pipes {
     public abstract class PipeStream : Stream {
+        public override Task FlushAsync(CancellationToken cancellationToken);
     }
 }

System.Linq

 namespace System.Linq {
     public class EnumerableQuery<T> : EnumerableQuery, IEnumerable, IEnumerable<T>, IOrderedQueryable, IOrderedQueryable<T>, IQueryable, IQueryable<T>, IQueryProvider {
-        IQueryable<S> System.Linq.IQueryProvider.CreateQuery<S>(Expression expression);

+        IQueryable<TElement> System.Linq.IQueryProvider.CreateQuery<TElement>(Expression expression);
-        S System.Linq.IQueryProvider.Execute<S>(Expression expression);

+        TElement System.Linq.IQueryProvider.Execute<TElement>(Expression expression);
     }
 }

System.Linq.Expressions

 namespace System.Linq.Expressions {
     public class DynamicExpression : Expression, IArgumentProvider, IDynamicExpression {
+        public override bool CanReduce { get; }
+        public override Expression Reduce();
     }
-    public abstract class DynamicExpressionVisitor : ExpressionVisitor {
+    public class DynamicExpressionVisitor : ExpressionVisitor {
-        protected DynamicExpressionVisitor();
+        public DynamicExpressionVisitor();
     }
     public sealed class ElementInit : IArgumentProvider {
+        public int ArgumentCount { get; }
-        int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get; }

+        public Expression GetArgument(int index);
-        Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index);

     }
-    public sealed class Expression<TDelegate> : LambdaExpression
+    public class Expression<TDelegate> : LambdaExpression
     public sealed class IndexExpression : Expression, IArgumentProvider {
+        public int ArgumentCount { get; }
-        int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get; }

+        public Expression GetArgument(int index);
-        Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index);

     }
-    public sealed class InvocationExpression : Expression, IArgumentProvider {
+    public class InvocationExpression : Expression, IArgumentProvider {
+        public virtual int ArgumentCount { get; }
-        int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get; }

+        public virtual Expression GetArgument(int index);
-        Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index);

     }
     public class MethodCallExpression : Expression, IArgumentProvider {
+        public virtual int ArgumentCount { get; }
-        int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get; }

+        public virtual Expression GetArgument(int index);
-        Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index);

     }
     public class NewExpression : Expression, IArgumentProvider {
+        public int ArgumentCount { get; }
-        int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get; }

+        public Expression GetArgument(int index);
-        Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index);

     }
 }

System.Linq.Expressions.Interpreter

+namespace System.Linq.Expressions.Interpreter {
+    public class LightLambda {
+        public object Run(params object[] arguments);
+        public object RunVoid(params object[] arguments);
+    }
+}

System.Net

 namespace System.Net {
     public sealed class FtpWebRequest : WebRequest {
+        public override RequestCachePolicy CachePolicy { get; set; }
     }
     public class FtpWebResponse : WebResponse, IDisposable {
-        public override string ContentType { get; }

     }
     public class HttpWebRequest : WebRequest, ISerializable {
+        public HttpWebRequest();
     }
     public class IPAddress {
-        public static IPAddress Parse(ReadOnlySpan<char> ipString);
+        public static IPAddress Parse(ReadOnlySpan<char> ipSpan);
-        public static bool TryParse(ReadOnlySpan<char> ipString, out IPAddress address);
+        public static bool TryParse(ReadOnlySpan<char> ipSpan, out IPAddress address);
     }
-    public class WebHeaderCollection : NameValueCollection, IEnumerable, ISerializable {
+    public class WebHeaderCollection : NameValueCollection, ISerializable {
-        public new string this[string name] { get; set; }

     }
 }

System.Net.Sockets

 namespace System.Net.Sockets {
     public sealed class SafeSocketHandle : SafeHandleMinusOneIsInvalid {
+        public override bool IsInvalid { get; }
     }
     public sealed class UnixDomainSocketEndPoint : EndPoint {
+        public override AddressFamily AddressFamily { get; }
+        public override EndPoint Create(SocketAddress socketAddress);
+        public override SocketAddress Serialize();
+        public override string ToString();
     }
 }

System.Reflection

 namespace System.Reflection {
     public static class AssemblyExtensions {
-        public static Type[] GetExportedTypes(this Assembly assembly);
+        public static Type[] GetExportedTypes(Assembly assembly);
-        public static Module[] GetModules(this Assembly assembly);
+        public static Module[] GetModules(Assembly assembly);
-        public static Type[] GetTypes(this Assembly assembly);
+        public static Type[] GetTypes(Assembly assembly);
     }
     public static class EventInfoExtensions {
-        public static MethodInfo GetAddMethod(this EventInfo eventInfo);
+        public static MethodInfo GetAddMethod(EventInfo eventInfo);
-        public static MethodInfo GetAddMethod(this EventInfo eventInfo, bool nonPublic);
+        public static MethodInfo GetAddMethod(EventInfo eventInfo, bool nonPublic);
-        public static MethodInfo GetRaiseMethod(this EventInfo eventInfo);
+        public static MethodInfo GetRaiseMethod(EventInfo eventInfo);
-        public static MethodInfo GetRaiseMethod(this EventInfo eventInfo, bool nonPublic);
+        public static MethodInfo GetRaiseMethod(EventInfo eventInfo, bool nonPublic);
-        public static MethodInfo GetRemoveMethod(this EventInfo eventInfo);
+        public static MethodInfo GetRemoveMethod(EventInfo eventInfo);
-        public static MethodInfo GetRemoveMethod(this EventInfo eventInfo, bool nonPublic);
+        public static MethodInfo GetRemoveMethod(EventInfo eventInfo, bool nonPublic);
     }
     public static class MethodInfoExtensions {
-        public static MethodInfo GetBaseDefinition(this MethodInfo method);
+        public static MethodInfo GetBaseDefinition(MethodInfo method);
     }
     public static class PropertyInfoExtensions {
-        public static MethodInfo[] GetAccessors(this PropertyInfo property);
+        public static MethodInfo[] GetAccessors(PropertyInfo property);
-        public static MethodInfo[] GetAccessors(this PropertyInfo property, bool nonPublic);
+        public static MethodInfo[] GetAccessors(PropertyInfo property, bool nonPublic);
-        public static MethodInfo GetGetMethod(this PropertyInfo property);
+        public static MethodInfo GetGetMethod(PropertyInfo property);
-        public static MethodInfo GetGetMethod(this PropertyInfo property, bool nonPublic);
+        public static MethodInfo GetGetMethod(PropertyInfo property, bool nonPublic);
-        public static MethodInfo GetSetMethod(this PropertyInfo property);
+        public static MethodInfo GetSetMethod(PropertyInfo property);
-        public static MethodInfo GetSetMethod(this PropertyInfo property, bool nonPublic);
+        public static MethodInfo GetSetMethod(PropertyInfo property, bool nonPublic);
     }
     public static class TypeExtensions {
-        public static ConstructorInfo GetConstructor(this Type type, Type[] types);
+        public static ConstructorInfo GetConstructor(Type type, Type[] types);
-        public static ConstructorInfo[] GetConstructors(this Type type);
+        public static ConstructorInfo[] GetConstructors(Type type);
-        public static ConstructorInfo[] GetConstructors(this Type type, BindingFlags bindingAttr);
+        public static ConstructorInfo[] GetConstructors(Type type, BindingFlags bindingAttr);
-        public static MemberInfo[] GetDefaultMembers(this Type type);
+        public static MemberInfo[] GetDefaultMembers(Type type);
-        public static EventInfo GetEvent(this Type type, string name);
+        public static EventInfo GetEvent(Type type, string name);
-        public static EventInfo GetEvent(this Type type, string name, BindingFlags bindingAttr);
+        public static EventInfo GetEvent(Type type, string name, BindingFlags bindingAttr);
-        public static EventInfo[] GetEvents(this Type type);
+        public static EventInfo[] GetEvents(Type type);
-        public static EventInfo[] GetEvents(this Type type, BindingFlags bindingAttr);
+        public static EventInfo[] GetEvents(Type type, BindingFlags bindingAttr);
-        public static FieldInfo GetField(this Type type, string name);
+        public static FieldInfo GetField(Type type, string name);
-        public static FieldInfo GetField(this Type type, string name, BindingFlags bindingAttr);
+        public static FieldInfo GetField(Type type, string name, BindingFlags bindingAttr);
-        public static FieldInfo[] GetFields(this Type type);
+        public static FieldInfo[] GetFields(Type type);
-        public static FieldInfo[] GetFields(this Type type, BindingFlags bindingAttr);
+        public static FieldInfo[] GetFields(Type type, BindingFlags bindingAttr);
-        public static Type[] GetGenericArguments(this Type type);
+        public static Type[] GetGenericArguments(Type type);
-        public static Type[] GetInterfaces(this Type type);
+        public static Type[] GetInterfaces(Type type);
-        public static MemberInfo[] GetMember(this Type type, string name);
+        public static MemberInfo[] GetMember(Type type, string name);
-        public static MemberInfo[] GetMember(this Type type, string name, BindingFlags bindingAttr);
+        public static MemberInfo[] GetMember(Type type, string name, BindingFlags bindingAttr);
-        public static MemberInfo[] GetMembers(this Type type);
+        public static MemberInfo[] GetMembers(Type type);
-        public static MemberInfo[] GetMembers(this Type type, BindingFlags bindingAttr);
+        public static MemberInfo[] GetMembers(Type type, BindingFlags bindingAttr);
-        public static MethodInfo GetMethod(this Type type, string name);
+        public static MethodInfo GetMethod(Type type, string name);
-        public static MethodInfo GetMethod(this Type type, string name, BindingFlags bindingAttr);
+        public static MethodInfo GetMethod(Type type, string name, BindingFlags bindingAttr);
-        public static MethodInfo GetMethod(this Type type, string name, Type[] types);
+        public static MethodInfo GetMethod(Type type, string name, Type[] types);
-        public static MethodInfo[] GetMethods(this Type type);
+        public static MethodInfo[] GetMethods(Type type);
-        public static MethodInfo[] GetMethods(this Type type, BindingFlags bindingAttr);
+        public static MethodInfo[] GetMethods(Type type, BindingFlags bindingAttr);
-        public static Type GetNestedType(this Type type, string name, BindingFlags bindingAttr);
+        public static Type GetNestedType(Type type, string name, BindingFlags bindingAttr);
-        public static Type[] GetNestedTypes(this Type type, BindingFlags bindingAttr);
+        public static Type[] GetNestedTypes(Type type, BindingFlags bindingAttr);
-        public static PropertyInfo[] GetProperties(this Type type);
+        public static PropertyInfo[] GetProperties(Type type);
-        public static PropertyInfo[] GetProperties(this Type type, BindingFlags bindingAttr);
+        public static PropertyInfo[] GetProperties(Type type, BindingFlags bindingAttr);
-        public static PropertyInfo GetProperty(this Type type, string name);
+        public static PropertyInfo GetProperty(Type type, string name);
-        public static PropertyInfo GetProperty(this Type type, string name, BindingFlags bindingAttr);
+        public static PropertyInfo GetProperty(Type type, string name, BindingFlags bindingAttr);
-        public static PropertyInfo GetProperty(this Type type, string name, Type returnType);
+        public static PropertyInfo GetProperty(Type type, string name, Type returnType);
-        public static PropertyInfo GetProperty(this Type type, string name, Type returnType, Type[] types);
+        public static PropertyInfo GetProperty(Type type, string name, Type returnType, Type[] types);
-        public static bool IsAssignableFrom(this Type type, Type c);
+        public static bool IsAssignableFrom(Type type, Type c);
-        public static bool IsInstanceOfType(this Type type, object o);
+        public static bool IsInstanceOfType(Type type, object o);
     }
 }

System.Runtime.CompilerServices

 namespace System.Runtime.CompilerServices {
+    public static class CallSiteOps {
+        public static void AddRule<T>(CallSite<T> site, T rule) where T : class;
+        public static T Bind<T>(CallSiteBinder binder, CallSite<T> site, object[] args) where T : class;
+        public static void ClearMatch(CallSite site);
+        public static CallSite<T> CreateMatchmaker<T>(CallSite<T> site) where T : class;
+        public static T[] GetCachedRules<T>(RuleCache<T> cache) where T : class;
+        public static bool GetMatch(CallSite site);
+        public static RuleCache<T> GetRuleCache<T>(CallSite<T> site) where T : class;
+        public static T[] GetRules<T>(CallSite<T> site) where T : class;
+        public static void MoveRule<T>(RuleCache<T> cache, T rule, int i) where T : class;
+        public static bool SetNotMatched(CallSite site);
+        public static void UpdateRules<T>(CallSite<T> @this, int matched) where T : class;
+    }
     public sealed class SwitchExpressionException : InvalidOperationException {
+        public override string Message { get; }
     }
 }

System.Runtime.InteropServices

 namespace System.Runtime.InteropServices {
+    public enum AssemblyRegistrationFlags {
+        None = 0,
+        SetCodeBase = 1,
+    }
     public class ComAwareEventInfo : EventInfo {
+        public override int MetadataToken { get; }
+        public override Module Module { get; }
+        public override IList<CustomAttributeData> GetCustomAttributesData();
+        public override MethodInfo[] GetOtherMethods(bool nonPublic);
     }
+    public enum ExporterEventKind {
+        ERROR_REFTOINVALIDASSEMBLY = 2,
+        NOTIF_CONVERTWARNING = 1,
+        NOTIF_TYPECONVERTED = 0,
+    }
+    public sealed class IDispatchImplAttribute : Attribute {
+        public IDispatchImplAttribute(short implType);
+        public IDispatchImplAttribute(IDispatchImplType implType);
+        public IDispatchImplType Value { get; }
+    }
+    public enum IDispatchImplType {
+        CompatibleImpl = 2,
+        InternalImpl = 1,
+        SystemDefinedImpl = 0,
+    }
+    public enum RegistrationClassContext {
+        DisableActivateAsActivator = 32768,
+        EnableActivateAsActivator = 65536,
+        EnableCodeDownload = 8192,
+        FromDefaultContext = 131072,
+        InProcessHandler = 2,
+        InProcessHandler16 = 32,
+        InProcessServer = 1,
+        InProcessServer16 = 8,
+        LocalServer = 4,
+        NoCodeDownload = 1024,
+        NoCustomMarshal = 4096,
+        NoFailureLog = 16384,
+        RemoteServer = 16,
+        Reserved1 = 64,
+        Reserved2 = 128,
+        Reserved3 = 256,
+        Reserved4 = 512,
+        Reserved5 = 2048,
+    }
+    public enum RegistrationConnectionType {
+        MultipleUse = 1,
+        MultiSeparate = 2,
+        SingleUse = 0,
+        Surrogate = 8,
+        Suspended = 4,
+    }
+    public sealed class SetWin32ContextInIDispatchAttribute : Attribute {
+        public SetWin32ContextInIDispatchAttribute();
+    }
 }

System.Security.Cryptography

 namespace System.Security.Cryptography {
     public abstract class DSA : AsymmetricAlgorithm {
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
+        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
     }
     public abstract class ECDiffieHellman : AsymmetricAlgorithm {
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
+        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
     }
     public abstract class ECDsa : AsymmetricAlgorithm {
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
+        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
     }
     public abstract class RSA : AsymmetricAlgorithm {
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportPkcs8PrivateKey(ReadOnlySpan<byte> source, out int bytesRead);
+        public override void ImportSubjectPublicKeyInfo(ReadOnlySpan<byte> source, out int bytesRead);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<byte> passwordBytes, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<char> password, PbeParameters pbeParameters, Span<byte> destination, out int bytesWritten);
+        public override bool TryExportPkcs8PrivateKey(Span<byte> destination, out int bytesWritten);
+        public override bool TryExportSubjectPublicKeyInfo(Span<byte> destination, out int bytesWritten);
     }
 }

System.Text.RegularExpressions

 namespace System.Text.RegularExpressions {
     public class Regex : ISerializable {
-        protected bool UseOptionR();
+        protected internal bool UseOptionR();
     }
     public class RegexMatchTimeoutException : TimeoutException, ISerializable {
-        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo si, StreamingContext context);
+        void System.Runtime.Serialization.ISerializable.GetObjectData(SerializationInfo info, StreamingContext context);
     }
 }
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment