jprdonnelly/core
1
0
Fork 0
mirror of synced 2025-12-23 21:05:00 -05:00
Code Issues Projects Releases Wiki Activity

Preview 2 release docs

Browse Source
This commit is contained in:
Lee Coward
2018-04-10 17:24:20 -07:00
parent d2398cec92
commit 84c9b04c7d
73 changed files with 99 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1.md Normal file
View File

@@ -0,0 +1,40 @@
# API Difference netcoreapp2.0 vs netcoreapp2.1-preview11
API listing follows standard diff formatting. Lines preceded by a '+' are
additions and a '-' indicates removal.
* [Microsoft.Win32.SafeHandles](2.1-preview1_Microsoft.Win32.SafeHandles.md)
* [System](2.1-preview1_System.md)
* [System.Buffers](2.1-preview1_System.Buffers.md)
* [System.Buffers.Binary](2.1-preview1_System.Buffers.Binary.md)
* [System.Buffers.Text](2.1-preview1_System.Buffers.Text.md)
* [System.Collections.Generic](2.1-preview1_System.Collections.Generic.md)
* [System.Collections.Immutable](2.1-preview1_System.Collections.Immutable.md)
* [System.ComponentModel.DataAnnotations](2.1-preview1_System.ComponentModel.DataAnnotations.md)
* [System.Data](2.1-preview1_System.Data.md)
* [System.Data.Common](2.1-preview1_System.Data.Common.md)
* [System.Diagnostics](2.1-preview1_System.Diagnostics.md)
* [System.Diagnostics.Tracing](2.1-preview1_System.Diagnostics.Tracing.md)
* [System.Drawing](2.1-preview1_System.Drawing.md)
* [System.Globalization](2.1-preview1_System.Globalization.md)
* [System.IO](2.1-preview1_System.IO.md)
* [System.IO.Compression](2.1-preview1_System.IO.Compression.md)
* [System.Net](2.1-preview1_System.Net.md)
* [System.Net.Http](2.1-preview1_System.Net.Http.md)
* [System.Net.Security](2.1-preview1_System.Net.Security.md)
* [System.Net.Sockets](2.1-preview1_System.Net.Sockets.md)
* [System.Net.WebSockets](2.1-preview1_System.Net.WebSockets.md)
* [System.Numerics](2.1-preview1_System.Numerics.md)
* [System.Reflection](2.1-preview1_System.Reflection.md)
* [System.Reflection.Emit](2.1-preview1_System.Reflection.Emit.md)
* [System.Reflection.Metadata](2.1-preview1_System.Reflection.Metadata.md)
* [System.Runtime.CompilerServices](2.1-preview1_System.Runtime.CompilerServices.md)
* [System.Runtime.InteropServices](2.1-preview1_System.Runtime.InteropServices.md)
* [System.Runtime.Intrinsics](2.1-preview1_System.Runtime.Intrinsics.md)
* [System.Runtime.Intrinsics.X86](2.1-preview1_System.Runtime.Intrinsics.X86.md)
* [System.Security.Cryptography](2.1-preview1_System.Security.Cryptography.md)
* [System.Security.Cryptography.X509Certificates](2.1-preview1_System.Security.Cryptography.X509Certificates.md)
* [System.Text](2.1-preview1_System.Text.md)
* [System.Text.RegularExpressions](2.1-preview1_System.Text.RegularExpressions.md)
* [System.Threading](2.1-preview1_System.Threading.md)

11
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_Microsoft.Win32.SafeHandles.md Normal file
View File

@@ -0,0 +1,11 @@
# Microsoft.Win32.SafeHandles
``` diff
namespace Microsoft.Win32.SafeHandles {
public sealed class SafeX509ChainHandle : SafeHandleZeroOrMinusOneIsInvalid {
- public override bool IsInvalid { get; }
}
}
```

69
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Buffers.Binary.md Normal file
View File

@@ -0,0 +1,69 @@
# System.Buffers.Binary
``` diff
+namespace System.Buffers.Binary {
+ public static class BinaryPrimitives {
+ public static short ReadInt16BigEndian(ReadOnlySpan<byte> buffer);
+ public static short ReadInt16LittleEndian(ReadOnlySpan<byte> buffer);
+ public static int ReadInt32BigEndian(ReadOnlySpan<byte> buffer);
+ public static int ReadInt32LittleEndian(ReadOnlySpan<byte> buffer);
+ public static long ReadInt64BigEndian(ReadOnlySpan<byte> buffer);
+ public static long ReadInt64LittleEndian(ReadOnlySpan<byte> buffer);
+ public static T ReadMachineEndian<T>(ReadOnlySpan<byte> buffer) where T : struct;
+ public static ushort ReadUInt16BigEndian(ReadOnlySpan<byte> buffer);
+ public static ushort ReadUInt16LittleEndian(ReadOnlySpan<byte> buffer);
+ public static uint ReadUInt32BigEndian(ReadOnlySpan<byte> buffer);
+ public static uint ReadUInt32LittleEndian(ReadOnlySpan<byte> buffer);
+ public static ulong ReadUInt64BigEndian(ReadOnlySpan<byte> buffer);
+ public static ulong ReadUInt64LittleEndian(ReadOnlySpan<byte> buffer);
+ public static byte ReverseEndianness(byte value);
+ public static short ReverseEndianness(short value);
+ public static int ReverseEndianness(int value);
+ public static long ReverseEndianness(long value);
+ public static sbyte ReverseEndianness(sbyte value);
+ public static ushort ReverseEndianness(ushort value);
+ public static uint ReverseEndianness(uint value);
+ public static ulong ReverseEndianness(ulong value);
+ public static bool TryReadInt16BigEndian(ReadOnlySpan<byte> buffer, out short value);
+ public static bool TryReadInt16LittleEndian(ReadOnlySpan<byte> buffer, out short value);
+ public static bool TryReadInt32BigEndian(ReadOnlySpan<byte> buffer, out int value);
+ public static bool TryReadInt32LittleEndian(ReadOnlySpan<byte> buffer, out int value);
+ public static bool TryReadInt64BigEndian(ReadOnlySpan<byte> buffer, out long value);
+ public static bool TryReadInt64LittleEndian(ReadOnlySpan<byte> buffer, out long value);
+ public static bool TryReadMachineEndian<T>(ReadOnlySpan<byte> buffer, out T value) where T : struct;
+ public static bool TryReadUInt16BigEndian(ReadOnlySpan<byte> buffer, out ushort value);
+ public static bool TryReadUInt16LittleEndian(ReadOnlySpan<byte> buffer, out ushort value);
+ public static bool TryReadUInt32BigEndian(ReadOnlySpan<byte> buffer, out uint value);
+ public static bool TryReadUInt32LittleEndian(ReadOnlySpan<byte> buffer, out uint value);
+ public static bool TryReadUInt64BigEndian(ReadOnlySpan<byte> buffer, out ulong value);
+ public static bool TryReadUInt64LittleEndian(ReadOnlySpan<byte> buffer, out ulong value);
+ public static bool TryWriteInt16BigEndian(Span<byte> buffer, short value);
+ public static bool TryWriteInt16LittleEndian(Span<byte> buffer, short value);
+ public static bool TryWriteInt32BigEndian(Span<byte> buffer, int value);
+ public static bool TryWriteInt32LittleEndian(Span<byte> buffer, int value);
+ public static bool TryWriteInt64BigEndian(Span<byte> buffer, long value);
+ public static bool TryWriteInt64LittleEndian(Span<byte> buffer, long value);
+ public static bool TryWriteMachineEndian<T>(Span<byte> buffer, ref T value) where T : struct;
+ public static bool TryWriteUInt16BigEndian(Span<byte> buffer, ushort value);
+ public static bool TryWriteUInt16LittleEndian(Span<byte> buffer, ushort value);
+ public static bool TryWriteUInt32BigEndian(Span<byte> buffer, uint value);
+ public static bool TryWriteUInt32LittleEndian(Span<byte> buffer, uint value);
+ public static bool TryWriteUInt64BigEndian(Span<byte> buffer, ulong value);
+ public static bool TryWriteUInt64LittleEndian(Span<byte> buffer, ulong value);
+ public static void WriteInt16BigEndian(Span<byte> buffer, short value);
+ public static void WriteInt16LittleEndian(Span<byte> buffer, short value);
+ public static void WriteInt32BigEndian(Span<byte> buffer, int value);
+ public static void WriteInt32LittleEndian(Span<byte> buffer, int value);
+ public static void WriteInt64BigEndian(Span<byte> buffer, long value);
+ public static void WriteInt64LittleEndian(Span<byte> buffer, long value);
+ public static void WriteMachineEndian<T>(Span<byte> buffer, ref T value) where T : struct;
+ public static void WriteUInt16BigEndian(Span<byte> buffer, ushort value);
+ public static void WriteUInt16LittleEndian(Span<byte> buffer, ushort value);
+ public static void WriteUInt32BigEndian(Span<byte> buffer, uint value);
+ public static void WriteUInt32LittleEndian(Span<byte> buffer, uint value);
+ public static void WriteUInt64BigEndian(Span<byte> buffer, ulong value);
+ public static void WriteUInt64LittleEndian(Span<byte> buffer, ulong value);
+ }
+}
```

51
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Buffers.Text.md Normal file
View File

@@ -0,0 +1,51 @@
# System.Buffers.Text
``` diff
+namespace System.Buffers.Text {
+ public static class Base64 {
+ public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> utf8, Span<byte> bytes, out int consumed, out int written, bool isFinalBlock=true);
+ public static OperationStatus DecodeFromUtf8InPlace(Span<byte> buffer, out int written);
+ public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> bytes, Span<byte> utf8, out int consumed, out int written, bool isFinalBlock=true);
+ public static OperationStatus EncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int written);
+ public static int GetMaxDecodedFromUtf8Length(int length);
+ public static int GetMaxEncodedToUtf8Length(int length);
+ }
+ public static class Utf8Formatter {
+ public static bool TryFormat(bool value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(byte value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(DateTime value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(DateTimeOffset value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(decimal value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(double value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(Guid value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(short value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(int value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(long value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(sbyte value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(float value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(TimeSpan value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(ushort value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(uint value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ public static bool TryFormat(ulong value, Span<byte> buffer, out int bytesWritten, StandardFormat format=default(StandardFormat));
+ }
+ public static class Utf8Parser {
+ public static bool TryParse(ReadOnlySpan<byte> text, out bool value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out byte value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out DateTime value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out DateTimeOffset value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out decimal value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out double value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out Guid value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out short value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out int value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out long value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out sbyte value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out float value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out TimeSpan value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out ushort value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out uint value, out int bytesConsumed, char standardFormat='\0');
+ public static bool TryParse(ReadOnlySpan<byte> text, out ulong value, out int bytesConsumed, char standardFormat='\0');
+ }
+}
```

59
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Buffers.md Normal file
View File

@@ -0,0 +1,59 @@
# System.Buffers
``` diff
namespace System.Buffers {
+ public interface IRetainable {
+ bool Release();
+ void Retain();
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct MemoryHandle : IDisposable {
+ public unsafe MemoryHandle(IRetainable owner, void* pointer=null, GCHandle handle=default(GCHandle));
+ public bool HasPointer { get; }
+ public unsafe void* Pointer { get; }
+ public void Dispose();
+ }
+ public enum OperationStatus {
+ DestinationTooSmall = 1,
+ Done = 0,
+ InvalidData = 3,
+ NeedMoreData = 2,
+ }
+ public abstract class OwnedMemory<T> : IDisposable, IRetainable {
+ protected OwnedMemory();
+ public abstract bool IsDisposed { get; }
+ protected abstract bool IsRetained { get; }
+ public abstract int Length { get; }
+ public Memory<T> Memory { get; }
+ public abstract Span<T> Span { get; }
+ public void Dispose();
+ protected abstract void Dispose(bool disposing);
+ public abstract MemoryHandle Pin(int offset=0);
+ public abstract bool Release();
+ public abstract void Retain();
+ protected internal abstract bool TryGetArray(out ArraySegment<T> arraySegment);
+ }
+ public delegate void ReadOnlySpanAction<T, in TArg>(ReadOnlySpan<T> span, TArg arg);
+ public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct StandardFormat : IEquatable<StandardFormat> {
+ public const byte MaxPrecision = (byte)99;
+ public const byte NoPrecision = (byte)255;
+ public StandardFormat(char symbol, byte precision=(byte)255);
+ public bool HasPrecision { get; }
+ public bool IsDefault { get; }
+ public byte Precision { get; }
+ public char Symbol { get; }
+ public bool Equals(StandardFormat other);
+ public override bool Equals(object obj);
+ public override int GetHashCode();
+ public static bool operator ==(StandardFormat left, StandardFormat right);
+ public static implicit operator StandardFormat (char symbol);
+ public static bool operator !=(StandardFormat left, StandardFormat right);
+ public static StandardFormat Parse(ReadOnlySpan<char> format);
+ public static StandardFormat Parse(string format);
+ public override string ToString();
+ }
}
```

9
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Collections.Generic.md Normal file
View File

@@ -0,0 +1,9 @@
# System.Collections.Generic
``` diff
namespace System.Collections.Generic {
- public class KeyNotFoundException : SystemException, ISerializable
+ public class KeyNotFoundException : SystemException
}
```

38
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Collections.Immutable.md Normal file
View File

@@ -0,0 +1,38 @@
# System.Collections.Immutable
``` diff
namespace System.Collections.Immutable {
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
+ public ref T ItemRef(int index);
public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+ public ref T ItemRef(int index);
}
}
public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+ public ref T ItemRef(int index);
public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+ public ref T ItemRef(int index);
}
}
public sealed class ImmutableQueue<T> : IEnumerable, IEnumerable<T>, IImmutableQueue<T> {
+ public ref T PeekRef();
}
public sealed class ImmutableSortedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IImmutableDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+ public ref TValue ValueRef(TKey key);
public sealed class Builder : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+ public ref TValue ValueRef(TKey key);
}
}
public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ISet<T> {
+ public ref T ItemRef(int index);
public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
+ public ref T ItemRef(int index);
}
}
public sealed class ImmutableStack<T> : IEnumerable, IEnumerable<T>, IImmutableStack<T> {
+ public ref T PeekRef();
}
}
```

11
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.ComponentModel.DataAnnotations.md Normal file
View File

@@ -0,0 +1,11 @@
# System.ComponentModel.DataAnnotations
``` diff
namespace System.ComponentModel.DataAnnotations {
public class DisplayFormatAttribute : Attribute {
+ public Type NullDisplayTextResourceType { get; set; }
+ public string GetNullDisplayText();
}
}
```

19
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Data.Common.md Normal file
View File

@@ -0,0 +1,19 @@
# System.Data.Common
``` diff
namespace System.Data.Common {
+ public static class DbProviderFactories {
+ public static DbProviderFactory GetFactory(DbConnection connection);
+ public static DbProviderFactory GetFactory(DataRow providerRow);
+ public static DbProviderFactory GetFactory(string providerInvariantName);
+ public static DataTable GetFactoryClasses();
+ public static IEnumerable<string> GetProviderInvariantNames();
+ public static void RegisterFactory(string providerInvariantName, DbProviderFactory factory);
+ public static void RegisterFactory(string providerInvariantName, string factoryTypeAssemblyQualifiedName);
+ public static void RegisterFactory(string providerInvariantName, Type factoryType);
+ public static bool TryGetFactory(string providerInvariantName, out DbProviderFactory factory);
+ public static bool UnregisterFactory(string providerInvariantName);
+ }
}
```

13
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Data.md Normal file
View File

@@ -0,0 +1,13 @@
# System.Data
``` diff
namespace System.Data {
public sealed class DBConcurrencyException : SystemException {
- public override void GetObjectData(SerializationInfo si, StreamingContext context);
+ public override void GetObjectData(SerializationInfo info, StreamingContext context);
}
- public class PropertyCollection : Hashtable
+ public class PropertyCollection : Hashtable, ICloneable
}
```

11
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Diagnostics.Tracing.md Normal file
View File

@@ -0,0 +1,11 @@
# System.Diagnostics.Tracing
``` diff
namespace System.Diagnostics.Tracing {
- public class EventCounter {
+ public class EventCounter : IDisposable {
+ public void Dispose();
}
}
```

10
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Diagnostics.md Normal file
View File

@@ -0,0 +1,10 @@
# System.Diagnostics
``` diff
namespace System.Diagnostics {
public sealed class ProcessStartInfo {
+ public Encoding StandardInputEncoding { get; set; }
}
}
```

205
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Drawing.md Normal file
View File

@@ -0,0 +1,205 @@
# System.Drawing
``` diff
namespace System.Drawing {
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
public struct Color : IEquatable<Color> {
+ public bool IsKnownColor { get; }
+ public bool IsSystemColor { get; }
+ public static Color FromKnownColor(KnownColor color);
+ public KnownColor ToKnownColor();
}
+ public enum KnownColor {
+ ActiveBorder = 1,
+ ActiveCaption = 2,
+ ActiveCaptionText = 3,
+ AliceBlue = 28,
+ AntiqueWhite = 29,
+ AppWorkspace = 4,
+ Aqua = 30,
+ Aquamarine = 31,
+ Azure = 32,
+ Beige = 33,
+ Bisque = 34,
+ Black = 35,
+ BlanchedAlmond = 36,
+ Blue = 37,
+ BlueViolet = 38,
+ Brown = 39,
+ BurlyWood = 40,
+ ButtonFace = 168,
+ ButtonHighlight = 169,
+ ButtonShadow = 170,
+ CadetBlue = 41,
+ Chartreuse = 42,
+ Chocolate = 43,
+ Control = 5,
+ ControlDark = 6,
+ ControlDarkDark = 7,
+ ControlLight = 8,
+ ControlLightLight = 9,
+ ControlText = 10,
+ Coral = 44,
+ CornflowerBlue = 45,
+ Cornsilk = 46,
+ Crimson = 47,
+ Cyan = 48,
+ DarkBlue = 49,
+ DarkCyan = 50,
+ DarkGoldenrod = 51,
+ DarkGray = 52,
+ DarkGreen = 53,
+ DarkKhaki = 54,
+ DarkMagenta = 55,
+ DarkOliveGreen = 56,
+ DarkOrange = 57,
+ DarkOrchid = 58,
+ DarkRed = 59,
+ DarkSalmon = 60,
+ DarkSeaGreen = 61,
+ DarkSlateBlue = 62,
+ DarkSlateGray = 63,
+ DarkTurquoise = 64,
+ DarkViolet = 65,
+ DeepPink = 66,
+ DeepSkyBlue = 67,
+ Desktop = 11,
+ DimGray = 68,
+ DodgerBlue = 69,
+ Firebrick = 70,
+ FloralWhite = 71,
+ ForestGreen = 72,
+ Fuchsia = 73,
+ Gainsboro = 74,
+ GhostWhite = 75,
+ Gold = 76,
+ Goldenrod = 77,
+ GradientActiveCaption = 171,
+ GradientInactiveCaption = 172,
+ Gray = 78,
+ GrayText = 12,
+ Green = 79,
+ GreenYellow = 80,
+ Highlight = 13,
+ HighlightText = 14,
+ Honeydew = 81,
+ HotPink = 82,
+ HotTrack = 15,
+ InactiveBorder = 16,
+ InactiveCaption = 17,
+ InactiveCaptionText = 18,
+ IndianRed = 83,
+ Indigo = 84,
+ Info = 19,
+ InfoText = 20,
+ Ivory = 85,
+ Khaki = 86,
+ Lavender = 87,
+ LavenderBlush = 88,
+ LawnGreen = 89,
+ LemonChiffon = 90,
+ LightBlue = 91,
+ LightCoral = 92,
+ LightCyan = 93,
+ LightGoldenrodYellow = 94,
+ LightGray = 95,
+ LightGreen = 96,
+ LightPink = 97,
+ LightSalmon = 98,
+ LightSeaGreen = 99,
+ LightSkyBlue = 100,
+ LightSlateGray = 101,
+ LightSteelBlue = 102,
+ LightYellow = 103,
+ Lime = 104,
+ LimeGreen = 105,
+ Linen = 106,
+ Magenta = 107,
+ Maroon = 108,
+ MediumAquamarine = 109,
+ MediumBlue = 110,
+ MediumOrchid = 111,
+ MediumPurple = 112,
+ MediumSeaGreen = 113,
+ MediumSlateBlue = 114,
+ MediumSpringGreen = 115,
+ MediumTurquoise = 116,
+ MediumVioletRed = 117,
+ Menu = 21,
+ MenuBar = 173,
+ MenuHighlight = 174,
+ MenuText = 22,
+ MidnightBlue = 118,
+ MintCream = 119,
+ MistyRose = 120,
+ Moccasin = 121,
+ NavajoWhite = 122,
+ Navy = 123,
+ OldLace = 124,
+ Olive = 125,
+ OliveDrab = 126,
+ Orange = 127,
+ OrangeRed = 128,
+ Orchid = 129,
+ PaleGoldenrod = 130,
+ PaleGreen = 131,
+ PaleTurquoise = 132,
+ PaleVioletRed = 133,
+ PapayaWhip = 134,
+ PeachPuff = 135,
+ Peru = 136,
+ Pink = 137,
+ Plum = 138,
+ PowderBlue = 139,
+ Purple = 140,
+ Red = 141,
+ RosyBrown = 142,
+ RoyalBlue = 143,
+ SaddleBrown = 144,
+ Salmon = 145,
+ SandyBrown = 146,
+ ScrollBar = 23,
+ SeaGreen = 147,
+ SeaShell = 148,
+ Sienna = 149,
+ Silver = 150,
+ SkyBlue = 151,
+ SlateBlue = 152,
+ SlateGray = 153,
+ Snow = 154,
+ SpringGreen = 155,
+ SteelBlue = 156,
+ Tan = 157,
+ Teal = 158,
+ Thistle = 159,
+ Tomato = 160,
+ Transparent = 27,
+ Turquoise = 161,
+ Violet = 162,
+ Wheat = 163,
+ White = 164,
+ WhiteSmoke = 165,
+ Window = 24,
+ WindowFrame = 25,
+ WindowText = 26,
+ Yellow = 166,
+ YellowGreen = 167,
+ }
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
public struct Size : IEquatable<Size> {
+ public static Size operator /(Size left, int right);
+ public static SizeF operator /(Size left, float right);
+ public static Size operator *(Size left, int right);
+ public static SizeF operator *(Size left, float right);
+ public static Size operator *(int left, Size right);
+ public static SizeF operator *(float left, Size right);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
public struct SizeF : IEquatable<SizeF> {
+ public static SizeF operator /(SizeF left, float right);
+ public static SizeF operator *(SizeF left, float right);
+ public static SizeF operator *(float left, SizeF right);
}
}
```

9
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Globalization.md Normal file
View File

@@ -0,0 +1,9 @@
# System.Globalization
``` diff
namespace System.Globalization {
- public class CultureNotFoundException : ArgumentException, ISerializable
+ public class CultureNotFoundException : ArgumentException
}
```

50
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.IO.Compression.md Normal file
View File

@@ -0,0 +1,50 @@
# System.IO.Compression
``` diff
namespace System.IO.Compression {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+ public struct BrotliDecoder : IDisposable {
+ public OperationStatus Decompress(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten);
+ public void Dispose();
+ public static bool TryDecompress(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+ public struct BrotliEncoder : IDisposable {
+ public BrotliEncoder(int quality, int window);
+ public OperationStatus Compress(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock);
+ public void Dispose();
+ public OperationStatus Flush(Span<byte> destination, out int bytesWritten);
+ public static int GetMaxCompressedLength(int inputSize);
+ public static bool TryCompress(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
+ public static bool TryCompress(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten, int quality, int window);
+ }
+ public sealed class BrotliStream : Stream {
+ public BrotliStream(Stream stream, CompressionLevel compressionLevel);
+ public BrotliStream(Stream stream, CompressionLevel compressionLevel, bool leaveOpen);
+ public BrotliStream(Stream stream, CompressionMode mode);
+ public BrotliStream(Stream stream, CompressionMode mode, bool leaveOpen);
+ public Stream BaseStream { get; }
+ public override bool CanRead { get; }
+ public override bool CanSeek { get; }
+ public override bool CanWrite { get; }
+ public override long Length { get; }
+ public override long Position { get; set; }
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback asyncCallback, object asyncState);
+ public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState);
+ protected override void Dispose(bool disposing);
+ public override int EndRead(IAsyncResult asyncResult);
+ public override void EndWrite(IAsyncResult asyncResult);
+ public override void Flush();
+ public override int Read(byte[] array, int offset, int count);
+ public override Task<int> ReadAsync(byte[] array, int offset, int count, CancellationToken cancellationToken);
+ public override long Seek(long offset, SeekOrigin origin);
+ public override void SetLength(long value);
+ public override void Write(byte[] array, int offset, int count);
+ public override Task WriteAsync(byte[] array, int offset, int count, CancellationToken cancellationToken);
+ }
public class ZipArchiveEntry {
+ public uint Crc32 { get; }
}
}
```

80
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.IO.md Normal file
View File

@@ -0,0 +1,80 @@
# System.IO
``` diff
namespace System.IO {
public class BinaryReader : IDisposable {
+ public virtual int Read(Span<byte> buffer);
+ public virtual int Read(Span<char> buffer);
}
public class BinaryWriter : IDisposable {
+ public virtual void Write(ReadOnlySpan<byte> buffer);
+ public virtual void Write(ReadOnlySpan<char> chars);
}
public class FileStream : Stream {
- public string Name { get; }
+ public virtual string Name { get; }
- public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+ public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback callback, object state);
- public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+ public override IAsyncResult BeginWrite(byte[] array, int offset, int numBytes, AsyncCallback callback, object state);
}
public class MemoryStream : Stream {
+ public override int Read(Span<byte> destination);
+ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken=default(CancellationToken));
+ public override void Write(ReadOnlySpan<byte> source);
+ public override Task WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken=default(CancellationToken));
}
public static class Path {
+ public static bool IsPathFullyQualified(string path);
}
public abstract class Stream : MarshalByRefObject, IDisposable {
+ public Task CopyToAsync(Stream destination, CancellationToken cancellationToken);
+ public virtual int Read(Span<byte> destination);
+ public virtual ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken=default(CancellationToken));
+ public virtual void Write(ReadOnlySpan<byte> source);
+ public virtual Task WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken=default(CancellationToken));
}
public class StreamReader : TextReader {
+ public override int Read(Span<char> buffer);
+ public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public override int ReadBlock(Span<char> buffer);
+ public override ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public class StreamWriter : TextWriter {
+ public override void Write(ReadOnlySpan<char> buffer);
+ public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public override void WriteLine(ReadOnlySpan<char> buffer);
+ public override void WriteLine(string value);
+ public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public class StringReader : TextReader {
+ public override int Read(Span<char> buffer);
+ public override ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public override int ReadBlock(Span<char> buffer);
+ public override ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public class StringWriter : TextWriter {
+ public override void Write(ReadOnlySpan<char> buffer);
+ public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public override void WriteLine(ReadOnlySpan<char> buffer);
+ public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public abstract class TextReader : MarshalByRefObject, IDisposable {
+ public virtual int Read(Span<char> buffer);
+ public virtual ValueTask<int> ReadAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public virtual int ReadBlock(Span<char> buffer);
+ public virtual ValueTask<int> ReadBlockAsync(Memory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public abstract class TextWriter : MarshalByRefObject, IDisposable {
+ public virtual void Write(ReadOnlySpan<char> buffer);
+ public virtual Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
+ public virtual void WriteLine(ReadOnlySpan<char> buffer);
+ public virtual Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken=default(CancellationToken));
}
public class UnmanagedMemoryStream : Stream {
+ public override int Read(Span<byte> destination);
+ public override void Write(ReadOnlySpan<byte> source);
}
}
```

21
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Net.Http.md Normal file
View File

@@ -0,0 +1,21 @@
# System.Net.Http
``` diff
namespace System.Net.Http {
public class HttpClient : HttpMessageInvoker {
+ public Task<HttpResponseMessage> PatchAsync(string requestUri, HttpContent content);
+ public Task<HttpResponseMessage> PatchAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
+ public Task<HttpResponseMessage> PatchAsync(Uri requestUri, HttpContent content);
+ public Task<HttpResponseMessage> PatchAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
}
public class HttpMethod : IEquatable<HttpMethod> {
+ public static HttpMethod Patch { get; }
}
+ public sealed class ReadOnlyMemoryContent : HttpContent {
+ public ReadOnlyMemoryContent(ReadOnlyMemory<byte> content);
+ protected override Task SerializeToStreamAsync(Stream stream, TransportContext context);
+ protected internal override bool TryComputeLength(out long length);
+ }
}
```

49
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Net.Security.md Normal file
View File

@@ -0,0 +1,49 @@
# System.Net.Security
``` diff
namespace System.Net.Security {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct SslApplicationProtocol : IEquatable<SslApplicationProtocol> {
+ public static readonly SslApplicationProtocol Http11;
+ public static readonly SslApplicationProtocol Http2;
+ public SslApplicationProtocol(byte[] protocol);
+ public SslApplicationProtocol(string protocol);
+ public ReadOnlyMemory<byte> Protocol { get; }
+ public bool Equals(SslApplicationProtocol other);
+ public override bool Equals(object obj);
+ public override int GetHashCode();
+ public static bool operator ==(SslApplicationProtocol left, SslApplicationProtocol right);
+ public static bool operator !=(SslApplicationProtocol left, SslApplicationProtocol right);
+ public override string ToString();
+ }
+ public class SslClientAuthenticationOptions {
+ public SslClientAuthenticationOptions();
+ public bool AllowRenegotiation { get; set; }
+ public List<SslApplicationProtocol> ApplicationProtocols { get; set; }
+ public X509RevocationMode CertificateRevocationCheckMode { get; set; }
+ public X509CertificateCollection ClientCertificates { get; set; }
+ public SslProtocols EnabledSslProtocols { get; set; }
+ public EncryptionPolicy EncryptionPolicy { get; set; }
+ public LocalCertificateSelectionCallback LocalCertificateSelectionCallback { get; set; }
+ public RemoteCertificateValidationCallback RemoteCertificateValidationCallback { get; set; }
+ public string TargetHost { get; set; }
+ }
+ public class SslServerAuthenticationOptions {
+ public SslServerAuthenticationOptions();
+ public bool AllowRenegotiation { get; set; }
+ public List<SslApplicationProtocol> ApplicationProtocols { get; set; }
+ public X509RevocationMode CertificateRevocationCheckMode { get; set; }
+ public bool ClientCertificateRequired { get; set; }
+ public SslProtocols EnabledSslProtocols { get; set; }
+ public EncryptionPolicy EncryptionPolicy { get; set; }
+ public RemoteCertificateValidationCallback RemoteCertificateValidationCallback { get; set; }
+ public X509Certificate ServerCertificate { get; set; }
+ }
public class SslStream : AuthenticatedStream {
+ public SslApplicationProtocol NegotiatedApplicationProtocol { get; }
+ public Task AuthenticateAsClientAsync(SslClientAuthenticationOptions sslClientAuthenticationOptions, CancellationToken cancellationToken);
+ public Task AuthenticateAsServerAsync(SslServerAuthenticationOptions sslClientAuthenticationOptions, CancellationToken cancellationToken);
}
}
```

26
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Net.Sockets.md Normal file
View File

@@ -0,0 +1,26 @@
# System.Net.Sockets
``` diff
namespace System.Net.Sockets {
public class Socket : IDisposable {
+ public int Receive(Span<byte> buffer);
+ public int Receive(Span<byte> buffer, SocketFlags socketFlags);
+ public int Receive(Span<byte> buffer, SocketFlags socketFlags, out SocketError errorCode);
+ public int Send(ReadOnlySpan<byte> buffer);
+ public int Send(ReadOnlySpan<byte> buffer, SocketFlags socketFlags);
+ public int Send(ReadOnlySpan<byte> buffer, SocketFlags socketFlags, out SocketError errorCode);
}
public class SocketAsyncEventArgs : EventArgs, IDisposable {
+ public Memory<byte> MemoryBuffer { get; }
+ public void SetBuffer(Memory<byte> buffer);
}
public static class SocketTaskExtensions {
+ public static ValueTask<int> ReceiveAsync(this Socket socket, Memory<byte> buffer, SocketFlags socketFlags, CancellationToken cancellationToken=default(CancellationToken));
+ public static ValueTask<int> SendAsync(this Socket socket, ReadOnlyMemory<byte> buffer, SocketFlags socketFlags, CancellationToken cancellationToken=default(CancellationToken));
}
+ public sealed class UnixDomainSocketEndPoint : EndPoint {
+ public UnixDomainSocketEndPoint(string path);
+ }
}
```

19
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Net.WebSockets.md Normal file
View File

@@ -0,0 +1,19 @@
# System.Net.WebSockets
``` diff
namespace System.Net.WebSockets {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct ValueWebSocketReceiveResult {
+ public ValueWebSocketReceiveResult(int count, WebSocketMessageType messageType, bool endOfMessage);
+ public int Count { get; }
+ public bool EndOfMessage { get; }
+ public WebSocketMessageType MessageType { get; }
+ }
public abstract class WebSocket : IDisposable {
+ public static WebSocket CreateFromStream(Stream stream, bool isServer, string subProtocol, TimeSpan keepAliveInterval, Memory<byte> buffer=default(Memory<byte>));
+ public virtual ValueTask<ValueWebSocketReceiveResult> ReceiveAsync(Memory<byte> buffer, CancellationToken cancellationToken);
+ public virtual Task SendAsync(ReadOnlyMemory<byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken);
}
}
```

15
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Net.md Normal file
View File

@@ -0,0 +1,15 @@
# System.Net
``` diff
namespace System.Net {
public class IPAddress {
+ public IPAddress(ReadOnlySpan<byte> address);
+ public IPAddress(ReadOnlySpan<byte> address, long scopeid);
+ public static IPAddress Parse(ReadOnlySpan<char> ipString);
+ public bool TryFormat(Span<char> destination, out int charsWritten);
+ public static bool TryParse(ReadOnlySpan<char> ipString, out IPAddress address);
+ public bool TryWriteBytes(Span<byte> destination, out int bytesWritten);
}
}
```

18
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Numerics.md Normal file
View File

@@ -0,0 +1,18 @@
# System.Numerics
``` diff
namespace System.Numerics {
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct BigInteger : IComparable, IComparable<BigInteger>, IEquatable<BigInteger>, IFormattable {
+ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned=false, bool isBigEndian=false);
+ public int GetByteCount(bool isUnsigned=false);
+ public static BigInteger Parse(ReadOnlySpan<char> value, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public byte[] ToByteArray(bool isUnsigned=false, bool isBigEndian=false);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> value, NumberStyles style, IFormatProvider provider, out BigInteger result);
+ public static bool TryParse(ReadOnlySpan<char> value, out BigInteger result);
+ public bool TryWriteBytes(Span<byte> destination, out int bytesWritten, bool isUnsigned=false, bool isBigEndian=false);
}
}
```

19
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Reflection.Emit.md Normal file
View File

@@ -0,0 +1,19 @@
# System.Reflection.Emit
``` diff
namespace System.Reflection.Emit {
public sealed class EnumBuilder : Type {
+ public override bool IsByRefLike { get; }
}
public sealed class GenericTypeParameterBuilder : Type {
+ public override bool IsByRefLike { get; }
}
public sealed class MethodBuilder : MethodInfo {
+ public override bool IsConstructedGenericMethod { get; }
}
public sealed class TypeBuilder : Type {
+ public override bool IsByRefLike { get; }
}
}
```

27
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Reflection.Metadata.md Normal file
View File

@@ -0,0 +1,27 @@
# System.Reflection.Metadata
``` diff
namespace System.Reflection.Metadata {
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct AssemblyDefinition {
+ public AssemblyName GetAssemblyName();
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct AssemblyReference {
+ public AssemblyName GetAssemblyName();
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct EventAccessors {
+ public ImmutableArray<MethodDefinitionHandle> Others { get; }
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct ModuleDefinition {
+ public CustomAttributeHandleCollection GetCustomAttributes();
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct PropertyAccessors {
+ public ImmutableArray<MethodDefinitionHandle> Others { get; }
}
}
```

24
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Reflection.md Normal file
View File

@@ -0,0 +1,24 @@
# System.Reflection
``` diff
namespace System.Reflection {
public abstract class Assembly : ICustomAttributeProvider, ISerializable {
+ public virtual Type[] GetForwardedTypes();
}
public enum BindingFlags {
+ DoNotWrapExceptions = 33554432,
}
public abstract class MemberInfo : ICustomAttributeProvider {
+ public virtual bool HasSameMetadataDefinitionAs(MemberInfo other);
}
public abstract class MethodBase : MemberInfo {
+ public virtual bool IsConstructedGenericMethod { get; }
}
public class TypeDelegator : TypeInfo {
+ public override bool IsByRefLike { get; }
+ public override bool IsGenericMethodParameter { get; }
+ public override bool IsGenericTypeParameter { get; }
}
}
```

13
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Runtime.CompilerServices.md Normal file
View File

@@ -0,0 +1,13 @@
# System.Runtime.CompilerServices
``` diff
namespace System.Runtime.CompilerServices {
public static class RuntimeFeature {
+ public const string PortablePdb = "PortablePdb";
}
public sealed class RuntimeWrappedException : Exception {
+ public RuntimeWrappedException(object thrownObject);
}
}
```

13
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Runtime.InteropServices.md Normal file
View File

@@ -0,0 +1,13 @@
# System.Runtime.InteropServices
``` diff
namespace System.Runtime.InteropServices {
+ public static class MemoryMarshal {
+ public static Memory<T> AsMemory<T>(ReadOnlyMemory<T> readOnlyMemory);
+ public static ref T GetReference<T>(ReadOnlySpan<T> span);
+ public static ref T GetReference<T>(Span<T> span);
+ public static bool TryGetArray<T>(ReadOnlyMemory<T> readOnlyMemory, out ArraySegment<T> arraySegment);
+ }
}
```

1360
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Runtime.Intrinsics.X86.md Normal file
View File

File diff suppressed because it is too large Load Diff

11
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Runtime.Intrinsics.md Normal file
View File

@@ -0,0 +1,11 @@
# System.Runtime.Intrinsics
``` diff
+namespace System.Runtime.Intrinsics {
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=16)]
+ public struct Vector128<T> where T : struct
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=32)]
+ public struct Vector256<T> where T : struct
+}
```

15
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Security.Cryptography.X509Certificates.md Normal file
View File

@@ -0,0 +1,15 @@
# System.Security.Cryptography.X509Certificates
``` diff
namespace System.Security.Cryptography.X509Certificates {
public class X509Certificate : IDeserializationCallback, IDisposable, ISerializable {
+ public virtual byte[] GetCertHash(HashAlgorithmName hashAlgorithm);
+ public virtual string GetCertHashString(HashAlgorithmName hashAlgorithm);
+ public virtual bool TryGetCertHash(HashAlgorithmName hashAlgorithm, Span<byte> destination, out int bytesWritten);
}
public class X509CertificateCollection : CollectionBase {
+ protected override void OnValidate(object value);
}
}
```

89
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Security.Cryptography.md Normal file
View File

@@ -0,0 +1,89 @@
# System.Security.Cryptography
``` diff
namespace System.Security.Cryptography {
public class CryptoStream : Stream, IDisposable {
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state);
+ public override int EndRead(IAsyncResult asyncResult);
+ public override void EndWrite(IAsyncResult asyncResult);
}
public abstract class DSA : AsymmetricAlgorithm {
+ public virtual bool TryCreateSignature(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
+ protected virtual bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+ public virtual bool TrySignData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+ public virtual bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm);
+ public virtual bool VerifySignature(ReadOnlySpan<byte> rgbHash, ReadOnlySpan<byte> rgbSignature);
}
public abstract class ECDsa : AsymmetricAlgorithm {
+ protected virtual bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+ public virtual bool TrySignData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+ public virtual bool TrySignHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
+ public virtual bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm);
+ public virtual bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature);
}
public abstract class HashAlgorithm : ICryptoTransform, IDisposable {
+ protected virtual void HashCore(ReadOnlySpan<byte> source);
+ public bool TryComputeHash(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten);
+ protected virtual bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public abstract class HMAC : KeyedHashAlgorithm {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public class HMACMD5 : HMAC {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public class HMACSHA1 : HMAC {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public class HMACSHA256 : HMAC {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public class HMACSHA384 : HMAC {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public class HMACSHA512 : HMAC {
+ protected override void HashCore(ReadOnlySpan<byte> source);
+ protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public sealed class IncrementalHash : IDisposable {
+ public void AppendData(ReadOnlySpan<byte> data);
+ public bool TryGetHashAndReset(Span<byte> destination, out int bytesWritten);
}
public abstract class RandomNumberGenerator : IDisposable {
+ public virtual void GetBytes(Span<byte> data);
+ public virtual void GetNonZeroBytes(Span<byte> data);
}
public abstract class RSA : AsymmetricAlgorithm {
+ public virtual bool TryDecrypt(ReadOnlySpan<byte> source, Span<byte> destination, RSAEncryptionPadding padding, out int bytesWritten);
+ public virtual bool TryEncrypt(ReadOnlySpan<byte> source, Span<byte> destination, RSAEncryptionPadding padding, out int bytesWritten);
+ protected virtual bool TryHashData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, out int bytesWritten);
+ public virtual bool TrySignData(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding, out int bytesWritten);
+ public virtual bool TrySignHash(ReadOnlySpan<byte> source, Span<byte> destination, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding, out int bytesWritten);
+ public virtual bool VerifyData(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
+ public virtual bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding);
}
public sealed class SHA1Managed : SHA1 {
+ protected sealed override void HashCore(ReadOnlySpan<byte> source);
+ protected sealed override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public sealed class SHA256Managed : SHA256 {
+ protected sealed override void HashCore(ReadOnlySpan<byte> source);
+ protected sealed override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public sealed class SHA384Managed : SHA384 {
+ protected sealed override void HashCore(ReadOnlySpan<byte> source);
+ protected sealed override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
public sealed class SHA512Managed : SHA512 {
+ protected sealed override void HashCore(ReadOnlySpan<byte> source);
+ protected sealed override bool TryHashFinal(Span<byte> destination, out int bytesWritten);
}
}
```

22
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Text.RegularExpressions.md Normal file
View File

@@ -0,0 +1,22 @@
# System.Text.RegularExpressions
``` diff
namespace System.Text.RegularExpressions {
public class Regex : ISerializable {
+ public static void CompileToAssembly(RegexCompilationInfo[] regexinfos, AssemblyName assemblyname);
+ public static void CompileToAssembly(RegexCompilationInfo[] regexinfos, AssemblyName assemblyname, CustomAttributeBuilder[] attributes);
+ public static void CompileToAssembly(RegexCompilationInfo[] regexinfos, AssemblyName assemblyname, CustomAttributeBuilder[] attributes, string resourceFile);
}
+ public class RegexCompilationInfo {
+ public RegexCompilationInfo(string pattern, RegexOptions options, string name, string fullnamespace, bool ispublic);
+ public RegexCompilationInfo(string pattern, RegexOptions options, string name, string fullnamespace, bool ispublic, TimeSpan matchTimeout);
+ public bool IsPublic { get; set; }
+ public TimeSpan MatchTimeout { get; set; }
+ public string Name { get; set; }
+ public string Namespace { get; set; }
+ public RegexOptions Options { get; set; }
+ public string Pattern { get; set; }
+ }
}
```

33
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Text.md Normal file
View File

@@ -0,0 +1,33 @@
# System.Text
``` diff
namespace System.Text {
public abstract class Decoder {
+ public virtual void Convert(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush, out int bytesUsed, out int charsUsed, out bool completed);
+ public virtual int GetCharCount(ReadOnlySpan<byte> bytes, bool flush);
+ public virtual int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars, bool flush);
}
public abstract class Encoder {
+ public virtual void Convert(ReadOnlySpan<char> chars, Span<byte> bytes, bool flush, out int charsUsed, out int bytesUsed, out bool completed);
+ public virtual int GetByteCount(ReadOnlySpan<char> chars, bool flush);
+ public virtual int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes, bool flush);
}
public abstract class Encoding : ICloneable {
+ public virtual ReadOnlySpan<byte> Preamble { get; }
+ public virtual int GetByteCount(ReadOnlySpan<char> chars);
+ public virtual int GetBytes(ReadOnlySpan<char> chars, Span<byte> bytes);
+ public virtual int GetCharCount(ReadOnlySpan<byte> bytes);
+ public virtual int GetChars(ReadOnlySpan<byte> bytes, Span<char> chars);
+ public string GetString(ReadOnlySpan<byte> bytes);
}
public sealed class StringBuilder : ISerializable {
+ public StringBuilder Append(ReadOnlySpan<char> value);
+ public StringBuilder Append(StringBuilder value);
+ public StringBuilder Append(StringBuilder value, int startIndex, int count);
+ public void CopyTo(int sourceIndex, Span<char> destination, int count);
+ public bool Equals(ReadOnlySpan<char> value);
+ public StringBuilder Insert(int index, ReadOnlySpan<char> value);
}
}
```

14
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.Threading.md Normal file
View File

@@ -0,0 +1,14 @@
# System.Threading
``` diff
namespace System.Threading {
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
+ public CancellationToken Token { get; }
}
public static class ThreadPool {
+ public static bool QueueUserWorkItem(WaitCallback callBack, object state, bool preferLocal);
}
}
```

413
release-notes/2.1/Preview/api-diff/preview1/2.1-preview1_System.md Normal file
View File

@@ -0,0 +1,413 @@
# System
``` diff
namespace System {
- public class ArgumentException : SystemException, ISerializable
+ public class ArgumentException : SystemException
- public class ArgumentOutOfRangeException : ArgumentException, ISerializable
+ public class ArgumentOutOfRangeException : ArgumentException
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct ArraySegment<T> : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
- void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
}
public static class BitConverter {
+ public static bool ToBoolean(ReadOnlySpan<byte> value);
+ public static char ToChar(ReadOnlySpan<byte> value);
+ public static double ToDouble(ReadOnlySpan<byte> value);
+ public static short ToInt16(ReadOnlySpan<byte> value);
+ public static int ToInt32(ReadOnlySpan<byte> value);
+ public static long ToInt64(ReadOnlySpan<byte> value);
+ public static float ToSingle(ReadOnlySpan<byte> value);
+ public static ushort ToUInt16(ReadOnlySpan<byte> value);
+ public static uint ToUInt32(ReadOnlySpan<byte> value);
+ public static ulong ToUInt64(ReadOnlySpan<byte> value);
+ public static bool TryWriteBytes(Span<byte> destination, bool value);
+ public static bool TryWriteBytes(Span<byte> destination, char value);
+ public static bool TryWriteBytes(Span<byte> destination, double value);
+ public static bool TryWriteBytes(Span<byte> destination, short value);
+ public static bool TryWriteBytes(Span<byte> destination, int value);
+ public static bool TryWriteBytes(Span<byte> destination, long value);
+ public static bool TryWriteBytes(Span<byte> destination, float value);
+ public static bool TryWriteBytes(Span<byte> destination, ushort value);
+ public static bool TryWriteBytes(Span<byte> destination, uint value);
+ public static bool TryWriteBytes(Span<byte> destination, ulong value);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool> {
+ public static Boolean Parse(ReadOnlySpan<char> value);
+ public Boolean TryFormat(Span<char> destination, out int charsWritten);
+ public static Boolean TryParse(ReadOnlySpan<char> value, out Boolean result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable {
+ public static Byte Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, out Byte result);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Byte result);
}
public static class Convert {
+ public static string ToBase64String(ReadOnlySpan<byte> bytes, Base64FormattingOptions options=(Base64FormattingOptions)(0));
+ public static bool TryFromBase64Chars(ReadOnlySpan<char> chars, Span<byte> bytes, out int bytesWritten);
+ public static bool TryFromBase64String(string s, Span<byte> bytes, out int bytesWritten);
+ public static bool TryToBase64Chars(ReadOnlySpan<byte> bytes, Span<char> chars, out int charsWritten, Base64FormattingOptions options=(Base64FormattingOptions)(0));
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, ISerializable {
+ public static readonly DateTime UnixEpoch;
+ public static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider provider=null, DateTimeStyles styles=(DateTimeStyles)(0));
+ public static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style=(DateTimeStyles)(0));
+ public static DateTime ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style=(DateTimeStyles)(0));
- int System.IComparable.CompareTo(object value);
- TypeCode System.IConvertible.GetTypeCode();
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, out DateTime result);
+ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider provider, DateTimeStyles styles, out DateTime result);
+ public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style, out DateTime result);
+ public static bool TryParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style, out DateTime result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable {
+ public static readonly DateTimeOffset UnixEpoch;
+ public static DateTimeOffset Parse(ReadOnlySpan<char> input, IFormatProvider formatProvider=null, DateTimeStyles styles=(DateTimeStyles)(0));
+ public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, DateTimeStyles styles=(DateTimeStyles)(0));
+ public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles=(DateTimeStyles)(0));
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider formatProvider=null);
+ public static bool TryParse(ReadOnlySpan<char> input, out DateTimeOffset result);
+ public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable {
+ public static Decimal Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, out Decimal result);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Decimal result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable {
+ public static bool IsFinite(Double d);
+ public static bool IsNegative(Double d);
+ public static bool IsNormal(Double d);
+ public static bool IsSubnormal(Double d);
+ public static Double Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, out Double result);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Double result);
}
- public class DuplicateWaitObjectException : ArgumentException, ISerializable
+ public class DuplicateWaitObjectException : ArgumentException
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable {
- TypeCode System.IConvertible.GetTypeCode();
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable {
+ public Guid(ReadOnlySpan<byte> b);
+ public static Guid Parse(ReadOnlySpan<char> input);
+ public static Guid ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>));
+ public static bool TryParse(ReadOnlySpan<char> input, out Guid result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, out Guid result);
+ public bool TryWriteBytes(Span<byte> destination);
}
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct HashCode {
+ public void Add<T>(T value);
+ public void Add<T>(T value, IEqualityComparer<T> comparer);
+ public static int Combine<T1, T2, T3, T4, T5, T6, T7, T8>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8);
+ public static int Combine<T1, T2, T3, T4, T5, T6, T7>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7);
+ public static int Combine<T1, T2, T3, T4, T5, T6>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6);
+ public static int Combine<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5);
+ public static int Combine<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4);
+ public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3);
+ public static int Combine<T1, T2>(T1 value1, T2 value2);
+ public static int Combine<T1>(T1 value1);
+ public override bool Equals(object obj);
+ public override int GetHashCode();
+ public int ToHashCode();
+ }
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable {
+ public static Int16 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int16 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out Int16 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable {
+ public static Int32 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out Int32 charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int32 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out Int32 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable {
+ public static Int64 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int64 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out Int64 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct IntPtr : IEquatable<IntPtr>, ISerializable {
- bool System.IEquatable<System.IntPtr>.Equals(IntPtr other);
+ bool System.IEquatable<System.IntPtr>.Equals(IntPtr value);
}
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct Memory<T> {
+ public Memory(T[] array);
+ public Memory(T[] array, int start, int length);
+ public static Memory<T> Empty { get; }
+ public bool IsEmpty { get; }
+ public int Length { get; }
+ public Span<T> Span { get; }
+ public void CopyTo(Memory<T> destination);
+ public bool Equals(Memory<T> other);
+ public override bool Equals(object obj);
+ public override int GetHashCode();
+ public static implicit operator Memory<T> (ArraySegment<T> arraySegment);
+ public static implicit operator ReadOnlyMemory<T> (Memory<T> memory);
+ public static implicit operator Memory<T> (T[] array);
+ public MemoryHandle Retain(bool pin=false);
+ public Memory<T> Slice(int start);
+ public Memory<T> Slice(int start, int length);
+ public T[] ToArray();
+ public bool TryCopyTo(Memory<T> destination);
+ public bool TryGetArray(out ArraySegment<T> arraySegment);
+ }
+ public static class MemoryExtensions {
+ public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> source) where T : struct;
+ public static Span<byte> AsBytes<T>(this Span<T> source) where T : struct;
+ public static ReadOnlyMemory<char> AsReadOnlyMemory(this string text);
+ public static ReadOnlyMemory<char> AsReadOnlyMemory(this string text, int start);
+ public static ReadOnlyMemory<char> AsReadOnlyMemory(this string text, int start, int length);
+ public static ReadOnlyMemory<T> AsReadOnlyMemory<T>(this Memory<T> memory);
+ public static ReadOnlySpan<char> AsReadOnlySpan(this string text);
+ public static ReadOnlySpan<char> AsReadOnlySpan(this string text, int start);
+ public static ReadOnlySpan<char> AsReadOnlySpan(this string text, int start, int length);
+ public static ReadOnlySpan<T> AsReadOnlySpan<T>(this ArraySegment<T> arraySegment);
+ public static ReadOnlySpan<T> AsReadOnlySpan<T>(this Span<T> span);
+ public static ReadOnlySpan<T> AsReadOnlySpan<T>(this T[] array);
+ public static Span<T> AsSpan<T>(this ArraySegment<T> arraySegment);
+ public static Span<T> AsSpan<T>(this T[] array);
+ public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>;
+ public static int BinarySearch<T, TComparable>(this Span<T> span, TComparable comparable) where TComparable : IComparable<T>;
+ public static int BinarySearch<T, TComparer>(this ReadOnlySpan<T> span, T value, TComparer comparer) where TComparer : IComparer<T>;
+ public static int BinarySearch<T, TComparer>(this Span<T> span, T value, TComparer comparer) where TComparer : IComparer<T>;
+ public static int BinarySearch<T>(this ReadOnlySpan<T> span, IComparable<T> comparable);
+ public static int BinarySearch<T>(this Span<T> span, IComparable<T> comparable);
+ public static void CopyTo<T>(this T[] array, Memory<T> destination);
+ public static void CopyTo<T>(this T[] array, Span<T> destination);
+ public static bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static bool EndsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
+ public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static int IndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>;
+ public static int IndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+ public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
+ public static int LastIndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static int LastIndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>;
+ public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+ public static ReadOnlySpan<TTo> NonPortableCast<TFrom, TTo>(this ReadOnlySpan<TFrom> source) where TFrom : struct where TTo : struct;
+ public static Span<TTo> NonPortableCast<TFrom, TTo>(this Span<TFrom> source) where TFrom : struct where TTo : struct;
+ public static bool Overlaps<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second);
+ public static bool Overlaps<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second, out int elementOffset);
+ public static bool Overlaps<T>(this Span<T> first, ReadOnlySpan<T> second);
+ public static bool Overlaps<T>(this Span<T> first, ReadOnlySpan<T> second, out int elementOffset);
+ public static void Reverse<T>(this Span<T> span);
+ public static int SequenceCompareTo<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : IComparable<T>;
+ public static int SequenceCompareTo<T>(this Span<T> first, ReadOnlySpan<T> second) where T : IComparable<T>;
+ public static bool SequenceEqual<T>(this ReadOnlySpan<T> first, ReadOnlySpan<T> second) where T : IEquatable<T>;
+ public static bool SequenceEqual<T>(this Span<T> first, ReadOnlySpan<T> second) where T : IEquatable<T>;
+ public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+ public static bool TryGetString(this ReadOnlyMemory<char> readOnlyMemory, out string text, out int start, out int length);
+ }
- public class MissingMethodException : MissingMemberException, ISerializable
+ public class MissingMethodException : MissingMemberException
public class Random {
+ public virtual void NextBytes(Span<byte> buffer);
}
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct ReadOnlyMemory<T> {
+ public ReadOnlyMemory(T[] array);
+ public ReadOnlyMemory(T[] array, int start, int length);
+ public static ReadOnlyMemory<T> Empty { get; }
+ public bool IsEmpty { get; }
+ public int Length { get; }
+ public ReadOnlySpan<T> Span { get; }
+ public void CopyTo(Memory<T> destination);
+ public override bool Equals(object obj);
+ public bool Equals(ReadOnlyMemory<T> other);
+ public override int GetHashCode();
+ public static implicit operator ReadOnlyMemory<T> (ArraySegment<T> arraySegment);
+ public static implicit operator ReadOnlyMemory<T> (T[] array);
+ public MemoryHandle Retain(bool pin=false);
+ public ReadOnlyMemory<T> Slice(int start);
+ public ReadOnlyMemory<T> Slice(int start, int length);
+ public T[] ToArray();
+ public bool TryCopyTo(Memory<T> destination);
+ }
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct ReadOnlySpan<T> {
+ public unsafe ReadOnlySpan(void* pointer, int length);
+ public ReadOnlySpan(T[] array);
+ public ReadOnlySpan(T[] array, int start, int length);
+ public static ReadOnlySpan<T> Empty { get; }
+ public bool IsEmpty { get; }
+ public int Length { get; }
+ public ref T this[int index] { get; }
+ public void CopyTo(Span<T> destination);
+ public static ReadOnlySpan<T> DangerousCreate(object obj, ref T objectData, int length);
+ public override bool Equals(object obj);
+ public ReadOnlySpan<T>.Enumerator GetEnumerator();
+ public override int GetHashCode();
+ public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+ public static implicit operator ReadOnlySpan<T> (ArraySegment<T> arraySegment);
+ public static implicit operator ReadOnlySpan<T> (T[] array);
+ public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+ public ReadOnlySpan<T> Slice(int start);
+ public ReadOnlySpan<T> Slice(int start, int length);
+ public T[] ToArray();
+ public bool TryCopyTo(Span<T> destination);
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct Enumerator {
+ public ref T Current { get; }
+ public bool MoveNext();
+ }
+ }
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable {
+ public static SByte Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out SByte result);
+ public static bool TryParse(ReadOnlySpan<char> s, out SByte result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable {
+ public static bool IsFinite(Single f);
+ public static bool IsNegative(Single f);
+ public static bool IsNormal(Single f);
+ public static bool IsSubnormal(Single f);
+ public static Single Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Single result);
+ public static bool TryParse(ReadOnlySpan<char> s, out Single result);
}
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct Span<T> {
+ public unsafe Span(void* pointer, int length);
+ public Span(T[] array);
+ public Span(T[] array, int start, int length);
+ public static Span<T> Empty { get; }
+ public bool IsEmpty { get; }
+ public int Length { get; }
+ public ref T this[int index] { get; }
+ public void Clear();
+ public void CopyTo(Span<T> destination);
+ public static Span<T> DangerousCreate(object obj, ref T objectData, int length);
+ public override bool Equals(object obj);
+ public void Fill(T value);
+ public Span<T>.Enumerator GetEnumerator();
+ public override int GetHashCode();
+ public static bool operator ==(Span<T> left, Span<T> right);
+ public static implicit operator Span<T> (ArraySegment<T> arraySegment);
+ public static implicit operator ReadOnlySpan<T> (Span<T> span);
+ public static implicit operator Span<T> (T[] array);
+ public static bool operator !=(Span<T> left, Span<T> right);
+ public Span<T> Slice(int start);
+ public Span<T> Slice(int start, int length);
+ public T[] ToArray();
+ public bool TryCopyTo(Span<T> destination);
+ [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+ public struct Enumerator {
+ public ref T Current { get; }
+ public bool MoveNext();
+ }
+ }
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
+ public String(ReadOnlySpan<char> value);
+ public bool Contains(char value);
+ public bool Contains(char value, StringComparison comparisonType);
+ public bool Contains(String value, StringComparison comparisonType);
+ public static String Create<TState>(int length, TState state, SpanAction<char, TState> action);
+ public int IndexOf(char value, StringComparison comparisonType);
+ public static implicit operator ReadOnlySpan<char> (String value);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable {
+ public static TimeSpan Parse(ReadOnlySpan<char> input, IFormatProvider formatProvider=null);
+ public static TimeSpan ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles=(TimeSpanStyles)(0));
+ public static TimeSpan ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles=(TimeSpanStyles)(0));
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider formatProvider=null);
+ public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result);
+ public static bool TryParse(ReadOnlySpan<char> s, out TimeSpan result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+ public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
}
public abstract class Type : MemberInfo, IReflect {
+ public virtual bool IsByRefLike { get; }
+ public virtual bool IsGenericMethodParameter { get; }
+ public virtual bool IsGenericTypeParameter { get; }
+ public virtual bool IsSignatureType { get; }
+ public MethodInfo GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+ public MethodInfo GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers);
+ public MethodInfo GetMethod(string name, int genericParameterCount, Type[] types);
+ public MethodInfo GetMethod(string name, int genericParameterCount, Type[] types, ParameterModifier[] modifiers);
+ protected virtual MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+ public static Type MakeGenericMethodParameter(int position);
}
- public class TypeUnloadedException : SystemException, ISerializable
+ public class TypeUnloadedException : SystemException
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable {
+ public static UInt16 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt16 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out UInt16 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable {
+ public static UInt32 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt32 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out UInt32 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable {
+ public static UInt64 Parse(ReadOnlySpan<char> s, NumberStyles style=(NumberStyles)(7), IFormatProvider provider=null);
+ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format=default(ReadOnlySpan<char>), IFormatProvider provider=null);
+ public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt64 result);
+ public static bool TryParse(ReadOnlySpan<char> s, out UInt64 result);
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct UIntPtr : IEquatable<UIntPtr>, ISerializable {
- bool System.IEquatable<System.UIntPtr>.Equals(UIntPtr other);
+ bool System.IEquatable<System.UIntPtr>.Equals(UIntPtr value);
}
public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version> {
+ public static Version Parse(ReadOnlySpan<char> input);
+ public bool TryFormat(Span<char> destination, out int charsWritten);
+ public bool TryFormat(Span<char> destination, int fieldCount, out int charsWritten);
+ public static bool TryParse(ReadOnlySpan<char> input, out Version result);
}
}
```