212 lines
14 KiB
Markdown
212 lines
14 KiB
Markdown
# System
|
|
|
|
``` diff
|
|
namespace System {
|
|
public static class Activator {
|
|
+ public static ObjectHandle CreateInstance(string assemblyName, string typeName);
|
|
+ public static ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public static ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
|
|
+ public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
|
|
+ public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public static ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
|
|
}
|
|
public sealed class AppDomain : MarshalByRefObject {
|
|
+ public PermissionSet PermissionSet { get; }
|
|
+ public AppDomainSetup SetupInformation { get; }
|
|
+ public ObjectHandle CreateInstance(string assemblyName, string typeName);
|
|
+ public ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes);
|
|
+ public object CreateInstanceAndUnwrap(string assemblyName, string typeName);
|
|
+ public object CreateInstanceAndUnwrap(string assemblyName, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public object CreateInstanceAndUnwrap(string assemblyName, string typeName, object[] activationAttributes);
|
|
+ public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName);
|
|
+ public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes);
|
|
+ public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName);
|
|
+ public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, bool ignoreCase, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes);
|
|
+ public object CreateInstanceFromAndUnwrap(string assemblyFile, string typeName, object[] activationAttributes);
|
|
}
|
|
+ public sealed class AppDomainSetup {
|
|
+ public string ApplicationBase { get; }
|
|
+ public string TargetFrameworkName { get; }
|
|
+ }
|
|
+ public ref struct ArgIterator {
|
|
+ public ArgIterator(RuntimeArgumentHandle arglist);
|
|
+ public unsafe ArgIterator(RuntimeArgumentHandle arglist, void* ptr);
|
|
+ public void End();
|
|
+ public override bool Equals(object o);
|
|
+ public override int GetHashCode();
|
|
+ public TypedReference GetNextArg();
|
|
+ public TypedReference GetNextArg(RuntimeTypeHandle rth);
|
|
+ public RuntimeTypeHandle GetNextArgType();
|
|
+ public int GetRemainingCount();
|
|
+ }
|
|
public readonly struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable {
|
|
+ public Decimal(ReadOnlySpan<int> bits);
|
|
+ public static int GetBits(Decimal d, Span<int> destination);
|
|
+ public static bool TryGetBits(Decimal d, Span<int> destination, out int valuesWritten);
|
|
}
|
|
public static class Environment {
|
|
+ public static long TickCount64 { get; }
|
|
}
|
|
public class Exception : ISerializable {
|
|
- public int HResult { get; protected set; }
|
|
+ public int HResult { get; set; }
|
|
}
|
|
public abstract class FormattableString : IFormattable {
|
|
+ public static string CurrentCulture(FormattableString formattable);
|
|
}
|
|
public static class GC {
|
|
+ public static T[] AllocateArray<T>(int length, bool pinned = false);
|
|
+ public static T[] AllocateUninitializedArray<T>(int length, bool pinned = false);
|
|
+ public static GCMemoryInfo GetGCMemoryInfo();
|
|
+ public static long GetTotalAllocatedBytes(bool precise = false);
|
|
}
|
|
+ public readonly struct GCMemoryInfo {
|
|
+ public long FragmentedBytes { get; }
|
|
+ public long HeapSizeBytes { get; }
|
|
+ public long HighMemoryLoadThresholdBytes { get; }
|
|
+ public long MemoryLoadBytes { get; }
|
|
+ public long TotalAvailableMemoryBytes { get; }
|
|
+ }
|
|
- public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable {
|
|
+ public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, ISerializable {
|
|
+ public static IntPtr MaxValue { get; }
|
|
+ public static IntPtr MinValue { get; }
|
|
+ public int CompareTo(IntPtr value);
|
|
+ public int CompareTo(object value);
|
|
+ public bool Equals(IntPtr other);
|
|
+ public static IntPtr Parse(string s);
|
|
+ public static IntPtr Parse(string s, NumberStyles style);
|
|
+ public static IntPtr Parse(string s, NumberStyles style, IFormatProvider provider);
|
|
+ public static IntPtr Parse(string s, IFormatProvider provider);
|
|
- bool System.IEquatable<System.IntPtr>.Equals(IntPtr other);
|
|
|
|
+ public string ToString(IFormatProvider provider);
|
|
+ public string ToString(string format, IFormatProvider provider);
|
|
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out IntPtr result);
|
|
+ public static bool TryParse(string s, out IntPtr result);
|
|
}
|
|
public sealed class LocalDataStoreSlot {
|
|
+ ~LocalDataStoreSlot();
|
|
}
|
|
public static class Math {
|
|
+ public static double BitDecrement(double x);
|
|
+ public static double BitIncrement(double x);
|
|
+ public static double CopySign(double x, double y);
|
|
+ public static double FusedMultiplyAdd(double x, double y, double z);
|
|
+ public static int ILogB(double x);
|
|
+ public static double Log2(double x);
|
|
+ public static double MaxMagnitude(double x, double y);
|
|
+ public static double MinMagnitude(double x, double y);
|
|
+ public static double ScaleB(double x, int n);
|
|
}
|
|
public static class MathF {
|
|
+ public static float BitDecrement(float x);
|
|
+ public static float BitIncrement(float x);
|
|
+ public static float CopySign(float x, float y);
|
|
+ public static float FusedMultiplyAdd(float x, float y, float z);
|
|
+ public static int ILogB(float x);
|
|
+ public static float Log2(float x);
|
|
+ public static float MaxMagnitude(float x, float y);
|
|
+ public static float MinMagnitude(float x, float y);
|
|
+ public static float ScaleB(float x, int n);
|
|
}
|
|
public static class MemoryExtensions {
|
|
+ public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
|
|
+ public static bool Contains<T>(this Span<T> span, T value) where T : IEquatable<T>;
|
|
+ public static SpanRuneEnumerator EnumerateRunes(this ReadOnlySpan<char> span);
|
|
+ public static SpanRuneEnumerator EnumerateRunes(this Span<char> span);
|
|
+ public static int LastIndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
|
|
+ public static void Sort<T, TComparer>(this Span<T> span, TComparer comparer) where TComparer : IComparer<T>;
|
|
+ public static void Sort<T>(this Span<T> span);
|
|
+ public static void Sort<T>(this Span<T> span, Comparison<T> comparison);
|
|
+ public static void Sort<TKey, TValue, TComparer>(this Span<TKey> keys, Span<TValue> items, TComparer comparer) where TComparer : IComparer<TKey>;
|
|
+ public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items);
|
|
+ public static void Sort<TKey, TValue>(this Span<TKey> keys, Span<TValue> items, Comparison<TKey> comparison);
|
|
+ public static Memory<char> Trim(this Memory<char> memory);
|
|
+ public static ReadOnlyMemory<char> Trim(this ReadOnlyMemory<char> memory);
|
|
+ public static Span<char> Trim(this Span<char> span);
|
|
+ public static Memory<T> Trim<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Memory<T> Trim<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> Trim<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> Trim<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
|
|
+ public static Span<T> Trim<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Span<T> Trim<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
|
|
+ public static Memory<char> TrimEnd(this Memory<char> memory);
|
|
+ public static ReadOnlyMemory<char> TrimEnd(this ReadOnlyMemory<char> memory);
|
|
+ public static Span<char> TrimEnd(this Span<char> span);
|
|
+ public static Memory<T> TrimEnd<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Memory<T> TrimEnd<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> TrimEnd<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> TrimEnd<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
|
|
+ public static Span<T> TrimEnd<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Span<T> TrimEnd<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
|
|
+ public static Memory<char> TrimStart(this Memory<char> memory);
|
|
+ public static ReadOnlyMemory<char> TrimStart(this ReadOnlyMemory<char> memory);
|
|
+ public static Span<char> TrimStart(this Span<char> span);
|
|
+ public static Memory<T> TrimStart<T>(this Memory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Memory<T> TrimStart<T>(this Memory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlyMemory<T> TrimStart<T>(this ReadOnlyMemory<T> memory, T trimElement) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static ReadOnlySpan<T> TrimStart<T>(this ReadOnlySpan<T> span, T trimElement) where T : IEquatable<T>;
|
|
+ public static Span<T> TrimStart<T>(this Span<T> span, ReadOnlySpan<T> trimElements) where T : IEquatable<T>;
|
|
+ public static Span<T> TrimStart<T>(this Span<T> span, T trimElement) where T : IEquatable<T>;
|
|
}
|
|
public enum MidpointRounding {
|
|
+ ToNegativeInfinity = 3,
|
|
+ ToPositiveInfinity = 4,
|
|
+ ToZero = 2,
|
|
}
|
|
public sealed class ObsoleteAttribute : Attribute {
|
|
+ public string DiagnosticId { get; set; }
|
|
+ public string UrlFormat { get; set; }
|
|
}
|
|
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
|
|
+ public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1);
|
|
+ public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2);
|
|
+ public static String Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3);
|
|
+ public StringRuneEnumerator EnumerateRunes();
|
|
+ public static int GetHashCode(ReadOnlySpan<char> value);
|
|
+ public static int GetHashCode(ReadOnlySpan<char> value, StringComparison comparisonType);
|
|
+ public ref readonly char GetPinnableReference();
|
|
}
|
|
public abstract class StringComparer : IComparer, IComparer<string>, IEqualityComparer, IEqualityComparer<string> {
|
|
- bool System.Collections.IEqualityComparer.Equals(object x, object y);
|
|
|
|
- int System.Collections.IEqualityComparer.GetHashCode(object obj);
|
|
|
|
}
|
|
public abstract class Type : MemberInfo, IReflect {
|
|
+ public static Type MakeGenericSignatureType(Type genericTypeDefinition, params Type[] typeArguments);
|
|
}
|
|
- public readonly struct UIntPtr : IEquatable<UIntPtr>, ISerializable {
|
|
+ public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, ISerializable {
|
|
+ public static UIntPtr MaxValue { get; }
|
|
+ public static UIntPtr MinValue { get; }
|
|
+ public int CompareTo(object value);
|
|
+ public int CompareTo(UIntPtr value);
|
|
+ public bool Equals(UIntPtr other);
|
|
+ public static UIntPtr Parse(string s);
|
|
+ public static UIntPtr Parse(string s, NumberStyles style);
|
|
+ public static UIntPtr Parse(string s, NumberStyles style, IFormatProvider provider);
|
|
+ public static UIntPtr Parse(string s, IFormatProvider provider);
|
|
- bool System.IEquatable<System.UIntPtr>.Equals(UIntPtr other);
|
|
|
|
+ public string ToString(IFormatProvider provider);
|
|
+ public string ToString(string format);
|
|
+ public string ToString(string format, IFormatProvider provider);
|
|
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out UIntPtr result);
|
|
+ public static bool TryParse(string s, out UIntPtr result);
|
|
}
|
|
public sealed class WeakReference<T> : ISerializable where T : class {
|
|
+ ~WeakReference();
|
|
}
|
|
}
|
|
```
|
|
|