2018-05-26 00:28:02 +02:00
# System
``` diff
namespace System {
- public class ArgumentException : SystemException, ISerializable
+ public class ArgumentException : SystemException
- public class ArgumentOutOfRangeException : ArgumentException, ISerializable
+ public class ArgumentOutOfRangeException : ArgumentException
2018-06-06 20:43:50 +02:00
- public struct ArraySegment< T > : ICollection< T > , IEnumerable, IEnumerable< T > , IList< T > , IReadOnlyCollection< T > , IReadOnlyList< T > {
+ public readonly struct ArraySegment< T > : ICollection< T > , IEnumerable, IEnumerable< T > , IList< T > , IReadOnlyCollection< T > , IReadOnlyList< T > {
2018-05-26 00:28:02 +02:00
- 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);
}
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);
}
public struct Byte : IComparable, IComparable< byte > , IConvertible, IEquatable< byte > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, out Byte result);
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Byte result);
}
2018-06-06 20:43:50 +02:00
- public struct ConsoleKeyInfo
+ public readonly struct ConsoleKeyInfo
2018-05-26 00:28:02 +02:00
public static class Convert {
2018-06-06 20:43:50 +02:00
+ public static string ToBase64String(ReadOnlySpan< byte > bytes, Base64FormattingOptions options = (Base64FormattingOptions)(0));
2018-05-26 00:28:02 +02:00
+ 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);
2018-06-06 20:43:50 +02:00
+ public static bool TryToBase64Chars(ReadOnlySpan< byte > bytes, Span< char > chars, out int charsWritten, Base64FormattingOptions options = (Base64FormattingOptions)(0));
2018-05-26 00:28:02 +02:00
}
2018-06-06 20:43:50 +02:00
- public struct DateTime : IComparable, IComparable< DateTime > , IConvertible, IEquatable< DateTime > , IFormattable, ISerializable {
+ public readonly struct DateTime : IComparable, IComparable< DateTime > , IConvertible, IEquatable< DateTime > , IFormattable, ISerializable {
2018-05-26 00:28:02 +02:00
+ public static readonly DateTime UnixEpoch;
2018-06-06 20:43:50 +02:00
+ 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));
2018-05-26 00:28:02 +02:00
- int System.IComparable.CompareTo(object value);
- TypeCode System.IConvertible.GetTypeCode();
2018-06-06 20:43:50 +02:00
+ public bool TryFormat(Span< char > destination, out int charsWritten, ReadOnlySpan< char > format = default(ReadOnlySpan< char > ), IFormatProvider provider = null);
2018-05-26 00:28:02 +02:00
+ 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);
}
public struct DateTimeOffset : IComparable, IComparable< DateTimeOffset > , IDeserializationCallback, IEquatable< DateTimeOffset > , IFormattable, ISerializable {
+ public static readonly DateTimeOffset UnixEpoch;
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ 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);
}
public struct Decimal : IComparable, IComparable< decimal > , IConvertible, IDeserializationCallback, IEquatable< decimal > , IFormattable {
2018-06-06 20:43:50 +02:00
+ public static Decimal Parse(ReadOnlySpan< char > s, NumberStyles style = (NumberStyles)(111), IFormatProvider provider = null);
+ public bool TryFormat(Span< char > destination, out int charsWritten, ReadOnlySpan< char > format = default(ReadOnlySpan< char > ), IFormatProvider provider = null);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, out Decimal result);
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Decimal result);
}
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);
2018-06-06 20:43:50 +02:00
+ public static Double Parse(ReadOnlySpan< char > s, NumberStyles style = (NumberStyles)(231), IFormatProvider provider = null);
+ public bool TryFormat(Span< char > destination, out int charsWritten, ReadOnlySpan< char > format = default(ReadOnlySpan< char > ), IFormatProvider provider = null);
2018-05-26 00:28:02 +02:00
+ 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();
}
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);
2018-06-06 20:43:50 +02:00
+ public bool TryFormat(Span< char > destination, out int charsWritten, ReadOnlySpan< char > format = default(ReadOnlySpan< char > ));
2018-05-26 00:28:02 +02:00
+ 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);
}
+ 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();
+ }
public struct Int16 : IComparable, IComparable< short > , IConvertible, IEquatable< short > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Int16 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out Int16 result);
}
public struct Int32 : IComparable, IComparable< int > , IConvertible, IEquatable< int > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Int32 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out Int32 result);
}
public struct Int64 : IComparable, IComparable< long > , IConvertible, IEquatable< long > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Int64 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out Int64 result);
}
public static class Math {
+ public static double Acosh(double d);
+ public static double Asinh(double d);
+ public static double Atanh(double d);
+ public static double Cbrt(double d);
}
public static class MathF {
+ public static float Acosh(float x);
+ public static float Asinh(float x);
+ public static float Atanh(float x);
+ public static float Cbrt(float x);
}
2018-06-06 20:43:50 +02:00
+ public readonly struct Memory< T > {
2018-05-26 00:28:02 +02:00
+ 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 > segment);
+ public static implicit operator ReadOnlyMemory< T > (Memory< T > memory);
+ public static implicit operator Memory< T > (T[] array);
+ public MemoryHandle Pin();
+ public Memory< T > Slice(int start);
+ public Memory< T > Slice(int start, int length);
+ public T[] ToArray();
+ public override string ToString();
+ public bool TryCopyTo(Memory< T > destination);
+ }
+ public static class MemoryExtensions {
+ public static ReadOnlyMemory< char > AsMemory(this string text);
+ public static ReadOnlyMemory< char > AsMemory(this string text, int start);
+ public static ReadOnlyMemory< char > AsMemory(this string text, int start, int length);
+ public static Memory< T > AsMemory< T > (this ArraySegment< T > segment);
+ public static Memory< T > AsMemory< T > (this ArraySegment< T > segment, int start);
+ public static Memory< T > AsMemory< T > (this ArraySegment< T > segment, int start, int length);
+ public static Memory< T > AsMemory< T > (this T[] array);
+ public static Memory< T > AsMemory< T > (this T[] array, int start);
+ public static Memory< T > AsMemory< T > (this T[] array, int start, int length);
+ public static ReadOnlySpan< char > AsSpan(this string text);
+ public static ReadOnlySpan< char > AsSpan(this string text, int start);
+ public static ReadOnlySpan< char > AsSpan(this string text, int start, int length);
+ public static Span< T > AsSpan< T > (this ArraySegment< T > segment);
+ public static Span< T > AsSpan< T > (this ArraySegment< T > segment, int start);
+ public static Span< T > AsSpan< T > (this ArraySegment< T > segment, int start, int length);
+ public static Span< T > AsSpan< T > (this T[] array);
+ public static Span< T > AsSpan< T > (this T[] array, int start);
+ public static Span< T > AsSpan< T > (this T[] array, int start, int length);
+ 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 int CompareTo(this ReadOnlySpan< char > span, ReadOnlySpan< char > other, StringComparison comparisonType);
+ public static bool Contains(this ReadOnlySpan< char > span, ReadOnlySpan< char > value, StringComparison comparisonType);
+ public static void CopyTo< T > (this T[] source, Memory< T > destination);
+ public static void CopyTo< T > (this T[] source, Span< T > destination);
+ public static bool EndsWith(this ReadOnlySpan< char > span, ReadOnlySpan< char > value, StringComparison comparisonType);
+ 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 bool Equals(this ReadOnlySpan< char > span, ReadOnlySpan< char > other, StringComparison comparisonType);
+ public static int IndexOf(this ReadOnlySpan< char > span, ReadOnlySpan< char > value, StringComparison comparisonType);
+ 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 bool IsWhiteSpace(this ReadOnlySpan< char > span);
+ 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 bool Overlaps< T > (this ReadOnlySpan< T > span, ReadOnlySpan< T > other);
+ public static bool Overlaps< T > (this ReadOnlySpan< T > span, ReadOnlySpan< T > other, out int elementOffset);
+ public static bool Overlaps< T > (this Span< T > span, ReadOnlySpan< T > other);
+ public static bool Overlaps< T > (this Span< T > span, ReadOnlySpan< T > other, out int elementOffset);
+ public static void Reverse< T > (this Span< T > span);
+ public static int SequenceCompareTo< T > (this ReadOnlySpan< T > span, ReadOnlySpan< T > other) where T : IComparable< T > ;
+ public static int SequenceCompareTo< T > (this Span< T > span, ReadOnlySpan< T > other) where T : IComparable< T > ;
+ public static bool SequenceEqual< T > (this ReadOnlySpan< T > span, ReadOnlySpan< T > other) where T : IEquatable< T > ;
+ public static bool SequenceEqual< T > (this Span< T > span, ReadOnlySpan< T > other) where T : IEquatable< T > ;
+ public static bool StartsWith(this ReadOnlySpan< char > span, ReadOnlySpan< char > value, StringComparison comparisonType);
+ 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 int ToLower(this ReadOnlySpan< char > source, Span< char > destination, CultureInfo culture);
+ public static int ToLowerInvariant(this ReadOnlySpan< char > source, Span< char > destination);
+ public static int ToUpper(this ReadOnlySpan< char > source, Span< char > destination, CultureInfo culture);
+ public static int ToUpperInvariant(this ReadOnlySpan< char > source, Span< char > destination);
+ public static ReadOnlySpan< char > Trim(this ReadOnlySpan< char > span);
+ public static ReadOnlySpan< char > Trim(this ReadOnlySpan< char > span, char trimChar);
+ public static ReadOnlySpan< char > Trim(this ReadOnlySpan< char > span, ReadOnlySpan< char > trimChars);
+ public static ReadOnlySpan< char > TrimEnd(this ReadOnlySpan< char > span);
+ public static ReadOnlySpan< char > TrimEnd(this ReadOnlySpan< char > span, char trimChar);
+ public static ReadOnlySpan< char > TrimEnd(this ReadOnlySpan< char > span, ReadOnlySpan< char > trimChars);
+ public static ReadOnlySpan< char > TrimStart(this ReadOnlySpan< char > span);
+ public static ReadOnlySpan< char > TrimStart(this ReadOnlySpan< char > span, char trimChar);
+ public static ReadOnlySpan< char > TrimStart(this ReadOnlySpan< char > span, ReadOnlySpan< char > trimChars);
+ }
- public class MissingMethodException : MissingMemberException, ISerializable
+ public class MissingMethodException : MissingMemberException
public class Random {
+ public virtual void NextBytes(Span< byte > buffer);
}
2018-06-06 20:43:50 +02:00
+ public readonly struct ReadOnlyMemory< T > {
2018-05-26 00:28:02 +02:00
+ 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 > segment);
+ public static implicit operator ReadOnlyMemory< T > (T[] array);
+ public MemoryHandle Pin();
+ public ReadOnlyMemory< T > Slice(int start);
+ public ReadOnlyMemory< T > Slice(int start, int length);
+ public T[] ToArray();
+ public override string ToString();
+ public bool TryCopyTo(Memory< T > destination);
+ }
2018-06-06 20:43:50 +02:00
+ public readonly ref struct ReadOnlySpan< T > {
2018-05-26 00:28:02 +02:00
+ 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; }
2018-06-06 20:43:50 +02:00
+ public ref readonly T this[int index] { get; }
2018-05-26 00:28:02 +02:00
+ public void CopyTo(Span< T > destination);
+ public override bool Equals(object obj);
+ public ReadOnlySpan< T > .Enumerator GetEnumerator();
+ public override int GetHashCode();
2018-06-06 20:43:50 +02:00
+ public ref readonly T GetPinnableReference();
2018-05-26 00:28:02 +02:00
+ public static bool operator ==(ReadOnlySpan< T > left, ReadOnlySpan< T > right);
+ public static implicit operator ReadOnlySpan< T > (ArraySegment< T > segment);
+ 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 override string ToString();
+ public bool TryCopyTo(Span< T > destination);
2018-06-06 20:43:50 +02:00
+ public ref struct Enumerator {
+ public ref readonly T Current { get; }
2018-05-26 00:28:02 +02:00
+ public bool MoveNext();
+ }
+ }
2018-06-06 20:43:50 +02:00
- public struct RuntimeArgumentHandle
+ public ref struct RuntimeArgumentHandle
2018-05-26 00:28:02 +02:00
public struct SByte : IComparable, IComparable< sbyte > , IConvertible, IEquatable< sbyte > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out SByte result);
+ public static bool TryParse(ReadOnlySpan< char > s, out SByte result);
}
2018-06-06 20:43:50 +02:00
+ public readonly struct SequencePosition : IEquatable< SequencePosition > {
2018-05-26 00:28:02 +02:00
+ public SequencePosition(object @object , int integer);
+ public override bool Equals(object obj);
+ public bool Equals(SequencePosition other);
+ public override int GetHashCode();
+ public int GetInteger();
+ public object GetObject();
+ }
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);
2018-06-06 20:43:50 +02:00
+ public static Single Parse(ReadOnlySpan< char > s, NumberStyles style = (NumberStyles)(231), IFormatProvider provider = null);
+ public bool TryFormat(Span< char > destination, out int charsWritten, ReadOnlySpan< char > format = default(ReadOnlySpan< char > ), IFormatProvider provider = null);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out Single result);
+ public static bool TryParse(ReadOnlySpan< char > s, out Single result);
}
2018-06-06 20:43:50 +02:00
+ public readonly ref struct Span< T > {
2018-05-26 00:28:02 +02:00
+ 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 override bool Equals(object obj);
+ public void Fill(T value);
+ public Span< T > .Enumerator GetEnumerator();
+ public override int GetHashCode();
+ public ref T GetPinnableReference();
+ public static bool operator ==(Span< T > left, Span< T > right);
+ public static implicit operator Span< T > (ArraySegment< T > segment);
+ 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 override string ToString();
+ public bool TryCopyTo(Span< T > destination);
2018-06-06 20:43:50 +02:00
+ public ref struct Enumerator {
2018-05-26 00:28:02 +02:00
+ 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);
}
public abstract class StringComparer : IComparer, IComparer< string > , IEqualityComparer, IEqualityComparer< string > {
+ public static StringComparer Create(CultureInfo culture, CompareOptions options);
}
public struct TimeSpan : IComparable, IComparable< TimeSpan > , IEquatable< TimeSpan > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ 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);
2018-06-06 20:43:50 +02:00
}
public sealed class TimeZoneInfo : IDeserializationCallback, IEquatable< TimeZoneInfo > , ISerializable {
- public struct TransitionTime : IDeserializationCallback, IEquatable< TimeZoneInfo.TransitionTime > , ISerializable
+ public readonly struct TransitionTime : IDeserializationCallback, IEquatable< TimeZoneInfo.TransitionTime > , ISerializable
2018-05-26 00:28:02 +02:00
}
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);
}
2018-06-06 20:43:50 +02:00
- public struct TypedReference
+ public ref struct TypedReference
2018-05-26 00:28:02 +02:00
- public class TypeUnloadedException : SystemException, ISerializable
+ public class TypeUnloadedException : SystemException
public struct UInt16 : IComparable, IComparable< ushort > , IConvertible, IEquatable< ushort > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out UInt16 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out UInt16 result);
}
public struct UInt32 : IComparable, IComparable< uint > , IConvertible, IEquatable< uint > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out UInt32 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out UInt32 result);
}
public struct UInt64 : IComparable, IComparable< ulong > , IConvertible, IEquatable< ulong > , IFormattable {
2018-06-06 20:43:50 +02:00
+ 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);
2018-05-26 00:28:02 +02:00
+ public static bool TryParse(ReadOnlySpan< char > s, NumberStyles style, IFormatProvider provider, out UInt64 result);
+ public static bool TryParse(ReadOnlySpan< char > s, out UInt64 result);
}
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);
}
}
```