2051 lines
No EOL
89 KiB
Markdown
2051 lines
No EOL
89 KiB
Markdown
# API Diff between RC1 and RC2
|
|
|
|
- [System](#system)
|
|
- [System.ComponentModel.DataAnnotations](#systemcomponentmodeldataannotations)
|
|
- [System.Data](#systemdata)
|
|
- [System.Data.Common](#systemdatacommon)
|
|
- [System.Data.SqlClient](#systemdatasqlclient)
|
|
- [System.Diagnostics](#systemdiagnostics)
|
|
- [System.Drawing](#systemdrawing)
|
|
- [System.IO](#systemio)
|
|
- [System.IO.Packaging](#systemiopackaging)
|
|
- [System.Linq](#systemlinq)
|
|
- [System.Net](#systemnet)
|
|
- [System.Net.NetworkInformation](#systemnetnetworkinformation)
|
|
- [System.Net.Security](#systemnetsecurity)
|
|
- [System.Net.Sockets](#systemnetsockets)
|
|
- [System.Reflection](#systemreflection)
|
|
- [System.Runtime.InteropServices](#systemruntimeinteropservices)
|
|
- [System.Runtime.Loader](#systemruntimeloader)
|
|
- [System.Runtime.Serialization](#systemruntimeserialization)
|
|
- [System.Security.Cryptography](#systemsecuritycryptography)
|
|
- [System.Security.Cryptography.X509Certificates](#systemsecuritycryptographyx509certificates)
|
|
- [System.Security.Principal](#systemsecurityprincipal)
|
|
- [System.ServiceModel](#systemservicemodel)
|
|
- [System.ServiceModel.Channels](#systemservicemodelchannels)
|
|
|
|
## System
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
namespace System.ComponentModel.DataAnnotations {
|
|
public class RegularExpressionAttribute : ValidationAttribute {
|
|
public int MatchTimeoutInMilliseconds { get; set; }
|
|
}
|
|
}
|
|
```
|
|
|
|
## System.Data
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
namespace System.Security.Cryptography.X509Certificates {
|
|
public enum X509ChainStatusFlags {
|
|
ExplicitDistrust = 67108864,
|
|
HasNotSupportedCriticalExtension = 134217728,
|
|
HasWeakSignature = 1048576,
|
|
}
|
|
}
|
|
```
|
|
|
|
## System.Security.Principal
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
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
|
|
|
|
```csharp
|
|
namespace System.ServiceModel.Channels {
|
|
public class HttpsTransportBindingElement : HttpTransportBindingElement {
|
|
public bool RequireClientCertificate { get; set; }
|
|
}
|
|
}
|
|
``` |