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
- System
- System.Collections.Generic
- System.Collections.Immutable
- System.ComponentModel
- System.ComponentModel.DataAnnotations
- System.Diagnostics
- System.IO
- System.IO.Compression
- System.IO.Enumeration
- System.IO.IsolatedStorage
- System.IO.Pipes
- System.Linq
- System.Linq.Expressions
- System.Linq.Expressions.Interpreter
- System.Net
- System.Net.Sockets
- System.Reflection
- System.Runtime.CompilerServices
- System.Runtime.InteropServices
- System.Security.Cryptography
- System.Text.RegularExpressions
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);
}
}
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);
}
}
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);
}
}
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);
}
}
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);
}
}
namespace System.ComponentModel.DataAnnotations {
public sealed class CustomValidationAttribute : ValidationAttribute {
+ public override bool RequiresValidationContext { get; }
}
}
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();
}
}
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));
}
}
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);
}
}
namespace System.IO.Enumeration {
public abstract class FileSystemEnumerator<TResult> : CriticalFinalizerObject, IDisposable, IEnumerator, IEnumerator<TResult> {
+ ~FileSystemEnumerator();
}
}
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);
}
}
namespace System.IO.Pipes {
public abstract class PipeStream : Stream {
+ public override Task FlushAsync(CancellationToken cancellationToken);
}
}
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);
}
}
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);
}
}
+namespace System.Linq.Expressions.Interpreter {
+ public class LightLambda {
+ public object Run(params object[] arguments);
+ public object RunVoid(params object[] arguments);
+ }
+}
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; }
}
}
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();
}
}
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);
}
}
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; }
}
}
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();
+ }
}
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);
}
}
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);
}
}