Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
2051 lines (2004 sloc) 89.1 KB

API Diff between RC1 and RC2

System

namespace System {
  public static class Activator {
    public static object CreateInstance(Type type, bool nonPublic);
  }
  public static class AppContext {
    public static string TargetFrameworkName { get; }
    public static object GetData(string name);
  }
  public static class Console {
    public static int BufferHeight { get; set; }
    public static int BufferWidth { get; set; }
    public static bool CapsLock { get; }
    public static int CursorLeft { get; set; }
    public static int CursorSize { get; set; }
    public static int CursorTop { get; set; }
    public static Encoding InputEncoding { get; set; }
    public static bool KeyAvailable { get; }
    public static int LargestWindowHeight { get; }
    public static int LargestWindowWidth { get; }
    public static bool NumberLock { get; }
    public static Encoding OutputEncoding { get; set; }
    public static string Title { get; set; }
    public static bool TreatControlCAsInput { get; set; }
    public static int WindowHeight { get; set; }
    public static int WindowLeft { get; set; }
    public static int WindowTop { get; set; }
    public static void Beep();
    public static void Beep(int frequency, int duration);
    public static void Clear();
    public static void MoveBufferArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop);
    public static void MoveBufferArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop, char sourceChar, ConsoleColor sourceForeColor, ConsoleColor sourceBackColor);
    public static void SetBufferSize(int width, int height);
    public static void SetCursorPosition(int left, int top);
    public static void SetWindowPosition(int left, int top);
    public static void SetWindowSize(int width, int height);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct ConsoleKeyInfo {
    public bool Equals(ConsoleKeyInfo obj);
    public override bool Equals(object value);
    public override int GetHashCode();
    public static bool operator ==(ConsoleKeyInfo a, ConsoleKeyInfo b);
    public static bool operator !=(ConsoleKeyInfo a, ConsoleKeyInfo b);
  }
  public static class Environment {
    public static string MachineName { get; }
    public static void Exit(int exitCode);
    public static string[] GetCommandLineArgs();
  }
  public abstract class Type {
    public static readonly char Delimiter;
    public static TypeCode GetTypeCode(Type type);
  }
}

System.ComponentModel.DataAnnotations

namespace System.ComponentModel.DataAnnotations {
  public class RegularExpressionAttribute : ValidationAttribute {
    public int MatchTimeoutInMilliseconds { get; set; }
  }
}

System.Data

namespace System.Data {
  public enum DataRowVersion {
    Default = 1536,
  }
  public class DataTable {
  }
  public interface IDataParameter {
    DbType DbType { get; set; }
    ParameterDirection Direction { get; set; }
    bool IsNullable { get; }
    string ParameterName { get; set; }
    string SourceColumn { get; set; }
    DataRowVersion SourceVersion { get; set; }
    object Value { get; set; }
  }
  public interface IDataParameterCollection : ICollection, IEnumerable, IList {
    object this[string parameterName] { get; set; }
    bool Contains(string parameterName);
    int IndexOf(string parameterName);
    void RemoveAt(string parameterName);
  }
  public interface IDataReader : IDataRecord, IDisposable {
    int Depth { get; }
    bool IsClosed { get; }
    int RecordsAffected { get; }
    void Close();
    DataTable GetSchemaTable();
    bool NextResult();
    bool Read();
  }
  public interface IDataRecord {
    int FieldCount { get; }
    object this[int i] { get; }
    object this[string name] { get; }
    bool GetBoolean(int i);
    byte GetByte(int i);
    long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length);
    char GetChar(int i);
    long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length);
    IDataReader GetData(int i);
    string GetDataTypeName(int i);
    DateTime GetDateTime(int i);
    decimal GetDecimal(int i);
    double GetDouble(int i);
    Type GetFieldType(int i);
    float GetFloat(int i);
    Guid GetGuid(int i);
    short GetInt16(int i);
    int GetInt32(int i);
    long GetInt64(int i);
    string GetName(int i);
    int GetOrdinal(string name);
    string GetString(int i);
    object GetValue(int i);
    int GetValues(object[] values);
    bool IsDBNull(int i);
  }
  public interface IDbCommand : IDisposable {
    string CommandText { get; set; }
    int CommandTimeout { get; set; }
    CommandType CommandType { get; set; }
    IDbConnection Connection { get; set; }
    IDataParameterCollection Parameters { get; }
    IDbTransaction Transaction { get; set; }
    UpdateRowSource UpdatedRowSource { get; set; }
    void Cancel();
    IDbDataParameter CreateParameter();
    int ExecuteNonQuery();
    IDataReader ExecuteReader();
    IDataReader ExecuteReader(CommandBehavior behavior);
    object ExecuteScalar();
    void Prepare();
  }
  public interface IDbConnection : IDisposable {
    string ConnectionString { get; set; }
    int ConnectionTimeout { get; }
    string Database { get; }
    ConnectionState State { get; }
    IDbTransaction BeginTransaction();
    IDbTransaction BeginTransaction(IsolationLevel il);
    void ChangeDatabase(string databaseName);
    void Close();
    IDbCommand CreateCommand();
    void Open();
  }
  public interface IDbDataParameter : IDataParameter {
    byte Precision { get; set; }
    byte Scale { get; set; }
    int Size { get; set; }
  }
  public interface IDbTransaction : IDisposable {
    IDbConnection Connection { get; }
    IsolationLevel IsolationLevel { get; }
    void Commit();
    void Rollback();
  }
}

System.Data.Common

namespace System.Data.Common {
  public abstract class DbColumn {
    protected DbColumn();
    public Nullable<bool> AllowDBNull { get; protected set; }
    public string BaseCatalogName { get; protected set; }
    public string BaseColumnName { get; protected set; }
    public string BaseSchemaName { get; protected set; }
    public string BaseServerName { get; protected set; }
    public string BaseTableName { get; protected set; }
    public string ColumnName { get; protected set; }
    public Nullable<int> ColumnOrdinal { get; protected set; }
    public Nullable<int> ColumnSize { get; protected set; }
    public Type DataType { get; protected set; }
    public string DataTypeName { get; protected set; }
    public Nullable<bool> IsAliased { get; protected set; }
    public Nullable<bool> IsAutoIncrement { get; protected set; }
    public Nullable<bool> IsExpression { get; protected set; }
    public Nullable<bool> IsHidden { get; protected set; }
    public Nullable<bool> IsIdentity { get; protected set; }
    public Nullable<bool> IsKey { get; protected set; }
    public Nullable<bool> IsLong { get; protected set; }
    public Nullable<bool> IsReadOnly { get; protected set; }
    public Nullable<bool> IsUnique { get; protected set; }
    public Nullable<int> NumericPrecision { get; protected set; }
    public Nullable<int> NumericScale { get; protected set; }
    public virtual object this[string property] { get; }
    public string UdtAssemblyQualifiedName { get; protected set; }
  }
  public abstract class DbCommand : IDbCommand, IDisposable {
    IDbConnection System.Data.IDbCommand.Connection { get; set; }
    IDataParameterCollection System.Data.IDbCommand.Parameters { get; }
    IDbTransaction System.Data.IDbCommand.Transaction { get; set; }
    IDbDataParameter System.Data.IDbCommand.CreateParameter();
    IDataReader System.Data.IDbCommand.ExecuteReader();
    IDataReader System.Data.IDbCommand.ExecuteReader(CommandBehavior behavior);
  }
  public abstract class DbConnection : IDbConnection, IDisposable {
    IDbTransaction System.Data.IDbConnection.BeginTransaction();
    IDbTransaction System.Data.IDbConnection.BeginTransaction(IsolationLevel isolationLevel);
    IDbCommand System.Data.IDbConnection.CreateCommand();
  }
  public abstract class DbDataReader : IDataReader, IDataRecord, IDisposable, IEnumerable {
    void System.Data.IDataReader.Close();
    DataTable System.Data.IDataReader.GetSchemaTable();
    IDataReader System.Data.IDataRecord.GetData(int ordinal);
  }
  public static class DbDataReaderExtensions {
    public static bool CanGetColumnSchema(this DbDataReader reader);
    public static ReadOnlyCollection<DbColumn> GetColumnSchema(this DbDataReader reader);
  }
  public abstract class DbDataRecord : IDataRecord {
    protected DbDataRecord();
    public abstract int FieldCount { get; }
    public abstract object this[int i] { get; }
    public abstract object this[string name] { get; }
    public abstract bool GetBoolean(int i);
    public abstract byte GetByte(int i);
    public abstract long GetBytes(int i, long dataIndex, byte[] buffer, int bufferIndex, int length);
    public abstract char GetChar(int i);
    public abstract long GetChars(int i, long dataIndex, char[] buffer, int bufferIndex, int length);
    public IDataReader GetData(int i);
    public abstract string GetDataTypeName(int i);
    public abstract DateTime GetDateTime(int i);
    protected virtual DbDataReader GetDbDataReader(int i);
    public abstract decimal GetDecimal(int i);
    public abstract double GetDouble(int i);
    public abstract Type GetFieldType(int i);
    public abstract float GetFloat(int i);
    public abstract Guid GetGuid(int i);
    public abstract short GetInt16(int i);
    public abstract int GetInt32(int i);
    public abstract long GetInt64(int i);
    public abstract string GetName(int i);
    public abstract int GetOrdinal(string name);
    public abstract string GetString(int i);
    public abstract object GetValue(int i);
    public abstract int GetValues(object[] values);
    public abstract bool IsDBNull(int i);
  }
  public abstract class DbParameter : IDataParameter, IDbDataParameter {
    DataRowVersion System.Data.IDataParameter.SourceVersion { get; set; }
    byte System.Data.IDbDataParameter.Precision { get; set; }
    byte System.Data.IDbDataParameter.Scale { get; set; }
  }
  public abstract class DbParameterCollection : ICollection, IDataParameterCollection, IEnumerable, IList {
    object System.Data.IDataParameterCollection.this[string parameterName] { get; set; }
  }
  public abstract class DbTransaction : IDbTransaction, IDisposable {
    IDbConnection System.Data.IDbTransaction.Connection { get; }
  }
  public interface IDbColumnSchemaGenerator {
    ReadOnlyCollection<DbColumn> GetColumnSchema();
  }
}

System.Data.SqlClient

namespace System.Data.SqlClient {
  public sealed class SqlBulkCopy : IDisposable {
    public SqlBulkCopy(SqlConnection connection);
    public SqlBulkCopy(SqlConnection connection, SqlBulkCopyOptions copyOptions, SqlTransaction externalTransaction);
    public SqlBulkCopy(string connectionString);
    public SqlBulkCopy(string connectionString, SqlBulkCopyOptions copyOptions);
    public int BatchSize { get; set; }
    public int BulkCopyTimeout { get; set; }
    public SqlBulkCopyColumnMappingCollection ColumnMappings { get; }
    public string DestinationTableName { get; set; }
    public bool EnableStreaming { get; set; }
    public int NotifyAfter { get; set; }
    public event SqlRowsCopiedEventHandler SqlRowsCopied;
    public void Close();
    void System.IDisposable.Dispose();
    public void WriteToServer(DbDataReader reader);
    public Task WriteToServerAsync(DbDataReader reader);
    public Task WriteToServerAsync(DbDataReader reader, CancellationToken cancellationToken);
  }
  public sealed class SqlBulkCopyColumnMapping {
    public SqlBulkCopyColumnMapping();
    public SqlBulkCopyColumnMapping(int sourceColumnOrdinal, int destinationOrdinal);
    public SqlBulkCopyColumnMapping(int sourceColumnOrdinal, string destinationColumn);
    public SqlBulkCopyColumnMapping(string sourceColumn, int destinationOrdinal);
    public SqlBulkCopyColumnMapping(string sourceColumn, string destinationColumn);
    public string DestinationColumn { get; set; }
    public int DestinationOrdinal { get; set; }
    public string SourceColumn { get; set; }
    public int SourceOrdinal { get; set; }
  }
  public sealed class SqlBulkCopyColumnMappingCollection : ICollection, IEnumerable, IList {
    public int Count { get; }
    bool System.Collections.ICollection.IsSynchronized { get; }
    object System.Collections.ICollection.SyncRoot { get; }
    bool System.Collections.IList.IsFixedSize { get; }
    bool System.Collections.IList.IsReadOnly { get; }
    object System.Collections.IList.this[int index] { get; set; }
    public SqlBulkCopyColumnMapping this[int index] { get; }
    public SqlBulkCopyColumnMapping Add(SqlBulkCopyColumnMapping bulkCopyColumnMapping);
    public SqlBulkCopyColumnMapping Add(int sourceColumnIndex, int destinationColumnIndex);
    public SqlBulkCopyColumnMapping Add(int sourceColumnIndex, string destinationColumn);
    public SqlBulkCopyColumnMapping Add(string sourceColumn, int destinationColumnIndex);
    public SqlBulkCopyColumnMapping Add(string sourceColumn, string destinationColumn);
    public void Clear();
    public bool Contains(SqlBulkCopyColumnMapping value);
    public void CopyTo(SqlBulkCopyColumnMapping[] array, int index);
    public IEnumerator GetEnumerator();
    public int IndexOf(SqlBulkCopyColumnMapping value);
    public void Insert(int index, SqlBulkCopyColumnMapping value);
    public void Remove(SqlBulkCopyColumnMapping value);
    public void RemoveAt(int index);
    void System.Collections.ICollection.CopyTo(Array array, int index);
    int System.Collections.IList.Add(object value);
    bool System.Collections.IList.Contains(object value);
    int System.Collections.IList.IndexOf(object value);
    void System.Collections.IList.Insert(int index, object value);
    void System.Collections.IList.Remove(object value);
  }
  public enum SqlBulkCopyOptions {
    CheckConstraints = 2,
    Default = 0,
    FireTriggers = 16,
    KeepIdentity = 1,
    KeepNulls = 8,
    TableLock = 4,
    UseInternalTransaction = 32,
  }
  public class SqlRowsCopiedEventArgs : EventArgs {
    public SqlRowsCopiedEventArgs(long rowsCopied);
    public bool Abort { get; set; }
    public long RowsCopied { get; }
  }
  public delegate void SqlRowsCopiedEventHandler(object sender, SqlRowsCopiedEventArgs e);
}

System.Diagnostics

namespace System.Diagnostics {
  public sealed class ProcessStartInfo {
    public string Domain { get; set; }
    public bool LoadUserProfile { get; set; }
    public string PasswordInClearText { get; set; }
    public string UserName { get; set; }
  }
}

System.Drawing

namespace System.Drawing {
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct Point {
    public static readonly Point Empty;
    public Point(Size sz);
    public Point(int dw);
    public Point(int x, int y);
    public bool IsEmpty { get; }
    public int X { get; set; }
    public int Y { get; set; }
    public static Point Add(Point pt, Size sz);
    public static Point Ceiling(PointF value);
    public override bool Equals(object obj);
    public override int GetHashCode();
    public void Offset(Point p);
    public void Offset(int dx, int dy);
    public static Point operator +(Point pt, Size sz);
    public static bool operator ==(Point left, Point right);
    public static explicit operator Size (Point p);
    public static implicit operator PointF (Point p);
    public static bool operator !=(Point left, Point right);
    public static Point operator -(Point pt, Size sz);
    public static Point Round(PointF value);
    public static Point Subtract(Point pt, Size sz);
    public override string ToString();
    public static Point Truncate(PointF value);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct PointF {
    public static readonly PointF Empty;
    public PointF(float x, float y);
    public bool IsEmpty { get; }
    public float X { get; set; }
    public float Y { get; set; }
    public static PointF Add(PointF pt, Size sz);
    public static PointF Add(PointF pt, SizeF sz);
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static PointF operator +(PointF pt, Size sz);
    public static PointF operator +(PointF pt, SizeF sz);
    public static bool operator ==(PointF left, PointF right);
    public static bool operator !=(PointF left, PointF right);
    public static PointF operator -(PointF pt, Size sz);
    public static PointF operator -(PointF pt, SizeF sz);
    public static PointF Subtract(PointF pt, Size sz);
    public static PointF Subtract(PointF pt, SizeF sz);
    public override string ToString();
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct Rectangle {
    public static readonly Rectangle Empty;
    public Rectangle(Point location, Size size);
    public Rectangle(int x, int y, int width, int height);
    public int Bottom { get; }
    public int Height { get; set; }
    public bool IsEmpty { get; }
    public int Left { get; }
    public Point Location { get; set; }
    public int Right { get; }
    public Size Size { get; set; }
    public int Top { get; }
    public int Width { get; set; }
    public int X { get; set; }
    public int Y { get; set; }
    public static Rectangle Ceiling(RectangleF value);
    public bool Contains(Point pt);
    public bool Contains(Rectangle rect);
    public bool Contains(int x, int y);
    public override bool Equals(object obj);
    public static Rectangle FromLTRB(int left, int top, int right, int bottom);
    public override int GetHashCode();
    public static Rectangle Inflate(Rectangle rect, int x, int y);
    public void Inflate(Size size);
    public void Inflate(int width, int height);
    public void Intersect(Rectangle rect);
    public static Rectangle Intersect(Rectangle a, Rectangle b);
    public bool IntersectsWith(Rectangle rect);
    public void Offset(Point pos);
    public void Offset(int x, int y);
    public static bool operator ==(Rectangle left, Rectangle right);
    public static bool operator !=(Rectangle left, Rectangle right);
    public static Rectangle Round(RectangleF value);
    public override string ToString();
    public static Rectangle Truncate(RectangleF value);
    public static Rectangle Union(Rectangle a, Rectangle b);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct RectangleF {
    public static readonly RectangleF Empty;
    public RectangleF(PointF location, SizeF size);
    public RectangleF(float x, float y, float width, float height);
    public float Bottom { get; }
    public float Height { get; set; }
    public bool IsEmpty { get; }
    public float Left { get; }
    public PointF Location { get; set; }
    public float Right { get; }
    public SizeF Size { get; set; }
    public float Top { get; }
    public float Width { get; set; }
    public float X { get; set; }
    public float Y { get; set; }
    public bool Contains(PointF pt);
    public bool Contains(RectangleF rect);
    public bool Contains(float x, float y);
    public override bool Equals(object obj);
    public static RectangleF FromLTRB(float left, float top, float right, float bottom);
    public override int GetHashCode();
    public static RectangleF Inflate(RectangleF rect, float x, float y);
    public void Inflate(SizeF size);
    public void Inflate(float x, float y);
    public void Intersect(RectangleF rect);
    public static RectangleF Intersect(RectangleF a, RectangleF b);
    public bool IntersectsWith(RectangleF rect);
    public void Offset(PointF pos);
    public void Offset(float x, float y);
    public static bool operator ==(RectangleF left, RectangleF right);
    public static implicit operator RectangleF (Rectangle r);
    public static bool operator !=(RectangleF left, RectangleF right);
    public override string ToString();
    public static RectangleF Union(RectangleF a, RectangleF b);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct Size {
    public static readonly Size Empty;
    public Size(Point pt);
    public Size(int width, int height);
    public int Height { get; set; }
    public bool IsEmpty { get; }
    public int Width { get; set; }
    public static Size Add(Size sz1, Size sz2);
    public static Size Ceiling(SizeF value);
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static Size operator +(Size sz1, Size sz2);
    public static bool operator ==(Size sz1, Size sz2);
    public static explicit operator Point (Size size);
    public static implicit operator SizeF (Size p);
    public static bool operator !=(Size sz1, Size sz2);
    public static Size operator -(Size sz1, Size sz2);
    public static Size Round(SizeF value);
    public static Size Subtract(Size sz1, Size sz2);
    public override string ToString();
    public static Size Truncate(SizeF value);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
  public struct SizeF {
    public static readonly SizeF Empty;
    public SizeF(PointF pt);
    public SizeF(SizeF size);
    public SizeF(float width, float height);
    public float Height { get; set; }
    public bool IsEmpty { get; }
    public float Width { get; set; }
    public static SizeF Add(SizeF sz1, SizeF sz2);
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static SizeF operator +(SizeF sz1, SizeF sz2);
    public static bool operator ==(SizeF sz1, SizeF sz2);
    public static explicit operator PointF (SizeF size);
    public static bool operator !=(SizeF sz1, SizeF sz2);
    public static SizeF operator -(SizeF sz1, SizeF sz2);
    public static SizeF Subtract(SizeF sz1, SizeF sz2);
    public PointF ToPointF();
    public Size ToSize();
    public override string ToString();
  }
}

System.IO

namespace System.IO {
  public sealed class BufferedStream : Stream {
    public BufferedStream(Stream stream);
    public BufferedStream(Stream stream, int bufferSize);
    public override bool CanRead { get; }
    public override bool CanSeek { get; }
    public override bool CanWrite { get; }
    public override long Length { get; }
    public override long Position { get; set; }
    protected override void Dispose(bool disposing);
    public override void Flush();
    public override Task FlushAsync(CancellationToken cancellationToken);
    public override int Read(byte[] array, int offset, int count);
    public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
    public override int ReadByte();
    public override long Seek(long offset, SeekOrigin origin);
    public override void SetLength(long value);
    public override void Write(byte[] array, int offset, int count);
    public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
    public override void WriteByte(byte value);
  }
  public class FileFormatException : FormatException {
    public FileFormatException();
    public FileFormatException(string message);
    public FileFormatException(string message, Exception innerException);
    public FileFormatException(Uri sourceUri);
    public FileFormatException(Uri sourceUri, Exception innerException);
    public FileFormatException(Uri sourceUri, string message);
    public FileFormatException(Uri sourceUri, string message, Exception innerException);
    public Uri SourceUri { get; }
  }
}

System.IO.Packaging

namespace System.IO.Packaging {
  public enum CompressionOption {
    Fast = 2,
    Maximum = 1,
    Normal = 0,
    NotCompressed = -1,
    SuperFast = 3,
  }
  public enum EncryptionOption {
    None = 0,
    RightsManagement = 1,
  }
  public abstract class Package : IDisposable {
    protected Package(FileAccess openFileAccess);
    public FileAccess FileOpenAccess { get; }
    public PackageProperties PackageProperties { get; }
    public void Close();
    public PackagePart CreatePart(Uri partUri, string contentType);
    public PackagePart CreatePart(Uri partUri, string contentType, CompressionOption compressionOption);
    protected abstract PackagePart CreatePartCore(Uri partUri, string contentType, CompressionOption compressionOption);
    public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType);
    public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType, string id);
    public void DeletePart(Uri partUri);
    protected abstract void DeletePartCore(Uri partUri);
    public void DeleteRelationship(string id);
    protected virtual void Dispose(bool disposing);
    public void Flush();
    protected abstract void FlushCore();
    public PackagePart GetPart(Uri partUri);
    protected abstract PackagePart GetPartCore(Uri partUri);
    public PackagePartCollection GetParts();
    protected abstract PackagePart[] GetPartsCore();
    public PackageRelationship GetRelationship(string id);
    public PackageRelationshipCollection GetRelationships();
    public PackageRelationshipCollection GetRelationshipsByType(string relationshipType);
    public static Package Open(Stream stream);
    public static Package Open(Stream stream, FileMode packageMode);
    public static Package Open(Stream stream, FileMode packageMode, FileAccess packageAccess);
    public static Package Open(string path);
    public static Package Open(string path, FileMode packageMode);
    public static Package Open(string path, FileMode packageMode, FileAccess packageAccess);
    public static Package Open(string path, FileMode packageMode, FileAccess packageAccess, FileShare packageShare);
    public virtual bool PartExists(Uri partUri);
    public bool RelationshipExists(string id);
    void System.IDisposable.Dispose();
  }
  public abstract class PackagePart {
    protected PackagePart(Package package, Uri partUri);
    protected PackagePart(Package package, Uri partUri, string contentType);
    protected PackagePart(Package package, Uri partUri, string contentType, CompressionOption compressionOption);
    public CompressionOption CompressionOption { get; }
    public string ContentType { get; }
    public Package Package { get; }
    public Uri Uri { get; }
    public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType);
    public PackageRelationship CreateRelationship(Uri targetUri, TargetMode targetMode, string relationshipType, string id);
    public void DeleteRelationship(string id);
    protected virtual string GetContentTypeCore();
    public PackageRelationship GetRelationship(string id);
    public PackageRelationshipCollection GetRelationships();
    public PackageRelationshipCollection GetRelationshipsByType(string relationshipType);
    public Stream GetStream();
    public Stream GetStream(FileMode mode);
    public Stream GetStream(FileMode mode, FileAccess access);
    protected abstract Stream GetStreamCore(FileMode mode, FileAccess access);
    public bool RelationshipExists(string id);
  }
  public class PackagePartCollection : IEnumerable, IEnumerable<PackagePart> {
    public IEnumerator<PackagePart> GetEnumerator();
    IEnumerator<PackagePart> System.Collections.Generic.IEnumerable<System.IO.Packaging.PackagePart>.GetEnumerator();
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
  public abstract class PackageProperties : IDisposable {
    protected PackageProperties();
    public abstract string Category { get; set; }
    public abstract string ContentStatus { get; set; }
    public abstract string ContentType { get; set; }
    public abstract Nullable<DateTime> Created { get; set; }
    public abstract string Creator { get; set; }
    public abstract string Description { get; set; }
    public abstract string Identifier { get; set; }
    public abstract string Keywords { get; set; }
    public abstract string Language { get; set; }
    public abstract string LastModifiedBy { get; set; }
    public abstract Nullable<DateTime> LastPrinted { get; set; }
    public abstract Nullable<DateTime> Modified { get; set; }
    public abstract string Revision { get; set; }
    public abstract string Subject { get; set; }
    public abstract string Title { get; set; }
    public abstract string Version { get; set; }
    public void Dispose();
    protected virtual void Dispose(bool disposing);
  }
  public class PackageRelationship {
    public string Id { get; }
    public Package Package { get; }
    public string RelationshipType { get; }
    public Uri SourceUri { get; }
    public TargetMode TargetMode { get; }
    public Uri TargetUri { get; }
  }
  public class PackageRelationshipCollection : IEnumerable, IEnumerable<PackageRelationship> {
    public IEnumerator<PackageRelationship> GetEnumerator();
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
  public sealed class PackageRelationshipSelector {
    public PackageRelationshipSelector(Uri sourceUri, PackageRelationshipSelectorType selectorType, string selectionCriteria);
    public string SelectionCriteria { get; }
    public PackageRelationshipSelectorType SelectorType { get; }
    public Uri SourceUri { get; }
    public List<PackageRelationship> Select(Package package);
  }
  public enum PackageRelationshipSelectorType {
    Id = 0,
    Type = 1,
  }
  public static class PackUriHelper {
    public static readonly string UriSchemePack;
    public static int ComparePartUri(Uri firstPartUri, Uri secondPartUri);
    public static Uri CreatePartUri(Uri partUri);
    public static Uri GetNormalizedPartUri(Uri partUri);
    public static Uri GetRelationshipPartUri(Uri partUri);
    public static Uri GetRelativeUri(Uri sourcePartUri, Uri targetPartUri);
    public static Uri GetSourcePartUriFromRelationshipPartUri(Uri relationshipPartUri);
    public static bool IsRelationshipPartUri(Uri partUri);
    public static Uri ResolvePartUri(Uri sourcePartUri, Uri targetUri);
  }
  public enum TargetMode {
    External = 1,
    Internal = 0,
  }
  public sealed class ZipPackage : Package {
    protected override PackagePart CreatePartCore(Uri partUri, string contentType, CompressionOption compressionOption);
    protected override void DeletePartCore(Uri partUri);
    protected override void Dispose(bool disposing);
    protected override void FlushCore();
    protected override PackagePart GetPartCore(Uri partUri);
    protected override PackagePart[] GetPartsCore();
  }
  public sealed class ZipPackagePart : PackagePart {
    protected override Stream GetStreamCore(FileMode streamFileMode, FileAccess streamFileAccess);
  }
}

System.Linq

namespace System.Linq {
  public static class Enumerable {
    public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element);
    public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element);
  }
}

System.Net

namespace System.Net {
  public class WebException : InvalidOperationException {
    public WebException(string message, Exception innerinnerException);
    public WebException(string message, Exception innerinnerException, WebExceptionStatus status, WebResponse response);
  }
}

System.Net.NetworkInformation

namespace System.Net.NetworkInformation {
  public enum DuplicateAddressDetectionState {
    Deprecated = 3,
    Duplicate = 2,
    Invalid = 0,
    Preferred = 4,
    Tentative = 1,
  }
  public abstract class GatewayIPAddressInformation {
    protected GatewayIPAddressInformation();
    public abstract IPAddress Address { get; }
  }
  public class GatewayIPAddressInformationCollection : ICollection<GatewayIPAddressInformation>, IEnumerable, IEnumerable<GatewayIPAddressInformation> {
    protected internal GatewayIPAddressInformationCollection();
    public virtual int Count { get; }
    public virtual bool IsReadOnly { get; }
    public virtual GatewayIPAddressInformation this[int index] { get; }
    public virtual void Add(GatewayIPAddressInformation address);
    public virtual void Clear();
    public virtual bool Contains(GatewayIPAddressInformation address);
    public virtual void CopyTo(GatewayIPAddressInformation[] array, int offset);
    public virtual IEnumerator<GatewayIPAddressInformation> GetEnumerator();
    public virtual bool Remove(GatewayIPAddressInformation address);
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
  public abstract class IcmpV4Statistics {
    protected IcmpV4Statistics();
    public abstract long AddressMaskRepliesReceived { get; }
    public abstract long AddressMaskRepliesSent { get; }
    public abstract long AddressMaskRequestsReceived { get; }
    public abstract long AddressMaskRequestsSent { get; }
    public abstract long DestinationUnreachableMessagesReceived { get; }
    public abstract long DestinationUnreachableMessagesSent { get; }
    public abstract long EchoRepliesReceived { get; }
    public abstract long EchoRepliesSent { get; }
    public abstract long EchoRequestsReceived { get; }
    public abstract long EchoRequestsSent { get; }
    public abstract long ErrorsReceived { get; }
    public abstract long ErrorsSent { get; }
    public abstract long MessagesReceived { get; }
    public abstract long MessagesSent { get; }
    public abstract long ParameterProblemsReceived { get; }
    public abstract long ParameterProblemsSent { get; }
    public abstract long RedirectsReceived { get; }
    public abstract long RedirectsSent { get; }
    public abstract long SourceQuenchesReceived { get; }
    public abstract long SourceQuenchesSent { get; }
    public abstract long TimeExceededMessagesReceived { get; }
    public abstract long TimeExceededMessagesSent { get; }
    public abstract long TimestampRepliesReceived { get; }
    public abstract long TimestampRepliesSent { get; }
    public abstract long TimestampRequestsReceived { get; }
    public abstract long TimestampRequestsSent { get; }
  }
  public abstract class IcmpV6Statistics {
    protected IcmpV6Statistics();
    public abstract long DestinationUnreachableMessagesReceived { get; }
    public abstract long DestinationUnreachableMessagesSent { get; }
    public abstract long EchoRepliesReceived { get; }
    public abstract long EchoRepliesSent { get; }
    public abstract long EchoRequestsReceived { get; }
    public abstract long EchoRequestsSent { get; }
    public abstract long ErrorsReceived { get; }
    public abstract long ErrorsSent { get; }
    public abstract long MembershipQueriesReceived { get; }
    public abstract long MembershipQueriesSent { get; }
    public abstract long MembershipReductionsReceived { get; }
    public abstract long MembershipReductionsSent { get; }
    public abstract long MembershipReportsReceived { get; }
    public abstract long MembershipReportsSent { get; }
    public abstract long MessagesReceived { get; }
    public abstract long MessagesSent { get; }
    public abstract long NeighborAdvertisementsReceived { get; }
    public abstract long NeighborAdvertisementsSent { get; }
    public abstract long NeighborSolicitsReceived { get; }
    public abstract long NeighborSolicitsSent { get; }
    public abstract long PacketTooBigMessagesReceived { get; }
    public abstract long PacketTooBigMessagesSent { get; }
    public abstract long ParameterProblemsReceived { get; }
    public abstract long ParameterProblemsSent { get; }
    public abstract long RedirectsReceived { get; }
    public abstract long RedirectsSent { get; }
    public abstract long RouterAdvertisementsReceived { get; }
    public abstract long RouterAdvertisementsSent { get; }
    public abstract long RouterSolicitsReceived { get; }
    public abstract long RouterSolicitsSent { get; }
    public abstract long TimeExceededMessagesReceived { get; }
    public abstract long TimeExceededMessagesSent { get; }
  }
  public abstract class IPAddressInformation {
    protected IPAddressInformation();
    public abstract IPAddress Address { get; }
    public abstract bool IsDnsEligible { get; }
    public abstract bool IsTransient { get; }
  }
  public class IPAddressInformationCollection : ICollection<IPAddressInformation>, IEnumerable, IEnumerable<IPAddressInformation> {
    public virtual int Count { get; }
    public virtual bool IsReadOnly { get; }
    public virtual IPAddressInformation this[int index] { get; }
    public virtual void Add(IPAddressInformation address);
    public virtual void Clear();
    public virtual bool Contains(IPAddressInformation address);
    public virtual void CopyTo(IPAddressInformation[] array, int offset);
    public virtual IEnumerator<IPAddressInformation> GetEnumerator();
    public virtual bool Remove(IPAddressInformation address);
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
  public abstract class IPGlobalProperties {
    protected IPGlobalProperties();
    public abstract string DhcpScopeName { get; }
    public abstract string DomainName { get; }
    public abstract string HostName { get; }
    public abstract bool IsWinsProxy { get; }
    public abstract NetBiosNodeType NodeType { get; }
    public abstract TcpConnectionInformation[] GetActiveTcpConnections();
    public abstract IPEndPoint[] GetActiveTcpListeners();
    public abstract IPEndPoint[] GetActiveUdpListeners();
    public abstract IcmpV4Statistics GetIcmpV4Statistics();
    public abstract IcmpV6Statistics GetIcmpV6Statistics();
    public static IPGlobalProperties GetIPGlobalProperties();
    public abstract IPGlobalStatistics GetIPv4GlobalStatistics();
    public abstract IPGlobalStatistics GetIPv6GlobalStatistics();
    public abstract TcpStatistics GetTcpIPv4Statistics();
    public abstract TcpStatistics GetTcpIPv6Statistics();
    public abstract UdpStatistics GetUdpIPv4Statistics();
    public abstract UdpStatistics GetUdpIPv6Statistics();
    public virtual Task<UnicastIPAddressInformationCollection> GetUnicastAddressesAsync();
  }
  public abstract class IPGlobalStatistics {
    protected IPGlobalStatistics();
    public abstract int DefaultTtl { get; }
    public abstract bool ForwardingEnabled { get; }
    public abstract int NumberOfInterfaces { get; }
    public abstract int NumberOfIPAddresses { get; }
    public abstract int NumberOfRoutes { get; }
    public abstract long OutputPacketRequests { get; }
    public abstract long OutputPacketRoutingDiscards { get; }
    public abstract long OutputPacketsDiscarded { get; }
    public abstract long OutputPacketsWithNoRoute { get; }
    public abstract long PacketFragmentFailures { get; }
    public abstract long PacketReassembliesRequired { get; }
    public abstract long PacketReassemblyFailures { get; }
    public abstract long PacketReassemblyTimeout { get; }
    public abstract long PacketsFragmented { get; }
    public abstract long PacketsReassembled { get; }
    public abstract long ReceivedPackets { get; }
    public abstract long ReceivedPacketsDelivered { get; }
    public abstract long ReceivedPacketsDiscarded { get; }
    public abstract long ReceivedPacketsForwarded { get; }
    public abstract long ReceivedPacketsWithAddressErrors { get; }
    public abstract long ReceivedPacketsWithHeadersErrors { get; }
    public abstract long ReceivedPacketsWithUnknownProtocol { get; }
  }
  public abstract class IPInterfaceProperties {
    protected IPInterfaceProperties();
    public abstract IPAddressInformationCollection AnycastAddresses { get; }
    public abstract IPAddressCollection DhcpServerAddresses { get; }
    public abstract IPAddressCollection DnsAddresses { get; }
    public abstract string DnsSuffix { get; }
    public abstract GatewayIPAddressInformationCollection GatewayAddresses { get; }
    public abstract bool IsDnsEnabled { get; }
    public abstract bool IsDynamicDnsEnabled { get; }
    public abstract MulticastIPAddressInformationCollection MulticastAddresses { get; }
    public abstract UnicastIPAddressInformationCollection UnicastAddresses { get; }
    public abstract IPAddressCollection WinsServersAddresses { get; }
    public abstract IPv4InterfaceProperties GetIPv4Properties();
    public abstract IPv6InterfaceProperties GetIPv6Properties();
  }
  public abstract class IPInterfaceStatistics {
    protected IPInterfaceStatistics();
    public abstract long BytesReceived { get; }
    public abstract long BytesSent { get; }
    public abstract long IncomingPacketsDiscarded { get; }
    public abstract long IncomingPacketsWithErrors { get; }
    public abstract long IncomingUnknownProtocolPackets { get; }
    public abstract long NonUnicastPacketsReceived { get; }
    public abstract long NonUnicastPacketsSent { get; }
    public abstract long OutgoingPacketsDiscarded { get; }
    public abstract long OutgoingPacketsWithErrors { get; }
    public abstract long OutputQueueLength { get; }
    public abstract long UnicastPacketsReceived { get; }
    public abstract long UnicastPacketsSent { get; }
  }
  public abstract class IPv4InterfaceProperties {
    protected IPv4InterfaceProperties();
    public abstract int Index { get; }
    public abstract bool IsAutomaticPrivateAddressingActive { get; }
    public abstract bool IsAutomaticPrivateAddressingEnabled { get; }
    public abstract bool IsDhcpEnabled { get; }
    public abstract bool IsForwardingEnabled { get; }
    public abstract int Mtu { get; }
    public abstract bool UsesWins { get; }
  }
  public abstract class IPv6InterfaceProperties {
    protected IPv6InterfaceProperties();
    public abstract int Index { get; }
    public abstract int Mtu { get; }
    public virtual long GetScopeId(ScopeLevel scopeLevel);
  }
  public abstract class MulticastIPAddressInformation : IPAddressInformation {
    protected MulticastIPAddressInformation();
    public abstract long AddressPreferredLifetime { get; }
    public abstract long AddressValidLifetime { get; }
    public abstract long DhcpLeaseLifetime { get; }
    public abstract DuplicateAddressDetectionState DuplicateAddressDetectionState { get; }
    public abstract PrefixOrigin PrefixOrigin { get; }
    public abstract SuffixOrigin SuffixOrigin { get; }
  }
  public class MulticastIPAddressInformationCollection : ICollection<MulticastIPAddressInformation>, IEnumerable, IEnumerable<MulticastIPAddressInformation> {
    protected internal MulticastIPAddressInformationCollection();
    public virtual int Count { get; }
    public virtual bool IsReadOnly { get; }
    public virtual MulticastIPAddressInformation this[int index] { get; }
    public virtual void Add(MulticastIPAddressInformation address);
    public virtual void Clear();
    public virtual bool Contains(MulticastIPAddressInformation address);
    public virtual void CopyTo(MulticastIPAddressInformation[] array, int offset);
    public virtual IEnumerator<MulticastIPAddressInformation> GetEnumerator();
    public virtual bool Remove(MulticastIPAddressInformation address);
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
  public enum NetBiosNodeType {
    Broadcast = 1,
    Hybrid = 8,
    Mixed = 4,
    Peer2Peer = 2,
    Unknown = 0,
  }
  public class NetworkInformationException : Exception {
    public NetworkInformationException();
    public NetworkInformationException(int errorCode);
    public int ErrorCode { get; }
  }
  public static abstract class NetworkInterface {
    protected NetworkInterface();
    public virtual string Description { get; }
    public virtual string Id { get; }
    public static int IPv6LoopbackInterfaceIndex { get; }
    public virtual bool IsReceiveOnly { get; }
    public static int LoopbackInterfaceIndex { get; }
    public virtual string Name { get; }
    public virtual NetworkInterfaceType NetworkInterfaceType { get; }
    public virtual OperationalStatus OperationalStatus { get; }
    public virtual long Speed { get; }
    public virtual bool SupportsMulticast { get; }
    public static NetworkInterface[] GetAllNetworkInterfaces();
    public virtual IPInterfaceProperties GetIPProperties();
    public virtual IPInterfaceStatistics GetIPStatistics();
    public virtual PhysicalAddress GetPhysicalAddress();
    public virtual bool Supports(NetworkInterfaceComponent networkInterfaceComponent);
  }
  public enum NetworkInterfaceComponent {
    IPv4 = 0,
    IPv6 = 1,
  }
  public enum NetworkInterfaceType {
    AsymmetricDsl = 94,
    Atm = 37,
    BasicIsdn = 20,
    Ethernet = 6,
    Ethernet3Megabit = 26,
    FastEthernetFx = 69,
    FastEthernetT = 62,
    Fddi = 15,
    GenericModem = 48,
    GigabitEthernet = 117,
    HighPerformanceSerialBus = 144,
    IPOverAtm = 114,
    Isdn = 63,
    Loopback = 24,
    MultiRateSymmetricDsl = 143,
    Ppp = 23,
    PrimaryIsdn = 21,
    RateAdaptDsl = 95,
    Slip = 28,
    SymmetricDsl = 96,
    TokenRing = 9,
    Tunnel = 131,
    Unknown = 1,
    VeryHighSpeedDsl = 97,
    Wireless80211 = 71,
    Wman = 237,
    Wwanpp = 243,
    Wwanpp2 = 244,
  }
  public enum OperationalStatus {
    Dormant = 5,
    Down = 2,
    LowerLayerDown = 7,
    NotPresent = 6,
    Testing = 3,
    Unknown = 4,
    Up = 1,
  }
  public class PhysicalAddress {
    public static readonly PhysicalAddress None;
    public PhysicalAddress(byte[] address);
    public override bool Equals(object comparand);
    public byte[] GetAddressBytes();
    public override int GetHashCode();
    public static PhysicalAddress Parse(string address);
    public override string ToString();
  }
  public enum PrefixOrigin {
    Dhcp = 3,
    Manual = 1,
    Other = 0,
    RouterAdvertisement = 4,
    WellKnown = 2,
  }
  public enum ScopeLevel {
    Admin = 4,
    Global = 14,
    Interface = 1,
    Link = 2,
    None = 0,
    Organization = 8,
    Site = 5,
    Subnet = 3,
  }
  public enum SuffixOrigin {
    LinkLayerAddress = 4,
    Manual = 1,
    OriginDhcp = 3,
    Other = 0,
    Random = 5,
    WellKnown = 2,
  }
  public abstract class TcpConnectionInformation {
    protected TcpConnectionInformation();
    public abstract IPEndPoint LocalEndPoint { get; }
    public abstract IPEndPoint RemoteEndPoint { get; }
    public abstract TcpState State { get; }
  }
  public enum TcpState {
    Closed = 1,
    CloseWait = 8,
    Closing = 9,
    DeleteTcb = 12,
    Established = 5,
    FinWait1 = 6,
    FinWait2 = 7,
    LastAck = 10,
    Listen = 2,
    SynReceived = 4,
    SynSent = 3,
    TimeWait = 11,
    Unknown = 0,
  }
  public abstract class TcpStatistics {
    protected TcpStatistics();
    public abstract long ConnectionsAccepted { get; }
    public abstract long ConnectionsInitiated { get; }
    public abstract long CumulativeConnections { get; }
    public abstract long CurrentConnections { get; }
    public abstract long ErrorsReceived { get; }
    public abstract long FailedConnectionAttempts { get; }
    public abstract long MaximumConnections { get; }
    public abstract long MaximumTransmissionTimeout { get; }
    public abstract long MinimumTransmissionTimeout { get; }
    public abstract long ResetConnections { get; }
    public abstract long ResetsSent { get; }
    public abstract long SegmentsReceived { get; }
    public abstract long SegmentsResent { get; }
    public abstract long SegmentsSent { get; }
  }
  public abstract class UdpStatistics {
    protected UdpStatistics();
    public abstract long DatagramsReceived { get; }
    public abstract long DatagramsSent { get; }
    public abstract long IncomingDatagramsDiscarded { get; }
    public abstract long IncomingDatagramsWithErrors { get; }
    public abstract int UdpListeners { get; }
  }
  public abstract class UnicastIPAddressInformation : IPAddressInformation {
    protected UnicastIPAddressInformation();
    public abstract long AddressPreferredLifetime { get; }
    public abstract long AddressValidLifetime { get; }
    public abstract long DhcpLeaseLifetime { get; }
    public abstract DuplicateAddressDetectionState DuplicateAddressDetectionState { get; }
    public abstract IPAddress IPv4Mask { get; }
    public virtual int PrefixLength { get; }
    public abstract PrefixOrigin PrefixOrigin { get; }
    public abstract SuffixOrigin SuffixOrigin { get; }
  }
  public class UnicastIPAddressInformationCollection : ICollection<UnicastIPAddressInformation>, IEnumerable, IEnumerable<UnicastIPAddressInformation> {
    protected internal UnicastIPAddressInformationCollection();
    public virtual int Count { get; }
    public virtual bool IsReadOnly { get; }
    public virtual UnicastIPAddressInformation this[int index] { get; }
    public virtual void Add(UnicastIPAddressInformation address);
    public virtual void Clear();
    public virtual bool Contains(UnicastIPAddressInformation address);
    public virtual void CopyTo(UnicastIPAddressInformation[] array, int offset);
    public virtual IEnumerator<UnicastIPAddressInformation> GetEnumerator();
    public virtual bool Remove(UnicastIPAddressInformation address);
    IEnumerator System.Collections.IEnumerable.GetEnumerator();
  }
}

System.Net.Security

namespace System.Net.Security {
  public abstract class AuthenticatedStream : Stream {
    protected AuthenticatedStream(Stream innerStream, bool leaveInnerStreamOpen);
    protected Stream InnerStream { get; }
    public abstract bool IsAuthenticated { get; }
    public abstract bool IsEncrypted { get; }
    public abstract bool IsMutuallyAuthenticated { get; }
    public abstract bool IsServer { get; }
    public abstract bool IsSigned { get; }
    public bool LeaveInnerStreamOpen { get; }
    protected override void Dispose(bool disposing);
  }
  public class NegotiateStream : AuthenticatedStream {
    public NegotiateStream(Stream innerStream);
    public NegotiateStream(Stream innerStream, bool leaveInnerStreamOpen);
    public override bool CanRead { get; }
    public override bool CanSeek { get; }
    public override bool CanTimeout { get; }
    public override bool CanWrite { get; }
    public virtual TokenImpersonationLevel ImpersonationLevel { get; }
    public override bool IsAuthenticated { get; }
    public override bool IsEncrypted { get; }
    public override bool IsMutuallyAuthenticated { get; }
    public override bool IsServer { get; }
    public override bool IsSigned { get; }
    public override long Length { get; }
    public override long Position { get; set; }
    public override int ReadTimeout { get; set; }
    public virtual IIdentity RemoteIdentity { get; }
    public override int WriteTimeout { get; set; }
    public virtual Task AuthenticateAsClientAsync();
    public virtual Task AuthenticateAsClientAsync(NetworkCredential credential, ChannelBinding binding, string targetName);
    public virtual Task AuthenticateAsClientAsync(NetworkCredential credential, ChannelBinding binding, string targetName, ProtectionLevel requiredProtectionLevel, TokenImpersonationLevel allowedImpersonationLevel);
    public virtual Task AuthenticateAsClientAsync(NetworkCredential credential, string targetName);
    public virtual Task AuthenticateAsClientAsync(NetworkCredential credential, string targetName, ProtectionLevel requiredProtectionLevel, TokenImpersonationLevel allowedImpersonationLevel);
    public virtual Task AuthenticateAsServerAsync();
    public virtual Task AuthenticateAsServerAsync(NetworkCredential credential, ProtectionLevel requiredProtectionLevel, TokenImpersonationLevel requiredImpersonationLevel);
    public virtual Task AuthenticateAsServerAsync(NetworkCredential credential, ExtendedProtectionPolicy policy, ProtectionLevel requiredProtectionLevel, TokenImpersonationLevel requiredImpersonationLevel);
    public virtual Task AuthenticateAsServerAsync(ExtendedProtectionPolicy policy);
    public override void Flush();
    public override int Read(byte[] buffer, int offset, int count);
    public override long Seek(long offset, SeekOrigin origin);
    public override void SetLength(long value);
    public override void Write(byte[] buffer, int offset, int count);
  }
  public enum ProtectionLevel {
    EncryptAndSign = 2,
    None = 0,
    Sign = 1,
  }
  public class SslStream : StreamAuthenticatedStream {
    public override bool IsAuthenticated { get; }
    public override bool IsEncrypted { get; }
    public override bool IsMutuallyAuthenticated { get; }
    public override bool IsServer { get; }
    public override bool IsSigned { get; }
    public virtual void AuthenticateAsClient(string targetHost);
    public virtual void AuthenticateAsClient(string targetHost, X509CertificateCollection clientCertificates, SslProtocols enabledSslProtocols, bool checkCertificateRevocation);
    public virtual void AuthenticateAsServer(X509Certificate serverCertificate);
    public virtual void AuthenticateAsServer(X509Certificate serverCertificate, bool clientCertificateRequired, SslProtocols enabledSslProtocols, bool checkCertificateRevocation);
  }
}

System.Net.Sockets

namespace System.Net.Sockets {
  public enum IOControlCode : long {
    AbsorbRouterAlert = (long)2550136837,
    AddMulticastGroupOnInterface = (long)2550136842,
    AddressListChange = (long)671088663,
    AddressListQuery = (long)1207959574,
    AddressListSort = (long)3355443225,
    AssociateHandle = (long)2281701377,
    AsyncIO = (long)2147772029,
    BindToInterface = (long)2550136840,
    DataToRead = (long)1074030207,
    DeleteMulticastGroupFromInterface = (long)2550136843,
    EnableCircularQueuing = (long)671088642,
    Flush = (long)671088644,
    GetBroadcastAddress = (long)1207959557,
    GetExtensionFunctionPointer = (long)3355443206,
    GetGroupQos = (long)3355443208,
    GetQos = (long)3355443207,
    KeepAliveValues = (long)2550136836,
    LimitBroadcasts = (long)2550136839,
    MulticastInterface = (long)2550136841,
    MulticastScope = (long)2281701386,
    MultipointLoopback = (long)2281701385,
    NamespaceChange = (long)2281701401,
    NonBlockingIO = (long)2147772030,
    OobDataRead = (long)1074033415,
    QueryTargetPnpHandle = (long)1207959576,
    ReceiveAll = (long)2550136833,
    ReceiveAllIgmpMulticast = (long)2550136835,
    ReceiveAllMulticast = (long)2550136834,
    RoutingInterfaceChange = (long)2281701397,
    RoutingInterfaceQuery = (long)3355443220,
    SetGroupQos = (long)2281701388,
    SetQos = (long)2281701387,
    TranslateHandle = (long)3355443213,
    UnicastInterface = (long)2550136838,
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct IPPacketInformation {
    public IPAddress Address { get; }
    public int Interface { get; }
    public override bool Equals(object comparand);
    public override int GetHashCode();
    public static bool operator ==(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
    public static bool operator !=(IPPacketInformation packetInformation1, IPPacketInformation packetInformation2);
  }
  public enum IPProtectionLevel {
    EdgeRestricted = 20,
    Restricted = 30,
    Unrestricted = 10,
    Unspecified = -1,
  }
  public class IPv6MulticastOption {
    public IPv6MulticastOption(IPAddress group);
    public IPv6MulticastOption(IPAddress group, long ifindex);
    public IPAddress Group { get; set; }
    public long InterfaceIndex { get; set; }
  }
  public class LingerOption {
    public LingerOption(bool enable, int seconds);
    public bool Enabled { get; set; }
    public int LingerTime { get; set; }
  }
  public class MulticastOption {
    public MulticastOption(IPAddress group);
    public MulticastOption(IPAddress group, int interfaceIndex);
    public MulticastOption(IPAddress group, IPAddress mcint);
    public IPAddress Group { get; set; }
    public int InterfaceIndex { get; set; }
    public IPAddress LocalAddress { get; set; }
  }
  public class NetworkStream : Stream {
    public NetworkStream(Socket socket);
    public NetworkStream(Socket socket, bool ownsSocket);
    public override bool CanRead { get; }
    public override bool CanSeek { get; }
    public override bool CanTimeout { get; }
    public override bool CanWrite { get; }
    public virtual bool DataAvailable { get; }
    public override long Length { get; }
    public override long Position { get; set; }
    public override int ReadTimeout { get; set; }
    public override int WriteTimeout { get; set; }
    protected override void Dispose(bool disposing);
    ~NetworkStream();
    public override void Flush();
    public override Task FlushAsync(CancellationToken cancellationToken);
    public override int Read(byte[] buffer, int offset, int size);
    public override Task<int> ReadAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
    public override long Seek(long offset, SeekOrigin origin);
    public override void SetLength(long value);
    public override void Write(byte[] buffer, int offset, int size);
    public override Task WriteAsync(byte[] buffer, int offset, int size, CancellationToken cancellationToken);
  }
  public enum ProtocolType {
    Ggp = 3,
    Icmp = 1,
    IcmpV6 = 58,
    Idp = 22,
    Igmp = 2,
    IP = 0,
    IPSecAuthenticationHeader = 51,
    IPSecEncapsulatingSecurityPayload = 50,
    IPv4 = 4,
    IPv6 = 41,
    IPv6DestinationOptions = 60,
    IPv6FragmentHeader = 44,
    IPv6HopByHopOptions = 0,
    IPv6NoNextHeader = 59,
    IPv6RoutingHeader = 43,
    Ipx = 1000,
    ND = 77,
    Pup = 12,
    Raw = 255,
    Spx = 1256,
    SpxII = 1257,
  }
  public enum SelectMode {
    SelectError = 2,
    SelectRead = 0,
    SelectWrite = 1,
  }
  public class SendPacketsElement {
    public SendPacketsElement(byte[] buffer);
    public SendPacketsElement(byte[] buffer, int offset, int count);
    public SendPacketsElement(byte[] buffer, int offset, int count, bool endOfPacket);
    public SendPacketsElement(string filepath);
    public SendPacketsElement(string filepath, int offset, int count);
    public SendPacketsElement(string filepath, int offset, int count, bool endOfPacket);
    public byte[] Buffer { get; }
    public int Count { get; }
    public bool EndOfPacket { get; }
    public string FilePath { get; }
    public int Offset { get; }
  }
  public class Socket : IDisposable {
    public int Available { get; }
    public bool Blocking { get; set; }
    public bool DontFragment { get; set; }
    public bool DualMode { get; set; }
    public bool EnableBroadcast { get; set; }
    public bool ExclusiveAddressUse { get; set; }
    public bool IsBound { get; }
    public LingerOption LingerState { get; set; }
    public bool MulticastLoopback { get; set; }
    public int ReceiveTimeout { get; set; }
    public int SendTimeout { get; set; }
    public SocketType SocketType { get; }
    public Socket Accept();
    public void Connect(EndPoint remoteEP);
    public void Connect(IPAddress address, int port);
    public void Connect(IPAddress[] addresses, int port);
    public void Connect(string host, int port);
    public object GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName);
    public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
    public byte[] GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionLength);
    public int IOControl(int ioControlCode, byte[] optionInValue, byte[] optionOutValue);
    public int IOControl(IOControlCode ioControlCode, byte[] optionInValue, byte[] optionOutValue);
    public bool Poll(int microSeconds, SelectMode mode);
    public int Receive(byte[] buffer);
    public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags);
    public int Receive(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
    public int Receive(byte[] buffer, int size, SocketFlags socketFlags);
    public int Receive(byte[] buffer, SocketFlags socketFlags);
    public int Receive(IList<ArraySegment<byte>> buffers);
    public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
    public int Receive(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
    public int ReceiveFrom(byte[] buffer, int offset, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
    public int ReceiveFrom(byte[] buffer, int size, SocketFlags socketFlags, ref EndPoint remoteEP);
    public int ReceiveFrom(byte[] buffer, ref EndPoint remoteEP);
    public int ReceiveFrom(byte[] buffer, SocketFlags socketFlags, ref EndPoint remoteEP);
    public int ReceiveMessageFrom(byte[] buffer, int offset, int size, ref SocketFlags socketFlags, ref EndPoint remoteEP, out IPPacketInformation ipPacketInformation);
    public bool ReceiveMessageFromAsync(SocketAsyncEventArgs e);
    public static void Select(IList checkRead, IList checkWrite, IList checkError, int microSeconds);
    public int Send(byte[] buffer);
    public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags);
    public int Send(byte[] buffer, int offset, int size, SocketFlags socketFlags, out SocketError errorCode);
    public int Send(byte[] buffer, int size, SocketFlags socketFlags);
    public int Send(byte[] buffer, SocketFlags socketFlags);
    public int Send(IList<ArraySegment<byte>> buffers);
    public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
    public int Send(IList<ArraySegment<byte>> buffers, SocketFlags socketFlags, out SocketError errorCode);
    public bool SendPacketsAsync(SocketAsyncEventArgs e);
    public int SendTo(byte[] buffer, int offset, int size, SocketFlags socketFlags, EndPoint remoteEP);
    public int SendTo(byte[] buffer, int size, SocketFlags socketFlags, EndPoint remoteEP);
    public int SendTo(byte[] buffer, EndPoint remoteEP);
    public int SendTo(byte[] buffer, SocketFlags socketFlags, EndPoint remoteEP);
    public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, bool optionValue);
    public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
    public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue);
    public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue);
  }
  public class SocketAsyncEventArgs : EventArgs, IDisposable {
    public IPPacketInformation ReceiveMessageFromPacketInfo { get; }
    public SendPacketsElement[] SendPacketsElements { get; set; }
    public int SendPacketsSendSize { get; set; }
    public SocketFlags SocketFlags { get; set; }
  }
  public enum SocketAsyncOperation {
    Disconnect = 3,
    ReceiveMessageFrom = 6,
    SendPackets = 8,
  }
  public enum SocketFlags {
    Broadcast = 1024,
    ControlDataTruncated = 512,
    DontRoute = 4,
    Multicast = 2048,
    None = 0,
    OutOfBand = 1,
    Partial = 32768,
    Peek = 2,
    Truncated = 256,
  }
  public enum SocketOptionLevel {
    IP = 0,
    IPv6 = 41,
    Socket = 65535,
    Tcp = 6,
    Udp = 17,
  }
  public enum SocketOptionName {
    AcceptConnection = 2,
    AddMembership = 12,
    AddSourceMembership = 15,
    BlockSource = 17,
    Broadcast = 32,
    BsdUrgent = 2,
    ChecksumCoverage = 20,
    Debug = 1,
    DontFragment = 14,
    DontLinger = -129,
    DontRoute = 16,
    DropMembership = 13,
    DropSourceMembership = 16,
    Error = 4103,
    ExclusiveAddressUse = -5,
    Expedited = 2,
    HeaderIncluded = 2,
    HopLimit = 21,
    IPOptions = 1,
    IPProtectionLevel = 23,
    IpTimeToLive = 4,
    IPv6Only = 27,
    KeepAlive = 8,
    Linger = 128,
    MaxConnections = 2147483647,
    MulticastInterface = 9,
    MulticastLoopback = 11,
    MulticastTimeToLive = 10,
    NoChecksum = 1,
    NoDelay = 1,
    OutOfBandInline = 256,
    PacketInformation = 19,
    ReceiveBuffer = 4098,
    ReceiveLowWater = 4100,
    ReceiveTimeout = 4102,
    ReuseAddress = 4,
    ReuseUnicastPort = 12295,
    SendBuffer = 4097,
    SendLowWater = 4099,
    SendTimeout = 4101,
    Type = 4104,
    TypeOfService = 3,
    UnblockSource = 18,
    UpdateAcceptContext = 28683,
    UpdateConnectContext = 28688,
    UseLoopback = 64,
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct SocketReceiveFromResult {
    public int ReceivedBytes;
    public EndPoint RemoteEndPoint;
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct SocketReceiveMessageFromResult {
    public int ReceivedBytes;
    public EndPoint RemoteEndPoint;
    public IPPacketInformation PacketInformation;
    public SocketFlags SocketFlags;
  }
  public static class SocketTaskExtensions {
    public static Task<Socket> AcceptAsync(this Socket socket);
    public static Task<Socket> AcceptAsync(this Socket socket, Socket acceptSocket);
    public static Task ConnectAsync(this Socket socket, EndPoint remoteEP);
    public static Task ConnectAsync(this Socket socket, IPAddress address, int port);
    public static Task ConnectAsync(this Socket socket, IPAddress[] addresses, int port);
    public static Task ConnectAsync(this Socket socket, string host, int port);
    public static Task<int> ReceiveAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
    public static Task<int> ReceiveAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
    public static Task<SocketReceiveFromResult> ReceiveFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
    public static Task<SocketReceiveMessageFromResult> ReceiveMessageFromAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEndPoint);
    public static Task<int> SendAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags);
    public static Task<int> SendAsync(this Socket socket, IList<ArraySegment<byte>> buffers, SocketFlags socketFlags);
    public static Task<int> SendToAsync(this Socket socket, ArraySegment<byte> buffer, SocketFlags socketFlags, EndPoint remoteEP);
  }
  public enum SocketType {
    Raw = 3,
    Rdm = 4,
    Seqpacket = 5,
  }
  public class TcpClient : IDisposable {
    public TcpClient();
    public TcpClient(AddressFamily family);
    protected bool Active { get; set; }
    public int Available { get; }
    public bool Connected { get; }
    public bool ExclusiveAddressUse { get; set; }
    public LingerOption LingerState { get; set; }
    public bool NoDelay { get; set; }
    public int ReceiveBufferSize { get; set; }
    public int ReceiveTimeout { get; set; }
    public int SendBufferSize { get; set; }
    public int SendTimeout { get; set; }
    public Task ConnectAsync(IPAddress address, int port);
    public Task ConnectAsync(IPAddress[] addresses, int port);
    public Task ConnectAsync(string host, int port);
    public void Dispose();
    protected virtual void Dispose(bool disposing);
    ~TcpClient();
    public NetworkStream GetStream();
  }
  public class TcpListener {
    public TcpListener(IPAddress localaddr, int port);
    public TcpListener(IPEndPoint localEP);
    protected bool Active { get; }
    public bool ExclusiveAddressUse { get; set; }
    public EndPoint LocalEndpoint { get; }
    public Socket Server { get; }
    public Task<Socket> AcceptSocketAsync();
    public Task<TcpClient> AcceptTcpClientAsync();
    public bool Pending();
    public void Start();
    public void Start(int backlog);
    public void Stop();
  }
  public class UdpClient : IDisposable {
    public UdpClient();
    public UdpClient(int port);
    public UdpClient(int port, AddressFamily family);
    public UdpClient(IPEndPoint localEP);
    public UdpClient(AddressFamily family);
    protected bool Active { get; set; }
    public int Available { get; }
    public bool DontFragment { get; set; }
    public bool EnableBroadcast { get; set; }
    public bool ExclusiveAddressUse { get; set; }
    public bool MulticastLoopback { get; set; }
    public short Ttl { get; set; }
    public void Dispose();
    protected virtual void Dispose(bool disposing);
    public void DropMulticastGroup(IPAddress multicastAddr);
    public void DropMulticastGroup(IPAddress multicastAddr, int ifindex);
    public void JoinMulticastGroup(int ifindex, IPAddress multicastAddr);
    public void JoinMulticastGroup(IPAddress multicastAddr);
    public void JoinMulticastGroup(IPAddress multicastAddr, int timeToLive);
    public void JoinMulticastGroup(IPAddress multicastAddr, IPAddress localAddress);
    public Task<UdpReceiveResult> ReceiveAsync();
    public Task<int> SendAsync(byte[] datagram, int bytes, IPEndPoint endPoint);
    public Task<int> SendAsync(byte[] datagram, int bytes, string hostname, int port);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct UdpReceiveResult : IEquatable<UdpReceiveResult> {
    public UdpReceiveResult(byte[] buffer, IPEndPoint remoteEndPoint);
    public byte[] Buffer { get; }
    public IPEndPoint RemoteEndPoint { get; }
    public bool Equals(UdpReceiveResult other);
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static bool operator ==(UdpReceiveResult left, UdpReceiveResult right);
    public static bool operator !=(UdpReceiveResult left, UdpReceiveResult right);
  }
}

System.Reflection

namespace System.Reflection {
  public abstract class Assembly : ICustomAttributeProvider {
    public virtual string CodeBase { get; }
    public virtual string ImageRuntimeVersion { get; }
    public object CreateInstance(string typeName);
    public object CreateInstance(string typeName, bool ignoreCase);
    public static string CreateQualifiedName(string assemblyName, string typeName);
    public static Assembly GetEntryAssembly();
    public virtual Type[] GetExportedTypes();
    public virtual AssemblyName[] GetReferencedAssemblies();
    public virtual Type GetType(string name, bool throwOnError);
    public virtual Type[] GetTypes();
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(bool inherit);
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit);
    bool System.Reflection.ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit);
  }
  public enum BindingFlags {
    CreateInstance = 512,
    Default = 0,
    GetField = 1024,
    GetProperty = 4096,
    InvokeMethod = 256,
    SetField = 2048,
    SetProperty = 8192,
  }
  public abstract class ConstructorInfo : MethodBase {
    public override MemberTypes MemberType { get; }
  }
  public class CustomAttributeData {
    public virtual ConstructorInfo Constructor { get; }
    public static IList<CustomAttributeData> GetCustomAttributes(Assembly target);
    public static IList<CustomAttributeData> GetCustomAttributes(MemberInfo target);
    public static IList<CustomAttributeData> GetCustomAttributes(Module target);
    public static IList<CustomAttributeData> GetCustomAttributes(ParameterInfo target);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct CustomAttributeNamedArgument {
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static bool operator ==(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right);
    public static bool operator !=(CustomAttributeNamedArgument left, CustomAttributeNamedArgument right);
    public override string ToString();
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct CustomAttributeTypedArgument {
    public override bool Equals(object obj);
    public override int GetHashCode();
    public static bool operator ==(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right);
    public static bool operator !=(CustomAttributeTypedArgument left, CustomAttributeTypedArgument right);
    public override string ToString();
  }
  public abstract class EventInfo : MemberInfo {
    public virtual bool IsMulticast { get; }
    public override MemberTypes MemberType { get; }
    public MethodInfo GetAddMethod();
    public abstract MethodInfo GetAddMethod(bool nonPublic);
    public MethodInfo GetRaiseMethod();
    public abstract MethodInfo GetRaiseMethod(bool nonPublic);
    public MethodInfo GetRemoveMethod();
    public abstract MethodInfo GetRemoveMethod(bool nonPublic);
  }
  public abstract class FieldInfo : MemberInfo {
    public override MemberTypes MemberType { get; }
    public virtual Type[] GetOptionalCustomModifiers();
    public virtual object GetRawConstantValue();
    public virtual Type[] GetRequiredCustomModifiers();
  }
  public interface ICustomAttributeProvider {
    object[] GetCustomAttributes(bool inherit);
    object[] GetCustomAttributes(Type attributeType, bool inherit);
    bool IsDefined(Type attributeType, bool inherit);
  }
  public class InvalidFilterCriteriaException : Exception {
    public InvalidFilterCriteriaException();
    public InvalidFilterCriteriaException(string message);
    public InvalidFilterCriteriaException(string message, Exception inner);
  }
  public delegate bool MemberFilter(MemberInfo m, object filterCriteria);
  public abstract class MemberInfo : ICustomAttributeProvider {
    public abstract MemberTypes MemberType { get; }
    public virtual int MetadataToken { get; }
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(bool inherit);
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit);
    bool System.Reflection.ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit);
  }
  public enum MemberTypes {
    All = 191,
    Constructor = 1,
    Custom = 64,
    Event = 2,
    Field = 4,
    Method = 8,
    NestedType = 128,
    Property = 16,
    TypeInfo = 32,
  }
  public abstract class MethodBase : MemberInfo {
    public abstract MethodImplAttributes GetMethodImplementationFlags();
  }
  public abstract class MethodInfo : MethodBase {
    public override MemberTypes MemberType { get; }
    public abstract ICustomAttributeProvider ReturnTypeCustomAttributes { get; }
    public abstract MethodInfo GetBaseDefinition();
  }
  public abstract class Module : ICustomAttributeProvider {
    public static readonly TypeFilter FilterTypeName;
    public static readonly TypeFilter FilterTypeNameIgnoreCase;
    public virtual Guid ModuleVersionId { get; }
    public virtual string ScopeName { get; }
    public virtual Type[] FindTypes(TypeFilter filter, object filterCriteria);
    public FieldInfo GetField(string name);
    public virtual FieldInfo GetField(string name, BindingFlags bindingAttr);
    public FieldInfo[] GetFields();
    public virtual FieldInfo[] GetFields(BindingFlags bindingFlags);
    public MethodInfo GetMethod(string name);
    public MethodInfo GetMethod(string name, Type[] types);
    public MethodInfo[] GetMethods();
    public virtual MethodInfo[] GetMethods(BindingFlags bindingFlags);
    public virtual Type GetType(string className);
    public virtual Type GetType(string className, bool ignoreCase);
    public virtual Type[] GetTypes();
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(bool inherit);
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit);
    bool System.Reflection.ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit);
  }
  public class ParameterInfo : ICustomAttributeProvider {
    public virtual object RawDefaultValue { get; }
    public virtual Type[] GetOptionalCustomModifiers();
    public virtual Type[] GetRequiredCustomModifiers();
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(bool inherit);
    object[] System.Reflection.ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit);
    bool System.Reflection.ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit);
  }
  [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
  public struct ParameterModifier {
    public ParameterModifier(int parameterCount);
    public bool this[int index] { get; set; }
  }
  public abstract class PropertyInfo : MemberInfo {
    public override MemberTypes MemberType { get; }
    public MethodInfo[] GetAccessors();
    public abstract MethodInfo[] GetAccessors(bool nonPublic);
    public MethodInfo GetGetMethod();
    public abstract MethodInfo GetGetMethod(bool nonPublic);
    public virtual Type[] GetOptionalCustomModifiers();
    public virtual object GetRawConstantValue();
    public virtual Type[] GetRequiredCustomModifiers();
    public MethodInfo GetSetMethod();
    public abstract MethodInfo GetSetMethod(bool nonPublic);
  }
  public class TargetException : Exception {
    public TargetException();
    public TargetException(string message);
    public TargetException(string message, Exception inner);
  }
  public delegate bool TypeFilter(Type m, object filterCriteria);
  public abstract class TypeInfo : MemberInfo, IReflectableType {
    public override MemberTypes MemberType { get; }
    public virtual StructLayoutAttribute StructLayoutAttribute { get; }
    public ConstructorInfo TypeInitializer { get; }
    public virtual Type UnderlyingSystemType { get; }
    public virtual Type[] FindInterfaces(TypeFilter filter, object filterCriteria);
    public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria);
    public ConstructorInfo GetConstructor(Type[] types);
    public ConstructorInfo[] GetConstructors();
    public virtual ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
    public virtual MemberInfo[] GetDefaultMembers();
    public virtual string GetEnumName(object value);
    public virtual string[] GetEnumNames();
    public virtual Type GetEnumUnderlyingType();
    public virtual Array GetEnumValues();
    public EventInfo GetEvent(string name);
    public virtual EventInfo GetEvent(string name, BindingFlags bindingAttr);
    public virtual EventInfo[] GetEvents();
    public virtual EventInfo[] GetEvents(BindingFlags bindingAttr);
    public FieldInfo GetField(string name);
    public virtual FieldInfo GetField(string name, BindingFlags bindingAttr);
    public FieldInfo[] GetFields();
    public virtual FieldInfo[] GetFields(BindingFlags bindingAttr);
    public virtual Type[] GetGenericArguments();
    public Type GetInterface(string name);
    public virtual Type GetInterface(string name, bool ignoreCase);
    public virtual Type[] GetInterfaces();
    public MemberInfo[] GetMember(string name);
    public virtual MemberInfo[] GetMember(string name, BindingFlags bindingAttr);
    public virtual MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr);
    public MemberInfo[] GetMembers();
    public virtual MemberInfo[] GetMembers(BindingFlags bindingAttr);
    public MethodInfo GetMethod(string name);
    public MethodInfo GetMethod(string name, BindingFlags bindingAttr);
    public MethodInfo GetMethod(string name, Type[] types);
    public MethodInfo GetMethod(string name, Type[] types, ParameterModifier[] modifiers);
    public MethodInfo[] GetMethods();
    public virtual MethodInfo[] GetMethods(BindingFlags bindingAttr);
    public Type GetNestedType(string name);
    public virtual Type GetNestedType(string name, BindingFlags bindingAttr);
    public Type[] GetNestedTypes();
    public virtual Type[] GetNestedTypes(BindingFlags bindingAttr);
    public PropertyInfo[] GetProperties();
    public virtual PropertyInfo[] GetProperties(BindingFlags bindingAttr);
    public PropertyInfo GetProperty(string name);
    public PropertyInfo GetProperty(string name, BindingFlags bindingAttr);
    public PropertyInfo GetProperty(string name, Type returnType);
    public PropertyInfo GetProperty(string name, Type returnType, Type[] types);
    public PropertyInfo GetProperty(string name, Type returnType, Type[] types, ParameterModifier[] modifiers);
    public PropertyInfo GetProperty(string name, Type[] types);
    public virtual bool IsAssignableFrom(Type c);
    public virtual bool IsEnumDefined(object value);
    public virtual bool IsEquivalentTo(Type other);
    public virtual bool IsInstanceOfType(object o);
  }
}

System.Runtime.InteropServices

namespace System.Runtime.InteropServices {
  public enum Architecture {
    Arm = 2,
    Arm64 = 3,
    X64 = 1,
    X86 = 0,
  }
  public static class PInvokeMarshal {
    public static readonly int SystemDefaultCharSize;
    public static readonly int SystemMaxDBCSCharSize;
    public static IntPtr AllocateMemory(int sizeInBytes);
    public static void DestroyStructure(IntPtr ptr, Type structureType);
    public static void DestroyStructure<T>(IntPtr ptr);
    public static void FreeMemory(IntPtr ptr);
    public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type delegateType);
    public static TDelegate GetDelegateForFunctionPointer<TDelegate>(IntPtr ptr);
    public static IntPtr GetFunctionPointerForDelegate(Delegate d);
    public static IntPtr GetFunctionPointerForDelegate<TDelegate>(TDelegate d);
    public static int GetLastError();
    public static IntPtr OffsetOf(Type type, string fieldName);
    public static IntPtr OffsetOf<T>(string fieldName);
    public static string PtrToStringAnsi(IntPtr ptr);
    public static string PtrToStringAnsi(IntPtr ptr, int len);
    public static string PtrToStringUTF16(IntPtr ptr);
    public static string PtrToStringUTF16(IntPtr ptr, int len);
    public static void PtrToStructure(IntPtr ptr, object structure);
    public static object PtrToStructure(IntPtr ptr, Type structureType);
    public static T PtrToStructure<T>(IntPtr ptr);
    public static void PtrToStructure<T>(IntPtr ptr, T structure);
    public static IntPtr ReallocateMemory(IntPtr ptr, int sizeInBytes);
    public static int SizeOf(object structure);
    public static int SizeOf(Type type);
    public static int SizeOf<T>();
    public static IntPtr StringToAllocatedMemoryAnsi(string s);
    public static IntPtr StringToAllocatedMemoryUTF16(string s);
    public static void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld);
    public static void StructureToPtr<T>(T structure, IntPtr ptr, bool fDeleteOld);
    public static IntPtr UnsafeAddrOfPinnedArrayElement(Array arr, int index);
    public static IntPtr UnsafeAddrOfPinnedArrayElement<T>(T[] arr, int index);
    public static void ZeroFreeMemoryAnsi(IntPtr s);
    public static void ZeroFreeMemoryUTF16(IntPtr s);
  }
  public static class RuntimeInformation {
    public static string FrameworkDescription { get; }
    public static Architecture OSArchitecture { get; }
    public static string OSDescription { get; }
    public static Architecture ProcessArchitecture { get; }
  }
}

System.Runtime.Loader

namespace System.Runtime.Loader {
  public abstract class AssemblyLoadContext {
    public event Func<AssemblyLoadContext, AssemblyName, Assembly> Resolving;
    public event Action<AssemblyLoadContext> Unloading;
    protectedpublic Assembly LoadFromAssemblyPath(string assemblyPath);
    protectedpublic Assembly LoadFromNativeImagePath(string nativeImagePath, string assemblyPath);
    protectedpublic Assembly LoadFromStream(Stream assembly);
    protectedpublic Assembly LoadFromStream(Stream assembly, Stream assemblySymbols);
  }
}

System.Runtime.Serialization

namespace System.Runtime.Serialization {
  public sealed class DataContractSerializer : XmlObjectSerializer {
    public ISerializationSurrogateProvider SerializationSurrogateProvider { get; set; }
  }
  public static class DataContractSerializerExtensions {
    public static ISerializationSurrogateProvider GetSerializationSurrogateProvider(this DataContractSerializer serializer);
    public static void SetSerializationSurrogateProvider(this DataContractSerializer serializer, ISerializationSurrogateProvider provider);
  }
}

System.Security.Cryptography

namespace System.Security.Cryptography {
  public abstract class Aes : SymmetricAlgorithm {
    public override KeySizes[] LegalBlockSizes { get; }
    public override KeySizes[] LegalKeySizes { get; }
  }
  public class HMACMD5 : HMAC {
    public HMACMD5();
    public HMACMD5(byte[] key);
    public override int HashSize { get; }
    public override byte[] Key { get; set; }
    protected override void Dispose(bool disposing);
    protected override void HashCore(byte[] rgb, int ib, int cb);
    protected override byte[] HashFinal();
    public override void Initialize();
  }
  public class HMACSHA1 : HMAC {
    public override int HashSize { get; }
    public override byte[] Key { get; set; }
    protected override void Dispose(bool disposing);
    protected override void HashCore(byte[] rgb, int ib, int cb);
    protected override byte[] HashFinal();
    public override void Initialize();
  }
  public class HMACSHA256 : HMAC {
    public override int HashSize { get; }
    public override byte[] Key { get; set; }
    protected override void Dispose(bool disposing);
    protected override void HashCore(byte[] rgb, int ib, int cb);
    protected override byte[] HashFinal();
    public override void Initialize();
  }
  public class HMACSHA384 : HMAC {
    public override int HashSize { get; }
    public override byte[] Key { get; set; }
    protected override void Dispose(bool disposing);
    protected override void HashCore(byte[] rgb, int ib, int cb);
    protected override byte[] HashFinal();
    public override void Initialize();
  }
  public class HMACSHA512 : HMAC {
    public override int HashSize { get; }
    public override byte[] Key { get; set; }
    protected override void Dispose(bool disposing);
    protected override void HashCore(byte[] rgb, int ib, int cb);
    protected override byte[] HashFinal();
    public override void Initialize();
  }
  public abstract class RSA : AsymmetricAlgorithm {
    public static RSA Create();
  }
  public sealed class RSACryptoServiceProvider : RSA, ICspAsymmetricAlgorithm {
    public override KeySizes[] LegalKeySizes { get; }
  }
}

System.Security.Cryptography.X509Certificates

namespace System.Security.Cryptography.X509Certificates {
  public enum X509ChainStatusFlags {
    ExplicitDistrust = 67108864,
    HasNotSupportedCriticalExtension = 134217728,
    HasWeakSignature = 1048576,
  }
}

System.Security.Principal

namespace System.Security.Principal {
  public class WindowsIdentity : ClaimsIdentity, IDisposable {
    public const string DefaultIssuer = "AD AUTHORITY";
    public sealed override string AuthenticationType { get; }
    public override IEnumerable<Claim> Claims { get; }
    public override bool IsAuthenticated { get; }
    public override string Name { get; }
    public override ClaimsIdentity Clone();
  }
  public class WindowsPrincipal : ClaimsPrincipal {
    public override IIdentity Identity { get; }
    public override bool IsInRole(string role);
  }
}

System.ServiceModel

namespace System.ServiceModel {
  public class BasicHttpsBinding : HttpBindingBase {
    public BasicHttpsBinding();
    public BasicHttpsBinding(BasicHttpsSecurityMode securityMode);
    public BasicHttpsSecurity Security { get; set; }
    public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters);
    public override BindingElementCollection CreateBindingElements();
  }
  public sealed class BasicHttpsSecurity {
    public BasicHttpsSecurityMode Mode { get; set; }
    public HttpTransportSecurity Transport { get; set; }
  }
  public enum BasicHttpsSecurityMode {
    Transport = 0,
    TransportWithMessageCredential = 1,
  }
  public class MessageHeaderAttribute : MessageContractMemberAttribute {
    public MessageHeaderAttribute();
    public bool MustUnderstand { get; set; }
  }
  public class NetHttpsBinding : HttpBindingBase {
    public NetHttpsBinding();
    public NetHttpsBinding(BasicHttpsSecurityMode securityMode);
    public NetHttpMessageEncoding MessageEncoding { get; set; }
    public BasicHttpsSecurity Security { get; set; }
    public WebSocketTransportSettings WebSocketSettings { get; }
    public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingParameterCollection parameters);
    public override BindingElementCollection CreateBindingElements();
  }
}

System.ServiceModel.Channels

namespace System.ServiceModel.Channels {
  public class HttpsTransportBindingElement : HttpTransportBindingElement {
    public bool RequireClientCertificate { get; set; }
  }
}
You can’t perform that action at this time.