Permalink
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
8309 lines (8307 sloc) 605 KB
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// ------------------------------------------------------------------------------
// Changes to this file must follow the http://aka.ms/api-review process.
// ------------------------------------------------------------------------------
namespace Microsoft.Win32.SafeHandles
{
public abstract partial class CriticalHandleMinusOneIsInvalid : System.Runtime.InteropServices.CriticalHandle
{
protected CriticalHandleMinusOneIsInvalid() : base (default(System.IntPtr)) { }
public override bool IsInvalid { get { throw null; } }
}
public abstract partial class CriticalHandleZeroOrMinusOneIsInvalid : System.Runtime.InteropServices.CriticalHandle
{
protected CriticalHandleZeroOrMinusOneIsInvalid() : base (default(System.IntPtr)) { }
public override bool IsInvalid { get { throw null; } }
}
public sealed partial class SafeFileHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
{
public SafeFileHandle(System.IntPtr preexistingHandle, bool ownsHandle) : base (default(bool)) { }
public override bool IsInvalid { get { throw null; } }
protected override bool ReleaseHandle() { throw null; }
}
public abstract partial class SafeHandleMinusOneIsInvalid : System.Runtime.InteropServices.SafeHandle
{
protected SafeHandleMinusOneIsInvalid(bool ownsHandle) : base (default(System.IntPtr), default(bool)) { }
public override bool IsInvalid { get { throw null; } }
}
public abstract partial class SafeHandleZeroOrMinusOneIsInvalid : System.Runtime.InteropServices.SafeHandle
{
protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle) : base (default(System.IntPtr), default(bool)) { }
public override bool IsInvalid { get { throw null; } }
}
public sealed partial class SafeWaitHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
{
public SafeWaitHandle(System.IntPtr existingHandle, bool ownsHandle) : base (default(bool)) { }
protected override bool ReleaseHandle() { throw null; }
}
}
namespace System
{
public partial class AccessViolationException : System.SystemException
{
public AccessViolationException() { }
protected AccessViolationException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public AccessViolationException(string message) { }
public AccessViolationException(string message, System.Exception innerException) { }
}
public delegate void Action();
public delegate void Action<in T>(T obj);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
public static partial class Activator
{
public static System.Runtime.Remoting.ObjectHandle CreateInstance(string assemblyName, string typeName) { throw null; }
public static System.Runtime.Remoting.ObjectHandle CreateInstance(string assemblyName, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes) { throw null; }
public static System.Runtime.Remoting.ObjectHandle CreateInstance(string assemblyName, string typeName, object[] activationAttributes) { throw null; }
public static object CreateInstance(System.Type type) { throw null; }
public static object CreateInstance(System.Type type, bool nonPublic) { throw null; }
public static object CreateInstance(System.Type type, params object[] args) { throw null; }
public static object CreateInstance(System.Type type, object[] args, object[] activationAttributes) { throw null; }
public static object CreateInstance(System.Type type, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture) { throw null; }
public static object CreateInstance(System.Type type, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes) { throw null; }
public static System.Runtime.Remoting.ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName) { throw null; }
public static System.Runtime.Remoting.ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, bool ignoreCase, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, object[] args, System.Globalization.CultureInfo culture, object[] activationAttributes) { throw null; }
public static System.Runtime.Remoting.ObjectHandle CreateInstanceFrom(string assemblyFile, string typeName, object[] activationAttributes) { throw null; }
public static T CreateInstance<T>() { throw null; }
}
public partial class AggregateException : System.Exception
{
public AggregateException() { }
public AggregateException(System.Collections.Generic.IEnumerable<System.Exception> innerExceptions) { }
public AggregateException(params System.Exception[] innerExceptions) { }
protected AggregateException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public AggregateException(string message) { }
public AggregateException(string message, System.Collections.Generic.IEnumerable<System.Exception> innerExceptions) { }
public AggregateException(string message, System.Exception innerException) { }
public AggregateException(string message, params System.Exception[] innerExceptions) { }
public System.Collections.ObjectModel.ReadOnlyCollection<System.Exception> InnerExceptions { get { throw null; } }
public override string Message { get { throw null; } }
public System.AggregateException Flatten() { throw null; }
public override System.Exception GetBaseException() { throw null; }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public void Handle(System.Func<System.Exception, bool> predicate) { }
public override string ToString() { throw null; }
}
public static partial class AppContext
{
public static string BaseDirectory { get { throw null; } }
public static string TargetFrameworkName { get { throw null; } }
public static object GetData(string name) { throw null; }
public static void SetSwitch(string switchName, bool isEnabled) { }
public static bool TryGetSwitch(string switchName, out bool isEnabled) { throw null; }
}
public partial class ApplicationException : System.Exception
{
public ApplicationException() { }
protected ApplicationException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ApplicationException(string message) { }
public ApplicationException(string message, System.Exception innerException) { }
}
public ref partial struct ArgIterator
{
private int _dummyPrimitive;
public ArgIterator(System.RuntimeArgumentHandle arglist) { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe ArgIterator(System.RuntimeArgumentHandle arglist, void* ptr) { throw null; }
public void End() { }
public override bool Equals(object o) { throw null; }
public override int GetHashCode() { throw null; }
[System.CLSCompliantAttribute(false)]
public System.TypedReference GetNextArg() { throw null; }
[System.CLSCompliantAttribute(false)]
public System.TypedReference GetNextArg(System.RuntimeTypeHandle rth) { throw null; }
public System.RuntimeTypeHandle GetNextArgType() { throw null; }
public int GetRemainingCount() { throw null; }
}
public partial class ArgumentException : System.SystemException
{
public ArgumentException() { }
protected ArgumentException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ArgumentException(string message) { }
public ArgumentException(string message, System.Exception innerException) { }
public ArgumentException(string message, string paramName) { }
public ArgumentException(string message, string paramName, System.Exception innerException) { }
public override string Message { get { throw null; } }
public virtual string ParamName { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
}
public partial class ArgumentNullException : System.ArgumentException
{
public ArgumentNullException() { }
protected ArgumentNullException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ArgumentNullException(string paramName) { }
public ArgumentNullException(string message, System.Exception innerException) { }
public ArgumentNullException(string paramName, string message) { }
}
public partial class ArgumentOutOfRangeException : System.ArgumentException
{
public ArgumentOutOfRangeException() { }
protected ArgumentOutOfRangeException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ArgumentOutOfRangeException(string paramName) { }
public ArgumentOutOfRangeException(string message, System.Exception innerException) { }
public ArgumentOutOfRangeException(string paramName, object actualValue, string message) { }
public ArgumentOutOfRangeException(string paramName, string message) { }
public virtual object ActualValue { get { throw null; } }
public override string Message { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
}
public partial class ArithmeticException : System.SystemException
{
public ArithmeticException() { }
protected ArithmeticException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ArithmeticException(string message) { }
public ArithmeticException(string message, System.Exception innerException) { }
}
public abstract partial class Array : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.ICloneable
{
internal Array() { }
public bool IsFixedSize { get { throw null; } }
public bool IsReadOnly { get { throw null; } }
public bool IsSynchronized { get { throw null; } }
public int Length { get { throw null; } }
public long LongLength { get { throw null; } }
public int Rank { get { throw null; } }
public object SyncRoot { get { throw null; } }
int System.Collections.ICollection.Count { get { throw null; } }
object System.Collections.IList.this[int index] { get { throw null; } set { } }
public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(T[] array) { throw null; }
public static int BinarySearch(System.Array array, int index, int length, object value) { throw null; }
public static int BinarySearch(System.Array array, int index, int length, object value, System.Collections.IComparer comparer) { throw null; }
public static int BinarySearch(System.Array array, object value) { throw null; }
public static int BinarySearch(System.Array array, object value, System.Collections.IComparer comparer) { throw null; }
public static int BinarySearch<T>(T[] array, int index, int length, T value) { throw null; }
public static int BinarySearch<T>(T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T> comparer) { throw null; }
public static int BinarySearch<T>(T[] array, T value) { throw null; }
public static int BinarySearch<T>(T[] array, T value, System.Collections.Generic.IComparer<T> comparer) { throw null; }
public static void Clear(System.Array array, int index, int length) { }
public object Clone() { throw null; }
public static void ConstrainedCopy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { }
public static TOutput[] ConvertAll<TInput, TOutput>(TInput[] array, System.Converter<TInput, TOutput> converter) { throw null; }
public static void Copy(System.Array sourceArray, System.Array destinationArray, int length) { }
public static void Copy(System.Array sourceArray, System.Array destinationArray, long length) { }
public static void Copy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { }
public static void Copy(System.Array sourceArray, long sourceIndex, System.Array destinationArray, long destinationIndex, long length) { }
public void CopyTo(System.Array array, int index) { }
public void CopyTo(System.Array array, long index) { }
public static System.Array CreateInstance(System.Type elementType, int length) { throw null; }
public static System.Array CreateInstance(System.Type elementType, int length1, int length2) { throw null; }
public static System.Array CreateInstance(System.Type elementType, int length1, int length2, int length3) { throw null; }
public static System.Array CreateInstance(System.Type elementType, params int[] lengths) { throw null; }
public static System.Array CreateInstance(System.Type elementType, int[] lengths, int[] lowerBounds) { throw null; }
public static System.Array CreateInstance(System.Type elementType, params long[] lengths) { throw null; }
public static T[] Empty<T>() { throw null; }
public static bool Exists<T>(T[] array, System.Predicate<T> match) { throw null; }
public static void Fill<T>(T[] array, T value) { }
public static void Fill<T>(T[] array, T value, int startIndex, int count) { }
public static T[] FindAll<T>(T[] array, System.Predicate<T> match) { throw null; }
public static int FindIndex<T>(T[] array, int startIndex, int count, System.Predicate<T> match) { throw null; }
public static int FindIndex<T>(T[] array, int startIndex, System.Predicate<T> match) { throw null; }
public static int FindIndex<T>(T[] array, System.Predicate<T> match) { throw null; }
public static int FindLastIndex<T>(T[] array, int startIndex, int count, System.Predicate<T> match) { throw null; }
public static int FindLastIndex<T>(T[] array, int startIndex, System.Predicate<T> match) { throw null; }
public static int FindLastIndex<T>(T[] array, System.Predicate<T> match) { throw null; }
public static T FindLast<T>(T[] array, System.Predicate<T> match) { throw null; }
public static T Find<T>(T[] array, System.Predicate<T> match) { throw null; }
public static void ForEach<T>(T[] array, System.Action<T> action) { }
public System.Collections.IEnumerator GetEnumerator() { throw null; }
public int GetLength(int dimension) { throw null; }
public long GetLongLength(int dimension) { throw null; }
public int GetLowerBound(int dimension) { throw null; }
public int GetUpperBound(int dimension) { throw null; }
public object GetValue(int index) { throw null; }
public object GetValue(int index1, int index2) { throw null; }
public object GetValue(int index1, int index2, int index3) { throw null; }
public object GetValue(params int[] indices) { throw null; }
public object GetValue(long index) { throw null; }
public object GetValue(long index1, long index2) { throw null; }
public object GetValue(long index1, long index2, long index3) { throw null; }
public object GetValue(params long[] indices) { throw null; }
public static int IndexOf(System.Array array, object value) { throw null; }
public static int IndexOf(System.Array array, object value, int startIndex) { throw null; }
public static int IndexOf(System.Array array, object value, int startIndex, int count) { throw null; }
public static int IndexOf<T>(T[] array, T value) { throw null; }
public static int IndexOf<T>(T[] array, T value, int startIndex) { throw null; }
public static int IndexOf<T>(T[] array, T value, int startIndex, int count) { throw null; }
public void Initialize() { }
public static int LastIndexOf(System.Array array, object value) { throw null; }
public static int LastIndexOf(System.Array array, object value, int startIndex) { throw null; }
public static int LastIndexOf(System.Array array, object value, int startIndex, int count) { throw null; }
public static int LastIndexOf<T>(T[] array, T value) { throw null; }
public static int LastIndexOf<T>(T[] array, T value, int startIndex) { throw null; }
public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count) { throw null; }
public static void Resize<T>(ref T[] array, int newSize) { }
public static void Reverse(System.Array array) { }
public static void Reverse(System.Array array, int index, int length) { }
public static void Reverse<T>(T[] array) { }
public static void Reverse<T>(T[] array, int index, int length) { }
public void SetValue(object value, int index) { }
public void SetValue(object value, int index1, int index2) { }
public void SetValue(object value, int index1, int index2, int index3) { }
public void SetValue(object value, params int[] indices) { }
public void SetValue(object value, long index) { }
public void SetValue(object value, long index1, long index2) { }
public void SetValue(object value, long index1, long index2, long index3) { }
public void SetValue(object value, params long[] indices) { }
public static void Sort(System.Array array) { }
public static void Sort(System.Array keys, System.Array items) { }
public static void Sort(System.Array keys, System.Array items, System.Collections.IComparer comparer) { }
public static void Sort(System.Array keys, System.Array items, int index, int length) { }
public static void Sort(System.Array keys, System.Array items, int index, int length, System.Collections.IComparer comparer) { }
public static void Sort(System.Array array, System.Collections.IComparer comparer) { }
public static void Sort(System.Array array, int index, int length) { }
public static void Sort(System.Array array, int index, int length, System.Collections.IComparer comparer) { }
public static void Sort<T>(T[] array) { }
public static void Sort<T>(T[] array, System.Collections.Generic.IComparer<T> comparer) { }
public static void Sort<T>(T[] array, System.Comparison<T> comparison) { }
public static void Sort<T>(T[] array, int index, int length) { }
public static void Sort<T>(T[] array, int index, int length, System.Collections.Generic.IComparer<T> comparer) { }
public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items) { }
public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, System.Collections.Generic.IComparer<TKey> comparer) { }
public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length) { }
public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer<TKey> comparer) { }
int System.Collections.IList.Add(object value) { throw null; }
void System.Collections.IList.Clear() { }
bool System.Collections.IList.Contains(object value) { throw null; }
int System.Collections.IList.IndexOf(object value) { throw null; }
void System.Collections.IList.Insert(int index, object value) { }
void System.Collections.IList.Remove(object value) { }
void System.Collections.IList.RemoveAt(int index) { }
int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; }
bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; }
int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; }
public static bool TrueForAll<T>(T[] array, System.Predicate<T> match) { throw null; }
}
public readonly partial struct ArraySegment<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.IEnumerable
{
private readonly T[] _array;
private readonly object _dummy;
private readonly int _dummyPrimitive;
public ArraySegment(T[] array) { throw null; }
public ArraySegment(T[] array, int offset, int count) { throw null; }
public T[] Array { get { throw null; } }
public int Count { get { throw null; } }
public static System.ArraySegment<T> Empty { get { throw null; } }
public T this[int index] { get { throw null; } set { } }
public int Offset { get { throw null; } }
bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
T System.Collections.Generic.IList<T>.this[int index] { get { throw null; } set { } }
T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get { throw null; } }
public void CopyTo(System.ArraySegment<T> destination) { }
public void CopyTo(T[] destination) { }
public void CopyTo(T[] destination, int destinationIndex) { }
public bool Equals(System.ArraySegment<T> obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public System.ArraySegment<T>.Enumerator GetEnumerator() { throw null; }
public override int GetHashCode() { throw null; }
public static bool operator ==(System.ArraySegment<T> a, System.ArraySegment<T> b) { throw null; }
public static implicit operator System.ArraySegment<T> (T[] array) { throw null; }
public static bool operator !=(System.ArraySegment<T> a, System.ArraySegment<T> b) { throw null; }
public System.ArraySegment<T> Slice(int index) { throw null; }
public System.ArraySegment<T> Slice(int index, int count) { throw null; }
void System.Collections.Generic.ICollection<T>.Add(T item) { }
void System.Collections.Generic.ICollection<T>.Clear() { }
bool System.Collections.Generic.ICollection<T>.Contains(T item) { throw null; }
bool System.Collections.Generic.ICollection<T>.Remove(T item) { throw null; }
System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
int System.Collections.Generic.IList<T>.IndexOf(T item) { throw null; }
void System.Collections.Generic.IList<T>.Insert(int index, T item) { }
void System.Collections.Generic.IList<T>.RemoveAt(int index) { }
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
public T[] ToArray() { throw null; }
public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
{
private readonly T[] _array;
private object _dummy;
private int _dummyPrimitive;
public T Current { get { throw null; } }
object System.Collections.IEnumerator.Current { get { throw null; } }
public void Dispose() { }
public bool MoveNext() { throw null; }
void System.Collections.IEnumerator.Reset() { }
}
}
public partial class ArrayTypeMismatchException : System.SystemException
{
public ArrayTypeMismatchException() { }
protected ArrayTypeMismatchException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ArrayTypeMismatchException(string message) { }
public ArrayTypeMismatchException(string message, System.Exception innerException) { }
}
public delegate void AsyncCallback(System.IAsyncResult ar);
[System.AttributeUsageAttribute(System.AttributeTargets.All, Inherited=true, AllowMultiple=false)]
public abstract partial class Attribute
{
protected Attribute() { }
public virtual object TypeId { get { throw null; } }
public override bool Equals(object obj) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.Assembly element, System.Type attributeType) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.Assembly element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.MemberInfo element, System.Type attributeType) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.MemberInfo element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.Module element, System.Type attributeType) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.Module element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.ParameterInfo element, System.Type attributeType) { throw null; }
public static System.Attribute GetCustomAttribute(System.Reflection.ParameterInfo element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Assembly element) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Assembly element, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Assembly element, System.Type attributeType) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Assembly element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.MemberInfo element) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.MemberInfo element, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.MemberInfo element, System.Type type) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.MemberInfo element, System.Type type, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Module element) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Module element, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Module element, System.Type attributeType) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.Module element, System.Type attributeType, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.ParameterInfo element) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.ParameterInfo element, bool inherit) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.ParameterInfo element, System.Type attributeType) { throw null; }
public static System.Attribute[] GetCustomAttributes(System.Reflection.ParameterInfo element, System.Type attributeType, bool inherit) { throw null; }
public override int GetHashCode() { throw null; }
public virtual bool IsDefaultAttribute() { throw null; }
public static bool IsDefined(System.Reflection.Assembly element, System.Type attributeType) { throw null; }
public static bool IsDefined(System.Reflection.Assembly element, System.Type attributeType, bool inherit) { throw null; }
public static bool IsDefined(System.Reflection.MemberInfo element, System.Type attributeType) { throw null; }
public static bool IsDefined(System.Reflection.MemberInfo element, System.Type attributeType, bool inherit) { throw null; }
public static bool IsDefined(System.Reflection.Module element, System.Type attributeType) { throw null; }
public static bool IsDefined(System.Reflection.Module element, System.Type attributeType, bool inherit) { throw null; }
public static bool IsDefined(System.Reflection.ParameterInfo element, System.Type attributeType) { throw null; }
public static bool IsDefined(System.Reflection.ParameterInfo element, System.Type attributeType, bool inherit) { throw null; }
public virtual bool Match(object obj) { throw null; }
}
[System.FlagsAttribute]
public enum AttributeTargets
{
All = 32767,
Assembly = 1,
Class = 4,
Constructor = 32,
Delegate = 4096,
Enum = 16,
Event = 512,
Field = 256,
GenericParameter = 16384,
Interface = 1024,
Method = 64,
Module = 2,
Parameter = 2048,
Property = 128,
ReturnValue = 8192,
Struct = 8,
}
[System.AttributeUsageAttribute(System.AttributeTargets.Class, Inherited=true)]
public sealed partial class AttributeUsageAttribute : System.Attribute
{
public AttributeUsageAttribute(System.AttributeTargets validOn) { }
public bool AllowMultiple { get { throw null; } set { } }
public bool Inherited { get { throw null; } set { } }
public System.AttributeTargets ValidOn { get { throw null; } }
}
public partial class BadImageFormatException : System.SystemException
{
public BadImageFormatException() { }
protected BadImageFormatException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public BadImageFormatException(string message) { }
public BadImageFormatException(string message, System.Exception inner) { }
public BadImageFormatException(string message, string fileName) { }
public BadImageFormatException(string message, string fileName, System.Exception inner) { }
public string FileName { get { throw null; } }
public string FusionLog { get { throw null; } }
public override string Message { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public override string ToString() { throw null; }
}
public readonly partial struct Boolean : System.IComparable, System.IComparable<bool>, System.IConvertible, System.IEquatable<bool>
{
private readonly bool _dummyPrimitive;
public static readonly string FalseString;
public static readonly string TrueString;
public int CompareTo(System.Boolean value) { throw null; }
public int CompareTo(object obj) { throw null; }
public System.Boolean Equals(System.Boolean obj) { throw null; }
public override System.Boolean Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Boolean Parse(System.ReadOnlySpan<char> value) { throw null; }
public static System.Boolean Parse(string value) { throw null; }
System.Boolean System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public System.Boolean TryFormat(System.Span<char> destination, out int charsWritten) { throw null; }
public static System.Boolean TryParse(System.ReadOnlySpan<char> value, out System.Boolean result) { throw null; }
public static System.Boolean TryParse(string value, out System.Boolean result) { throw null; }
}
public static partial class Buffer
{
public static void BlockCopy(System.Array src, int srcOffset, System.Array dst, int dstOffset, int count) { }
public static int ByteLength(System.Array array) { throw null; }
public static byte GetByte(System.Array array, int index) { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy) { }
[System.CLSCompliantAttribute(false)]
public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy) { }
public static void SetByte(System.Array array, int index, byte value) { }
}
public readonly partial struct Byte : System.IComparable, System.IComparable<byte>, System.IConvertible, System.IEquatable<byte>, System.IFormattable
{
private readonly byte _dummyPrimitive;
public const byte MaxValue = (byte)255;
public const byte MinValue = (byte)0;
public int CompareTo(System.Byte value) { throw null; }
public int CompareTo(object value) { throw null; }
public bool Equals(System.Byte obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Byte Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, System.IFormatProvider provider = null) { throw null; }
public static System.Byte Parse(string s) { throw null; }
public static System.Byte Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Byte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Byte Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
System.Byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Byte result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; }
public static bool TryParse(string s, out System.Byte result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; }
}
public readonly partial struct Char : System.IComparable, System.IComparable<char>, System.IConvertible, System.IEquatable<char>
{
private readonly char _dummyPrimitive;
public const char MaxValue = '\uFFFF';
public const char MinValue = '\0';
public int CompareTo(System.Char value) { throw null; }
public int CompareTo(object value) { throw null; }
public static string ConvertFromUtf32(int utf32) { throw null; }
public static int ConvertToUtf32(System.Char highSurrogate, System.Char lowSurrogate) { throw null; }
public static int ConvertToUtf32(string s, int index) { throw null; }
public bool Equals(System.Char obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public static double GetNumericValue(System.Char c) { throw null; }
public static double GetNumericValue(string s, int index) { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Globalization.UnicodeCategory GetUnicodeCategory(System.Char c) { throw null; }
public static System.Globalization.UnicodeCategory GetUnicodeCategory(string s, int index) { throw null; }
public static bool IsControl(System.Char c) { throw null; }
public static bool IsControl(string s, int index) { throw null; }
public static bool IsDigit(System.Char c) { throw null; }
public static bool IsDigit(string s, int index) { throw null; }
public static bool IsHighSurrogate(System.Char c) { throw null; }
public static bool IsHighSurrogate(string s, int index) { throw null; }
public static bool IsLetter(System.Char c) { throw null; }
public static bool IsLetter(string s, int index) { throw null; }
public static bool IsLetterOrDigit(System.Char c) { throw null; }
public static bool IsLetterOrDigit(string s, int index) { throw null; }
public static bool IsLower(System.Char c) { throw null; }
public static bool IsLower(string s, int index) { throw null; }
public static bool IsLowSurrogate(System.Char c) { throw null; }
public static bool IsLowSurrogate(string s, int index) { throw null; }
public static bool IsNumber(System.Char c) { throw null; }
public static bool IsNumber(string s, int index) { throw null; }
public static bool IsPunctuation(System.Char c) { throw null; }
public static bool IsPunctuation(string s, int index) { throw null; }
public static bool IsSeparator(System.Char c) { throw null; }
public static bool IsSeparator(string s, int index) { throw null; }
public static bool IsSurrogate(System.Char c) { throw null; }
public static bool IsSurrogate(string s, int index) { throw null; }
public static bool IsSurrogatePair(System.Char highSurrogate, System.Char lowSurrogate) { throw null; }
public static bool IsSurrogatePair(string s, int index) { throw null; }
public static bool IsSymbol(System.Char c) { throw null; }
public static bool IsSymbol(string s, int index) { throw null; }
public static bool IsUpper(System.Char c) { throw null; }
public static bool IsUpper(string s, int index) { throw null; }
public static bool IsWhiteSpace(System.Char c) { throw null; }
public static bool IsWhiteSpace(string s, int index) { throw null; }
public static System.Char Parse(string s) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
System.Char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public static System.Char ToLower(System.Char c) { throw null; }
public static System.Char ToLower(System.Char c, System.Globalization.CultureInfo culture) { throw null; }
public static System.Char ToLowerInvariant(System.Char c) { throw null; }
public override string ToString() { throw null; }
public static string ToString(System.Char c) { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public static System.Char ToUpper(System.Char c) { throw null; }
public static System.Char ToUpper(System.Char c, System.Globalization.CultureInfo culture) { throw null; }
public static System.Char ToUpperInvariant(System.Char c) { throw null; }
public static bool TryParse(string s, out System.Char result) { throw null; }
}
public sealed partial class CharEnumerator : System.Collections.Generic.IEnumerator<char>, System.Collections.IEnumerator, System.ICloneable, System.IDisposable
{
internal CharEnumerator() { }
public char Current { get { throw null; } }
object System.Collections.IEnumerator.Current { get { throw null; } }
public object Clone() { throw null; }
public void Dispose() { }
public bool MoveNext() { throw null; }
public void Reset() { }
}
[System.AttributeUsageAttribute(System.AttributeTargets.All, Inherited=true, AllowMultiple=false)]
public sealed partial class CLSCompliantAttribute : System.Attribute
{
public CLSCompliantAttribute(bool isCompliant) { }
public bool IsCompliant { get { throw null; } }
}
public delegate int Comparison<in T>(T x, T y);
public delegate TOutput Converter<in TInput, out TOutput>(TInput input);
public readonly partial struct DateTime : System.IComparable, System.IComparable<System.DateTime>, System.IConvertible, System.IEquatable<System.DateTime>, System.IFormattable, System.Runtime.Serialization.ISerializable
{
private readonly int _dummyPrimitive;
public static readonly System.DateTime MaxValue;
public static readonly System.DateTime MinValue;
public static readonly System.DateTime UnixEpoch;
public DateTime(int year, int month, int day) { throw null; }
public DateTime(int year, int month, int day, System.Globalization.Calendar calendar) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, System.DateTimeKind kind) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, System.Globalization.Calendar calendar) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.DateTimeKind kind) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.Globalization.Calendar calendar) { throw null; }
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.Globalization.Calendar calendar, System.DateTimeKind kind) { throw null; }
public DateTime(long ticks) { throw null; }
public DateTime(long ticks, System.DateTimeKind kind) { throw null; }
public System.DateTime Date { get { throw null; } }
public int Day { get { throw null; } }
public System.DayOfWeek DayOfWeek { get { throw null; } }
public int DayOfYear { get { throw null; } }
public int Hour { get { throw null; } }
public System.DateTimeKind Kind { get { throw null; } }
public int Millisecond { get { throw null; } }
public int Minute { get { throw null; } }
public int Month { get { throw null; } }
public static System.DateTime Now { get { throw null; } }
public int Second { get { throw null; } }
public long Ticks { get { throw null; } }
public System.TimeSpan TimeOfDay { get { throw null; } }
public static System.DateTime Today { get { throw null; } }
public static System.DateTime UtcNow { get { throw null; } }
public int Year { get { throw null; } }
public System.DateTime Add(System.TimeSpan value) { throw null; }
public System.DateTime AddDays(double value) { throw null; }
public System.DateTime AddHours(double value) { throw null; }
public System.DateTime AddMilliseconds(double value) { throw null; }
public System.DateTime AddMinutes(double value) { throw null; }
public System.DateTime AddMonths(int months) { throw null; }
public System.DateTime AddSeconds(double value) { throw null; }
public System.DateTime AddTicks(long value) { throw null; }
public System.DateTime AddYears(int value) { throw null; }
public static int Compare(System.DateTime t1, System.DateTime t2) { throw null; }
public int CompareTo(System.DateTime value) { throw null; }
public int CompareTo(object value) { throw null; }
public static int DaysInMonth(int year, int month) { throw null; }
public bool Equals(System.DateTime value) { throw null; }
public static bool Equals(System.DateTime t1, System.DateTime t2) { throw null; }
public override bool Equals(object value) { throw null; }
public static System.DateTime FromBinary(long dateData) { throw null; }
public static System.DateTime FromFileTime(long fileTime) { throw null; }
public static System.DateTime FromFileTimeUtc(long fileTime) { throw null; }
public static System.DateTime FromOADate(double d) { throw null; }
public string[] GetDateTimeFormats() { throw null; }
public string[] GetDateTimeFormats(char format) { throw null; }
public string[] GetDateTimeFormats(char format, System.IFormatProvider provider) { throw null; }
public string[] GetDateTimeFormats(System.IFormatProvider provider) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public bool IsDaylightSavingTime() { throw null; }
public static bool IsLeapYear(int year) { throw null; }
public static System.DateTime operator +(System.DateTime d, System.TimeSpan t) { throw null; }
public static bool operator ==(System.DateTime d1, System.DateTime d2) { throw null; }
public static bool operator >(System.DateTime t1, System.DateTime t2) { throw null; }
public static bool operator >=(System.DateTime t1, System.DateTime t2) { throw null; }
public static bool operator !=(System.DateTime d1, System.DateTime d2) { throw null; }
public static bool operator <(System.DateTime t1, System.DateTime t2) { throw null; }
public static bool operator <=(System.DateTime t1, System.DateTime t2) { throw null; }
public static System.TimeSpan operator -(System.DateTime d1, System.DateTime d2) { throw null; }
public static System.DateTime operator -(System.DateTime d, System.TimeSpan t) { throw null; }
public static System.DateTime Parse(System.ReadOnlySpan<char> s, System.IFormatProvider provider = null, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTime Parse(string s) { throw null; }
public static System.DateTime Parse(string s, System.IFormatProvider provider) { throw null; }
public static System.DateTime Parse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles) { throw null; }
public static System.DateTime ParseExact(System.ReadOnlySpan<char> s, System.ReadOnlySpan<char> format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTime ParseExact(System.ReadOnlySpan<char> s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider) { throw null; }
public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; }
public static System.DateTime ParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; }
public static System.DateTime SpecifyKind(System.DateTime value, System.DateTimeKind kind) { throw null; }
public System.TimeSpan Subtract(System.DateTime value) { throw null; }
public System.DateTime Subtract(System.TimeSpan value) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public long ToBinary() { throw null; }
public long ToFileTime() { throw null; }
public long ToFileTimeUtc() { throw null; }
public System.DateTime ToLocalTime() { throw null; }
public string ToLongDateString() { throw null; }
public string ToLongTimeString() { throw null; }
public double ToOADate() { throw null; }
public string ToShortDateString() { throw null; }
public string ToShortTimeString() { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public System.DateTime ToUniversalTime() { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.DateTime result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; }
public static bool TryParse(string s, out System.DateTime result) { throw null; }
public static bool TryParse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; }
public static bool TryParseExact(System.ReadOnlySpan<char> s, System.ReadOnlySpan<char> format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; }
public static bool TryParseExact(System.ReadOnlySpan<char> s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; }
public static bool TryParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; }
public static bool TryParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; }
}
public enum DateTimeKind
{
Local = 2,
Unspecified = 0,
Utc = 1,
}
public readonly partial struct DateTimeOffset : System.IComparable, System.IComparable<System.DateTimeOffset>, System.IEquatable<System.DateTimeOffset>, System.IFormattable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
{
private readonly int _dummyPrimitive;
public static readonly System.DateTimeOffset MaxValue;
public static readonly System.DateTimeOffset MinValue;
public static readonly System.DateTimeOffset UnixEpoch;
public DateTimeOffset(System.DateTime dateTime) { throw null; }
public DateTimeOffset(System.DateTime dateTime, System.TimeSpan offset) { throw null; }
public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.Globalization.Calendar calendar, System.TimeSpan offset) { throw null; }
public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.TimeSpan offset) { throw null; }
public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, System.TimeSpan offset) { throw null; }
public DateTimeOffset(long ticks, System.TimeSpan offset) { throw null; }
public System.DateTime Date { get { throw null; } }
public System.DateTime DateTime { get { throw null; } }
public int Day { get { throw null; } }
public System.DayOfWeek DayOfWeek { get { throw null; } }
public int DayOfYear { get { throw null; } }
public int Hour { get { throw null; } }
public System.DateTime LocalDateTime { get { throw null; } }
public int Millisecond { get { throw null; } }
public int Minute { get { throw null; } }
public int Month { get { throw null; } }
public static System.DateTimeOffset Now { get { throw null; } }
public System.TimeSpan Offset { get { throw null; } }
public int Second { get { throw null; } }
public long Ticks { get { throw null; } }
public System.TimeSpan TimeOfDay { get { throw null; } }
public System.DateTime UtcDateTime { get { throw null; } }
public static System.DateTimeOffset UtcNow { get { throw null; } }
public long UtcTicks { get { throw null; } }
public int Year { get { throw null; } }
public System.DateTimeOffset Add(System.TimeSpan timeSpan) { throw null; }
public System.DateTimeOffset AddDays(double days) { throw null; }
public System.DateTimeOffset AddHours(double hours) { throw null; }
public System.DateTimeOffset AddMilliseconds(double milliseconds) { throw null; }
public System.DateTimeOffset AddMinutes(double minutes) { throw null; }
public System.DateTimeOffset AddMonths(int months) { throw null; }
public System.DateTimeOffset AddSeconds(double seconds) { throw null; }
public System.DateTimeOffset AddTicks(long ticks) { throw null; }
public System.DateTimeOffset AddYears(int years) { throw null; }
public static int Compare(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; }
public int CompareTo(System.DateTimeOffset other) { throw null; }
public bool Equals(System.DateTimeOffset other) { throw null; }
public static bool Equals(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; }
public override bool Equals(object obj) { throw null; }
public bool EqualsExact(System.DateTimeOffset other) { throw null; }
public static System.DateTimeOffset FromFileTime(long fileTime) { throw null; }
public static System.DateTimeOffset FromUnixTimeMilliseconds(long milliseconds) { throw null; }
public static System.DateTimeOffset FromUnixTimeSeconds(long seconds) { throw null; }
public override int GetHashCode() { throw null; }
public static System.DateTimeOffset operator +(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; }
public static bool operator ==(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static bool operator >(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static bool operator >=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static implicit operator System.DateTimeOffset (System.DateTime dateTime) { throw null; }
public static bool operator !=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static bool operator <(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static bool operator <=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static System.TimeSpan operator -(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; }
public static System.DateTimeOffset operator -(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; }
public static System.DateTimeOffset Parse(System.ReadOnlySpan<char> input, System.IFormatProvider formatProvider = null, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTimeOffset Parse(string input) { throw null; }
public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider) { throw null; }
public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; }
public static System.DateTimeOffset ParseExact(System.ReadOnlySpan<char> input, System.ReadOnlySpan<char> format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTimeOffset ParseExact(System.ReadOnlySpan<char> input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles = System.Globalization.DateTimeStyles.None) { throw null; }
public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; }
public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; }
public static System.DateTimeOffset ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; }
public System.TimeSpan Subtract(System.DateTimeOffset value) { throw null; }
public System.DateTimeOffset Subtract(System.TimeSpan value) { throw null; }
int System.IComparable.CompareTo(object obj) { throw null; }
void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public long ToFileTime() { throw null; }
public System.DateTimeOffset ToLocalTime() { throw null; }
public System.DateTimeOffset ToOffset(System.TimeSpan offset) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider formatProvider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider formatProvider) { throw null; }
public System.DateTimeOffset ToUniversalTime() { throw null; }
public long ToUnixTimeMilliseconds() { throw null; }
public long ToUnixTimeSeconds() { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider formatProvider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> input, out System.DateTimeOffset result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
public static bool TryParse(string input, out System.DateTimeOffset result) { throw null; }
public static bool TryParse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
public static bool TryParseExact(System.ReadOnlySpan<char> input, System.ReadOnlySpan<char> format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
public static bool TryParseExact(System.ReadOnlySpan<char> input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; }
}
public enum DayOfWeek
{
Friday = 5,
Monday = 1,
Saturday = 6,
Sunday = 0,
Thursday = 4,
Tuesday = 2,
Wednesday = 3,
}
public sealed partial class DBNull : System.IConvertible, System.Runtime.Serialization.ISerializable
{
internal DBNull() { }
public static readonly System.DBNull Value;
public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public System.TypeCode GetTypeCode() { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
}
public readonly partial struct Decimal : System.IComparable, System.IComparable<decimal>, System.IConvertible, System.IEquatable<decimal>, System.IFormattable, System.Runtime.Serialization.IDeserializationCallback
{
private readonly int _dummyPrimitive;
[System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)4294967295, (uint)4294967295, (uint)4294967295)]
public static readonly decimal MaxValue;
[System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)0, (uint)0, (uint)1)]
public static readonly decimal MinusOne;
[System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)4294967295, (uint)4294967295, (uint)4294967295)]
public static readonly decimal MinValue;
[System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)1)]
public static readonly decimal One;
[System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)0)]
public static readonly decimal Zero;
public Decimal(double value) { throw null; }
public Decimal(int value) { throw null; }
public Decimal(int lo, int mid, int hi, bool isNegative, byte scale) { throw null; }
public Decimal(int[] bits) { throw null; }
public Decimal(long value) { throw null; }
public Decimal(float value) { throw null; }
[System.CLSCompliantAttribute(false)]
public Decimal(uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public Decimal(ulong value) { throw null; }
public static System.Decimal Add(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal Ceiling(System.Decimal d) { throw null; }
public static int Compare(System.Decimal d1, System.Decimal d2) { throw null; }
public int CompareTo(System.Decimal value) { throw null; }
public int CompareTo(object value) { throw null; }
public static System.Decimal Divide(System.Decimal d1, System.Decimal d2) { throw null; }
public bool Equals(System.Decimal value) { throw null; }
public static bool Equals(System.Decimal d1, System.Decimal d2) { throw null; }
public override bool Equals(object value) { throw null; }
public static System.Decimal Floor(System.Decimal d) { throw null; }
public static System.Decimal FromOACurrency(long cy) { throw null; }
public static int[] GetBits(System.Decimal d) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Decimal Multiply(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal Negate(System.Decimal d) { throw null; }
public static System.Decimal operator +(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal operator --(System.Decimal d) { throw null; }
public static System.Decimal operator /(System.Decimal d1, System.Decimal d2) { throw null; }
public static bool operator ==(System.Decimal d1, System.Decimal d2) { throw null; }
public static explicit operator byte (System.Decimal value) { throw null; }
public static explicit operator char (System.Decimal value) { throw null; }
public static explicit operator double (System.Decimal value) { throw null; }
public static explicit operator short (System.Decimal value) { throw null; }
public static explicit operator int (System.Decimal value) { throw null; }
public static explicit operator long (System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static explicit operator sbyte (System.Decimal value) { throw null; }
public static explicit operator float (System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static explicit operator ushort (System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static explicit operator uint (System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static explicit operator ulong (System.Decimal value) { throw null; }
public static explicit operator System.Decimal (double value) { throw null; }
public static explicit operator System.Decimal (float value) { throw null; }
public static bool operator >(System.Decimal d1, System.Decimal d2) { throw null; }
public static bool operator >=(System.Decimal d1, System.Decimal d2) { throw null; }
public static implicit operator System.Decimal (byte value) { throw null; }
public static implicit operator System.Decimal (char value) { throw null; }
public static implicit operator System.Decimal (short value) { throw null; }
public static implicit operator System.Decimal (int value) { throw null; }
public static implicit operator System.Decimal (long value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static implicit operator System.Decimal (sbyte value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static implicit operator System.Decimal (ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static implicit operator System.Decimal (uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static implicit operator System.Decimal (ulong value) { throw null; }
public static System.Decimal operator ++(System.Decimal d) { throw null; }
public static bool operator !=(System.Decimal d1, System.Decimal d2) { throw null; }
public static bool operator <(System.Decimal d1, System.Decimal d2) { throw null; }
public static bool operator <=(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal operator %(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal operator *(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal operator -(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal operator -(System.Decimal d) { throw null; }
public static System.Decimal operator +(System.Decimal d) { throw null; }
public static System.Decimal Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Number, System.IFormatProvider provider = null) { throw null; }
public static System.Decimal Parse(string s) { throw null; }
public static System.Decimal Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Decimal Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Decimal Parse(string s, System.IFormatProvider provider) { throw null; }
public static System.Decimal Remainder(System.Decimal d1, System.Decimal d2) { throw null; }
public static System.Decimal Round(System.Decimal d) { throw null; }
public static System.Decimal Round(System.Decimal d, int decimals) { throw null; }
public static System.Decimal Round(System.Decimal d, int decimals, System.MidpointRounding mode) { throw null; }
public static System.Decimal Round(System.Decimal d, System.MidpointRounding mode) { throw null; }
public static System.Decimal Subtract(System.Decimal d1, System.Decimal d2) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
System.Decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object sender) { }
public static byte ToByte(System.Decimal value) { throw null; }
public static double ToDouble(System.Decimal d) { throw null; }
public static short ToInt16(System.Decimal value) { throw null; }
public static int ToInt32(System.Decimal d) { throw null; }
public static long ToInt64(System.Decimal d) { throw null; }
public static long ToOACurrency(System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static sbyte ToSByte(System.Decimal value) { throw null; }
public static float ToSingle(System.Decimal d) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ushort ToUInt16(System.Decimal value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static uint ToUInt32(System.Decimal d) { throw null; }
[System.CLSCompliantAttribute(false)]
public static ulong ToUInt64(System.Decimal d) { throw null; }
public static System.Decimal Truncate(System.Decimal d) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Decimal result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; }
public static bool TryParse(string s, out System.Decimal result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; }
}
public abstract partial class Delegate : System.ICloneable, System.Runtime.Serialization.ISerializable
{
protected Delegate(object target, string method) { }
protected Delegate(System.Type target, string method) { }
public System.Reflection.MethodInfo Method { get { throw null; } }
public object Target { get { throw null; } }
public virtual object Clone() { throw null; }
public static System.Delegate Combine(System.Delegate a, System.Delegate b) { throw null; }
public static System.Delegate Combine(params System.Delegate[] delegates) { throw null; }
protected virtual System.Delegate CombineImpl(System.Delegate d) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, object firstArgument, System.Reflection.MethodInfo method) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, object firstArgument, System.Reflection.MethodInfo method, bool throwOnBindFailure) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, object target, string method) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, object target, string method, bool ignoreCase) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, System.Reflection.MethodInfo method) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, System.Type target, string method) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, System.Type target, string method, bool ignoreCase) { throw null; }
public static System.Delegate CreateDelegate(System.Type type, System.Type target, string method, bool ignoreCase, bool throwOnBindFailure) { throw null; }
public object DynamicInvoke(params object[] args) { throw null; }
protected virtual object DynamicInvokeImpl(object[] args) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public virtual System.Delegate[] GetInvocationList() { throw null; }
protected virtual System.Reflection.MethodInfo GetMethodImpl() { throw null; }
public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public static bool operator ==(System.Delegate d1, System.Delegate d2) { throw null; }
public static bool operator !=(System.Delegate d1, System.Delegate d2) { throw null; }
public static System.Delegate Remove(System.Delegate source, System.Delegate value) { throw null; }
public static System.Delegate RemoveAll(System.Delegate source, System.Delegate value) { throw null; }
protected virtual System.Delegate RemoveImpl(System.Delegate d) { throw null; }
}
public partial class DivideByZeroException : System.ArithmeticException
{
public DivideByZeroException() { }
protected DivideByZeroException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public DivideByZeroException(string message) { }
public DivideByZeroException(string message, System.Exception innerException) { }
}
public readonly partial struct Double : System.IComparable, System.IComparable<double>, System.IConvertible, System.IEquatable<double>, System.IFormattable
{
private readonly double _dummyPrimitive;
//public const double Epsilon = 4.94065645841247E-324; -- defined in System.Runtime.Manual.cs
//public const double MaxValue = 1.7976931348623157E+308; -- defined in System.Runtime.Manual.cs
//public const double MinValue = -1.7976931348623157E+308; -- defined in System.Runtime.Manual.cs
//public const double NaN = 0.0 / 0.0; -- defined in System.Runtime.Manual.cs
//public const double NegativeInfinity = -1.0 / 0.0; -- defined in System.Runtime.Manual.cs
//public const double PositiveInfinity = 1.0 / 0.0; -- defined in System.Runtime.Manual.cs
public int CompareTo(System.Double value) { throw null; }
public int CompareTo(object value) { throw null; }
public bool Equals(System.Double obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static bool IsFinite(System.Double d) { throw null; }
public static bool IsInfinity(System.Double d) { throw null; }
public static bool IsNaN(System.Double d) { throw null; }
public static bool IsNegative(System.Double d) { throw null; }
public static bool IsNegativeInfinity(System.Double d) { throw null; }
public static bool IsNormal(System.Double d) { throw null; }
public static bool IsPositiveInfinity(System.Double d) { throw null; }
public static bool IsSubnormal(System.Double d) { throw null; }
public static bool operator ==(System.Double left, System.Double right) { throw null; }
public static bool operator >(System.Double left, System.Double right) { throw null; }
public static bool operator >=(System.Double left, System.Double right) { throw null; }
public static bool operator !=(System.Double left, System.Double right) { throw null; }
public static bool operator <(System.Double left, System.Double right) { throw null; }
public static bool operator <=(System.Double left, System.Double right) { throw null; }
public static System.Double Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowDecimalPoint | System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowLeadingSign | System.Globalization.NumberStyles.AllowLeadingWhite | System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.AllowTrailingWhite, System.IFormatProvider provider = null) { throw null; }
public static System.Double Parse(string s) { throw null; }
public static System.Double Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Double Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Double Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
System.Double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Double result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; }
public static bool TryParse(string s, out System.Double result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; }
}
public partial class DuplicateWaitObjectException : System.ArgumentException
{
public DuplicateWaitObjectException() { }
protected DuplicateWaitObjectException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public DuplicateWaitObjectException(string parameterName) { }
public DuplicateWaitObjectException(string message, System.Exception innerException) { }
public DuplicateWaitObjectException(string parameterName, string message) { }
}
public partial class EntryPointNotFoundException : System.TypeLoadException
{
public EntryPointNotFoundException() { }
protected EntryPointNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public EntryPointNotFoundException(string message) { }
public EntryPointNotFoundException(string message, System.Exception inner) { }
}
public abstract partial class Enum : System.ValueType, System.IComparable, System.IConvertible, System.IFormattable
{
protected Enum() { }
public int CompareTo(object target) { throw null; }
public override bool Equals(object obj) { throw null; }
public static string Format(System.Type enumType, object value, string format) { throw null; }
public override int GetHashCode() { throw null; }
public static string GetName(System.Type enumType, object value) { throw null; }
public static string[] GetNames(System.Type enumType) { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Type GetUnderlyingType(System.Type enumType) { throw null; }
public static System.Array GetValues(System.Type enumType) { throw null; }
public bool HasFlag(System.Enum flag) { throw null; }
public static bool IsDefined(System.Type enumType, object value) { throw null; }
public static object Parse(System.Type enumType, string value) { throw null; }
public static object Parse(System.Type enumType, string value, bool ignoreCase) { throw null; }
public static TEnum Parse<TEnum>(string value) where TEnum : struct { throw null; }
public static TEnum Parse<TEnum>(string value, bool ignoreCase) where TEnum : struct { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public static object ToObject(System.Type enumType, byte value) { throw null; }
public static object ToObject(System.Type enumType, short value) { throw null; }
public static object ToObject(System.Type enumType, int value) { throw null; }
public static object ToObject(System.Type enumType, long value) { throw null; }
public static object ToObject(System.Type enumType, object value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static object ToObject(System.Type enumType, sbyte value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static object ToObject(System.Type enumType, ushort value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static object ToObject(System.Type enumType, uint value) { throw null; }
[System.CLSCompliantAttribute(false)]
public static object ToObject(System.Type enumType, ulong value) { throw null; }
public override string ToString() { throw null; }
[System.ObsoleteAttribute("The provider argument is not used. Please use ToString().")]
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
[System.ObsoleteAttribute("The provider argument is not used. Please use ToString(String).")]
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public static bool TryParse(System.Type enumType, string value, bool ignoreCase, out object result) { throw null; }
public static bool TryParse(System.Type enumType, string value, out object result) { throw null; }
public static bool TryParse<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct { throw null; }
public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct { throw null; }
}
public partial class EventArgs
{
public static readonly System.EventArgs Empty;
public EventArgs() { }
}
public delegate void EventHandler(object sender, System.EventArgs e);
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
public partial class Exception : System.Runtime.Serialization.ISerializable
{
public Exception() { }
protected Exception(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public Exception(string message) { }
public Exception(string message, System.Exception innerException) { }
public virtual System.Collections.IDictionary Data { get { throw null; } }
public virtual string HelpLink { get { throw null; } set { } }
public int HResult { get { throw null; } set { } }
public System.Exception InnerException { get { throw null; } }
public virtual string Message { get { throw null; } }
public virtual string Source { get { throw null; } set { } }
public virtual string StackTrace { get { throw null; } }
public System.Reflection.MethodBase TargetSite { get { throw null; } }
protected event System.EventHandler<System.Runtime.Serialization.SafeSerializationEventArgs> SerializeObjectState { add { } remove { } }
public virtual System.Exception GetBaseException() { throw null; }
public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public new System.Type GetType() { throw null; }
public override string ToString() { throw null; }
}
[System.ObsoleteAttribute("This type previously indicated an unspecified fatal error in the runtime. The runtime no longer raises this exception so this type is obsolete.")]
public sealed partial class ExecutionEngineException : System.SystemException
{
public ExecutionEngineException() { }
public ExecutionEngineException(string message) { }
public ExecutionEngineException(string message, System.Exception innerException) { }
}
public partial class FieldAccessException : System.MemberAccessException
{
public FieldAccessException() { }
protected FieldAccessException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public FieldAccessException(string message) { }
public FieldAccessException(string message, System.Exception inner) { }
}
public partial class FileStyleUriParser : System.UriParser
{
public FileStyleUriParser() { }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Enum, Inherited=false)]
public partial class FlagsAttribute : System.Attribute
{
public FlagsAttribute() { }
}
public partial class FormatException : System.SystemException
{
public FormatException() { }
protected FormatException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public FormatException(string message) { }
public FormatException(string message, System.Exception innerException) { }
}
public abstract partial class FormattableString : System.IFormattable
{
protected FormattableString() { }
public abstract int ArgumentCount { get; }
public abstract string Format { get; }
public static string CurrentCulture(System.FormattableString formattable) { throw null; }
public abstract object GetArgument(int index);
public abstract object[] GetArguments();
public static string Invariant(System.FormattableString formattable) { throw null; }
string System.IFormattable.ToString(string ignored, System.IFormatProvider formatProvider) { throw null; }
public override string ToString() { throw null; }
public abstract string ToString(System.IFormatProvider formatProvider);
}
public partial class FtpStyleUriParser : System.UriParser
{
public FtpStyleUriParser() { }
}
public delegate TResult Func<out TResult>();
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
public delegate TResult Func<in T, out TResult>(T arg);
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3);
public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
public static partial class GC
{
public static int MaxGeneration { get { throw null; } }
public static void AddMemoryPressure(long bytesAllocated) { }
public static void CancelFullGCNotification() { }
public static void Collect() { }
public static void Collect(int generation) { }
public static void Collect(int generation, System.GCCollectionMode mode) { }
public static void Collect(int generation, System.GCCollectionMode mode, bool blocking) { }
public static void Collect(int generation, System.GCCollectionMode mode, bool blocking, bool compacting) { }
public static int CollectionCount(int generation) { throw null; }
public static void EndNoGCRegion() { }
public static long GetAllocatedBytesForCurrentThread() { throw null; }
public static int GetGeneration(object obj) { throw null; }
public static int GetGeneration(System.WeakReference wo) { throw null; }
public static long GetTotalMemory(bool forceFullCollection) { throw null; }
public static void KeepAlive(object obj) { }
public static void RegisterForFullGCNotification(int maxGenerationThreshold, int largeObjectHeapThreshold) { }
public static void RemoveMemoryPressure(long bytesAllocated) { }
public static void ReRegisterForFinalize(object obj) { }
public static void SuppressFinalize(object obj) { }
public static bool TryStartNoGCRegion(long totalSize) { throw null; }
public static bool TryStartNoGCRegion(long totalSize, bool disallowFullBlockingGC) { throw null; }
public static bool TryStartNoGCRegion(long totalSize, long lohSize) { throw null; }
public static bool TryStartNoGCRegion(long totalSize, long lohSize, bool disallowFullBlockingGC) { throw null; }
public static System.GCNotificationStatus WaitForFullGCApproach() { throw null; }
public static System.GCNotificationStatus WaitForFullGCApproach(int millisecondsTimeout) { throw null; }
public static System.GCNotificationStatus WaitForFullGCComplete() { throw null; }
public static System.GCNotificationStatus WaitForFullGCComplete(int millisecondsTimeout) { throw null; }
public static void WaitForPendingFinalizers() { }
}
public enum GCCollectionMode
{
Default = 0,
Forced = 1,
Optimized = 2,
}
public enum GCNotificationStatus
{
Canceled = 2,
Failed = 1,
NotApplicable = 4,
Succeeded = 0,
Timeout = 3,
}
public partial class GenericUriParser : System.UriParser
{
public GenericUriParser(System.GenericUriParserOptions options) { }
}
[System.FlagsAttribute]
public enum GenericUriParserOptions
{
AllowEmptyAuthority = 2,
Default = 0,
DontCompressPath = 128,
DontConvertPathBackslashes = 64,
DontUnescapePathDotsAndSlashes = 256,
GenericAuthority = 1,
Idn = 512,
IriParsing = 1024,
NoFragment = 32,
NoPort = 8,
NoQuery = 16,
NoUserInfo = 4,
}
public partial class GopherStyleUriParser : System.UriParser
{
public GopherStyleUriParser() { }
}
public partial struct Guid : System.IComparable, System.IComparable<System.Guid>, System.IEquatable<System.Guid>, System.IFormattable
{
private int _dummyPrimitive;
public static readonly System.Guid Empty;
public Guid(byte[] b) { throw null; }
public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; }
public Guid(int a, short b, short c, byte[] d) { throw null; }
public Guid(System.ReadOnlySpan<byte> b) { throw null; }
public Guid(string g) { throw null; }
[System.CLSCompliantAttribute(false)]
public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; }
public int CompareTo(System.Guid value) { throw null; }
public int CompareTo(object value) { throw null; }
public bool Equals(System.Guid g) { throw null; }
public override bool Equals(object o) { throw null; }
public override int GetHashCode() { throw null; }
public static System.Guid NewGuid() { throw null; }
public static bool operator ==(System.Guid a, System.Guid b) { throw null; }
public static bool operator !=(System.Guid a, System.Guid b) { throw null; }
public static System.Guid Parse(System.ReadOnlySpan<char> input) { throw null; }
public static System.Guid Parse(string input) { throw null; }
public static System.Guid ParseExact(System.ReadOnlySpan<char> input, System.ReadOnlySpan<char> format) { throw null; }
public static System.Guid ParseExact(string input, string format) { throw null; }
public byte[] ToByteArray() { throw null; }
public override string ToString() { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>)) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> input, out System.Guid result) { throw null; }
public static bool TryParse(string input, out System.Guid result) { throw null; }
public static bool TryParseExact(System.ReadOnlySpan<char> input, System.ReadOnlySpan<char> format, out System.Guid result) { throw null; }
public static bool TryParseExact(string input, string format, out System.Guid result) { throw null; }
public bool TryWriteBytes(System.Span<byte> destination) { throw null; }
}
public partial struct HashCode
{
private int _dummyPrimitive;
public void Add<T>(T value) { }
public void Add<T>(T value, System.Collections.Generic.IEqualityComparer<T> comparer) { }
public static int Combine<T1>(T1 value1) { throw null; }
public static int Combine<T1, T2>(T1 value1, T2 value2) { throw null; }
public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3) { throw null; }
public static int Combine<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4) { throw null; }
public static int Combine<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) { throw null; }
public static int Combine<T1, T2, T3, T4, T5, T6>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6) { throw null; }
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) { throw null; }
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) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
[System.ObsoleteAttribute("HashCode is a mutable struct and should not be compared with other HashCodes.", true)]
public override bool Equals(object obj) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
[System.ObsoleteAttribute("HashCode is a mutable struct and should not be compared with other HashCodes. Use ToHashCode to retrieve the computed hash code.", true)]
public override int GetHashCode() { throw null; }
public int ToHashCode() { throw null; }
}
public partial class HttpStyleUriParser : System.UriParser
{
public HttpStyleUriParser() { }
}
public partial interface IAsyncDisposable
{
System.Threading.Tasks.ValueTask DisposeAsync();
}
public partial interface IAsyncResult
{
object AsyncState { get; }
System.Threading.WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}
public partial interface ICloneable
{
object Clone();
}
public partial interface IComparable
{
int CompareTo(object obj);
}
public partial interface IComparable<in T>
{
int CompareTo(T other);
}
[System.CLSCompliantAttribute(false)]
public partial interface IConvertible
{
System.TypeCode GetTypeCode();
bool ToBoolean(System.IFormatProvider provider);
byte ToByte(System.IFormatProvider provider);
char ToChar(System.IFormatProvider provider);
System.DateTime ToDateTime(System.IFormatProvider provider);
decimal ToDecimal(System.IFormatProvider provider);
double ToDouble(System.IFormatProvider provider);
short ToInt16(System.IFormatProvider provider);
int ToInt32(System.IFormatProvider provider);
long ToInt64(System.IFormatProvider provider);
sbyte ToSByte(System.IFormatProvider provider);
float ToSingle(System.IFormatProvider provider);
string ToString(System.IFormatProvider provider);
object ToType(System.Type conversionType, System.IFormatProvider provider);
ushort ToUInt16(System.IFormatProvider provider);
uint ToUInt32(System.IFormatProvider provider);
ulong ToUInt64(System.IFormatProvider provider);
}
public partial interface ICustomFormatter
{
string Format(string format, object arg, System.IFormatProvider formatProvider);
}
public partial interface IDisposable
{
void Dispose();
}
public partial interface IEquatable<T>
{
bool Equals(T other);
}
public partial interface IFormatProvider
{
object GetFormat(System.Type formatType);
}
public partial interface IFormattable
{
string ToString(string format, System.IFormatProvider formatProvider);
}
public readonly partial struct Index : System.IEquatable<System.Index>
{
private readonly int _dummyPrimitive;
public Index(int value, bool fromEnd) { throw null; }
public bool FromEnd { get { throw null; } }
public int Value { get { throw null; } }
public bool Equals(System.Index other) { throw null; }
public override bool Equals(object value) { throw null; }
public override int GetHashCode() { throw null; }
public static implicit operator System.Index (int value) { throw null; }
public override string ToString() { throw null; }
}
public sealed partial class IndexOutOfRangeException : System.SystemException
{
public IndexOutOfRangeException() { }
public IndexOutOfRangeException(string message) { }
public IndexOutOfRangeException(string message, System.Exception innerException) { }
}
public sealed partial class InsufficientExecutionStackException : System.SystemException
{
public InsufficientExecutionStackException() { }
public InsufficientExecutionStackException(string message) { }
public InsufficientExecutionStackException(string message, System.Exception innerException) { }
}
public sealed partial class InsufficientMemoryException : System.OutOfMemoryException
{
public InsufficientMemoryException() { }
public InsufficientMemoryException(string message) { }
public InsufficientMemoryException(string message, System.Exception innerException) { }
}
public readonly partial struct Int16 : System.IComparable, System.IComparable<short>, System.IConvertible, System.IEquatable<short>, System.IFormattable
{
private readonly short _dummyPrimitive;
public const short MaxValue = (short)32767;
public const short MinValue = (short)-32768;
public int CompareTo(System.Int16 value) { throw null; }
public int CompareTo(object value) { throw null; }
public bool Equals(System.Int16 obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Int16 Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, System.IFormatProvider provider = null) { throw null; }
public static System.Int16 Parse(string s) { throw null; }
public static System.Int16 Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Int16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Int16 Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
System.Int16 System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Int16 result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; }
public static bool TryParse(string s, out System.Int16 result) { throw null; }
}
public readonly partial struct Int32 : System.IComparable, System.IComparable<int>, System.IConvertible, System.IEquatable<int>, System.IFormattable
{
private readonly int _dummyPrimitive;
public const int MaxValue = 2147483647;
public const int MinValue = -2147483648;
public System.Int32 CompareTo(System.Int32 value) { throw null; }
public System.Int32 CompareTo(object value) { throw null; }
public bool Equals(System.Int32 obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override System.Int32 GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Int32 Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, System.IFormatProvider provider = null) { throw null; }
public static System.Int32 Parse(string s) { throw null; }
public static System.Int32 Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Int32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Int32 Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
System.Int32 System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out System.Int32 charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Int32 result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; }
public static bool TryParse(string s, out System.Int32 result) { throw null; }
}
public readonly partial struct Int64 : System.IComparable, System.IComparable<long>, System.IConvertible, System.IEquatable<long>, System.IFormattable
{
private readonly long _dummyPrimitive;
public const long MaxValue = (long)9223372036854775807;
public const long MinValue = (long)-9223372036854775808;
public int CompareTo(System.Int64 value) { throw null; }
public int CompareTo(object value) { throw null; }
public bool Equals(System.Int64 obj) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static System.Int64 Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, System.IFormatProvider provider = null) { throw null; }
public static System.Int64 Parse(string s) { throw null; }
public static System.Int64 Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Int64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Int64 Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
System.Int64 System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Int64 result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; }
public static bool TryParse(string s, out System.Int64 result) { throw null; }
}
public readonly partial struct IntPtr : System.IEquatable<System.IntPtr>, System.Runtime.Serialization.ISerializable
{
private readonly int _dummyPrimitive;
public static readonly System.IntPtr Zero;
public IntPtr(int value) { throw null; }
public IntPtr(long value) { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe IntPtr(void* value) { throw null; }
public static int Size { get { throw null; } }
public static System.IntPtr Add(System.IntPtr pointer, int offset) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public static System.IntPtr operator +(System.IntPtr pointer, int offset) { throw null; }
public static bool operator ==(System.IntPtr value1, System.IntPtr value2) { throw null; }
public static explicit operator System.IntPtr (int value) { throw null; }
public static explicit operator System.IntPtr (long value) { throw null; }
public static explicit operator int (System.IntPtr value) { throw null; }
public static explicit operator long (System.IntPtr value) { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe static explicit operator void* (System.IntPtr value) { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe static explicit operator System.IntPtr (void* value) { throw null; }
public static bool operator !=(System.IntPtr value1, System.IntPtr value2) { throw null; }
public static System.IntPtr operator -(System.IntPtr pointer, int offset) { throw null; }
public static System.IntPtr Subtract(System.IntPtr pointer, int offset) { throw null; }
bool System.IEquatable<System.IntPtr>.Equals(System.IntPtr other) { throw null; }
void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public int ToInt32() { throw null; }
public long ToInt64() { throw null; }
[System.CLSCompliantAttribute(false)]
public unsafe void* ToPointer() { throw null; }
public override string ToString() { throw null; }
public string ToString(string format) { throw null; }
}
public partial class InvalidCastException : System.SystemException
{
public InvalidCastException() { }
protected InvalidCastException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public InvalidCastException(string message) { }
public InvalidCastException(string message, System.Exception innerException) { }
public InvalidCastException(string message, int errorCode) { }
}
public partial class InvalidOperationException : System.SystemException
{
public InvalidOperationException() { }
protected InvalidOperationException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public InvalidOperationException(string message) { }
public InvalidOperationException(string message, System.Exception innerException) { }
}
public sealed partial class InvalidProgramException : System.SystemException
{
public InvalidProgramException() { }
public InvalidProgramException(string message) { }
public InvalidProgramException(string message, System.Exception inner) { }
}
public partial class InvalidTimeZoneException : System.Exception
{
public InvalidTimeZoneException() { }
protected InvalidTimeZoneException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public InvalidTimeZoneException(string message) { }
public InvalidTimeZoneException(string message, System.Exception innerException) { }
}
public partial interface IObservable<out T>
{
System.IDisposable Subscribe(System.IObserver<T> observer);
}
public partial interface IObserver<in T>
{
void OnCompleted();
void OnError(System.Exception error);
void OnNext(T value);
}
public partial interface IProgress<in T>
{
void Report(T value);
}
public partial class Lazy<T>
{
public Lazy() { }
public Lazy(bool isThreadSafe) { }
public Lazy(System.Func<T> valueFactory) { }
public Lazy(System.Func<T> valueFactory, bool isThreadSafe) { }
public Lazy(System.Func<T> valueFactory, System.Threading.LazyThreadSafetyMode mode) { }
public Lazy(System.Threading.LazyThreadSafetyMode mode) { }
public Lazy(T value) { }
public bool IsValueCreated { get { throw null; } }
public T Value { get { throw null; } }
public override string ToString() { throw null; }
}
public partial class Lazy<T, TMetadata> : System.Lazy<T>
{
public Lazy(System.Func<T> valueFactory, TMetadata metadata) { }
public Lazy(System.Func<T> valueFactory, TMetadata metadata, bool isThreadSafe) { }
public Lazy(System.Func<T> valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { }
public Lazy(TMetadata metadata) { }
public Lazy(TMetadata metadata, bool isThreadSafe) { }
public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { }
public TMetadata Metadata { get { throw null; } }
}
public partial class LdapStyleUriParser : System.UriParser
{
public LdapStyleUriParser() { }
}
public abstract partial class MarshalByRefObject
{
protected MarshalByRefObject() { }
public object GetLifetimeService() { throw null; }
public virtual object InitializeLifetimeService() { throw null; }
protected System.MarshalByRefObject MemberwiseClone(bool cloneIdentity) { throw null; }
}
public partial class MemberAccessException : System.SystemException
{
public MemberAccessException() { }
protected MemberAccessException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public MemberAccessException(string message) { }
public MemberAccessException(string message, System.Exception inner) { }
}
public readonly partial struct Memory<T>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public Memory(T[] array) { throw null; }
public Memory(T[] array, int start, int length) { throw null; }
public static System.Memory<T> Empty { get { throw null; } }
public bool IsEmpty { get { throw null; } }
public int Length { get { throw null; } }
public System.Span<T> Span { get { throw null; } }
public void CopyTo(System.Memory<T> destination) { }
public bool Equals(System.Memory<T> other) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
public override bool Equals(object obj) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
public override int GetHashCode() { throw null; }
public static implicit operator System.Memory<T> (System.ArraySegment<T> segment) { throw null; }
public static implicit operator System.ReadOnlyMemory<T> (System.Memory<T> memory) { throw null; }
public static implicit operator System.Memory<T> (T[] array) { throw null; }
public System.Buffers.MemoryHandle Pin() { throw null; }
public System.Memory<T> Slice(int start) { throw null; }
public System.Memory<T> Slice(int start, int length) { throw null; }
public T[] ToArray() { throw null; }
public override string ToString() { throw null; }
public bool TryCopyTo(System.Memory<T> destination) { throw null; }
}
public partial class MethodAccessException : System.MemberAccessException
{
public MethodAccessException() { }
protected MethodAccessException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public MethodAccessException(string message) { }
public MethodAccessException(string message, System.Exception inner) { }
}
public enum MidpointRounding
{
AwayFromZero = 1,
ToEven = 0,
}
public partial class MissingFieldException : System.MissingMemberException, System.Runtime.Serialization.ISerializable
{
public MissingFieldException() { }
protected MissingFieldException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public MissingFieldException(string message) { }
public MissingFieldException(string message, System.Exception inner) { }
public MissingFieldException(string className, string fieldName) { }
public override string Message { get { throw null; } }
}
public partial class MissingMemberException : System.MemberAccessException, System.Runtime.Serialization.ISerializable
{
protected string ClassName;
protected string MemberName;
protected byte[] Signature;
public MissingMemberException() { }
protected MissingMemberException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public MissingMemberException(string message) { }
public MissingMemberException(string message, System.Exception inner) { }
public MissingMemberException(string className, string memberName) { }
public override string Message { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
}
public partial class MissingMethodException : System.MissingMemberException
{
public MissingMethodException() { }
protected MissingMethodException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public MissingMethodException(string message) { }
public MissingMethodException(string message, System.Exception inner) { }
public MissingMethodException(string className, string methodName) { }
public override string Message { get { throw null; } }
}
public partial struct ModuleHandle
{
private object _dummy;
public static readonly System.ModuleHandle EmptyHandle;
public int MDStreamVersion { get { throw null; } }
public bool Equals(System.ModuleHandle handle) { throw null; }
public override bool Equals(object obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.RuntimeFieldHandle GetRuntimeFieldHandleFromMetadataToken(int fieldToken) { throw null; }
public System.RuntimeMethodHandle GetRuntimeMethodHandleFromMetadataToken(int methodToken) { throw null; }
public System.RuntimeTypeHandle GetRuntimeTypeHandleFromMetadataToken(int typeToken) { throw null; }
public static bool operator ==(System.ModuleHandle left, System.ModuleHandle right) { throw null; }
public static bool operator !=(System.ModuleHandle left, System.ModuleHandle right) { throw null; }
public System.RuntimeFieldHandle ResolveFieldHandle(int fieldToken) { throw null; }
public System.RuntimeFieldHandle ResolveFieldHandle(int fieldToken, System.RuntimeTypeHandle[] typeInstantiationContext, System.RuntimeTypeHandle[] methodInstantiationContext) { throw null; }
public System.RuntimeMethodHandle ResolveMethodHandle(int methodToken) { throw null; }
public System.RuntimeMethodHandle ResolveMethodHandle(int methodToken, System.RuntimeTypeHandle[] typeInstantiationContext, System.RuntimeTypeHandle[] methodInstantiationContext) { throw null; }
public System.RuntimeTypeHandle ResolveTypeHandle(int typeToken) { throw null; }
public System.RuntimeTypeHandle ResolveTypeHandle(int typeToken, System.RuntimeTypeHandle[] typeInstantiationContext, System.RuntimeTypeHandle[] methodInstantiationContext) { throw null; }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Method)]
public sealed partial class MTAThreadAttribute : System.Attribute
{
public MTAThreadAttribute() { }
}
public abstract partial class MulticastDelegate : System.Delegate
{
protected MulticastDelegate(object target, string method) : base (default(object), default(string)) { }
protected MulticastDelegate(System.Type target, string method) : base (default(object), default(string)) { }
protected sealed override System.Delegate CombineImpl(System.Delegate follow) { throw null; }
public sealed override bool Equals(object obj) { throw null; }
public sealed override int GetHashCode() { throw null; }
public sealed override System.Delegate[] GetInvocationList() { throw null; }
protected override System.Reflection.MethodInfo GetMethodImpl() { throw null; }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public static bool operator ==(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; }
public static bool operator !=(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; }
protected sealed override System.Delegate RemoveImpl(System.Delegate value) { throw null; }
}
public sealed partial class MulticastNotSupportedException : System.SystemException
{
public MulticastNotSupportedException() { }
public MulticastNotSupportedException(string message) { }
public MulticastNotSupportedException(string message, System.Exception inner) { }
}
public partial class NetPipeStyleUriParser : System.UriParser
{
public NetPipeStyleUriParser() { }
}
public partial class NetTcpStyleUriParser : System.UriParser
{
public NetTcpStyleUriParser() { }
}
public partial class NewsStyleUriParser : System.UriParser
{
public NewsStyleUriParser() { }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Field, Inherited=false)]
public sealed partial class NonSerializedAttribute : System.Attribute
{
public NonSerializedAttribute() { }
}
public partial class NotFiniteNumberException : System.ArithmeticException
{
public NotFiniteNumberException() { }
public NotFiniteNumberException(double offendingNumber) { }
protected NotFiniteNumberException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public NotFiniteNumberException(string message) { }
public NotFiniteNumberException(string message, double offendingNumber) { }
public NotFiniteNumberException(string message, double offendingNumber, System.Exception innerException) { }
public NotFiniteNumberException(string message, System.Exception innerException) { }
public double OffendingNumber { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
}
public partial class NotImplementedException : System.SystemException
{
public NotImplementedException() { }
protected NotImplementedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public NotImplementedException(string message) { }
public NotImplementedException(string message, System.Exception inner) { }
}
public partial class NotSupportedException : System.SystemException
{
public NotSupportedException() { }
protected NotSupportedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public NotSupportedException(string message) { }
public NotSupportedException(string message, System.Exception innerException) { }
}
public static partial class Nullable
{
public static int Compare<T>(System.Nullable<T> n1, System.Nullable<T> n2) where T : struct { throw null; }
public static bool Equals<T>(System.Nullable<T> n1, System.Nullable<T> n2) where T : struct { throw null; }
public static System.Type GetUnderlyingType(System.Type nullableType) { throw null; }
}
public partial struct Nullable<T> where T : struct
{
internal T value;
private int _dummyPrimitive;
public Nullable(T value) { throw null; }
public bool HasValue { get { throw null; } }
public T Value { get { throw null; } }
public override bool Equals(object other) { throw null; }
public override int GetHashCode() { throw null; }
public T GetValueOrDefault() { throw null; }
public T GetValueOrDefault(T defaultValue) { throw null; }
public static explicit operator T (System.Nullable<T> value) { throw null; }
public static implicit operator System.Nullable<T> (T value) { throw null; }
public override string ToString() { throw null; }
}
public partial class NullReferenceException : System.SystemException
{
public NullReferenceException() { }
protected NullReferenceException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public NullReferenceException(string message) { }
public NullReferenceException(string message, System.Exception innerException) { }
}
public partial class Object
{
public Object() { }
public virtual bool Equals(System.Object obj) { throw null; }
public static bool Equals(System.Object objA, System.Object objB) { throw null; }
~Object() { }
public virtual int GetHashCode() { throw null; }
public System.Type GetType() { throw null; }
protected System.Object MemberwiseClone() { throw null; }
public static bool ReferenceEquals(System.Object objA, System.Object objB) { throw null; }
public virtual string ToString() { throw null; }
}
public partial class ObjectDisposedException : System.InvalidOperationException
{
protected ObjectDisposedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public ObjectDisposedException(string objectName) { }
public ObjectDisposedException(string message, System.Exception innerException) { }
public ObjectDisposedException(string objectName, string message) { }
public override string Message { get { throw null; } }
public string ObjectName { get { throw null; } }
public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Constructor | System.AttributeTargets.Delegate | System.AttributeTargets.Enum | System.AttributeTargets.Event | System.AttributeTargets.Field | System.AttributeTargets.Interface | System.AttributeTargets.Method | System.AttributeTargets.Property | System.AttributeTargets.Struct, Inherited=false)]
public sealed partial class ObsoleteAttribute : System.Attribute
{
public ObsoleteAttribute() { }
public ObsoleteAttribute(string message) { }
public ObsoleteAttribute(string message, bool error) { }
public bool IsError { get { throw null; } }
public string Message { get { throw null; } }
}
public partial class OutOfMemoryException : System.SystemException
{
public OutOfMemoryException() { }
protected OutOfMemoryException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public OutOfMemoryException(string message) { }
public OutOfMemoryException(string message, System.Exception innerException) { }
}
public partial class OverflowException : System.ArithmeticException
{
public OverflowException() { }
protected OverflowException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public OverflowException(string message) { }
public OverflowException(string message, System.Exception innerException) { }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Parameter, Inherited=true, AllowMultiple=false)]
public sealed partial class ParamArrayAttribute : System.Attribute
{
public ParamArrayAttribute() { }
}
public partial class PlatformNotSupportedException : System.NotSupportedException
{
public PlatformNotSupportedException() { }
protected PlatformNotSupportedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public PlatformNotSupportedException(string message) { }
public PlatformNotSupportedException(string message, System.Exception inner) { }
}
public delegate bool Predicate<in T>(T obj);
public readonly partial struct Range : System.IEquatable<System.Range>
{
private readonly int _dummyPrimitive;
public System.Index End { get { throw null; } }
public System.Index Start { get { throw null; } }
public static System.Range All() { throw null; }
public static System.Range Create(System.Index start, System.Index end) { throw null; }
public override bool Equals(object value) { throw null; }
public bool Equals(System.Range other) { throw null; }
public static System.Range FromStart(System.Index start) { throw null; }
public override int GetHashCode() { throw null; }
public static System.Range ToEnd(System.Index end) { throw null; }
public override string ToString() { throw null; }
}
public partial class RankException : System.SystemException
{
public RankException() { }
protected RankException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public RankException(string message) { }
public RankException(string message, System.Exception innerException) { }
}
public readonly partial struct ReadOnlyMemory<T>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public ReadOnlyMemory(T[] array) { throw null; }
public ReadOnlyMemory(T[] array, int start, int length) { throw null; }
public static System.ReadOnlyMemory<T> Empty { get { throw null; } }
public bool IsEmpty { get { throw null; } }
public int Length { get { throw null; } }
public System.ReadOnlySpan<T> Span { get { throw null; } }
public void CopyTo(System.Memory<T> destination) { }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
public override bool Equals(object obj) { throw null; }
public bool Equals(System.ReadOnlyMemory<T> other) { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
public override int GetHashCode() { throw null; }
public static implicit operator System.ReadOnlyMemory<T> (System.ArraySegment<T> segment) { throw null; }
public static implicit operator System.ReadOnlyMemory<T> (T[] array) { throw null; }
public System.Buffers.MemoryHandle Pin() { throw null; }
public System.ReadOnlyMemory<T> Slice(int start) { throw null; }
public System.ReadOnlyMemory<T> Slice(int start, int length) { throw null; }
public T[] ToArray() { throw null; }
public override string ToString() { throw null; }
public bool TryCopyTo(System.Memory<T> destination) { throw null; }
}
public readonly ref partial struct ReadOnlySpan<T>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
[System.CLSCompliantAttribute(false)]
public unsafe ReadOnlySpan(void* pointer, int length) { throw null; }
public ReadOnlySpan(T[] array) { throw null; }
public ReadOnlySpan(T[] array, int start, int length) { throw null; }
public static System.ReadOnlySpan<T> Empty { get { throw null; } }
public bool IsEmpty { get { throw null; } }
public ref readonly T this[System.Index index] { get { throw null; } }
public ref readonly T this[int index] { get { throw null; } }
public System.ReadOnlySpan<T> this[System.Range range] { get { throw null; } }
public int Length { get { throw null; } }
public void CopyTo(System.Span<T> destination) { }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
[System.ObsoleteAttribute("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")]
public override bool Equals(object obj) { throw null; }
public System.ReadOnlySpan<T>.Enumerator GetEnumerator() { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
[System.ObsoleteAttribute("GetHashCode() on ReadOnlySpan will always throw an exception.")]
public override int GetHashCode() { throw null; }
[System.ComponentModel.EditorBrowsableAttribute((System.ComponentModel.EditorBrowsableState)(1))]
public ref readonly T GetPinnableReference() { throw null; }
public static bool operator ==(System.ReadOnlySpan<T> left, System.ReadOnlySpan<T> right) { throw null; }
public static implicit operator System.ReadOnlySpan<T> (System.ArraySegment<T> segment) { throw null; }
public static implicit operator System.ReadOnlySpan<T> (T[] array) { throw null; }
public static bool operator !=(System.ReadOnlySpan<T> left, System.ReadOnlySpan<T> right) { throw null; }
public System.ReadOnlySpan<T> Slice(int start) { throw null; }
public System.ReadOnlySpan<T> Slice(int start, int length) { throw null; }
public T[] ToArray() { throw null; }
public override string ToString() { throw null; }
public bool TryCopyTo(System.Span<T> destination) { throw null; }
public ref partial struct Enumerator
{
private object _dummy;
private int _dummyPrimitive;
public ref readonly T Current { get { throw null; } }
public bool MoveNext() { throw null; }
}
}
public partial class ResolveEventArgs : System.EventArgs
{
public ResolveEventArgs(string name) { }
public ResolveEventArgs(string name, System.Reflection.Assembly requestingAssembly) { }
public string Name { get { throw null; } }
public System.Reflection.Assembly RequestingAssembly { get { throw null; } }
}
public ref partial struct RuntimeArgumentHandle
{
private int _dummyPrimitive;
}
public partial struct RuntimeFieldHandle : System.Runtime.Serialization.ISerializable
{
private object _dummy;
public System.IntPtr Value { get { throw null; } }
public override bool Equals(object obj) { throw null; }
public bool Equals(System.RuntimeFieldHandle handle) { throw null; }
public override int GetHashCode() { throw null; }
public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public static bool operator ==(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; }
public static bool operator !=(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; }
}
public partial struct RuntimeMethodHandle : System.Runtime.Serialization.ISerializable
{
private object _dummy;
public System.IntPtr Value { get { throw null; } }
public override bool Equals(object obj) { throw null; }
public bool Equals(System.RuntimeMethodHandle handle) { throw null; }
public System.IntPtr GetFunctionPointer() { throw null; }
public override int GetHashCode() { throw null; }
public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public static bool operator ==(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; }
public static bool operator !=(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; }
}
public partial struct RuntimeTypeHandle : System.Runtime.Serialization.ISerializable
{
private object _dummy;
public System.IntPtr Value { get { throw null; } }
public override bool Equals(object obj) { throw null; }
public bool Equals(System.RuntimeTypeHandle handle) { throw null; }
public override int GetHashCode() { throw null; }
public System.ModuleHandle GetModuleHandle() { throw null; }
public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
public static bool operator ==(object left, System.RuntimeTypeHandle right) { throw null; }
public static bool operator ==(System.RuntimeTypeHandle left, object right) { throw null; }
public static bool operator !=(object left, System.RuntimeTypeHandle right) { throw null; }
public static bool operator !=(System.RuntimeTypeHandle left, object right) { throw null; }
}
[System.CLSCompliantAttribute(false)]
public readonly partial struct SByte : System.IComparable, System.IComparable<sbyte>, System.IConvertible, System.IEquatable<sbyte>, System.IFormattable
{
private readonly sbyte _dummyPrimitive;
public const sbyte MaxValue = (sbyte)127;
public const sbyte MinValue = (sbyte)-128;
public int CompareTo(object obj) { throw null; }
public int CompareTo(System.SByte value) { throw null; }
public override bool Equals(object obj) { throw null; }
public bool Equals(System.SByte obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
[System.CLSCompliantAttribute(false)]
public static System.SByte Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, System.IFormatProvider provider = null) { throw null; }
[System.CLSCompliantAttribute(false)]
public static System.SByte Parse(string s) { throw null; }
[System.CLSCompliantAttribute(false)]
public static System.SByte Parse(string s, System.Globalization.NumberStyles style) { throw null; }
[System.CLSCompliantAttribute(false)]
public static System.SByte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
[System.CLSCompliantAttribute(false)]
public static System.SByte Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
System.SByte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(System.ReadOnlySpan<char> s, out System.SByte result) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; }
[System.CLSCompliantAttribute(false)]
public static bool TryParse(string s, out System.SByte result) { throw null; }
}
[System.AttributeUsageAttribute(System.AttributeTargets.Class | System.AttributeTargets.Delegate | System.AttributeTargets.Enum | System.AttributeTargets.Struct, Inherited=false)]
public sealed partial class SerializableAttribute : System.Attribute
{
public SerializableAttribute() { }
}
public readonly partial struct Single : System.IComparable, System.IComparable<float>, System.IConvertible, System.IEquatable<float>, System.IFormattable
{
private readonly float _dummyPrimitive;
//public const float Epsilon = 1.401298E-45f; -- defined in System.Runtime.Manual.cs
//public const float MaxValue = 3.40282347E+38f; -- defined in System.Runtime.Manual.cs
//public const float MinValue = -3.40282347E+38f; -- defined in System.Runtime.Manual.cs
//public const float NaN = 0.0f / 0.0f; -- defined in System.Runtime.Manual.cs
//public const float NegativeInfinity = -1.0f / 0.0f; -- defined in System.Runtime.Manual.cs
//public const float PositiveInfinity = 1.0f / 0.0f; -- defined in System.Runtime.Manual.cs
public int CompareTo(object value) { throw null; }
public int CompareTo(System.Single value) { throw null; }
public override bool Equals(object obj) { throw null; }
public bool Equals(System.Single obj) { throw null; }
public override int GetHashCode() { throw null; }
public System.TypeCode GetTypeCode() { throw null; }
public static bool IsFinite(System.Single f) { throw null; }
public static bool IsInfinity(System.Single f) { throw null; }
public static bool IsNaN(System.Single f) { throw null; }
public static bool IsNegative(System.Single f) { throw null; }
public static bool IsNegativeInfinity(System.Single f) { throw null; }
public static bool IsNormal(System.Single f) { throw null; }
public static bool IsPositiveInfinity(System.Single f) { throw null; }
public static bool IsSubnormal(System.Single f) { throw null; }
public static bool operator ==(System.Single left, System.Single right) { throw null; }
public static bool operator >(System.Single left, System.Single right) { throw null; }
public static bool operator >=(System.Single left, System.Single right) { throw null; }
public static bool operator !=(System.Single left, System.Single right) { throw null; }
public static bool operator <(System.Single left, System.Single right) { throw null; }
public static bool operator <=(System.Single left, System.Single right) { throw null; }
public static System.Single Parse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.AllowDecimalPoint | System.Globalization.NumberStyles.AllowExponent | System.Globalization.NumberStyles.AllowLeadingSign | System.Globalization.NumberStyles.AllowLeadingWhite | System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.AllowTrailingWhite, System.IFormatProvider provider = null) { throw null; }
public static System.Single Parse(string s) { throw null; }
public static System.Single Parse(string s, System.Globalization.NumberStyles style) { throw null; }
public static System.Single Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; }
public static System.Single Parse(string s, System.IFormatProvider provider) { throw null; }
bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; }
byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; }
char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; }
System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; }
decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; }
double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; }
short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; }
int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; }
long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; }
sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; }
System.Single System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; }
object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; }
ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; }
uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; }
ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; }
public override string ToString() { throw null; }
public string ToString(System.IFormatProvider provider) { throw null; }
public string ToString(string format) { throw null; }
public string ToString(string format, System.IFormatProvider provider) { throw null; }
public bool TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format = default(System.ReadOnlySpan<char>), System.IFormatProvider provider = null) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; }
public static bool TryParse(System.ReadOnlySpan<char> s, out System.Single result) { throw null; }
public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; }
public static bool TryParse(string s, out System.Single result) { throw null; }
}
public readonly ref partial struct Span<T>
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
[System.CLSCompliantAttribute(false)]
public unsafe Span(void* pointer, int length) { throw null; }
public Span(T[] array) {