Replace source projects with depprojs

Now that we have stable packages we can redistribute the previously
built binaries rather than rebuilding them.

Also cleaning up some unused projects.

[tfs-changeset: 1614403]

Commit migrated from https://github.com/dotnet/corefx/commit/9eb1e7d6939c79459e84651a69c03a11887ff9f5

diff --git a/src/libraries/System.Data.SqlClient/pkg/System.Data.SqlClient.pkgproj b/src/libraries/System.Data.SqlClient/pkg/System.Data.SqlClient.pkgproj
index ab24348..c045ce1 100644 (file)
--- a/src/libraries/System.Data.SqlClient/pkg/System.Data.SqlClient.pkgproj
+++ b/src/libraries/System.Data.SqlClient/pkg/System.Data.SqlClient.pkgproj
@@ -2,7 +2,7 @@
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <ItemGroup>
-    <ProjectReference Include="..\ref\4.0\System.Data.SqlClient.csproj">
+    <ProjectReference Include="..\ref\4.0\System.Data.SqlClient.depproj">
       <SupportedFramework>net451;</SupportedFramework>
     </ProjectReference>
     <ProjectReference Include="..\ref\System.Data.SqlClient.csproj">

diff --git a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.Manual.cs b/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.Manual.cs
deleted file mode 100644 (file)
index cc750a8..0000000
--- a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.Manual.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-namespace System.Data.SqlClient
-{
-    public sealed partial class SqlCommand : System.Data.Common.DbCommand
-    {
-        // SqlCommand expects IDisposable methods to be implemented via System.ComponentModel.Component, which it no longer inherits from
-        override protected void Dispose(bool disposing) { }
-    }
-    public sealed partial class SqlConnection : System.Data.Common.DbConnection
-    {
-        // SqlConection expects IDisposable methods to be implemented via System.ComponentModel.Component, which it no longer inherits from
-        override protected void Dispose(bool disposing) { }
-    }
-}

diff --git a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.cs b/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.cs
deleted file mode 100644 (file)
index cd9a28b..0000000
--- a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.cs
+++ /dev/null
@@ -1,1410 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace Microsoft.SqlServer.Server
-{
-    public partial class SqlDataRecord
-    {
-        public SqlDataRecord(params Microsoft.SqlServer.Server.SqlMetaData[] metaData) { }
-        public virtual int FieldCount { get { return default(int); } }
-        public virtual object this[int ordinal] { get { return default(object); } }
-        public virtual object this[string name] { get { return default(object); } }
-        public virtual bool GetBoolean(int ordinal) { return default(bool); }
-        public virtual byte GetByte(int ordinal) { return default(byte); }
-        public virtual long GetBytes(int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length) { return default(long); }
-        public virtual char GetChar(int ordinal) { return default(char); }
-        public virtual long GetChars(int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length) { return default(long); }
-        public virtual string GetDataTypeName(int ordinal) { return default(string); }
-        public virtual System.DateTime GetDateTime(int ordinal) { return default(System.DateTime); }
-        public virtual System.DateTimeOffset GetDateTimeOffset(int ordinal) { return default(System.DateTimeOffset); }
-        public virtual decimal GetDecimal(int ordinal) { return default(decimal); }
-        public virtual double GetDouble(int ordinal) { return default(double); }
-        public virtual System.Type GetFieldType(int ordinal) { return default(System.Type); }
-        public virtual float GetFloat(int ordinal) { return default(float); }
-        public virtual System.Guid GetGuid(int ordinal) { return default(System.Guid); }
-        public virtual short GetInt16(int ordinal) { return default(short); }
-        public virtual int GetInt32(int ordinal) { return default(int); }
-        public virtual long GetInt64(int ordinal) { return default(long); }
-        public virtual string GetName(int ordinal) { return default(string); }
-        public virtual int GetOrdinal(string name) { return default(int); }
-        public virtual System.Data.SqlTypes.SqlBinary GetSqlBinary(int ordinal) { return default(System.Data.SqlTypes.SqlBinary); }
-        public virtual System.Data.SqlTypes.SqlBoolean GetSqlBoolean(int ordinal) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public virtual System.Data.SqlTypes.SqlByte GetSqlByte(int ordinal) { return default(System.Data.SqlTypes.SqlByte); }
-        public virtual System.Data.SqlTypes.SqlBytes GetSqlBytes(int ordinal) { return default(System.Data.SqlTypes.SqlBytes); }
-        public virtual System.Data.SqlTypes.SqlChars GetSqlChars(int ordinal) { return default(System.Data.SqlTypes.SqlChars); }
-        public virtual System.Data.SqlTypes.SqlDateTime GetSqlDateTime(int ordinal) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public virtual System.Data.SqlTypes.SqlDecimal GetSqlDecimal(int ordinal) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public virtual System.Data.SqlTypes.SqlDouble GetSqlDouble(int ordinal) { return default(System.Data.SqlTypes.SqlDouble); }
-        public virtual System.Type GetSqlFieldType(int ordinal) { return default(System.Type); }
-        public virtual System.Data.SqlTypes.SqlGuid GetSqlGuid(int ordinal) { return default(System.Data.SqlTypes.SqlGuid); }
-        public virtual System.Data.SqlTypes.SqlInt16 GetSqlInt16(int ordinal) { return default(System.Data.SqlTypes.SqlInt16); }
-        public virtual System.Data.SqlTypes.SqlInt32 GetSqlInt32(int ordinal) { return default(System.Data.SqlTypes.SqlInt32); }
-        public virtual System.Data.SqlTypes.SqlInt64 GetSqlInt64(int ordinal) { return default(System.Data.SqlTypes.SqlInt64); }
-        public virtual Microsoft.SqlServer.Server.SqlMetaData GetSqlMetaData(int ordinal) { return default(Microsoft.SqlServer.Server.SqlMetaData); }
-        public virtual System.Data.SqlTypes.SqlMoney GetSqlMoney(int ordinal) { return default(System.Data.SqlTypes.SqlMoney); }
-        public virtual System.Data.SqlTypes.SqlSingle GetSqlSingle(int ordinal) { return default(System.Data.SqlTypes.SqlSingle); }
-        public virtual System.Data.SqlTypes.SqlString GetSqlString(int ordinal) { return default(System.Data.SqlTypes.SqlString); }
-        public virtual object GetSqlValue(int ordinal) { return default(object); }
-        public virtual int GetSqlValues(object[] values) { return default(int); }
-        public virtual System.Data.SqlTypes.SqlXml GetSqlXml(int ordinal) { return default(System.Data.SqlTypes.SqlXml); }
-        public virtual string GetString(int ordinal) { return default(string); }
-        public virtual System.TimeSpan GetTimeSpan(int ordinal) { return default(System.TimeSpan); }
-        public virtual object GetValue(int ordinal) { return default(object); }
-        public virtual int GetValues(object[] values) { return default(int); }
-        public virtual bool IsDBNull(int ordinal) { return default(bool); }
-        public virtual void SetBoolean(int ordinal, bool value) { }
-        public virtual void SetByte(int ordinal, byte value) { }
-        public virtual void SetBytes(int ordinal, long fieldOffset, byte[] buffer, int bufferOffset, int length) { }
-        public virtual void SetChar(int ordinal, char value) { }
-        public virtual void SetChars(int ordinal, long fieldOffset, char[] buffer, int bufferOffset, int length) { }
-        public virtual void SetDateTime(int ordinal, System.DateTime value) { }
-        public virtual void SetDateTimeOffset(int ordinal, System.DateTimeOffset value) { }
-        public virtual void SetDBNull(int ordinal) { }
-        public virtual void SetDecimal(int ordinal, decimal value) { }
-        public virtual void SetDouble(int ordinal, double value) { }
-        public virtual void SetFloat(int ordinal, float value) { }
-        public virtual void SetGuid(int ordinal, System.Guid value) { }
-        public virtual void SetInt16(int ordinal, short value) { }
-        public virtual void SetInt32(int ordinal, int value) { }
-        public virtual void SetInt64(int ordinal, long value) { }
-        public virtual void SetSqlBinary(int ordinal, System.Data.SqlTypes.SqlBinary value) { }
-        public virtual void SetSqlBoolean(int ordinal, System.Data.SqlTypes.SqlBoolean value) { }
-        public virtual void SetSqlByte(int ordinal, System.Data.SqlTypes.SqlByte value) { }
-        public virtual void SetSqlBytes(int ordinal, System.Data.SqlTypes.SqlBytes value) { }
-        public virtual void SetSqlChars(int ordinal, System.Data.SqlTypes.SqlChars value) { }
-        public virtual void SetSqlDateTime(int ordinal, System.Data.SqlTypes.SqlDateTime value) { }
-        public virtual void SetSqlDecimal(int ordinal, System.Data.SqlTypes.SqlDecimal value) { }
-        public virtual void SetSqlDouble(int ordinal, System.Data.SqlTypes.SqlDouble value) { }
-        public virtual void SetSqlGuid(int ordinal, System.Data.SqlTypes.SqlGuid value) { }
-        public virtual void SetSqlInt16(int ordinal, System.Data.SqlTypes.SqlInt16 value) { }
-        public virtual void SetSqlInt32(int ordinal, System.Data.SqlTypes.SqlInt32 value) { }
-        public virtual void SetSqlInt64(int ordinal, System.Data.SqlTypes.SqlInt64 value) { }
-        public virtual void SetSqlMoney(int ordinal, System.Data.SqlTypes.SqlMoney value) { }
-        public virtual void SetSqlSingle(int ordinal, System.Data.SqlTypes.SqlSingle value) { }
-        public virtual void SetSqlString(int ordinal, System.Data.SqlTypes.SqlString value) { }
-        public virtual void SetSqlXml(int ordinal, System.Data.SqlTypes.SqlXml value) { }
-        public virtual void SetString(int ordinal, string value) { }
-        public virtual void SetTimeSpan(int ordinal, System.TimeSpan value) { }
-        public virtual void SetValue(int ordinal, object value) { }
-        public virtual int SetValues(params object[] values) { return default(int); }
-    }
-    public sealed partial class SqlMetaData
-    {
-        public SqlMetaData(string name, System.Data.SqlDbType dbType) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, byte precision, byte scale) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, byte precision, byte scale, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength, byte precision, byte scale, long locale, System.Data.SqlTypes.SqlCompareOptions compareOptions, System.Type userDefinedType) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength, byte precision, byte scale, long localeId, System.Data.SqlTypes.SqlCompareOptions compareOptions, System.Type userDefinedType, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength, long locale, System.Data.SqlTypes.SqlCompareOptions compareOptions) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, long maxLength, long locale, System.Data.SqlTypes.SqlCompareOptions compareOptions, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, string database, string owningSchema, string objectName) { }
-        public SqlMetaData(string name, System.Data.SqlDbType dbType, string database, string owningSchema, string objectName, bool useServerDefault, bool isUniqueKey, System.Data.SqlClient.SortOrder columnSortOrder, int sortOrdinal) { }
-        public System.Data.SqlTypes.SqlCompareOptions CompareOptions { get { return default(System.Data.SqlTypes.SqlCompareOptions); } }
-        public bool IsUniqueKey { get { return default(bool); } }
-        public long LocaleId { get { return default(long); } }
-        public static long Max { get { return default(long); } }
-        public long MaxLength { get { return default(long); } }
-        public string Name { get { return default(string); } }
-        public byte Precision { get { return default(byte); } }
-        public byte Scale { get { return default(byte); } }
-        public System.Data.SqlClient.SortOrder SortOrder { get { return default(System.Data.SqlClient.SortOrder); } }
-        public int SortOrdinal { get { return default(int); } }
-        public System.Data.SqlDbType SqlDbType { get { return default(System.Data.SqlDbType); } }
-        public string TypeName { get { return default(string); } }
-        public bool UseServerDefault { get { return default(bool); } }
-        public string XmlSchemaCollectionDatabase { get { return default(string); } }
-        public string XmlSchemaCollectionName { get { return default(string); } }
-        public string XmlSchemaCollectionOwningSchema { get { return default(string); } }
-        public bool Adjust(bool value) { return default(bool); }
-        public byte Adjust(byte value) { return default(byte); }
-        public byte[] Adjust(byte[] value) { return default(byte[]); }
-        public char Adjust(char value) { return default(char); }
-        public char[] Adjust(char[] value) { return default(char[]); }
-        public System.Data.SqlTypes.SqlBinary Adjust(System.Data.SqlTypes.SqlBinary value) { return default(System.Data.SqlTypes.SqlBinary); }
-        public System.Data.SqlTypes.SqlBoolean Adjust(System.Data.SqlTypes.SqlBoolean value) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte Adjust(System.Data.SqlTypes.SqlByte value) { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlBytes Adjust(System.Data.SqlTypes.SqlBytes value) { return default(System.Data.SqlTypes.SqlBytes); }
-        public System.Data.SqlTypes.SqlChars Adjust(System.Data.SqlTypes.SqlChars value) { return default(System.Data.SqlTypes.SqlChars); }
-        public System.Data.SqlTypes.SqlDateTime Adjust(System.Data.SqlTypes.SqlDateTime value) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public System.Data.SqlTypes.SqlDecimal Adjust(System.Data.SqlTypes.SqlDecimal value) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble Adjust(System.Data.SqlTypes.SqlDouble value) { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlGuid Adjust(System.Data.SqlTypes.SqlGuid value) { return default(System.Data.SqlTypes.SqlGuid); }
-        public System.Data.SqlTypes.SqlInt16 Adjust(System.Data.SqlTypes.SqlInt16 value) { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 Adjust(System.Data.SqlTypes.SqlInt32 value) { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 Adjust(System.Data.SqlTypes.SqlInt64 value) { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney Adjust(System.Data.SqlTypes.SqlMoney value) { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle Adjust(System.Data.SqlTypes.SqlSingle value) { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString Adjust(System.Data.SqlTypes.SqlString value) { return default(System.Data.SqlTypes.SqlString); }
-        public System.Data.SqlTypes.SqlXml Adjust(System.Data.SqlTypes.SqlXml value) { return default(System.Data.SqlTypes.SqlXml); }
-        public System.DateTime Adjust(System.DateTime value) { return default(System.DateTime); }
-        public System.DateTimeOffset Adjust(System.DateTimeOffset value) { return default(System.DateTimeOffset); }
-        public decimal Adjust(decimal value) { return default(decimal); }
-        public double Adjust(double value) { return default(double); }
-        public System.Guid Adjust(System.Guid value) { return default(System.Guid); }
-        public short Adjust(short value) { return default(short); }
-        public int Adjust(int value) { return default(int); }
-        public long Adjust(long value) { return default(long); }
-        public object Adjust(object value) { return default(object); }
-        public float Adjust(float value) { return default(float); }
-        public string Adjust(string value) { return default(string); }
-        public System.TimeSpan Adjust(System.TimeSpan value) { return default(System.TimeSpan); }
-        public static Microsoft.SqlServer.Server.SqlMetaData InferFromValue(object value, string name) { return default(Microsoft.SqlServer.Server.SqlMetaData); }
-    }
-}
-namespace System.Data
-{
-    public enum SqlDbType
-    {
-        BigInt = 0,
-        Binary = 1,
-        Bit = 2,
-        Char = 3,
-        Date = 31,
-        DateTime = 4,
-        DateTime2 = 33,
-        DateTimeOffset = 34,
-        Decimal = 5,
-        Float = 6,
-        Image = 7,
-        Int = 8,
-        Money = 9,
-        NChar = 10,
-        NText = 11,
-        NVarChar = 12,
-        Real = 13,
-        SmallDateTime = 15,
-        SmallInt = 16,
-        SmallMoney = 17,
-        Structured = 30,
-        Text = 18,
-        Time = 32,
-        Timestamp = 19,
-        TinyInt = 20,
-        Udt = 29,
-        UniqueIdentifier = 14,
-        VarBinary = 21,
-        VarChar = 22,
-        Variant = 23,
-        Xml = 25,
-    }
-    public sealed partial class StatementCompletedEventArgs : System.EventArgs
-    {
-        public StatementCompletedEventArgs(int recordCount) { }
-        public int RecordCount { get { return default(int); } }
-    }
-    public delegate void StatementCompletedEventHandler(object sender, System.Data.StatementCompletedEventArgs e);
-}
-namespace System.Data.SqlClient
-{
-    public enum ApplicationIntent
-    {
-        ReadOnly = 1,
-        ReadWrite = 0,
-    }
-    public enum SortOrder
-    {
-        Ascending = 0,
-        Descending = 1,
-        Unspecified = -1,
-    }
-    public sealed partial class SqlClientFactory : System.Data.Common.DbProviderFactory
-    {
-        internal SqlClientFactory() { }
-        public static readonly System.Data.SqlClient.SqlClientFactory Instance;
-        public override System.Data.Common.DbCommand CreateCommand() { return default(System.Data.Common.DbCommand); }
-        public override System.Data.Common.DbConnection CreateConnection() { return default(System.Data.Common.DbConnection); }
-        public override System.Data.Common.DbConnectionStringBuilder CreateConnectionStringBuilder() { return default(System.Data.Common.DbConnectionStringBuilder); }
-        public override System.Data.Common.DbParameter CreateParameter() { return default(System.Data.Common.DbParameter); }
-    }
-    public sealed partial class SqlCommand : System.Data.Common.DbCommand
-    {
-        public SqlCommand() { }
-        public SqlCommand(string cmdText) { }
-        public SqlCommand(string cmdText, System.Data.SqlClient.SqlConnection connection) { }
-        public SqlCommand(string cmdText, System.Data.SqlClient.SqlConnection connection, System.Data.SqlClient.SqlTransaction transaction) { }
-        public override string CommandText { get { return default(string); } set { } }
-        public override int CommandTimeout { get { return default(int); } set { } }
-        public override System.Data.CommandType CommandType { get { return default(System.Data.CommandType); } set { } }
-        public new System.Data.SqlClient.SqlConnection Connection { get { return default(System.Data.SqlClient.SqlConnection); } set { } }
-        protected override System.Data.Common.DbConnection DbConnection { get { return default(System.Data.Common.DbConnection); } set { } }
-        protected override System.Data.Common.DbParameterCollection DbParameterCollection { get { return default(System.Data.Common.DbParameterCollection); } }
-        protected override System.Data.Common.DbTransaction DbTransaction { get { return default(System.Data.Common.DbTransaction); } set { } }
-        public override bool DesignTimeVisible { get { return default(bool); } set { } }
-        public new System.Data.SqlClient.SqlParameterCollection Parameters { get { return default(System.Data.SqlClient.SqlParameterCollection); } }
-        public new System.Data.SqlClient.SqlTransaction Transaction { get { return default(System.Data.SqlClient.SqlTransaction); } set { } }
-        public override System.Data.UpdateRowSource UpdatedRowSource { get { return default(System.Data.UpdateRowSource); } set { } }
-        public event System.Data.StatementCompletedEventHandler StatementCompleted { add { } remove { } }
-        public override void Cancel() { }
-        protected override System.Data.Common.DbParameter CreateDbParameter() { return default(System.Data.Common.DbParameter); }
-        public new System.Data.SqlClient.SqlParameter CreateParameter() { return default(System.Data.SqlClient.SqlParameter); }
-        protected override System.Data.Common.DbDataReader ExecuteDbDataReader(System.Data.CommandBehavior behavior) { return default(System.Data.Common.DbDataReader); }
-        protected override System.Threading.Tasks.Task<System.Data.Common.DbDataReader> ExecuteDbDataReaderAsync(System.Data.CommandBehavior behavior, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<System.Data.Common.DbDataReader>); }
-        public override int ExecuteNonQuery() { return default(int); }
-        public override System.Threading.Tasks.Task<int> ExecuteNonQueryAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<int>); }
-        public new System.Data.SqlClient.SqlDataReader ExecuteReader() { return default(System.Data.SqlClient.SqlDataReader); }
-        public new System.Data.SqlClient.SqlDataReader ExecuteReader(System.Data.CommandBehavior behavior) { return default(System.Data.SqlClient.SqlDataReader); }
-        public new System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader> ExecuteReaderAsync() { return default(System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader>); }
-        public new System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader> ExecuteReaderAsync(System.Data.CommandBehavior behavior) { return default(System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader>); }
-        public new System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader> ExecuteReaderAsync(System.Data.CommandBehavior behavior, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader>); }
-        public new System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader> ExecuteReaderAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<System.Data.SqlClient.SqlDataReader>); }
-        public override object ExecuteScalar() { return default(object); }
-        public override System.Threading.Tasks.Task<object> ExecuteScalarAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<object>); }
-        public System.Xml.XmlReader ExecuteXmlReader() { return default(System.Xml.XmlReader); }
-        public System.Threading.Tasks.Task<System.Xml.XmlReader> ExecuteXmlReaderAsync() { return default(System.Threading.Tasks.Task<System.Xml.XmlReader>); }
-        public System.Threading.Tasks.Task<System.Xml.XmlReader> ExecuteXmlReaderAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<System.Xml.XmlReader>); }
-        public override void Prepare() { }
-    }
-    public sealed partial class SqlConnection : System.Data.Common.DbConnection
-    {
-        public SqlConnection() { }
-        public SqlConnection(string connectionString) { }
-        public System.Guid ClientConnectionId { get { return default(System.Guid); } }
-        public override string ConnectionString { get { return default(string); } set { } }
-        public override int ConnectionTimeout { get { return default(int); } }
-        public override string Database { get { return default(string); } }
-        public override string DataSource { get { return default(string); } }
-        public bool FireInfoMessageEventOnUserErrors { get { return default(bool); } set { } }
-        public int PacketSize { get { return default(int); } }
-        public override string ServerVersion { get { return default(string); } }
-        public override System.Data.ConnectionState State { get { return default(System.Data.ConnectionState); } }
-        public bool StatisticsEnabled { get { return default(bool); } set { } }
-        public string WorkstationId { get { return default(string); } }
-        public event System.Data.SqlClient.SqlInfoMessageEventHandler InfoMessage { add { } remove { } }
-        protected override System.Data.Common.DbTransaction BeginDbTransaction(System.Data.IsolationLevel isolationLevel) { return default(System.Data.Common.DbTransaction); }
-        public new System.Data.SqlClient.SqlTransaction BeginTransaction() { return default(System.Data.SqlClient.SqlTransaction); }
-        public new System.Data.SqlClient.SqlTransaction BeginTransaction(System.Data.IsolationLevel iso) { return default(System.Data.SqlClient.SqlTransaction); }
-        public System.Data.SqlClient.SqlTransaction BeginTransaction(System.Data.IsolationLevel iso, string transactionName) { return default(System.Data.SqlClient.SqlTransaction); }
-        public System.Data.SqlClient.SqlTransaction BeginTransaction(string transactionName) { return default(System.Data.SqlClient.SqlTransaction); }
-        public override void ChangeDatabase(string database) { }
-        public static void ClearAllPools() { }
-        public static void ClearPool(System.Data.SqlClient.SqlConnection connection) { }
-        public override void Close() { }
-        public new System.Data.SqlClient.SqlCommand CreateCommand() { return default(System.Data.SqlClient.SqlCommand); }
-        protected override System.Data.Common.DbCommand CreateDbCommand() { return default(System.Data.Common.DbCommand); }
-        public override void Open() { }
-        public override System.Threading.Tasks.Task OpenAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task); }
-        public void ResetStatistics() { }
-        public System.Collections.IDictionary RetrieveStatistics() { return default(System.Collections.IDictionary); }
-    }
-    public sealed partial class SqlConnectionStringBuilder : System.Data.Common.DbConnectionStringBuilder
-    {
-        public SqlConnectionStringBuilder() { }
-        public SqlConnectionStringBuilder(string connectionString) { }
-        public System.Data.SqlClient.ApplicationIntent ApplicationIntent { get { return default(System.Data.SqlClient.ApplicationIntent); } set { } }
-        public string ApplicationName { get { return default(string); } set { } }
-        public string AttachDBFilename { get { return default(string); } set { } }
-        public int ConnectRetryCount { get { return default(int); } set { } }
-        public int ConnectRetryInterval { get { return default(int); } set { } }
-        public int ConnectTimeout { get { return default(int); } set { } }
-        public string CurrentLanguage { get { return default(string); } set { } }
-        public string DataSource { get { return default(string); } set { } }
-        public bool Encrypt { get { return default(bool); } set { } }
-        public string FailoverPartner { get { return default(string); } set { } }
-        public string InitialCatalog { get { return default(string); } set { } }
-        public bool IntegratedSecurity { get { return default(bool); } set { } }
-        public override object this[string keyword] { get { return default(object); } set { } }
-        public override System.Collections.ICollection Keys { get { return default(System.Collections.ICollection); } }
-        public int LoadBalanceTimeout { get { return default(int); } set { } }
-        public int MaxPoolSize { get { return default(int); } set { } }
-        public int MinPoolSize { get { return default(int); } set { } }
-        public bool MultipleActiveResultSets { get { return default(bool); } set { } }
-        public bool MultiSubnetFailover { get { return default(bool); } set { } }
-        public int PacketSize { get { return default(int); } set { } }
-        public string Password { get { return default(string); } set { } }
-        public bool PersistSecurityInfo { get { return default(bool); } set { } }
-        public bool Pooling { get { return default(bool); } set { } }
-        public bool Replication { get { return default(bool); } set { } }
-        public bool TrustServerCertificate { get { return default(bool); } set { } }
-        public string TypeSystemVersion { get { return default(string); } set { } }
-        public string UserID { get { return default(string); } set { } }
-        public bool UserInstance { get { return default(bool); } set { } }
-        public override System.Collections.ICollection Values { get { return default(System.Collections.ICollection); } }
-        public string WorkstationID { get { return default(string); } set { } }
-        public override void Clear() { }
-        public override bool ContainsKey(string keyword) { return default(bool); }
-        public override bool Remove(string keyword) { return default(bool); }
-        public override bool ShouldSerialize(string keyword) { return default(bool); }
-        public override bool TryGetValue(string keyword, out object value) { value = default(object); return default(bool); }
-    }
-    public partial class SqlDataReader : System.Data.Common.DbDataReader, System.IDisposable
-    {
-        internal SqlDataReader() { }
-        protected System.Data.SqlClient.SqlConnection Connection { get { return default(System.Data.SqlClient.SqlConnection); } }
-        public override int Depth { get { return default(int); } }
-        public override int FieldCount { get { return default(int); } }
-        public override bool HasRows { get { return default(bool); } }
-        public override bool IsClosed { get { return default(bool); } }
-        public override object this[int i] { get { return default(object); } }
-        public override object this[string name] { get { return default(object); } }
-        public override int RecordsAffected { get { return default(int); } }
-        public override int VisibleFieldCount { get { return default(int); } }
-        public override bool GetBoolean(int i) { return default(bool); }
-        public override byte GetByte(int i) { return default(byte); }
-        public override long GetBytes(int i, long dataIndex, byte[] buffer, int bufferIndex, int length) { return default(long); }
-        public override char GetChar(int i) { return default(char); }
-        public override long GetChars(int i, long dataIndex, char[] buffer, int bufferIndex, int length) { return default(long); }
-        public override string GetDataTypeName(int i) { return default(string); }
-        public override System.DateTime GetDateTime(int i) { return default(System.DateTime); }
-        public virtual System.DateTimeOffset GetDateTimeOffset(int i) { return default(System.DateTimeOffset); }
-        public override decimal GetDecimal(int i) { return default(decimal); }
-        public override double GetDouble(int i) { return default(double); }
-        public override System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
-        public override System.Type GetFieldType(int i) { return default(System.Type); }
-        public override T GetFieldValue<T>(int i) { return default(T); }
-        public override System.Threading.Tasks.Task<T> GetFieldValueAsync<T>(int i, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<T>); }
-        public override float GetFloat(int i) { return default(float); }
-        public override System.Guid GetGuid(int i) { return default(System.Guid); }
-        public override short GetInt16(int i) { return default(short); }
-        public override int GetInt32(int i) { return default(int); }
-        public override long GetInt64(int i) { return default(long); }
-        public override string GetName(int i) { return default(string); }
-        public override int GetOrdinal(string name) { return default(int); }
-        public override System.Type GetProviderSpecificFieldType(int i) { return default(System.Type); }
-        public override object GetProviderSpecificValue(int i) { return default(object); }
-        public override int GetProviderSpecificValues(object[] values) { return default(int); }
-        public virtual System.Data.SqlTypes.SqlBinary GetSqlBinary(int i) { return default(System.Data.SqlTypes.SqlBinary); }
-        public virtual System.Data.SqlTypes.SqlBoolean GetSqlBoolean(int i) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public virtual System.Data.SqlTypes.SqlByte GetSqlByte(int i) { return default(System.Data.SqlTypes.SqlByte); }
-        public virtual System.Data.SqlTypes.SqlBytes GetSqlBytes(int i) { return default(System.Data.SqlTypes.SqlBytes); }
-        public virtual System.Data.SqlTypes.SqlChars GetSqlChars(int i) { return default(System.Data.SqlTypes.SqlChars); }
-        public virtual System.Data.SqlTypes.SqlDateTime GetSqlDateTime(int i) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public virtual System.Data.SqlTypes.SqlDecimal GetSqlDecimal(int i) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public virtual System.Data.SqlTypes.SqlDouble GetSqlDouble(int i) { return default(System.Data.SqlTypes.SqlDouble); }
-        public virtual System.Data.SqlTypes.SqlGuid GetSqlGuid(int i) { return default(System.Data.SqlTypes.SqlGuid); }
-        public virtual System.Data.SqlTypes.SqlInt16 GetSqlInt16(int i) { return default(System.Data.SqlTypes.SqlInt16); }
-        public virtual System.Data.SqlTypes.SqlInt32 GetSqlInt32(int i) { return default(System.Data.SqlTypes.SqlInt32); }
-        public virtual System.Data.SqlTypes.SqlInt64 GetSqlInt64(int i) { return default(System.Data.SqlTypes.SqlInt64); }
-        public virtual System.Data.SqlTypes.SqlMoney GetSqlMoney(int i) { return default(System.Data.SqlTypes.SqlMoney); }
-        public virtual System.Data.SqlTypes.SqlSingle GetSqlSingle(int i) { return default(System.Data.SqlTypes.SqlSingle); }
-        public virtual System.Data.SqlTypes.SqlString GetSqlString(int i) { return default(System.Data.SqlTypes.SqlString); }
-        public virtual object GetSqlValue(int i) { return default(object); }
-        public virtual int GetSqlValues(object[] values) { return default(int); }
-        public virtual System.Data.SqlTypes.SqlXml GetSqlXml(int i) { return default(System.Data.SqlTypes.SqlXml); }
-        public override System.IO.Stream GetStream(int i) { return default(System.IO.Stream); }
-        public override string GetString(int i) { return default(string); }
-        public override System.IO.TextReader GetTextReader(int i) { return default(System.IO.TextReader); }
-        public virtual System.TimeSpan GetTimeSpan(int i) { return default(System.TimeSpan); }
-        public override object GetValue(int i) { return default(object); }
-        public override int GetValues(object[] values) { return default(int); }
-        public virtual System.Xml.XmlReader GetXmlReader(int i) { return default(System.Xml.XmlReader); }
-        public override bool IsDBNull(int i) { return default(bool); }
-        public override System.Threading.Tasks.Task<bool> IsDBNullAsync(int i, System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<bool>); }
-        public override bool NextResult() { return default(bool); }
-        public override System.Threading.Tasks.Task<bool> NextResultAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<bool>); }
-        public override bool Read() { return default(bool); }
-        public override System.Threading.Tasks.Task<bool> ReadAsync(System.Threading.CancellationToken cancellationToken) { return default(System.Threading.Tasks.Task<bool>); }
-    }
-    public sealed partial class SqlError
-    {
-        internal SqlError() { }
-        public byte Class { get { return default(byte); } }
-        public int LineNumber { get { return default(int); } }
-        public string Message { get { return default(string); } }
-        public int Number { get { return default(int); } }
-        public string Procedure { get { return default(string); } }
-        public string Server { get { return default(string); } }
-        public string Source { get { return default(string); } }
-        public byte State { get { return default(byte); } }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class SqlErrorCollection : System.Collections.ICollection, System.Collections.IEnumerable
-    {
-        internal SqlErrorCollection() { }
-        public int Count { get { return default(int); } }
-        public System.Data.SqlClient.SqlError this[int index] { get { return default(System.Data.SqlClient.SqlError); } }
-        bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
-        object System.Collections.ICollection.SyncRoot { get { return default(object); } }
-        public void CopyTo(System.Array array, int index) { }
-        public void CopyTo(System.Data.SqlClient.SqlError[] array, int index) { }
-        public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
-    }
-    public sealed partial class SqlException : System.Data.Common.DbException
-    {
-        internal SqlException() { }
-        public byte Class { get { return default(byte); } }
-        public System.Guid ClientConnectionId { get { return default(System.Guid); } }
-        public System.Data.SqlClient.SqlErrorCollection Errors { get { return default(System.Data.SqlClient.SqlErrorCollection); } }
-        public int LineNumber { get { return default(int); } }
-        public int Number { get { return default(int); } }
-        public string Procedure { get { return default(string); } }
-        public string Server { get { return default(string); } }
-        public override string Source { get { return default(string); } }
-        public byte State { get { return default(byte); } }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class SqlInfoMessageEventArgs : System.EventArgs
-    {
-        internal SqlInfoMessageEventArgs() { }
-        public System.Data.SqlClient.SqlErrorCollection Errors { get { return default(System.Data.SqlClient.SqlErrorCollection); } }
-        public string Message { get { return default(string); } }
-        public string Source { get { return default(string); } }
-        public override string ToString() { return default(string); }
-    }
-    public delegate void SqlInfoMessageEventHandler(object sender, System.Data.SqlClient.SqlInfoMessageEventArgs e);
-    public sealed partial class SqlParameter : System.Data.Common.DbParameter
-    {
-        public SqlParameter() { }
-        public SqlParameter(string parameterName, System.Data.SqlDbType dbType) { }
-        public SqlParameter(string parameterName, System.Data.SqlDbType dbType, int size) { }
-        public SqlParameter(string parameterName, System.Data.SqlDbType dbType, int size, string sourceColumn) { }
-        public SqlParameter(string parameterName, object value) { }
-        public System.Data.SqlTypes.SqlCompareOptions CompareInfo { get { return default(System.Data.SqlTypes.SqlCompareOptions); } set { } }
-        public override System.Data.DbType DbType { get { return default(System.Data.DbType); } set { } }
-        public override System.Data.ParameterDirection Direction { get { return default(System.Data.ParameterDirection); } set { } }
-        public override bool IsNullable { get { return default(bool); } set { } }
-        public int LocaleId { get { return default(int); } set { } }
-        public int Offset { get { return default(int); } set { } }
-        public override string ParameterName { get { return default(string); } set { } }
-        public new byte Precision { get { return default(byte); } set { } }
-        public new byte Scale { get { return default(byte); } set { } }
-        public override int Size { get { return default(int); } set { } }
-        public override string SourceColumn { get { return default(string); } set { } }
-        public override bool SourceColumnNullMapping { get { return default(bool); } set { } }
-        public System.Data.SqlDbType SqlDbType { get { return default(System.Data.SqlDbType); } set { } }
-        public object SqlValue { get { return default(object); } set { } }
-        public string TypeName { get { return default(string); } set { } }
-        public override object Value { get { return default(object); } set { } }
-        public string XmlSchemaCollectionDatabase { get { return default(string); } set { } }
-        public string XmlSchemaCollectionName { get { return default(string); } set { } }
-        public string XmlSchemaCollectionOwningSchema { get { return default(string); } set { } }
-        public override void ResetDbType() { }
-        public void ResetSqlDbType() { }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class SqlParameterCollection : System.Data.Common.DbParameterCollection
-    {
-        internal SqlParameterCollection() { }
-        public override int Count { get { return default(int); } }
-        public new System.Data.SqlClient.SqlParameter this[int index] { get { return default(System.Data.SqlClient.SqlParameter); } set { } }
-        public new System.Data.SqlClient.SqlParameter this[string parameterName] { get { return default(System.Data.SqlClient.SqlParameter); } set { } }
-        public override object SyncRoot { get { return default(object); } }
-        public System.Data.SqlClient.SqlParameter Add(System.Data.SqlClient.SqlParameter value) { return default(System.Data.SqlClient.SqlParameter); }
-        public override int Add(object value) { return default(int); }
-        public System.Data.SqlClient.SqlParameter Add(string parameterName, System.Data.SqlDbType sqlDbType) { return default(System.Data.SqlClient.SqlParameter); }
-        public System.Data.SqlClient.SqlParameter Add(string parameterName, System.Data.SqlDbType sqlDbType, int size) { return default(System.Data.SqlClient.SqlParameter); }
-        public override void AddRange(System.Array values) { }
-        public void AddRange(System.Data.SqlClient.SqlParameter[] values) { }
-        public System.Data.SqlClient.SqlParameter AddWithValue(string parameterName, object value) { return default(System.Data.SqlClient.SqlParameter); }
-        public override void Clear() { }
-        public bool Contains(System.Data.SqlClient.SqlParameter value) { return default(bool); }
-        public override bool Contains(object value) { return default(bool); }
-        public override bool Contains(string value) { return default(bool); }
-        public override void CopyTo(System.Array array, int index) { }
-        public void CopyTo(System.Data.SqlClient.SqlParameter[] array, int index) { }
-        public override System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
-        protected override System.Data.Common.DbParameter GetParameter(int index) { return default(System.Data.Common.DbParameter); }
-        protected override System.Data.Common.DbParameter GetParameter(string parameterName) { return default(System.Data.Common.DbParameter); }
-        public int IndexOf(System.Data.SqlClient.SqlParameter value) { return default(int); }
-        public override int IndexOf(object value) { return default(int); }
-        public override int IndexOf(string parameterName) { return default(int); }
-        public void Insert(int index, System.Data.SqlClient.SqlParameter value) { }
-        public override void Insert(int index, object value) { }
-        public void Remove(System.Data.SqlClient.SqlParameter value) { }
-        public override void Remove(object value) { }
-        public override void RemoveAt(int index) { }
-        public override void RemoveAt(string parameterName) { }
-        protected override void SetParameter(int index, System.Data.Common.DbParameter value) { }
-        protected override void SetParameter(string parameterName, System.Data.Common.DbParameter value) { }
-    }
-    public sealed partial class SqlTransaction : System.Data.Common.DbTransaction
-    {
-        internal SqlTransaction() { }
-        public new System.Data.SqlClient.SqlConnection Connection { get { return default(System.Data.SqlClient.SqlConnection); } }
-        protected override System.Data.Common.DbConnection DbConnection { get { return default(System.Data.Common.DbConnection); } }
-        public override System.Data.IsolationLevel IsolationLevel { get { return default(System.Data.IsolationLevel); } }
-        public override void Commit() { }
-        protected override void Dispose(bool disposing) { }
-        public override void Rollback() { }
-        public void Rollback(string transactionName) { }
-        public void Save(string savePointName) { }
-    }
-}
-namespace System.Data.SqlTypes
-{
-    public partial interface INullable
-    {
-        bool IsNull { get; }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlBinary : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlBinary Null;
-        public SqlBinary(byte[] value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public byte this[int index] { get { return default(byte); } }
-        public int Length { get { return default(int); } }
-        public byte[] Value { get { return default(byte[]); } }
-        public static System.Data.SqlTypes.SqlBinary Add(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBinary); }
-        public int CompareTo(System.Data.SqlTypes.SqlBinary value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlBinary Concat(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBinary); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBinary operator +(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBinary); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator byte[] (System.Data.SqlTypes.SqlBinary x) { return default(byte[]); }
-        public static explicit operator System.Data.SqlTypes.SqlBinary(System.Data.SqlTypes.SqlGuid x) { return default(System.Data.SqlTypes.SqlBinary); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlBinary(byte[] x) { return default(System.Data.SqlTypes.SqlBinary); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlBinary x, System.Data.SqlTypes.SqlBinary y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlGuid ToSqlGuid() { return default(System.Data.SqlTypes.SqlGuid); }
-        public override string ToString() { return default(string); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlBoolean : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlBoolean False;
-        public static readonly System.Data.SqlTypes.SqlBoolean Null;
-        public static readonly System.Data.SqlTypes.SqlBoolean One;
-        public static readonly System.Data.SqlTypes.SqlBoolean True;
-        public static readonly System.Data.SqlTypes.SqlBoolean Zero;
-        public SqlBoolean(bool value) { throw new System.NotImplementedException(); }
-        public SqlBoolean(int value) { throw new System.NotImplementedException(); }
-        public byte ByteValue { get { return default(byte); } }
-        public bool IsFalse { get { return default(bool); } }
-        public bool IsNull { get { return default(bool); } }
-        public bool IsTrue { get { return default(bool); } }
-        public bool Value { get { return default(bool); } }
-        public static System.Data.SqlTypes.SqlBoolean And(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public int CompareTo(System.Data.SqlTypes.SqlBoolean value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEquals(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEquals(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean OnesComplement(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator &(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator |(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator ^(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator bool (System.Data.SqlTypes.SqlBoolean x) { return default(bool); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlBoolean(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static bool operator false(System.Data.SqlTypes.SqlBoolean x) { return default(bool); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlBoolean(bool x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator !(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator ~(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static bool operator true(System.Data.SqlTypes.SqlBoolean x) { return default(bool); }
-        public static System.Data.SqlTypes.SqlBoolean Or(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean Parse(string s) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlBoolean Xor(System.Data.SqlTypes.SqlBoolean x, System.Data.SqlTypes.SqlBoolean y) { return default(System.Data.SqlTypes.SqlBoolean); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlByte : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlByte MaxValue;
-        public static readonly System.Data.SqlTypes.SqlByte MinValue;
-        public static readonly System.Data.SqlTypes.SqlByte Null;
-        public static readonly System.Data.SqlTypes.SqlByte Zero;
-        public SqlByte(byte value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public byte Value { get { return default(byte); } }
-        public static System.Data.SqlTypes.SqlByte Add(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte BitwiseAnd(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte BitwiseOr(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public int CompareTo(System.Data.SqlTypes.SqlByte value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlByte Divide(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlByte Mod(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte Modulus(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte Multiply(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlByte OnesComplement(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator +(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator &(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator |(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator /(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlByte operator ^(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator byte (System.Data.SqlTypes.SqlByte x) { return default(byte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static explicit operator System.Data.SqlTypes.SqlByte(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlByte(byte x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlByte operator %(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator *(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator ~(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte operator -(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte Parse(string s) { return default(System.Data.SqlTypes.SqlByte); }
-        public static System.Data.SqlTypes.SqlByte Subtract(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlByte Xor(System.Data.SqlTypes.SqlByte x, System.Data.SqlTypes.SqlByte y) { return default(System.Data.SqlTypes.SqlByte); }
-    }
-    public sealed partial class SqlBytes : System.Data.SqlTypes.INullable
-    {
-        public SqlBytes() { }
-        public SqlBytes(byte[] buffer) { }
-        public SqlBytes(System.Data.SqlTypes.SqlBinary value) { }
-        public SqlBytes(System.IO.Stream s) { }
-        public byte[] Buffer { get { return default(byte[]); } }
-        public bool IsNull { get { return default(bool); } }
-        public byte this[long offset] { get { return default(byte); } set { } }
-        public long Length { get { return default(long); } }
-        public long MaxLength { get { return default(long); } }
-        public static System.Data.SqlTypes.SqlBytes Null { get { return default(System.Data.SqlTypes.SqlBytes); } }
-        public System.IO.Stream Stream { get { return default(System.IO.Stream); } set { } }
-        public byte[] Value { get { return default(byte[]); } }
-        public static explicit operator System.Data.SqlTypes.SqlBytes(System.Data.SqlTypes.SqlBinary value) { return default(System.Data.SqlTypes.SqlBytes); }
-        public static explicit operator System.Data.SqlTypes.SqlBinary(System.Data.SqlTypes.SqlBytes value) { return default(System.Data.SqlTypes.SqlBinary); }
-        public long Read(long offset, byte[] buffer, int offsetInBuffer, int count) { return default(long); }
-        public void SetLength(long value) { }
-        public void SetNull() { }
-        public System.Data.SqlTypes.SqlBinary ToSqlBinary() { return default(System.Data.SqlTypes.SqlBinary); }
-        public void Write(long offset, byte[] buffer, int offsetInBuffer, int count) { }
-    }
-    public sealed partial class SqlChars : System.Data.SqlTypes.INullable
-    {
-        public SqlChars() { }
-        public SqlChars(char[] buffer) { }
-        public SqlChars(System.Data.SqlTypes.SqlString value) { }
-        public char[] Buffer { get { return default(char[]); } }
-        public bool IsNull { get { return default(bool); } }
-        public char this[long offset] { get { return default(char); } set { } }
-        public long Length { get { return default(long); } }
-        public long MaxLength { get { return default(long); } }
-        public static System.Data.SqlTypes.SqlChars Null { get { return default(System.Data.SqlTypes.SqlChars); } }
-        public char[] Value { get { return default(char[]); } }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlChars value) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlChars(System.Data.SqlTypes.SqlString value) { return default(System.Data.SqlTypes.SqlChars); }
-        public long Read(long offset, char[] buffer, int offsetInBuffer, int count) { return default(long); }
-        public void SetLength(long value) { }
-        public void SetNull() { }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public void Write(long offset, char[] buffer, int offsetInBuffer, int count) { }
-    }
-    [System.FlagsAttribute]
-    public enum SqlCompareOptions
-    {
-        BinarySort = 32768,
-        BinarySort2 = 16384,
-        IgnoreCase = 1,
-        IgnoreKanaType = 8,
-        IgnoreNonSpace = 2,
-        IgnoreWidth = 16,
-        None = 0,
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlDateTime : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlDateTime MaxValue;
-        public static readonly System.Data.SqlTypes.SqlDateTime MinValue;
-        public static readonly System.Data.SqlTypes.SqlDateTime Null;
-        public static readonly int SQLTicksPerHour;
-        public static readonly int SQLTicksPerMinute;
-        public static readonly int SQLTicksPerSecond;
-        public SqlDateTime(System.DateTime value) { throw new System.NotImplementedException(); }
-        public SqlDateTime(int dayTicks, int timeTicks) { throw new System.NotImplementedException(); }
-        public SqlDateTime(int year, int month, int day) { throw new System.NotImplementedException(); }
-        public SqlDateTime(int year, int month, int day, int hour, int minute, int second) { throw new System.NotImplementedException(); }
-        public SqlDateTime(int year, int month, int day, int hour, int minute, int second, double millisecond) { throw new System.NotImplementedException(); }
-        public SqlDateTime(int year, int month, int day, int hour, int minute, int second, int bilisecond) { throw new System.NotImplementedException(); }
-        public int DayTicks { get { return default(int); } }
-        public bool IsNull { get { return default(bool); } }
-        public int TimeTicks { get { return default(int); } }
-        public System.DateTime Value { get { return default(System.DateTime); } }
-        public static System.Data.SqlTypes.SqlDateTime Add(System.Data.SqlTypes.SqlDateTime x, System.TimeSpan t) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public int CompareTo(System.Data.SqlTypes.SqlDateTime value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDateTime operator +(System.Data.SqlTypes.SqlDateTime x, System.TimeSpan t) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.DateTime(System.Data.SqlTypes.SqlDateTime x) { return default(System.DateTime); }
-        public static explicit operator System.Data.SqlTypes.SqlDateTime(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlDateTime(System.DateTime value) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDateTime x, System.Data.SqlTypes.SqlDateTime y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDateTime operator -(System.Data.SqlTypes.SqlDateTime x, System.TimeSpan t) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public static System.Data.SqlTypes.SqlDateTime Parse(string s) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public static System.Data.SqlTypes.SqlDateTime Subtract(System.Data.SqlTypes.SqlDateTime x, System.TimeSpan t) { return default(System.Data.SqlTypes.SqlDateTime); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlDecimal : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly byte MaxPrecision;
-        public static readonly byte MaxScale;
-        public static readonly System.Data.SqlTypes.SqlDecimal MaxValue;
-        public static readonly System.Data.SqlTypes.SqlDecimal MinValue;
-        public static readonly System.Data.SqlTypes.SqlDecimal Null;
-        public SqlDecimal(byte bPrecision, byte bScale, bool fPositive, int data1, int data2, int data3, int data4) { throw new System.NotImplementedException(); }
-        public SqlDecimal(byte bPrecision, byte bScale, bool fPositive, int[] bits) { throw new System.NotImplementedException(); }
-        public SqlDecimal(decimal value) { throw new System.NotImplementedException(); }
-        public SqlDecimal(double dVal) { throw new System.NotImplementedException(); }
-        public SqlDecimal(int value) { throw new System.NotImplementedException(); }
-        public SqlDecimal(long value) { throw new System.NotImplementedException(); }
-        public byte[] BinData { get { return default(byte[]); } }
-        public int[] Data { get { return default(int[]); } }
-        public bool IsNull { get { return default(bool); } }
-        public bool IsPositive { get { return default(bool); } }
-        public byte Precision { get { return default(byte); } }
-        public byte Scale { get { return default(byte); } }
-        public decimal Value { get { return default(decimal); } }
-        public static System.Data.SqlTypes.SqlDecimal Abs(System.Data.SqlTypes.SqlDecimal n) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Add(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal AdjustScale(System.Data.SqlTypes.SqlDecimal n, int digits, bool fRound) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Ceiling(System.Data.SqlTypes.SqlDecimal n) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public int CompareTo(System.Data.SqlTypes.SqlDecimal value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlDecimal ConvertToPrecScale(System.Data.SqlTypes.SqlDecimal n, int precision, int scale) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Divide(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public static System.Data.SqlTypes.SqlDecimal Floor(System.Data.SqlTypes.SqlDecimal n) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDecimal Multiply(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDecimal operator +(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal operator /(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static explicit operator decimal (System.Data.SqlTypes.SqlDecimal x) { return default(decimal); }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static explicit operator System.Data.SqlTypes.SqlDecimal(double x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(decimal x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static implicit operator System.Data.SqlTypes.SqlDecimal(long x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDecimal operator *(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal operator -(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal operator -(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Parse(string s) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Power(System.Data.SqlTypes.SqlDecimal n, double exp) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlDecimal Round(System.Data.SqlTypes.SqlDecimal n, int position) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public static System.Data.SqlTypes.SqlInt32 Sign(System.Data.SqlTypes.SqlDecimal n) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlDecimal Subtract(System.Data.SqlTypes.SqlDecimal x, System.Data.SqlTypes.SqlDecimal y) { return default(System.Data.SqlTypes.SqlDecimal); }
-        public double ToDouble() { return default(double); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlDecimal Truncate(System.Data.SqlTypes.SqlDecimal n, int position) { return default(System.Data.SqlTypes.SqlDecimal); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlDouble : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlDouble MaxValue;
-        public static readonly System.Data.SqlTypes.SqlDouble MinValue;
-        public static readonly System.Data.SqlTypes.SqlDouble Null;
-        public static readonly System.Data.SqlTypes.SqlDouble Zero;
-        public SqlDouble(double value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public double Value { get { return default(double); } }
-        public static System.Data.SqlTypes.SqlDouble Add(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public int CompareTo(System.Data.SqlTypes.SqlDouble value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlDouble Divide(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDouble Multiply(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDouble operator +(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlDouble operator /(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static explicit operator double (System.Data.SqlTypes.SqlDouble x) { return default(double); }
-        public static explicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static implicit operator System.Data.SqlTypes.SqlDouble(double x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlDouble operator *(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlDouble operator -(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlDouble operator -(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlDouble Parse(string s) { return default(System.Data.SqlTypes.SqlDouble); }
-        public static System.Data.SqlTypes.SqlDouble Subtract(System.Data.SqlTypes.SqlDouble x, System.Data.SqlTypes.SqlDouble y) { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlGuid : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlGuid Null;
-        public SqlGuid(byte[] value) { throw new System.NotImplementedException(); }
-        public SqlGuid(System.Guid g) { throw new System.NotImplementedException(); }
-        public SqlGuid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw new System.NotImplementedException(); }
-        public SqlGuid(string s) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public System.Guid Value { get { return default(System.Guid); } }
-        public int CompareTo(System.Data.SqlTypes.SqlGuid value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlGuid(System.Data.SqlTypes.SqlBinary x) { return default(System.Data.SqlTypes.SqlGuid); }
-        public static explicit operator System.Guid(System.Data.SqlTypes.SqlGuid x) { return default(System.Guid); }
-        public static explicit operator System.Data.SqlTypes.SqlGuid(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlGuid); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlGuid(System.Guid x) { return default(System.Data.SqlTypes.SqlGuid); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlGuid x, System.Data.SqlTypes.SqlGuid y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlGuid Parse(string s) { return default(System.Data.SqlTypes.SqlGuid); }
-        public byte[] ToByteArray() { return default(byte[]); }
-        public System.Data.SqlTypes.SqlBinary ToSqlBinary() { return default(System.Data.SqlTypes.SqlBinary); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlInt16 : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlInt16 MaxValue;
-        public static readonly System.Data.SqlTypes.SqlInt16 MinValue;
-        public static readonly System.Data.SqlTypes.SqlInt16 Null;
-        public static readonly System.Data.SqlTypes.SqlInt16 Zero;
-        public SqlInt16(short value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public short Value { get { return default(short); } }
-        public static System.Data.SqlTypes.SqlInt16 Add(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 BitwiseAnd(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 BitwiseOr(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public int CompareTo(System.Data.SqlTypes.SqlInt16 value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlInt16 Divide(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt16 Mod(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 Modulus(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 Multiply(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt16 OnesComplement(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator +(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator &(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator |(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator /(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt16 operator ^(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator short (System.Data.SqlTypes.SqlInt16 x) { return default(short); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static explicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlInt16(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static implicit operator System.Data.SqlTypes.SqlInt16(short x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt16 operator %(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator *(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator ~(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator -(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 operator -(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 Parse(string s) { return default(System.Data.SqlTypes.SqlInt16); }
-        public static System.Data.SqlTypes.SqlInt16 Subtract(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlInt16 Xor(System.Data.SqlTypes.SqlInt16 x, System.Data.SqlTypes.SqlInt16 y) { return default(System.Data.SqlTypes.SqlInt16); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlInt32 : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlInt32 MaxValue;
-        public static readonly System.Data.SqlTypes.SqlInt32 MinValue;
-        public static readonly System.Data.SqlTypes.SqlInt32 Null;
-        public static readonly System.Data.SqlTypes.SqlInt32 Zero;
-        public SqlInt32(int value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public int Value { get { return default(int); } }
-        public static System.Data.SqlTypes.SqlInt32 Add(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 BitwiseAnd(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 BitwiseOr(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public int CompareTo(System.Data.SqlTypes.SqlInt32 value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlInt32 Divide(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt32 Mod(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 Modulus(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 Multiply(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt32 OnesComplement(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator +(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator &(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator |(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator /(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt32 operator ^(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator int (System.Data.SqlTypes.SqlInt32 x) { return default(int); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static explicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static implicit operator System.Data.SqlTypes.SqlInt32(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static implicit operator System.Data.SqlTypes.SqlInt32(int x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt32 operator %(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator *(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator ~(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator -(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 operator -(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 Parse(string s) { return default(System.Data.SqlTypes.SqlInt32); }
-        public static System.Data.SqlTypes.SqlInt32 Subtract(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlInt32 Xor(System.Data.SqlTypes.SqlInt32 x, System.Data.SqlTypes.SqlInt32 y) { return default(System.Data.SqlTypes.SqlInt32); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlInt64 : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlInt64 MaxValue;
-        public static readonly System.Data.SqlTypes.SqlInt64 MinValue;
-        public static readonly System.Data.SqlTypes.SqlInt64 Null;
-        public static readonly System.Data.SqlTypes.SqlInt64 Zero;
-        public SqlInt64(long value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public long Value { get { return default(long); } }
-        public static System.Data.SqlTypes.SqlInt64 Add(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 BitwiseAnd(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 BitwiseOr(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public int CompareTo(System.Data.SqlTypes.SqlInt64 value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlInt64 Divide(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt64 Mod(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 Modulus(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 Multiply(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt64 OnesComplement(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator +(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator &(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator |(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator /(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt64 operator ^(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator long (System.Data.SqlTypes.SqlInt64 x) { return default(long); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static explicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static implicit operator System.Data.SqlTypes.SqlInt64(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static implicit operator System.Data.SqlTypes.SqlInt64(long x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlInt64 operator %(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator *(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator ~(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator -(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 operator -(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 Parse(string s) { return default(System.Data.SqlTypes.SqlInt64); }
-        public static System.Data.SqlTypes.SqlInt64 Subtract(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-        public static System.Data.SqlTypes.SqlInt64 Xor(System.Data.SqlTypes.SqlInt64 x, System.Data.SqlTypes.SqlInt64 y) { return default(System.Data.SqlTypes.SqlInt64); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlMoney : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlMoney MaxValue;
-        public static readonly System.Data.SqlTypes.SqlMoney MinValue;
-        public static readonly System.Data.SqlTypes.SqlMoney Null;
-        public static readonly System.Data.SqlTypes.SqlMoney Zero;
-        public SqlMoney(decimal value) { throw new System.NotImplementedException(); }
-        public SqlMoney(double value) { throw new System.NotImplementedException(); }
-        public SqlMoney(int value) { throw new System.NotImplementedException(); }
-        public SqlMoney(long value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public decimal Value { get { return default(decimal); } }
-        public static System.Data.SqlTypes.SqlMoney Add(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public int CompareTo(System.Data.SqlTypes.SqlMoney value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlMoney Divide(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlMoney Multiply(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlMoney operator +(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlMoney operator /(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static explicit operator decimal (System.Data.SqlTypes.SqlMoney x) { return default(decimal); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static explicit operator System.Data.SqlTypes.SqlMoney(double x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(decimal x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static implicit operator System.Data.SqlTypes.SqlMoney(long x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlMoney operator *(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlMoney operator -(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlMoney operator -(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlMoney Parse(string s) { return default(System.Data.SqlTypes.SqlMoney); }
-        public static System.Data.SqlTypes.SqlMoney Subtract(System.Data.SqlTypes.SqlMoney x, System.Data.SqlTypes.SqlMoney y) { return default(System.Data.SqlTypes.SqlMoney); }
-        public decimal ToDecimal() { return default(decimal); }
-        public double ToDouble() { return default(double); }
-        public int ToInt32() { return default(int); }
-        public long ToInt64() { return default(long); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class SqlNullValueException : System.Data.SqlTypes.SqlTypeException
-    {
-        public SqlNullValueException() { }
-        public SqlNullValueException(string message) { }
-        public SqlNullValueException(string message, System.Exception e) { }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlSingle : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly System.Data.SqlTypes.SqlSingle MaxValue;
-        public static readonly System.Data.SqlTypes.SqlSingle MinValue;
-        public static readonly System.Data.SqlTypes.SqlSingle Null;
-        public static readonly System.Data.SqlTypes.SqlSingle Zero;
-        public SqlSingle(double value) { throw new System.NotImplementedException(); }
-        public SqlSingle(float value) { throw new System.NotImplementedException(); }
-        public bool IsNull { get { return default(bool); } }
-        public float Value { get { return default(float); } }
-        public static System.Data.SqlTypes.SqlSingle Add(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public int CompareTo(System.Data.SqlTypes.SqlSingle value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlSingle Divide(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlSingle Multiply(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlSingle operator +(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlSingle operator /(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static explicit operator float (System.Data.SqlTypes.SqlSingle x) { return default(float); }
-        public static explicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlString x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static implicit operator System.Data.SqlTypes.SqlSingle(float x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlSingle operator *(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlSingle operator -(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlSingle operator -(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlSingle Parse(string s) { return default(System.Data.SqlTypes.SqlSingle); }
-        public static System.Data.SqlTypes.SqlSingle Subtract(System.Data.SqlTypes.SqlSingle x, System.Data.SqlTypes.SqlSingle y) { return default(System.Data.SqlTypes.SqlSingle); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlString ToSqlString() { return default(System.Data.SqlTypes.SqlString); }
-        public override string ToString() { return default(string); }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct SqlString : System.Data.SqlTypes.INullable, System.IComparable
-    {
-        public static readonly int BinarySort;
-        public static readonly int BinarySort2;
-        public static readonly int IgnoreCase;
-        public static readonly int IgnoreKanaType;
-        public static readonly int IgnoreNonSpace;
-        public static readonly int IgnoreWidth;
-        public static readonly System.Data.SqlTypes.SqlString Null;
-        public SqlString(int lcid, System.Data.SqlTypes.SqlCompareOptions compareOptions, byte[] data) { throw new System.NotImplementedException(); }
-        public SqlString(int lcid, System.Data.SqlTypes.SqlCompareOptions compareOptions, byte[] data, bool fUnicode) { throw new System.NotImplementedException(); }
-        public SqlString(int lcid, System.Data.SqlTypes.SqlCompareOptions compareOptions, byte[] data, int index, int count) { throw new System.NotImplementedException(); }
-        public SqlString(int lcid, System.Data.SqlTypes.SqlCompareOptions compareOptions, byte[] data, int index, int count, bool fUnicode) { throw new System.NotImplementedException(); }
-        public SqlString(string data) { throw new System.NotImplementedException(); }
-        public SqlString(string data, int lcid) { throw new System.NotImplementedException(); }
-        public SqlString(string data, int lcid, System.Data.SqlTypes.SqlCompareOptions compareOptions) { throw new System.NotImplementedException(); }
-        public System.Globalization.CompareInfo CompareInfo { get { return default(System.Globalization.CompareInfo); } }
-        public System.Globalization.CultureInfo CultureInfo { get { return default(System.Globalization.CultureInfo); } }
-        public bool IsNull { get { return default(bool); } }
-        public int LCID { get { return default(int); } }
-        public System.Data.SqlTypes.SqlCompareOptions SqlCompareOptions { get { return default(System.Data.SqlTypes.SqlCompareOptions); } }
-        public string Value { get { return default(string); } }
-        public static System.Data.SqlTypes.SqlString Add(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlString); }
-        public System.Data.SqlTypes.SqlString Clone() { return default(System.Data.SqlTypes.SqlString); }
-        public static System.Globalization.CompareOptions CompareOptionsFromSqlCompareOptions(System.Data.SqlTypes.SqlCompareOptions compareOptions) { return default(System.Globalization.CompareOptions); }
-        public int CompareTo(System.Data.SqlTypes.SqlString value) { return default(int); }
-        public int CompareTo(object value) { return default(int); }
-        public static System.Data.SqlTypes.SqlString Concat(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlString); }
-        public static System.Data.SqlTypes.SqlBoolean Equals(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public override bool Equals(object value) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public byte[] GetNonUnicodeBytes() { return default(byte[]); }
-        public byte[] GetUnicodeBytes() { return default(byte[]); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThan(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean GreaterThanOrEqual(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThan(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean LessThanOrEqual(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean NotEquals(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlString operator +(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlString); }
-        public static System.Data.SqlTypes.SqlBoolean operator ==(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlBoolean x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlByte x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDateTime x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDecimal x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlDouble x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlGuid x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt16 x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt32 x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlInt64 x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlMoney x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator System.Data.SqlTypes.SqlString(System.Data.SqlTypes.SqlSingle x) { return default(System.Data.SqlTypes.SqlString); }
-        public static explicit operator string (System.Data.SqlTypes.SqlString x) { return default(string); }
-        public static System.Data.SqlTypes.SqlBoolean operator >(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator >=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static implicit operator System.Data.SqlTypes.SqlString(string x) { return default(System.Data.SqlTypes.SqlString); }
-        public static System.Data.SqlTypes.SqlBoolean operator !=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public static System.Data.SqlTypes.SqlBoolean operator <=(System.Data.SqlTypes.SqlString x, System.Data.SqlTypes.SqlString y) { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlBoolean ToSqlBoolean() { return default(System.Data.SqlTypes.SqlBoolean); }
-        public System.Data.SqlTypes.SqlByte ToSqlByte() { return default(System.Data.SqlTypes.SqlByte); }
-        public System.Data.SqlTypes.SqlDateTime ToSqlDateTime() { return default(System.Data.SqlTypes.SqlDateTime); }
-        public System.Data.SqlTypes.SqlDecimal ToSqlDecimal() { return default(System.Data.SqlTypes.SqlDecimal); }
-        public System.Data.SqlTypes.SqlDouble ToSqlDouble() { return default(System.Data.SqlTypes.SqlDouble); }
-        public System.Data.SqlTypes.SqlGuid ToSqlGuid() { return default(System.Data.SqlTypes.SqlGuid); }
-        public System.Data.SqlTypes.SqlInt16 ToSqlInt16() { return default(System.Data.SqlTypes.SqlInt16); }
-        public System.Data.SqlTypes.SqlInt32 ToSqlInt32() { return default(System.Data.SqlTypes.SqlInt32); }
-        public System.Data.SqlTypes.SqlInt64 ToSqlInt64() { return default(System.Data.SqlTypes.SqlInt64); }
-        public System.Data.SqlTypes.SqlMoney ToSqlMoney() { return default(System.Data.SqlTypes.SqlMoney); }
-        public System.Data.SqlTypes.SqlSingle ToSqlSingle() { return default(System.Data.SqlTypes.SqlSingle); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class SqlTruncateException : System.Data.SqlTypes.SqlTypeException
-    {
-        public SqlTruncateException() { }
-        public SqlTruncateException(string message) { }
-        public SqlTruncateException(string message, System.Exception e) { }
-    }
-    public partial class SqlTypeException : System.Exception
-    {
-        public SqlTypeException() { }
-        public SqlTypeException(string message) { }
-        public SqlTypeException(string message, System.Exception e) { }
-    }
-    public sealed partial class SqlXml : System.Data.SqlTypes.INullable
-    {
-        public SqlXml() { }
-        public SqlXml(System.IO.Stream value) { }
-        public SqlXml(System.Xml.XmlReader value) { }
-        public bool IsNull { get { return default(bool); } }
-        public static System.Data.SqlTypes.SqlXml Null { get { return default(System.Data.SqlTypes.SqlXml); } }
-        public string Value { get { return default(string); } }
-        public System.Xml.XmlReader CreateReader() { return default(System.Xml.XmlReader); }
-    }
-}

diff --git a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.csproj b/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.depproj
similarity index 69%
rename from src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.csproj
rename to src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.depproj
index 17e7c99..07d7940 100644 (file)
--- a/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.csproj
+++ b/src/libraries/System.Data.SqlClient/ref/4.0/System.Data.SqlClient.depproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <PropertyGroup>
     <AssemblyVersion>4.0.0.0</AssemblyVersion>
@@ -8,10 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.2</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Data.SqlClient.cs" />
-    <Compile Include="System.Data.SqlClient.Manual.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Data.SqlClient/ref/4.0/project.json b/src/libraries/System.Data.SqlClient/ref/4.0/project.json
index 02272a2..bbe3cf3 100644 (file)
--- a/src/libraries/System.Data.SqlClient/ref/4.0/project.json
+++ b/src/libraries/System.Data.SqlClient/ref/4.0/project.json
@@ -1,17 +1,14 @@
 {
   "dependencies": {
-    "System.Data.Common": "4.0.0",
-    "System.Globalization": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Runtime": "4.0.0",
-    "System.Threading.Tasks": "4.0.0",
-    "System.Xml.ReaderWriter": "4.0.0"
+    "System.Data.SqlClient": "4.1.0",
+    "System.Data.Common": "4.0.0"
   },
   "frameworks": {
     "netstandard1.2": {
       "imports": [
         "dotnet5.3"
       ]
+
     }
   }
 }
\ No newline at end of file

diff --git a/src/libraries/System.Data.SqlClient/src/System.Data.SqlClient.csproj b/src/libraries/System.Data.SqlClient/src/System.Data.SqlClient.csproj
index 25afec6..dfda7aa 100644 (file)
--- a/src/libraries/System.Data.SqlClient/src/System.Data.SqlClient.csproj
+++ b/src/libraries/System.Data.SqlClient/src/System.Data.SqlClient.csproj
@@ -10,6 +10,7 @@
     <AssemblyVersion Condition="'$(TargetGroup)' == 'net451'">4.0.0.0</AssemblyVersion>
     <AssemblyVersion Condition="'$(TargetGroup)' != 'net451'">4.1.1.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.0.0.0'">..\ref\4.0\System.Data.SqlClient.depproj</ContractProject>
     <IsPartialFacadeAssembly Condition="'$(TargetGroup)' == 'net451' OR '$(TargetGroup)' == 'net46'">true</IsPartialFacadeAssembly>
     <PackageTargetFramework Condition="'$(TargetGroup)' == 'net451'">net451</PackageTargetFramework>
     <PackageTargetFramework Condition="'$(TargetGroup)' == ''">netstandard1.3</PackageTargetFramework>

diff --git a/src/libraries/System.Diagnostics.Process/pkg/System.Diagnostics.Process.pkgproj b/src/libraries/System.Diagnostics.Process/pkg/System.Diagnostics.Process.pkgproj
index 21b18d8..1f83d50 100644 (file)
--- a/src/libraries/System.Diagnostics.Process/pkg/System.Diagnostics.Process.pkgproj
+++ b/src/libraries/System.Diagnostics.Process/pkg/System.Diagnostics.Process.pkgproj
@@ -5,7 +5,7 @@
     <ProjectReference Include="..\ref\System.Diagnostics.Process.csproj">
       <SupportedFramework>net461;netcoreapp1.0</SupportedFramework>
     </ProjectReference>
-    <ProjectReference Include="..\ref\4.0\System.Diagnostics.Process.csproj">
+    <ProjectReference Include="..\ref\4.0\System.Diagnostics.Process.depproj">
       <SupportedFramework>net46</SupportedFramework>
     </ProjectReference>
     <ProjectReference Include="..\src\System.Diagnostics.Process.builds" />

diff --git a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.Manual.cs b/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.Manual.cs
deleted file mode 100644 (file)
index b23c05b..0000000
--- a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.Manual.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-namespace System.Diagnostics
-{
-    public partial class Process : System.IDisposable
-    {
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-    }
-    public partial class ProcessModuleCollection : System.Collections.ICollection
-    {
-        public int Count { get { return default(int); } }
-        bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
-        object System.Collections.ICollection.SyncRoot { get { return default(object); } }
-        void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
-        public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
-    }
-    public partial class ProcessThreadCollection : System.Collections.ICollection
-    {
-        public int Count { get { return default(int); } }
-        bool System.Collections.ICollection.IsSynchronized { get { return default(bool); } }
-        object System.Collections.ICollection.SyncRoot { get { return default(object); } }
-        void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
-        public System.Collections.IEnumerator GetEnumerator() { return default(System.Collections.IEnumerator); }
-    }
-}
-namespace Microsoft.Win32.SafeHandles
-{
-    // Members from SafeHandleMinusOneOrZeroIsInvalid needed after removing base
-    [System.Security.SecurityCritical]
-    public sealed partial class SafeProcessHandle : System.Runtime.InteropServices.SafeHandle
-    {
-        public override bool IsInvalid {[System.Security.SecurityCritical] get { return false; } }
-    }
-}

diff --git a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.cs b/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.cs
deleted file mode 100644 (file)
index f6ce9e6..0000000
--- a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-namespace Microsoft.Win32.SafeHandles
-{
-    public sealed partial class SafeProcessHandle : System.Runtime.InteropServices.SafeHandle
-    {
-        public SafeProcessHandle(System.IntPtr existingHandle, bool ownsHandle) : base(default(System.IntPtr), default(bool)) { }
-        protected override bool ReleaseHandle() { return default(bool); }
-    }
-}
-namespace System.Diagnostics
-{
-    public partial class DataReceivedEventArgs : System.EventArgs
-    {
-        internal DataReceivedEventArgs() { }
-        public string Data { get { return default(string); } }
-    }
-    public delegate void DataReceivedEventHandler(object sender, System.Diagnostics.DataReceivedEventArgs e);
-    public partial class Process
-    {
-        public Process() { }
-        public int BasePriority { get { return default(int); } }
-        [System.ComponentModel.DefaultValueAttribute(false)]
-        public bool EnableRaisingEvents { get { return default(bool); } set { } }
-        public int ExitCode { get { return default(int); } }
-        public System.DateTime ExitTime { get { return default(System.DateTime); } }
-        public bool HasExited { get { return default(bool); } }
-        public int Id { get { return default(int); } }
-        public string MachineName { get { return default(string); } }
-        public System.Diagnostics.ProcessModule MainModule { get { return default(System.Diagnostics.ProcessModule); } }
-        public System.IntPtr MaxWorkingSet { get { return default(System.IntPtr); } set { } }
-        public System.IntPtr MinWorkingSet { get { return default(System.IntPtr); } set { } }
-        public System.Diagnostics.ProcessModuleCollection Modules { get { return default(System.Diagnostics.ProcessModuleCollection); } }
-        public long NonpagedSystemMemorySize64 { get { return default(long); } }
-        public long PagedMemorySize64 { get { return default(long); } }
-        public long PagedSystemMemorySize64 { get { return default(long); } }
-        public long PeakPagedMemorySize64 { get { return default(long); } }
-        public long PeakVirtualMemorySize64 { get { return default(long); } }
-        public long PeakWorkingSet64 { get { return default(long); } }
-        public bool PriorityBoostEnabled { get { return default(bool); } set { } }
-        public System.Diagnostics.ProcessPriorityClass PriorityClass { get { return default(System.Diagnostics.ProcessPriorityClass); } set { } }
-        public long PrivateMemorySize64 { get { return default(long); } }
-        public System.TimeSpan PrivilegedProcessorTime { get { return default(System.TimeSpan); } }
-        public string ProcessName { get { return default(string); } }
-        public System.IntPtr ProcessorAffinity { get { return default(System.IntPtr); } set { } }
-        public Microsoft.Win32.SafeHandles.SafeProcessHandle SafeHandle { get { return default(Microsoft.Win32.SafeHandles.SafeProcessHandle); } }
-        public int SessionId { get { return default(int); } }
-        public System.IO.StreamReader StandardError { get { return default(System.IO.StreamReader); } }
-        public System.IO.StreamWriter StandardInput { get { return default(System.IO.StreamWriter); } }
-        public System.IO.StreamReader StandardOutput { get { return default(System.IO.StreamReader); } }
-        public System.Diagnostics.ProcessStartInfo StartInfo { get { return default(System.Diagnostics.ProcessStartInfo); } set { } }
-        public System.DateTime StartTime { get { return default(System.DateTime); } }
-        public System.Diagnostics.ProcessThreadCollection Threads { get { return default(System.Diagnostics.ProcessThreadCollection); } }
-        public System.TimeSpan TotalProcessorTime { get { return default(System.TimeSpan); } }
-        public System.TimeSpan UserProcessorTime { get { return default(System.TimeSpan); } }
-        public long VirtualMemorySize64 { get { return default(long); } }
-        public long WorkingSet64 { get { return default(long); } }
-        public event System.Diagnostics.DataReceivedEventHandler ErrorDataReceived { add { } remove { } }
-        public event System.EventHandler Exited { add { } remove { } }
-        public event System.Diagnostics.DataReceivedEventHandler OutputDataReceived { add { } remove { } }
-        public void BeginErrorReadLine() { }
-        public void BeginOutputReadLine() { }
-        public void CancelErrorRead() { }
-        public void CancelOutputRead() { }
-        public static void EnterDebugMode() { }
-        public static System.Diagnostics.Process GetCurrentProcess() { return default(System.Diagnostics.Process); }
-        public static System.Diagnostics.Process GetProcessById(int processId) { return default(System.Diagnostics.Process); }
-        public static System.Diagnostics.Process GetProcessById(int processId, string machineName) { return default(System.Diagnostics.Process); }
-        public static System.Diagnostics.Process[] GetProcesses() { return default(System.Diagnostics.Process[]); }
-        public static System.Diagnostics.Process[] GetProcesses(string machineName) { return default(System.Diagnostics.Process[]); }
-        public static System.Diagnostics.Process[] GetProcessesByName(string processName) { return default(System.Diagnostics.Process[]); }
-        public static System.Diagnostics.Process[] GetProcessesByName(string processName, string machineName) { return default(System.Diagnostics.Process[]); }
-        public void Kill() { }
-        public static void LeaveDebugMode() { }
-        protected void OnExited() { }
-        public void Refresh() { }
-        public bool Start() { return default(bool); }
-        public static System.Diagnostics.Process Start(System.Diagnostics.ProcessStartInfo startInfo) { return default(System.Diagnostics.Process); }
-        public static System.Diagnostics.Process Start(string fileName) { return default(System.Diagnostics.Process); }
-        public static System.Diagnostics.Process Start(string fileName, string arguments) { return default(System.Diagnostics.Process); }
-        public void WaitForExit() { }
-        public bool WaitForExit(int milliseconds) { return default(bool); }
-    }
-    public partial class ProcessModule
-    {
-        internal ProcessModule() { }
-        public System.IntPtr BaseAddress { get { return default(System.IntPtr); } }
-        public System.IntPtr EntryPointAddress { get { return default(System.IntPtr); } }
-        public string FileName { get { return default(string); } }
-        public int ModuleMemorySize { get { return default(int); } }
-        public string ModuleName { get { return default(string); } }
-        public override string ToString() { return default(string); }
-    }
-    public partial class ProcessModuleCollection
-    {
-        protected ProcessModuleCollection() { }
-        public ProcessModuleCollection(System.Diagnostics.ProcessModule[] processModules) { }
-        public System.Diagnostics.ProcessModule this[int index] { get { return default(System.Diagnostics.ProcessModule); } }
-        public bool Contains(System.Diagnostics.ProcessModule module) { return default(bool); }
-        public void CopyTo(System.Diagnostics.ProcessModule[] array, int index) { }
-        public int IndexOf(System.Diagnostics.ProcessModule module) { return default(int); }
-    }
-    public enum ProcessPriorityClass
-    {
-        AboveNormal = 32768,
-        BelowNormal = 16384,
-        High = 128,
-        Idle = 64,
-        Normal = 32,
-        RealTime = 256,
-    }
-    public sealed partial class ProcessStartInfo
-    {
-        public ProcessStartInfo() { }
-        public ProcessStartInfo(string fileName) { }
-        public ProcessStartInfo(string fileName, string arguments) { }
-        public string Arguments { get { return default(string); } set { } }
-        public bool CreateNoWindow { get { return default(bool); } set { } }
-        [System.ComponentModel.DefaultValueAttribute(null)]
-        public System.Collections.Generic.IDictionary<string, string> Environment { get { return default(System.Collections.Generic.IDictionary<string, string>); } }
-        public string FileName { get { return default(string); } set { } }
-        public bool RedirectStandardError { get { return default(bool); } set { } }
-        public bool RedirectStandardInput { get { return default(bool); } set { } }
-        public bool RedirectStandardOutput { get { return default(bool); } set { } }
-        public System.Text.Encoding StandardErrorEncoding { get { return default(System.Text.Encoding); } set { } }
-        public System.Text.Encoding StandardOutputEncoding { get { return default(System.Text.Encoding); } set { } }
-        public bool UseShellExecute { get { return default(bool); } set { } }
-        public string WorkingDirectory { get { return default(string); } set { } }
-    }
-    public partial class ProcessThread
-    {
-        internal ProcessThread() { }
-        public int BasePriority { get { return default(int); } }
-        public int CurrentPriority { get { return default(int); } }
-        public int Id { get { return default(int); } }
-        public int IdealProcessor { set { } }
-        public bool PriorityBoostEnabled { get { return default(bool); } set { } }
-        public System.Diagnostics.ThreadPriorityLevel PriorityLevel { get { return default(System.Diagnostics.ThreadPriorityLevel); } set { } }
-        public System.TimeSpan PrivilegedProcessorTime { get { return default(System.TimeSpan); } }
-        public System.IntPtr ProcessorAffinity { set { } }
-        public System.IntPtr StartAddress { get { return default(System.IntPtr); } }
-        public System.DateTime StartTime { get { return default(System.DateTime); } }
-        public System.Diagnostics.ThreadState ThreadState { get { return default(System.Diagnostics.ThreadState); } }
-        public System.TimeSpan TotalProcessorTime { get { return default(System.TimeSpan); } }
-        public System.TimeSpan UserProcessorTime { get { return default(System.TimeSpan); } }
-        public System.Diagnostics.ThreadWaitReason WaitReason { get { return default(System.Diagnostics.ThreadWaitReason); } }
-        public void ResetIdealProcessor() { }
-    }
-    public partial class ProcessThreadCollection
-    {
-        protected ProcessThreadCollection() { }
-        public ProcessThreadCollection(System.Diagnostics.ProcessThread[] processThreads) { }
-        public System.Diagnostics.ProcessThread this[int index] { get { return default(System.Diagnostics.ProcessThread); } }
-        public int Add(System.Diagnostics.ProcessThread thread) { return default(int); }
-        public bool Contains(System.Diagnostics.ProcessThread thread) { return default(bool); }
-        public void CopyTo(System.Diagnostics.ProcessThread[] array, int index) { }
-        public int IndexOf(System.Diagnostics.ProcessThread thread) { return default(int); }
-        public void Insert(int index, System.Diagnostics.ProcessThread thread) { }
-        public void Remove(System.Diagnostics.ProcessThread thread) { }
-    }
-    public enum ThreadPriorityLevel
-    {
-        AboveNormal = 1,
-        BelowNormal = -1,
-        Highest = 2,
-        Idle = -15,
-        Lowest = -2,
-        Normal = 0,
-        TimeCritical = 15,
-    }
-    public enum ThreadState
-    {
-        Initialized = 0,
-        Ready = 1,
-        Running = 2,
-        Standby = 3,
-        Terminated = 4,
-        Transition = 6,
-        Unknown = 7,
-        Wait = 5,
-    }
-    public enum ThreadWaitReason
-    {
-        EventPairHigh = 7,
-        EventPairLow = 8,
-        ExecutionDelay = 4,
-        Executive = 0,
-        FreePage = 1,
-        LpcReceive = 9,
-        LpcReply = 10,
-        PageIn = 2,
-        PageOut = 12,
-        Suspended = 5,
-        SystemAllocation = 3,
-        Unknown = 13,
-        UserRequest = 6,
-        VirtualMemory = 11,
-    }
-}

diff --git a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.csproj b/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.depproj
similarity index 68%
rename from src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.csproj
rename to src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.depproj
index e7eda50..936df44 100644 (file)
--- a/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.csproj
+++ b/src/libraries/System.Diagnostics.Process/ref/4.0/System.Diagnostics.Process.depproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <PropertyGroup>
     <AssemblyVersion>4.0.0.0</AssemblyVersion>
@@ -8,10 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.3</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Diagnostics.Process.cs" />
-    <Compile Include="System.Diagnostics.Process.Manual.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Diagnostics.Process/ref/4.0/project.json b/src/libraries/System.Diagnostics.Process/ref/4.0/project.json
index 96ad4db..7290e04 100644 (file)
--- a/src/libraries/System.Diagnostics.Process/ref/4.0/project.json
+++ b/src/libraries/System.Diagnostics.Process/ref/4.0/project.json
@@ -1,15 +1,8 @@
 {
   "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.Runtime.Handles": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Text.Encoding": "4.0.0"
+    "System.Diagnostics.Process": "4.1.0"
   },
   "frameworks": {
-    "netstandard1.3": {
-      "imports": [
-        "dotnet5.4"
-      ]
-    }
+    "netstandard1.3": {}
   }
 }
\ No newline at end of file

diff --git a/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj b/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
index 5426901..ec0ac16 100644 (file)
--- a/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
+++ b/src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj
@@ -13,6 +13,7 @@
     <AssemblyVersion Condition="'$(TargetGroup)'!='net46'">4.1.1.0</AssemblyVersion>
     <AssemblyVersion Condition="'$(TargetGroup)'=='net46'">4.0.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.0.0.0'">..\ref\4.0\System.Diagnostics.Process.depproj</ContractProject>
     <PackageTargetFramework Condition="'$(TargetGroup)'==''">netstandard1.4</PackageTargetFramework>
     <IsPartialFacadeAssembly Condition="'$(TargetGroup)'=='net46' OR '$(TargetGroup)'=='net461'">true</IsPartialFacadeAssembly>
     <NuGetTargetMoniker Condition="'$(TargetGroup)' == ''">.NETStandard,Version=v1.4</NuGetTargetMoniker>

diff --git a/src/libraries/System.Reflection/ref/4.0/System.Reflection.Manual.cs b/src/libraries/System.Reflection/ref/4.0/System.Reflection.Manual.cs
deleted file mode 100644 (file)
index 52b685b..0000000
--- a/src/libraries/System.Reflection/ref/4.0/System.Reflection.Manual.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-// This is only needed for COMAwareEventInfo to inherit from EventInfo. Next version when
-// Reflection is extensible then we should remove this InternalsVisibleTo.
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Runtime.InteropServices, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")]
-
-// This is required so that AssemblyBuilder can derive from Assembly.
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reflection.Emit, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")]
-
-// This is required so that DynamicMethod can derive from MethodInfo.
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Reflection.Emit.Lightweight, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")]
-
-// This is required for ProjectN to extend reflection. Once we make extensibility via contracts work on desktop, this can be removed.
-[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("System.Private.Reflection.Extensibility, PublicKey=002400000480000094000000060200000024000052534131000400000100010007D1FA57C4AED9F0A32E84AA0FAEFD0DE9E8FD6AEC8F87FB03766C834C99921EB23BE79AD9D5DCC1DD9AD236132102900B723CF980957FC4E177108FC607774F29E8320E92EA05ECE4E821C0A5EFE8F1645C4C0C93C1AB99285D622CAA652C1DFAD63D745D6F2DE5F17E5EAF0FC4963D261C8A12436518206DC093344D5AD293")]
-
-namespace System.Reflection
-{
-    public partial class TypeInfo
-    {
-        // These members are promoted from Type.
-        public abstract System.Reflection.TypeAttributes Attributes { get; }
-        public abstract int GetArrayRank();
-        public abstract System.Type GetElementType();
-        public abstract Type[] GetGenericParameterConstraints();
-        public virtual bool IsSubclassOf(System.Type c) { return default(bool); }
-        public abstract Type[] GenericTypeArguments { get; }
-        public abstract Type GetGenericTypeDefinition();
-        public abstract Assembly Assembly { get; }
-        public abstract Type BaseType { get; }
-        public abstract bool ContainsGenericParameters { get; }
-
-        public abstract MethodBase DeclaringMethod { get; }
-        public abstract string FullName { get; }
-        public abstract GenericParameterAttributes GenericParameterAttributes { get; }
-        public abstract int GenericParameterPosition { get; }
-        public abstract Guid GUID { get; }
-        public bool HasElementType { get { return default(bool); } }
-        public bool IsAbstract { get { return default(bool); } }
-        public bool IsAnsiClass { get { return default(bool); } }
-        public bool IsArray { get { return default(bool); } }
-        public bool IsAutoClass { get { return default(bool); } }
-        public bool IsAutoLayout { get { return default(bool); } }
-        public bool IsByRef { get { return default(bool); } }
-        public bool IsClass { get { return default(bool); } }
-        public abstract bool IsEnum { get; }
-        public bool IsExplicitLayout { get { return default(bool); } }
-        public abstract bool IsGenericParameter { get; }
-        public abstract bool IsGenericType { get; }
-        public abstract bool IsGenericTypeDefinition { get; }
-        public bool IsImport { get { return default(bool); } }
-        public bool IsInterface { get { return default(bool); } }
-        public bool IsLayoutSequential { get { return default(bool); } }
-        public bool IsMarshalByRef { get { return default(bool); } }
-        public bool IsNested { get { return default(bool); } }
-        public bool IsNestedAssembly { get { return default(bool); } }
-        public bool IsNestedFamANDAssem { get { return default(bool); } }
-        public bool IsNestedFamily { get { return default(bool); } }
-        public bool IsNestedFamORAssem { get { return default(bool); } }
-        public bool IsNestedPrivate { get { return default(bool); } }
-        public bool IsNestedPublic { get { return default(bool); } }
-        public bool IsNotPublic { get { return default(bool); } }
-        public bool IsPointer { get { return default(bool); } }
-        public virtual bool IsPrimitive { get { return default(bool); } }
-        public bool IsPublic { get { return default(bool); } }
-        public bool IsSealed { get { return default(bool); } }
-        public bool IsVisible { get { return default(bool); } }
-        public abstract bool IsSerializable { get; }
-        public bool IsSpecialName { get { return default(bool); } }
-        public bool IsUnicodeClass { get { return default(bool); } }
-        public virtual bool IsValueType { get { return default(bool); } }
-        public abstract string Namespace { get; }
-        public abstract string AssemblyQualifiedName { get; }
-
-        public abstract Type MakeArrayType();
-        public abstract Type MakeArrayType(int rank);
-        public abstract Type MakeByRefType();
-        public abstract Type MakeGenericType(params System.Type[] typeArguments);
-        public abstract Type MakePointerType();
-    }
-
-    // These should be made public when reflection extensibility via contracts is supported on all platforms.
-    // In the meantime, these will be exposed via wrapper factory methods in System.Private.Reflection.Extensibility.
-    public partial struct CustomAttributeNamedArgument
-    {
-        internal CustomAttributeNamedArgument(Type attributeType, string memberName, bool isField, CustomAttributeTypedArgument typedValue) { }
-    }
-
-    public partial struct CustomAttributeTypedArgument
-    {
-        internal CustomAttributeTypedArgument(Type argumentType, object value) { }
-    }
-}

diff --git a/src/libraries/System.Reflection/ref/4.0/System.Reflection.cs b/src/libraries/System.Reflection/ref/4.0/System.Reflection.cs
deleted file mode 100644 (file)
index 6f0e1e2..0000000
--- a/src/libraries/System.Reflection/ref/4.0/System.Reflection.cs
+++ /dev/null
@@ -1,302 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace System.Reflection
-{
-    public sealed partial class AmbiguousMatchException : System.Exception
-    {
-        public AmbiguousMatchException() { }
-        public AmbiguousMatchException(string message) { }
-        public AmbiguousMatchException(string message, System.Exception inner) { }
-    }
-    public abstract partial class Assembly
-    {
-        internal Assembly() { }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData> CustomAttributes { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData>); } }
-        public abstract System.Collections.Generic.IEnumerable<System.Reflection.TypeInfo> DefinedTypes { get; }
-        public virtual System.Collections.Generic.IEnumerable<System.Type> ExportedTypes { get { return default(System.Collections.Generic.IEnumerable<System.Type>); } }
-        public virtual string FullName { get { return default(string); } }
-        public virtual bool IsDynamic { get { return default(bool); } }
-        public virtual System.Reflection.Module ManifestModule { get { return default(System.Reflection.Module); } }
-        public abstract System.Collections.Generic.IEnumerable<System.Reflection.Module> Modules { get; }
-        public override bool Equals(object o) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public virtual System.Reflection.ManifestResourceInfo GetManifestResourceInfo(string resourceName) { return default(System.Reflection.ManifestResourceInfo); }
-        public virtual string[] GetManifestResourceNames() { return default(string[]); }
-        public virtual System.IO.Stream GetManifestResourceStream(string name) { return default(System.IO.Stream); }
-        public virtual System.Reflection.AssemblyName GetName() { return default(System.Reflection.AssemblyName); }
-        public virtual System.Type GetType(string name) { return default(System.Type); }
-        public virtual System.Type GetType(string name, bool throwOnError, bool ignoreCase) { return default(System.Type); }
-        public static System.Reflection.Assembly Load(System.Reflection.AssemblyName assemblyRef) { return default(System.Reflection.Assembly); }
-        public override string ToString() { return default(string); }
-    }
-    public enum AssemblyContentType
-    {
-        Default = 0,
-        WindowsRuntime = 1,
-    }
-    public sealed partial class AssemblyName
-    {
-        public AssemblyName() { }
-        public AssemblyName(string assemblyName) { }
-        public System.Reflection.AssemblyContentType ContentType { get { return default(System.Reflection.AssemblyContentType); } set { } }
-        public string CultureName { get { return default(string); } set { } }
-        public System.Reflection.AssemblyNameFlags Flags { get { return default(System.Reflection.AssemblyNameFlags); } set { } }
-        public string FullName { get { return default(string); } }
-        public string Name { get { return default(string); } set { } }
-        public System.Reflection.ProcessorArchitecture ProcessorArchitecture { get { return default(System.Reflection.ProcessorArchitecture); } set { } }
-        public System.Version Version { get { return default(System.Version); } set { } }
-        public byte[] GetPublicKey() { return default(byte[]); }
-        public byte[] GetPublicKeyToken() { return default(byte[]); }
-        public void SetPublicKey(byte[] publicKey) { }
-        public void SetPublicKeyToken(byte[] publicKeyToken) { }
-        public override string ToString() { return default(string); }
-    }
-    public abstract partial class ConstructorInfo : System.Reflection.MethodBase
-    {
-        public static readonly string ConstructorName;
-        public static readonly string TypeConstructorName;
-        internal ConstructorInfo() { }
-        public override bool Equals(object obj) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public virtual object Invoke(object[] parameters) { return default(object); }
-    }
-    public partial class CustomAttributeData
-    {
-        internal CustomAttributeData() { }
-        public virtual System.Type AttributeType { get { return default(System.Type); } }
-        public virtual System.Collections.Generic.IList<System.Reflection.CustomAttributeTypedArgument> ConstructorArguments { get { return default(System.Collections.Generic.IList<System.Reflection.CustomAttributeTypedArgument>); } }
-        public virtual System.Collections.Generic.IList<System.Reflection.CustomAttributeNamedArgument> NamedArguments { get { return default(System.Collections.Generic.IList<System.Reflection.CustomAttributeNamedArgument>); } }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct CustomAttributeNamedArgument
-    {
-        public bool IsField { get { return default(bool); } }
-        public string MemberName { get { return default(string); } }
-        public System.Reflection.CustomAttributeTypedArgument TypedValue { get { return default(System.Reflection.CustomAttributeTypedArgument); } }
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct CustomAttributeTypedArgument
-    {
-        public System.Type ArgumentType { get { return default(System.Type); } }
-        public object Value { get { return default(object); } }
-    }
-    public abstract partial class EventInfo : System.Reflection.MemberInfo
-    {
-        internal EventInfo() { }
-        public virtual System.Reflection.MethodInfo AddMethod { get { return default(System.Reflection.MethodInfo); } }
-        public abstract System.Reflection.EventAttributes Attributes { get; }
-        public virtual System.Type EventHandlerType { get { return default(System.Type); } }
-        public bool IsSpecialName { get { return default(bool); } }
-        public virtual System.Reflection.MethodInfo RaiseMethod { get { return default(System.Reflection.MethodInfo); } }
-        public virtual System.Reflection.MethodInfo RemoveMethod { get { return default(System.Reflection.MethodInfo); } }
-        public virtual void AddEventHandler(object target, System.Delegate handler) { }
-        public override bool Equals(object obj) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public virtual void RemoveEventHandler(object target, System.Delegate handler) { }
-    }
-    public abstract partial class FieldInfo : System.Reflection.MemberInfo
-    {
-        internal FieldInfo() { }
-        public abstract System.Reflection.FieldAttributes Attributes { get; }
-        public abstract System.Type FieldType { get; }
-        public bool IsAssembly { get { return default(bool); } }
-        public bool IsFamily { get { return default(bool); } }
-        public bool IsFamilyAndAssembly { get { return default(bool); } }
-        public bool IsFamilyOrAssembly { get { return default(bool); } }
-        public bool IsInitOnly { get { return default(bool); } }
-        public bool IsLiteral { get { return default(bool); } }
-        public bool IsPrivate { get { return default(bool); } }
-        public bool IsPublic { get { return default(bool); } }
-        public bool IsSpecialName { get { return default(bool); } }
-        public bool IsStatic { get { return default(bool); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public static System.Reflection.FieldInfo GetFieldFromHandle(System.RuntimeFieldHandle handle) { return default(System.Reflection.FieldInfo); }
-        public static System.Reflection.FieldInfo GetFieldFromHandle(System.RuntimeFieldHandle handle, System.RuntimeTypeHandle declaringType) { return default(System.Reflection.FieldInfo); }
-        public override int GetHashCode() { return default(int); }
-        public abstract object GetValue(object obj);
-        public virtual void SetValue(object obj, object value) { }
-    }
-    public static partial class IntrospectionExtensions
-    {
-        public static System.Reflection.TypeInfo GetTypeInfo(this System.Type type) { return default(System.Reflection.TypeInfo); }
-    }
-    public partial interface IReflectableType
-    {
-        System.Reflection.TypeInfo GetTypeInfo();
-    }
-    public partial class LocalVariableInfo
-    {
-        protected LocalVariableInfo() { }
-        public virtual bool IsPinned { get { return default(bool); } }
-        public virtual int LocalIndex { get { return default(int); } }
-        public virtual System.Type LocalType { get { return default(System.Type); } }
-        public override string ToString() { return default(string); }
-    }
-    public partial class ManifestResourceInfo
-    {
-        public ManifestResourceInfo(System.Reflection.Assembly containingAssembly, string containingFileName, System.Reflection.ResourceLocation resourceLocation) { }
-        public virtual string FileName { get { return default(string); } }
-        public virtual System.Reflection.Assembly ReferencedAssembly { get { return default(System.Reflection.Assembly); } }
-        public virtual System.Reflection.ResourceLocation ResourceLocation { get { return default(System.Reflection.ResourceLocation); } }
-    }
-    public abstract partial class MemberInfo
-    {
-        internal MemberInfo() { }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData> CustomAttributes { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData>); } }
-        public abstract System.Type DeclaringType { get; }
-        public virtual System.Reflection.Module Module { get { return default(System.Reflection.Module); } }
-        public abstract string Name { get; }
-        public override bool Equals(object obj) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-    }
-    public abstract partial class MethodBase : System.Reflection.MemberInfo
-    {
-        internal MethodBase() { }
-        public abstract System.Reflection.MethodAttributes Attributes { get; }
-        public virtual System.Reflection.CallingConventions CallingConvention { get { return default(System.Reflection.CallingConventions); } }
-        public virtual bool ContainsGenericParameters { get { return default(bool); } }
-        public bool IsAbstract { get { return default(bool); } }
-        public bool IsAssembly { get { return default(bool); } }
-        public bool IsConstructor { get { return default(bool); } }
-        public bool IsFamily { get { return default(bool); } }
-        public bool IsFamilyAndAssembly { get { return default(bool); } }
-        public bool IsFamilyOrAssembly { get { return default(bool); } }
-        public bool IsFinal { get { return default(bool); } }
-        public virtual bool IsGenericMethod { get { return default(bool); } }
-        public virtual bool IsGenericMethodDefinition { get { return default(bool); } }
-        public bool IsHideBySig { get { return default(bool); } }
-        public bool IsPrivate { get { return default(bool); } }
-        public bool IsPublic { get { return default(bool); } }
-        public bool IsSpecialName { get { return default(bool); } }
-        public bool IsStatic { get { return default(bool); } }
-        public bool IsVirtual { get { return default(bool); } }
-        public abstract System.Reflection.MethodImplAttributes MethodImplementationFlags { get; }
-        public override bool Equals(object obj) { return default(bool); }
-        public virtual System.Type[] GetGenericArguments() { return default(System.Type[]); }
-        public override int GetHashCode() { return default(int); }
-        public static System.Reflection.MethodBase GetMethodFromHandle(System.RuntimeMethodHandle handle) { return default(System.Reflection.MethodBase); }
-        public static System.Reflection.MethodBase GetMethodFromHandle(System.RuntimeMethodHandle handle, System.RuntimeTypeHandle declaringType) { return default(System.Reflection.MethodBase); }
-        public abstract System.Reflection.ParameterInfo[] GetParameters();
-        public virtual object Invoke(object obj, object[] parameters) { return default(object); }
-    }
-    public abstract partial class MethodInfo : System.Reflection.MethodBase
-    {
-        internal MethodInfo() { }
-        public virtual System.Reflection.ParameterInfo ReturnParameter { get { return default(System.Reflection.ParameterInfo); } }
-        public virtual System.Type ReturnType { get { return default(System.Type); } }
-        public virtual System.Delegate CreateDelegate(System.Type delegateType) { return default(System.Delegate); }
-        public virtual System.Delegate CreateDelegate(System.Type delegateType, object target) { return default(System.Delegate); }
-        public override bool Equals(object obj) { return default(bool); }
-        public override System.Type[] GetGenericArguments() { return default(System.Type[]); }
-        public virtual System.Reflection.MethodInfo GetGenericMethodDefinition() { return default(System.Reflection.MethodInfo); }
-        public override int GetHashCode() { return default(int); }
-        public virtual System.Reflection.MethodInfo MakeGenericMethod(params System.Type[] typeArguments) { return default(System.Reflection.MethodInfo); }
-    }
-    public abstract partial class Module
-    {
-        internal Module() { }
-        public virtual System.Reflection.Assembly Assembly { get { return default(System.Reflection.Assembly); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData> CustomAttributes { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData>); } }
-        public virtual string FullyQualifiedName { get { return default(string); } }
-        public virtual string Name { get { return default(string); } }
-        public override bool Equals(object o) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public virtual System.Type GetType(string className, bool throwOnError, bool ignoreCase) { return default(System.Type); }
-        public override string ToString() { return default(string); }
-    }
-    public partial class ParameterInfo
-    {
-        internal ParameterInfo() { }
-        public virtual System.Reflection.ParameterAttributes Attributes { get { return default(System.Reflection.ParameterAttributes); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData> CustomAttributes { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.CustomAttributeData>); } }
-        public virtual object DefaultValue { get { return default(object); } }
-        public virtual bool HasDefaultValue { get { return default(bool); } }
-        public bool IsIn { get { return default(bool); } }
-        public bool IsOptional { get { return default(bool); } }
-        public bool IsOut { get { return default(bool); } }
-        public bool IsRetval { get { return default(bool); } }
-        public virtual System.Reflection.MemberInfo Member { get { return default(System.Reflection.MemberInfo); } }
-        public virtual string Name { get { return default(string); } }
-        public virtual System.Type ParameterType { get { return default(System.Type); } }
-        public virtual int Position { get { return default(int); } }
-    }
-    public abstract partial class PropertyInfo : System.Reflection.MemberInfo
-    {
-        internal PropertyInfo() { }
-        public abstract System.Reflection.PropertyAttributes Attributes { get; }
-        public abstract bool CanRead { get; }
-        public abstract bool CanWrite { get; }
-        public virtual System.Reflection.MethodInfo GetMethod { get { return default(System.Reflection.MethodInfo); } }
-        public bool IsSpecialName { get { return default(bool); } }
-        public abstract System.Type PropertyType { get; }
-        public virtual System.Reflection.MethodInfo SetMethod { get { return default(System.Reflection.MethodInfo); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public virtual object GetConstantValue() { return default(object); }
-        public override int GetHashCode() { return default(int); }
-        public abstract System.Reflection.ParameterInfo[] GetIndexParameters();
-        public object GetValue(object obj) { return default(object); }
-        public virtual object GetValue(object obj, object[] index) { return default(object); }
-        public void SetValue(object obj, object value) { }
-        public virtual void SetValue(object obj, object value, object[] index) { }
-    }
-    public abstract partial class ReflectionContext
-    {
-        protected ReflectionContext() { }
-        public virtual System.Reflection.TypeInfo GetTypeForObject(object value) { return default(System.Reflection.TypeInfo); }
-        public abstract System.Reflection.Assembly MapAssembly(System.Reflection.Assembly assembly);
-        public abstract System.Reflection.TypeInfo MapType(System.Reflection.TypeInfo type);
-    }
-    public sealed partial class ReflectionTypeLoadException : System.Exception
-    {
-        public ReflectionTypeLoadException(System.Type[] classes, System.Exception[] exceptions) { }
-        public ReflectionTypeLoadException(System.Type[] classes, System.Exception[] exceptions, string message) { }
-        public System.Exception[] LoaderExceptions { get { return default(System.Exception[]); } }
-        public System.Type[] Types { get { return default(System.Type[]); } }
-    }
-    [System.FlagsAttribute]
-    public enum ResourceLocation
-    {
-        ContainedInAnotherAssembly = 2,
-        ContainedInManifestFile = 4,
-        Embedded = 1,
-    }
-    public sealed partial class TargetInvocationException : System.Exception
-    {
-        public TargetInvocationException(System.Exception inner) { }
-        public TargetInvocationException(string message, System.Exception inner) { }
-    }
-    public sealed partial class TargetParameterCountException : System.Exception
-    {
-        public TargetParameterCountException() { }
-        public TargetParameterCountException(string message) { }
-        public TargetParameterCountException(string message, System.Exception inner) { }
-    }
-    public abstract partial class TypeInfo : System.Reflection.MemberInfo, System.Reflection.IReflectableType
-    {
-        internal TypeInfo() { }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.ConstructorInfo> DeclaredConstructors { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.ConstructorInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.EventInfo> DeclaredEvents { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.EventInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.FieldInfo> DeclaredFields { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.FieldInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.MemberInfo> DeclaredMembers { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.MemberInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> DeclaredMethods { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.TypeInfo> DeclaredNestedTypes { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.TypeInfo>); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo> DeclaredProperties { get { return default(System.Collections.Generic.IEnumerable<System.Reflection.PropertyInfo>); } }
-        public virtual System.Type[] GenericTypeParameters { get { return default(System.Type[]); } }
-        public virtual System.Collections.Generic.IEnumerable<System.Type> ImplementedInterfaces { get { return default(System.Collections.Generic.IEnumerable<System.Type>); } }
-        public virtual System.Type AsType() { return default(System.Type); }
-        public virtual System.Reflection.EventInfo GetDeclaredEvent(string name) { return default(System.Reflection.EventInfo); }
-        public virtual System.Reflection.FieldInfo GetDeclaredField(string name) { return default(System.Reflection.FieldInfo); }
-        public virtual System.Reflection.MethodInfo GetDeclaredMethod(string name) { return default(System.Reflection.MethodInfo); }
-        public virtual System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo> GetDeclaredMethods(string name) { return default(System.Collections.Generic.IEnumerable<System.Reflection.MethodInfo>); }
-        public virtual System.Reflection.TypeInfo GetDeclaredNestedType(string name) { return default(System.Reflection.TypeInfo); }
-        public virtual System.Reflection.PropertyInfo GetDeclaredProperty(string name) { return default(System.Reflection.PropertyInfo); }
-        public virtual bool IsAssignableFrom(System.Reflection.TypeInfo typeInfo) { return default(bool); }
-        System.Reflection.TypeInfo System.Reflection.IReflectableType.GetTypeInfo() { return default(System.Reflection.TypeInfo); }
-    }
-}

diff --git a/src/libraries/System.Reflection/ref/4.0/System.Reflection.csproj b/src/libraries/System.Reflection/ref/4.0/System.Reflection.csproj
deleted file mode 100644 (file)
index 54c584c..0000000
--- a/src/libraries/System.Reflection/ref/4.0/System.Reflection.csproj
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
-  <PropertyGroup>
-    <AssemblyVersion>4.0.11.0</AssemblyVersion>
-    <OutputType>Library</OutputType>
-    <NuGetTargetMoniker>.NETStandard,Version=v1.0</NuGetTargetMoniker>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="System.Reflection.cs" />
-    <Compile Include="System.Reflection.Manual.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="project.json" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
\ No newline at end of file

diff --git a/src/libraries/System.Reflection/ref/4.0/project.json b/src/libraries/System.Reflection/ref/4.0/project.json
deleted file mode 100644 (file)
index 5bbb80b..0000000
--- a/src/libraries/System.Reflection/ref/4.0/project.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-  "dependencies": {
-    "System.Runtime": "4.0.20",
-    "System.IO": "4.0.0",
-    "System.Reflection.Primitives": "4.0.0"
-  },
-  "frameworks": {
-    "netstandard1.0": { "imports": "dotnet5.1" }
-  }
-}
\ No newline at end of file

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/pkg/System.Security.Cryptography.Algorithms.pkgproj b/src/libraries/System.Security.Cryptography.Algorithms/pkg/System.Security.Cryptography.Algorithms.pkgproj
index f415540..9a9854b 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/pkg/System.Security.Cryptography.Algorithms.pkgproj
+++ b/src/libraries/System.Security.Cryptography.Algorithms/pkg/System.Security.Cryptography.Algorithms.pkgproj
@@ -2,10 +2,10 @@
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <ItemGroup>
-    <ProjectReference Include="..\ref\4.0\System.Security.Cryptography.Algorithms.csproj">
+    <ProjectReference Include="..\ref\4.0\System.Security.Cryptography.Algorithms.depproj">
       <SupportedFramework>net46</SupportedFramework>
     </ProjectReference>
-    <ProjectReference Include="..\ref\4.1\System.Security.Cryptography.Algorithms.csproj">
+    <ProjectReference Include="..\ref\4.1\System.Security.Cryptography.Algorithms.depproj">
       <SupportedFramework>net461;netcore50</SupportedFramework>
     </ProjectReference>
     <ProjectReference Include="..\ref\System.Security.Cryptography.Algorithms.csproj">

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.cs b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.cs
deleted file mode 100644 (file)
index 20f4dcc..0000000
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.cs
+++ /dev/null
@@ -1,219 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace System.Security.Cryptography
-{
-    public abstract partial class Aes : System.Security.Cryptography.SymmetricAlgorithm
-    {
-        protected Aes() { }
-        public override System.Security.Cryptography.KeySizes[] LegalBlockSizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public static System.Security.Cryptography.Aes Create() { return default(System.Security.Cryptography.Aes); }
-    }
-    public abstract partial class DeriveBytes : System.IDisposable
-    {
-        protected DeriveBytes() { }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public abstract byte[] GetBytes(int cb);
-        public abstract void Reset();
-    }
-    public partial class HMACMD5 : System.Security.Cryptography.HMAC
-    {
-        public HMACMD5() { }
-        public HMACMD5(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA1 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA1() { }
-        public HMACSHA1(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA256 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA256() { }
-        public HMACSHA256(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA384 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA384() { }
-        public HMACSHA384(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA512 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA512() { }
-        public HMACSHA512(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public sealed partial class IncrementalHash : System.IDisposable
-    {
-        internal IncrementalHash() { }
-        public System.Security.Cryptography.HashAlgorithmName AlgorithmName { get { return default(System.Security.Cryptography.HashAlgorithmName); } }
-        public void AppendData(byte[] data) { }
-        public void AppendData(byte[] data, int offset, int count) { }
-        public static System.Security.Cryptography.IncrementalHash CreateHash(System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(System.Security.Cryptography.IncrementalHash); }
-        public static System.Security.Cryptography.IncrementalHash CreateHMAC(System.Security.Cryptography.HashAlgorithmName hashAlgorithm, byte[] key) { return default(System.Security.Cryptography.IncrementalHash); }
-        public void Dispose() { }
-        public byte[] GetHashAndReset() { return default(byte[]); }
-    }
-    public abstract partial class MD5 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected MD5() { }
-        public static System.Security.Cryptography.MD5 Create() { return default(System.Security.Cryptography.MD5); }
-    }
-    public abstract partial class RandomNumberGenerator : System.IDisposable
-    {
-        protected RandomNumberGenerator() { }
-        public static System.Security.Cryptography.RandomNumberGenerator Create() { return default(System.Security.Cryptography.RandomNumberGenerator); }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public abstract void GetBytes(byte[] data);
-    }
-    public partial class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes
-    {
-        public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations) { }
-        public Rfc2898DeriveBytes(string password, byte[] salt) { }
-        public Rfc2898DeriveBytes(string password, byte[] salt, int iterations) { }
-        public Rfc2898DeriveBytes(string password, int saltSize) { }
-        public Rfc2898DeriveBytes(string password, int saltSize, int iterations) { }
-        public int IterationCount { get { return default(int); } set { } }
-        public byte[] Salt { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        public override byte[] GetBytes(int cb) { return default(byte[]); }
-        public override void Reset() { }
-    }
-    public abstract partial class RSA : System.Security.Cryptography.AsymmetricAlgorithm
-    {
-        protected RSA() { }
-        public static RSA Create() { return default(RSA); }
-        public abstract byte[] Decrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding);
-        public abstract byte[] Encrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding);
-        public abstract System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters);
-        protected abstract byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        protected abstract byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        public abstract void ImportParameters(System.Security.Cryptography.RSAParameters parameters);
-        public virtual byte[] SignData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public byte[] SignData(byte[] data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public virtual byte[] SignData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public abstract byte[] SignHash(byte[] hash, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding);
-        public bool VerifyData(byte[] data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public bool VerifyData(System.IO.Stream data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public abstract bool VerifyHash(byte[] hash, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding);
-    }
-    public sealed partial class RSAEncryptionPadding : System.IEquatable<System.Security.Cryptography.RSAEncryptionPadding>
-    {
-        internal RSAEncryptionPadding() { }
-        public System.Security.Cryptography.RSAEncryptionPaddingMode Mode { get { return default(System.Security.Cryptography.RSAEncryptionPaddingMode); } }
-        public System.Security.Cryptography.HashAlgorithmName OaepHashAlgorithm { get { return default(System.Security.Cryptography.HashAlgorithmName); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA1 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA256 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA384 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA512 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding Pkcs1 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding CreateOaep(System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(System.Security.Cryptography.RSAEncryptionPadding); }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.RSAEncryptionPadding other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.RSAEncryptionPadding left, System.Security.Cryptography.RSAEncryptionPadding right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.RSAEncryptionPadding left, System.Security.Cryptography.RSAEncryptionPadding right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public enum RSAEncryptionPaddingMode
-    {
-        Oaep = 1,
-        Pkcs1 = 0,
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct RSAParameters
-    {
-        public byte[] D;
-        public byte[] DP;
-        public byte[] DQ;
-        public byte[] Exponent;
-        public byte[] InverseQ;
-        public byte[] Modulus;
-        public byte[] P;
-        public byte[] Q;
-    }
-    public sealed partial class RSASignaturePadding : System.IEquatable<System.Security.Cryptography.RSASignaturePadding>
-    {
-        internal RSASignaturePadding() { }
-        public System.Security.Cryptography.RSASignaturePaddingMode Mode { get { return default(System.Security.Cryptography.RSASignaturePaddingMode); } }
-        public static System.Security.Cryptography.RSASignaturePadding Pkcs1 { get { return default(System.Security.Cryptography.RSASignaturePadding); } }
-        public static System.Security.Cryptography.RSASignaturePadding Pss { get { return default(System.Security.Cryptography.RSASignaturePadding); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.RSASignaturePadding other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.RSASignaturePadding left, System.Security.Cryptography.RSASignaturePadding right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.RSASignaturePadding left, System.Security.Cryptography.RSASignaturePadding right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public enum RSASignaturePaddingMode
-    {
-        Pkcs1 = 0,
-        Pss = 1,
-    }
-    public abstract partial class SHA1 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA1() { }
-        public static System.Security.Cryptography.SHA1 Create() { return default(System.Security.Cryptography.SHA1); }
-    }
-    public abstract partial class SHA256 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA256() { }
-        public static System.Security.Cryptography.SHA256 Create() { return default(System.Security.Cryptography.SHA256); }
-    }
-    public abstract partial class SHA384 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA384() { }
-        public static System.Security.Cryptography.SHA384 Create() { return default(System.Security.Cryptography.SHA384); }
-    }
-    public abstract partial class SHA512 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA512() { }
-        public static System.Security.Cryptography.SHA512 Create() { return default(System.Security.Cryptography.SHA512); }
-    }
-    public abstract partial class TripleDES : System.Security.Cryptography.SymmetricAlgorithm
-    {
-        protected TripleDES() { }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        public override System.Security.Cryptography.KeySizes[] LegalBlockSizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public static System.Security.Cryptography.TripleDES Create() { return default(System.Security.Cryptography.TripleDES); }
-        public static bool IsWeakKey(byte[] rgbKey) { return default(bool); }
-    }
-}

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.csproj b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.depproj
similarity index 88%
rename from src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.csproj
rename to src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.depproj
index c8130dc..7f7271e 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.csproj
+++ b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.depproj
@@ -8,9 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.3</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Security.Cryptography.Cng.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/project.json b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/project.json
index 0f7efba..c7ac1b6 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/project.json
+++ b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/project.json
@@ -1,14 +1,8 @@
 {
   "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Security.Cryptography.Primitives": "4.0.0"
+    "System.Security.Cryptography.Algorithms": "4.2.0"
   },
   "frameworks": {
-    "netstandard1.3": {
-      "imports": [
-        "dotnet5.4"
-      ]
-    }
+    "netstandard1.3": { }
   }
 }

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.cs b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.cs
deleted file mode 100644 (file)
index 56a1307..0000000
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.cs
+++ /dev/null
@@ -1,233 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace System.Security.Cryptography
-{
-    public abstract partial class Aes : System.Security.Cryptography.SymmetricAlgorithm
-    {
-        protected Aes() { }
-        public override System.Security.Cryptography.KeySizes[] LegalBlockSizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public static System.Security.Cryptography.Aes Create() { return default(System.Security.Cryptography.Aes); }
-    }
-    public abstract partial class DeriveBytes : System.IDisposable
-    {
-        protected DeriveBytes() { }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public abstract byte[] GetBytes(int cb);
-        public abstract void Reset();
-    }
-    public abstract partial class ECDsa : System.Security.Cryptography.AsymmetricAlgorithm
-    {
-        protected ECDsa() { }
-        protected abstract byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        protected abstract byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        public virtual byte[] SignData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public virtual byte[] SignData(byte[] data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public virtual byte[] SignData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public abstract byte[] SignHash(byte[] hash);
-        public bool VerifyData(byte[] data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(bool); }
-        public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(bool); }
-        public bool VerifyData(System.IO.Stream data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(bool); }
-        public abstract bool VerifyHash(byte[] hash, byte[] signature);
-    }
-    public partial class HMACMD5 : System.Security.Cryptography.HMAC
-    {
-        public HMACMD5() { }
-        public HMACMD5(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA1 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA1() { }
-        public HMACSHA1(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA256 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA256() { }
-        public HMACSHA256(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA384 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA384() { }
-        public HMACSHA384(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public partial class HMACSHA512 : System.Security.Cryptography.HMAC
-    {
-        public HMACSHA512() { }
-        public HMACSHA512(byte[] key) { }
-        public override int HashSize { get { return default(int); } }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        protected override void HashCore(byte[] rgb, int ib, int cb) { }
-        protected override byte[] HashFinal() { return default(byte[]); }
-        public override void Initialize() { }
-    }
-    public sealed partial class IncrementalHash : System.IDisposable
-    {
-        internal IncrementalHash() { }
-        public System.Security.Cryptography.HashAlgorithmName AlgorithmName { get { return default(System.Security.Cryptography.HashAlgorithmName); } }
-        public void AppendData(byte[] data) { }
-        public void AppendData(byte[] data, int offset, int count) { }
-        public static System.Security.Cryptography.IncrementalHash CreateHash(System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(System.Security.Cryptography.IncrementalHash); }
-        public static System.Security.Cryptography.IncrementalHash CreateHMAC(System.Security.Cryptography.HashAlgorithmName hashAlgorithm, byte[] key) { return default(System.Security.Cryptography.IncrementalHash); }
-        public void Dispose() { }
-        public byte[] GetHashAndReset() { return default(byte[]); }
-    }
-    public abstract partial class MD5 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected MD5() { }
-        public static System.Security.Cryptography.MD5 Create() { return default(System.Security.Cryptography.MD5); }
-    }
-    public abstract partial class RandomNumberGenerator : System.IDisposable
-    {
-        protected RandomNumberGenerator() { }
-        public static System.Security.Cryptography.RandomNumberGenerator Create() { return default(System.Security.Cryptography.RandomNumberGenerator); }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public abstract void GetBytes(byte[] data);
-    }
-    public partial class Rfc2898DeriveBytes : System.Security.Cryptography.DeriveBytes
-    {
-        public Rfc2898DeriveBytes(byte[] password, byte[] salt, int iterations) { }
-        public Rfc2898DeriveBytes(string password, byte[] salt) { }
-        public Rfc2898DeriveBytes(string password, byte[] salt, int iterations) { }
-        public Rfc2898DeriveBytes(string password, int saltSize) { }
-        public Rfc2898DeriveBytes(string password, int saltSize, int iterations) { }
-        public int IterationCount { get { return default(int); } set { } }
-        public byte[] Salt { get { return default(byte[]); } set { } }
-        protected override void Dispose(bool disposing) { }
-        public override byte[] GetBytes(int cb) { return default(byte[]); }
-        public override void Reset() { }
-    }
-    public abstract partial class RSA : System.Security.Cryptography.AsymmetricAlgorithm
-    {
-        protected RSA() { }
-        public static RSA Create() { return default(RSA); }
-        public abstract byte[] Decrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding);
-        public abstract byte[] Encrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding);
-        public abstract System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters);
-        protected abstract byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        protected abstract byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm);
-        public abstract void ImportParameters(System.Security.Cryptography.RSAParameters parameters);
-        public virtual byte[] SignData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public byte[] SignData(byte[] data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public virtual byte[] SignData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public abstract byte[] SignHash(byte[] hash, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding);
-        public bool VerifyData(byte[] data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public virtual bool VerifyData(byte[] data, int offset, int count, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public bool VerifyData(System.IO.Stream data, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-        public abstract bool VerifyHash(byte[] hash, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding);
-    }
-    public sealed partial class RSAEncryptionPadding : System.IEquatable<System.Security.Cryptography.RSAEncryptionPadding>
-    {
-        internal RSAEncryptionPadding() { }
-        public System.Security.Cryptography.RSAEncryptionPaddingMode Mode { get { return default(System.Security.Cryptography.RSAEncryptionPaddingMode); } }
-        public System.Security.Cryptography.HashAlgorithmName OaepHashAlgorithm { get { return default(System.Security.Cryptography.HashAlgorithmName); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA1 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA256 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA384 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding OaepSHA512 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding Pkcs1 { get { return default(System.Security.Cryptography.RSAEncryptionPadding); } }
-        public static System.Security.Cryptography.RSAEncryptionPadding CreateOaep(System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(System.Security.Cryptography.RSAEncryptionPadding); }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.RSAEncryptionPadding other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.RSAEncryptionPadding left, System.Security.Cryptography.RSAEncryptionPadding right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.RSAEncryptionPadding left, System.Security.Cryptography.RSAEncryptionPadding right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public enum RSAEncryptionPaddingMode
-    {
-        Oaep = 1,
-        Pkcs1 = 0,
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct RSAParameters
-    {
-        public byte[] D;
-        public byte[] DP;
-        public byte[] DQ;
-        public byte[] Exponent;
-        public byte[] InverseQ;
-        public byte[] Modulus;
-        public byte[] P;
-        public byte[] Q;
-    }
-    public sealed partial class RSASignaturePadding : System.IEquatable<System.Security.Cryptography.RSASignaturePadding>
-    {
-        internal RSASignaturePadding() { }
-        public System.Security.Cryptography.RSASignaturePaddingMode Mode { get { return default(System.Security.Cryptography.RSASignaturePaddingMode); } }
-        public static System.Security.Cryptography.RSASignaturePadding Pkcs1 { get { return default(System.Security.Cryptography.RSASignaturePadding); } }
-        public static System.Security.Cryptography.RSASignaturePadding Pss { get { return default(System.Security.Cryptography.RSASignaturePadding); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.RSASignaturePadding other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.RSASignaturePadding left, System.Security.Cryptography.RSASignaturePadding right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.RSASignaturePadding left, System.Security.Cryptography.RSASignaturePadding right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public enum RSASignaturePaddingMode
-    {
-        Pkcs1 = 0,
-        Pss = 1,
-    }
-    public abstract partial class SHA1 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA1() { }
-        public static System.Security.Cryptography.SHA1 Create() { return default(System.Security.Cryptography.SHA1); }
-    }
-    public abstract partial class SHA256 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA256() { }
-        public static System.Security.Cryptography.SHA256 Create() { return default(System.Security.Cryptography.SHA256); }
-    }
-    public abstract partial class SHA384 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA384() { }
-        public static System.Security.Cryptography.SHA384 Create() { return default(System.Security.Cryptography.SHA384); }
-    }
-    public abstract partial class SHA512 : System.Security.Cryptography.HashAlgorithm
-    {
-        protected SHA512() { }
-        public static System.Security.Cryptography.SHA512 Create() { return default(System.Security.Cryptography.SHA512); }
-    }
-    public abstract partial class TripleDES : System.Security.Cryptography.SymmetricAlgorithm
-    {
-        protected TripleDES() { }
-        public override byte[] Key { get { return default(byte[]); } set { } }
-        public override System.Security.Cryptography.KeySizes[] LegalBlockSizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public static System.Security.Cryptography.TripleDES Create() { return default(System.Security.Cryptography.TripleDES); }
-        public static bool IsWeakKey(byte[] rgbKey) { return default(bool); }
-    }
-}

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.csproj b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.depproj
similarity index 88%
rename from src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.csproj
rename to src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.depproj
index c99a81e..352d843 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.csproj
+++ b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.depproj
@@ -8,9 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Security.Cryptography.Cng.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/project.json b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/project.json
index 299ced2..f159282 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/project.json
+++ b/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/project.json
@@ -1,14 +1,8 @@
 {
   "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Security.Cryptography.Primitives": "4.0.0"
+    "System.Security.Cryptography.Algorithms": "4.2.0"
   },
   "frameworks": {
-    "netstandard1.4": {
-      "imports": [
-        "dotnet5.5"
-      ]
-    }
+    "netstandard1.4": { }
   }
 }

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj b/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
index 50fd555..c5e5a6d 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
+++ b/src/libraries/System.Security.Cryptography.Algorithms/src/System.Security.Cryptography.Algorithms.csproj
@@ -15,6 +15,8 @@
     <AssemblyVersion Condition="'$(TargetGroup)'=='net461' or '$(TargetGroup)' == 'netcore50'">4.1.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>INTERNAL_ASYMMETRIC_IMPLEMENTATIONS</DefineConstants>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.0.0.0'">..\ref\4.0\System.Security.Cryptography.Algorithms.depproj</ContractProject>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.1.0.0'">..\ref\4.1\System.Security.Cryptography.Algorithms.depproj</ContractProject>
     <PackageTargetFramework Condition="'$(PackageTargetFramework)'==''">netstandard1.6</PackageTargetFramework>
     <IsPartialFacadeAssembly Condition="'$(TargetGroup)'=='net46' OR '$(TargetGroup)'=='net461' OR '$(TargetGroup)'=='net463'">true</IsPartialFacadeAssembly>
     <NuGetTargetMoniker Condition="'$(TargetGroup)' == ''">.NETStandard,Version=v1.6</NuGetTargetMoniker>

diff --git a/src/libraries/System.Security.Cryptography.Cng/pkg/System.Security.Cryptography.Cng.pkgproj b/src/libraries/System.Security.Cryptography.Cng/pkg/System.Security.Cryptography.Cng.pkgproj
index e0deb0b..3391574 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/pkg/System.Security.Cryptography.Cng.pkgproj
+++ b/src/libraries/System.Security.Cryptography.Cng/pkg/System.Security.Cryptography.Cng.pkgproj
@@ -3,10 +3,10 @@
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
 
   <ItemGroup>
-    <ProjectReference Include="..\ref\4.0\System.Security.Cryptography.Cng.csproj">
+    <ProjectReference Include="..\ref\4.0\System.Security.Cryptography.Cng.depproj">
       <SupportedFramework>net46</SupportedFramework>
     </ProjectReference>
-    <ProjectReference Include="..\ref\4.1\System.Security.Cryptography.Cng.csproj">
+    <ProjectReference Include="..\ref\4.1\System.Security.Cryptography.Cng.depproj">
       <SupportedFramework>net461;netcore50</SupportedFramework>
     </ProjectReference>
     <ProjectReference Include="..\ref\System.Security.Cryptography.Cng.csproj">

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.cs b/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.cs
deleted file mode 100644 (file)
index 61349fd..0000000
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.cs
+++ /dev/null
@@ -1,252 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace Microsoft.Win32.SafeHandles
-{
-    public abstract partial class SafeNCryptHandle : System.Runtime.InteropServices.SafeHandle
-    {
-        protected SafeNCryptHandle() : base(default(System.IntPtr), default(bool)) { }
-        protected override bool ReleaseHandle() { return default(bool); }
-        protected abstract bool ReleaseNativeHandle();
-        public override bool IsInvalid { get { return default(bool); } }
-    }
-    public sealed partial class SafeNCryptKeyHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptKeyHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-    public sealed partial class SafeNCryptProviderHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptProviderHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-    public sealed partial class SafeNCryptSecretHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptSecretHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-}
-namespace System.Security.Cryptography
-{
-    public sealed partial class CngAlgorithm : System.IEquatable<System.Security.Cryptography.CngAlgorithm>
-    {
-        public CngAlgorithm(string algorithm) { }
-        public string Algorithm { get { return default(string); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP521 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP521 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm MD5 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Rsa { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha1 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha512 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngAlgorithm other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngAlgorithm left, System.Security.Cryptography.CngAlgorithm right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngAlgorithm left, System.Security.Cryptography.CngAlgorithm right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class CngAlgorithmGroup : System.IEquatable<System.Security.Cryptography.CngAlgorithmGroup>
-    {
-        public CngAlgorithmGroup(string algorithmGroup) { }
-        public string AlgorithmGroup { get { return default(string); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup DiffieHellman { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup Dsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup ECDiffieHellman { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup ECDsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup Rsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngAlgorithmGroup other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngAlgorithmGroup left, System.Security.Cryptography.CngAlgorithmGroup right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngAlgorithmGroup left, System.Security.Cryptography.CngAlgorithmGroup right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    [System.FlagsAttribute]
-    public enum CngExportPolicies
-    {
-        AllowArchiving = 4,
-        AllowExport = 1,
-        AllowPlaintextArchiving = 8,
-        AllowPlaintextExport = 2,
-        None = 0,
-    }
-    public sealed partial class CngKey : System.IDisposable
-    {
-        internal CngKey() { }
-        public System.Security.Cryptography.CngAlgorithm Algorithm { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public System.Security.Cryptography.CngAlgorithmGroup AlgorithmGroup { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public System.Security.Cryptography.CngExportPolicies ExportPolicy { get { return default(System.Security.Cryptography.CngExportPolicies); } }
-        public Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle Handle { get { return default(Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle); } }
-        public bool IsEphemeral { get { return default(bool); } }
-        public bool IsMachineKey { get { return default(bool); } }
-        public string KeyName { get { return default(string); } }
-        public int KeySize { get { return default(int); } }
-        public System.Security.Cryptography.CngKeyUsages KeyUsage { get { return default(System.Security.Cryptography.CngKeyUsages); } }
-        public System.IntPtr ParentWindowHandle { get { return default(System.IntPtr); } set { } }
-        public System.Security.Cryptography.CngProvider Provider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public Microsoft.Win32.SafeHandles.SafeNCryptProviderHandle ProviderHandle { get { return default(Microsoft.Win32.SafeHandles.SafeNCryptProviderHandle); } }
-        public System.Security.Cryptography.CngUIPolicy UIPolicy { get { return default(System.Security.Cryptography.CngUIPolicy); } }
-        public string UniqueName { get { return default(string); } }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm, string keyName) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm, string keyName, System.Security.Cryptography.CngKeyCreationParameters creationParameters) { return default(System.Security.Cryptography.CngKey); }
-        public void Delete() { }
-        public void Dispose() { }
-        public static bool Exists(string keyName) { return default(bool); }
-        public static bool Exists(string keyName, System.Security.Cryptography.CngProvider provider) { return default(bool); }
-        public static bool Exists(string keyName, System.Security.Cryptography.CngProvider provider, System.Security.Cryptography.CngKeyOpenOptions options) { return default(bool); }
-        public byte[] Export(System.Security.Cryptography.CngKeyBlobFormat format) { return default(byte[]); }
-        public System.Security.Cryptography.CngProperty GetProperty(string name, System.Security.Cryptography.CngPropertyOptions options) { return default(System.Security.Cryptography.CngProperty); }
-        public bool HasProperty(string name, System.Security.Cryptography.CngPropertyOptions options) { return default(bool); }
-        public static System.Security.Cryptography.CngKey Import(byte[] keyBlob, System.Security.Cryptography.CngKeyBlobFormat format) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Import(byte[] keyBlob, System.Security.Cryptography.CngKeyBlobFormat format, System.Security.Cryptography.CngProvider provider) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle keyHandle, System.Security.Cryptography.CngKeyHandleOpenOptions keyHandleOpenOptions) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName, System.Security.Cryptography.CngProvider provider) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName, System.Security.Cryptography.CngProvider provider, System.Security.Cryptography.CngKeyOpenOptions openOptions) { return default(System.Security.Cryptography.CngKey); }
-        public void SetProperty(System.Security.Cryptography.CngProperty property) { }
-    }
-    public sealed partial class CngKeyBlobFormat : System.IEquatable<System.Security.Cryptography.CngKeyBlobFormat>
-    {
-        public CngKeyBlobFormat(string format) { }
-        public static System.Security.Cryptography.CngKeyBlobFormat EccPrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat EccPublicBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public string Format { get { return default(string); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat GenericPrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat GenericPublicBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat OpaqueTransportBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat Pkcs8PrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngKeyBlobFormat other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngKeyBlobFormat left, System.Security.Cryptography.CngKeyBlobFormat right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngKeyBlobFormat left, System.Security.Cryptography.CngKeyBlobFormat right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyCreationOptions
-    {
-        MachineKey = 32,
-        None = 0,
-        OverwriteExistingKey = 128,
-    }
-    public sealed partial class CngKeyCreationParameters
-    {
-        public CngKeyCreationParameters() { }
-        public System.Nullable<System.Security.Cryptography.CngExportPolicies> ExportPolicy { get { return default(System.Nullable<System.Security.Cryptography.CngExportPolicies>); } set { } }
-        public System.Security.Cryptography.CngKeyCreationOptions KeyCreationOptions { get { return default(System.Security.Cryptography.CngKeyCreationOptions); } set { } }
-        public System.Nullable<System.Security.Cryptography.CngKeyUsages> KeyUsage { get { return default(System.Nullable<System.Security.Cryptography.CngKeyUsages>); } set { } }
-        public System.Security.Cryptography.CngPropertyCollection Parameters { get { return default(System.Security.Cryptography.CngPropertyCollection); } }
-        public System.IntPtr ParentWindowHandle { get { return default(System.IntPtr); } set { } }
-        public System.Security.Cryptography.CngProvider Provider { get { return default(System.Security.Cryptography.CngProvider); } set { } }
-        public System.Security.Cryptography.CngUIPolicy UIPolicy { get { return default(System.Security.Cryptography.CngUIPolicy); } set { } }
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyHandleOpenOptions
-    {
-        EphemeralKey = 1,
-        None = 0,
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyOpenOptions
-    {
-        MachineKey = 32,
-        None = 0,
-        Silent = 64,
-        UserKey = 0,
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyUsages
-    {
-        AllUsages = 16777215,
-        Decryption = 1,
-        KeyAgreement = 4,
-        None = 0,
-        Signing = 2,
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct CngProperty : System.IEquatable<System.Security.Cryptography.CngProperty>
-    {
-        public CngProperty(string name, byte[] value, System.Security.Cryptography.CngPropertyOptions options) { throw new System.NotImplementedException(); }
-        public string Name { get { return default(string); } }
-        public System.Security.Cryptography.CngPropertyOptions Options { get { return default(System.Security.Cryptography.CngPropertyOptions); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngProperty other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public byte[] GetValue() { return default(byte[]); }
-        public static bool operator ==(System.Security.Cryptography.CngProperty left, System.Security.Cryptography.CngProperty right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngProperty left, System.Security.Cryptography.CngProperty right) { return default(bool); }
-    }
-    public sealed partial class CngPropertyCollection : System.Collections.ObjectModel.Collection<System.Security.Cryptography.CngProperty>
-    {
-        public CngPropertyCollection() { }
-    }
-    [System.FlagsAttribute]
-    public enum CngPropertyOptions
-    {
-        CustomProperty = 1073741824,
-        None = 0,
-        Persist = -2147483648,
-    }
-    public sealed partial class CngProvider : System.IEquatable<System.Security.Cryptography.CngProvider>
-    {
-        public CngProvider(string provider) { }
-        public static System.Security.Cryptography.CngProvider MicrosoftSmartCardKeyStorageProvider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public static System.Security.Cryptography.CngProvider MicrosoftSoftwareKeyStorageProvider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public string Provider { get { return default(string); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngProvider other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngProvider left, System.Security.Cryptography.CngProvider right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngProvider left, System.Security.Cryptography.CngProvider right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class CngUIPolicy
-    {
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description, string useContext) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description, string useContext, string creationTitle) { }
-        public string CreationTitle { get { return default(string); } }
-        public string Description { get { return default(string); } }
-        public string FriendlyName { get { return default(string); } }
-        public System.Security.Cryptography.CngUIProtectionLevels ProtectionLevel { get { return default(System.Security.Cryptography.CngUIProtectionLevels); } }
-        public string UseContext { get { return default(string); } }
-    }
-    [System.FlagsAttribute]
-    public enum CngUIProtectionLevels
-    {
-        ForceHighProtection = 2,
-        None = 0,
-        ProtectKey = 1,
-    }
-    public sealed partial class RSACng : System.Security.Cryptography.RSA
-    {
-        public RSACng() { }
-        public RSACng(int keySize) { }
-        public RSACng(System.Security.Cryptography.CngKey key) { }
-        public System.Security.Cryptography.CngKey Key { get { return default(System.Security.Cryptography.CngKey); } }
-        public override byte[] Decrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding) { return default(byte[]); }
-        protected override void Dispose(bool disposing) { }
-        public override byte[] Encrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding) { return default(byte[]); }
-        public override System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters) { return default(System.Security.Cryptography.RSAParameters); }
-        protected override byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        protected override byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public override void ImportParameters(System.Security.Cryptography.RSAParameters parameters) { }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override byte[] SignHash(byte[] hash, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public override bool VerifyHash(byte[] hash, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-    }
-}

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.csproj b/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.depproj
similarity index 88%
rename from src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.csproj
rename to src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.depproj
index dd8be42..7f7271e 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.0/System.Security.Cryptography.Algorithms.csproj
+++ b/src/libraries/System.Security.Cryptography.Cng/ref/4.0/System.Security.Cryptography.Cng.depproj
@@ -8,9 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.3</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Security.Cryptography.Algorithms.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/project.json b/src/libraries/System.Security.Cryptography.Cng/ref/4.0/project.json
index 631b5c5..7a51c4b 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.0/project.json
+++ b/src/libraries/System.Security.Cryptography.Cng/ref/4.0/project.json
@@ -1,16 +1,8 @@
 {
   "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Runtime.Handles": "4.0.0",
-    "System.Security.Cryptography.Algorithms": "4.2.0",
-    "System.Security.Cryptography.Primitives": "4.0.0"
+    "System.Security.Cryptography.Cng": "4.2.0"
   },
   "frameworks": {
-    "netstandard1.3": {
-      "imports": [
-        "dotnet5.4"
-      ]
-    }
+    "netstandard1.3": { }
   }
 }

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.cs b/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.cs
deleted file mode 100644 (file)
index e6d52de..0000000
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.cs
+++ /dev/null
@@ -1,265 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace Microsoft.Win32.SafeHandles
-{
-    public abstract partial class SafeNCryptHandle : System.Runtime.InteropServices.SafeHandle
-    {
-        protected SafeNCryptHandle() : base(default(System.IntPtr), default(bool)) { }
-        protected override bool ReleaseHandle() { return default(bool); }
-        protected abstract bool ReleaseNativeHandle();
-        public override bool IsInvalid { get { return default(bool); } }
-    }
-    public sealed partial class SafeNCryptKeyHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptKeyHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-    public sealed partial class SafeNCryptProviderHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptProviderHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-    public sealed partial class SafeNCryptSecretHandle : Microsoft.Win32.SafeHandles.SafeNCryptHandle
-    {
-        public SafeNCryptSecretHandle() { }
-        protected override bool ReleaseNativeHandle() { return default(bool); }
-    }
-}
-namespace System.Security.Cryptography
-{
-    public sealed partial class CngAlgorithm : System.IEquatable<System.Security.Cryptography.CngAlgorithm>
-    {
-        public CngAlgorithm(string algorithm) { }
-        public string Algorithm { get { return default(string); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDiffieHellmanP521 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm ECDsaP521 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm MD5 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Rsa { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha1 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha256 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha384 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public static System.Security.Cryptography.CngAlgorithm Sha512 { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngAlgorithm other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngAlgorithm left, System.Security.Cryptography.CngAlgorithm right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngAlgorithm left, System.Security.Cryptography.CngAlgorithm right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class CngAlgorithmGroup : System.IEquatable<System.Security.Cryptography.CngAlgorithmGroup>
-    {
-        public CngAlgorithmGroup(string algorithmGroup) { }
-        public string AlgorithmGroup { get { return default(string); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup DiffieHellman { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup Dsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup ECDiffieHellman { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup ECDsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public static System.Security.Cryptography.CngAlgorithmGroup Rsa { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngAlgorithmGroup other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngAlgorithmGroup left, System.Security.Cryptography.CngAlgorithmGroup right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngAlgorithmGroup left, System.Security.Cryptography.CngAlgorithmGroup right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    [System.FlagsAttribute]
-    public enum CngExportPolicies
-    {
-        AllowArchiving = 4,
-        AllowExport = 1,
-        AllowPlaintextArchiving = 8,
-        AllowPlaintextExport = 2,
-        None = 0,
-    }
-    public sealed partial class CngKey : System.IDisposable
-    {
-        internal CngKey() { }
-        public System.Security.Cryptography.CngAlgorithm Algorithm { get { return default(System.Security.Cryptography.CngAlgorithm); } }
-        public System.Security.Cryptography.CngAlgorithmGroup AlgorithmGroup { get { return default(System.Security.Cryptography.CngAlgorithmGroup); } }
-        public System.Security.Cryptography.CngExportPolicies ExportPolicy { get { return default(System.Security.Cryptography.CngExportPolicies); } }
-        public Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle Handle { get { return default(Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle); } }
-        public bool IsEphemeral { get { return default(bool); } }
-        public bool IsMachineKey { get { return default(bool); } }
-        public string KeyName { get { return default(string); } }
-        public int KeySize { get { return default(int); } }
-        public System.Security.Cryptography.CngKeyUsages KeyUsage { get { return default(System.Security.Cryptography.CngKeyUsages); } }
-        public System.IntPtr ParentWindowHandle { get { return default(System.IntPtr); } set { } }
-        public System.Security.Cryptography.CngProvider Provider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public Microsoft.Win32.SafeHandles.SafeNCryptProviderHandle ProviderHandle { get { return default(Microsoft.Win32.SafeHandles.SafeNCryptProviderHandle); } }
-        public System.Security.Cryptography.CngUIPolicy UIPolicy { get { return default(System.Security.Cryptography.CngUIPolicy); } }
-        public string UniqueName { get { return default(string); } }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm, string keyName) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Create(System.Security.Cryptography.CngAlgorithm algorithm, string keyName, System.Security.Cryptography.CngKeyCreationParameters creationParameters) { return default(System.Security.Cryptography.CngKey); }
-        public void Delete() { }
-        public void Dispose() { }
-        public static bool Exists(string keyName) { return default(bool); }
-        public static bool Exists(string keyName, System.Security.Cryptography.CngProvider provider) { return default(bool); }
-        public static bool Exists(string keyName, System.Security.Cryptography.CngProvider provider, System.Security.Cryptography.CngKeyOpenOptions options) { return default(bool); }
-        public byte[] Export(System.Security.Cryptography.CngKeyBlobFormat format) { return default(byte[]); }
-        public System.Security.Cryptography.CngProperty GetProperty(string name, System.Security.Cryptography.CngPropertyOptions options) { return default(System.Security.Cryptography.CngProperty); }
-        public bool HasProperty(string name, System.Security.Cryptography.CngPropertyOptions options) { return default(bool); }
-        public static System.Security.Cryptography.CngKey Import(byte[] keyBlob, System.Security.Cryptography.CngKeyBlobFormat format) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Import(byte[] keyBlob, System.Security.Cryptography.CngKeyBlobFormat format, System.Security.Cryptography.CngProvider provider) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(Microsoft.Win32.SafeHandles.SafeNCryptKeyHandle keyHandle, System.Security.Cryptography.CngKeyHandleOpenOptions keyHandleOpenOptions) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName, System.Security.Cryptography.CngProvider provider) { return default(System.Security.Cryptography.CngKey); }
-        public static System.Security.Cryptography.CngKey Open(string keyName, System.Security.Cryptography.CngProvider provider, System.Security.Cryptography.CngKeyOpenOptions openOptions) { return default(System.Security.Cryptography.CngKey); }
-        public void SetProperty(System.Security.Cryptography.CngProperty property) { }
-    }
-    public sealed partial class CngKeyBlobFormat : System.IEquatable<System.Security.Cryptography.CngKeyBlobFormat>
-    {
-        public CngKeyBlobFormat(string format) { }
-        public static System.Security.Cryptography.CngKeyBlobFormat EccPrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat EccPublicBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public string Format { get { return default(string); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat GenericPrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat GenericPublicBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat OpaqueTransportBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public static System.Security.Cryptography.CngKeyBlobFormat Pkcs8PrivateBlob { get { return default(System.Security.Cryptography.CngKeyBlobFormat); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngKeyBlobFormat other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngKeyBlobFormat left, System.Security.Cryptography.CngKeyBlobFormat right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngKeyBlobFormat left, System.Security.Cryptography.CngKeyBlobFormat right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyCreationOptions
-    {
-        MachineKey = 32,
-        None = 0,
-        OverwriteExistingKey = 128,
-    }
-    public sealed partial class CngKeyCreationParameters
-    {
-        public CngKeyCreationParameters() { }
-        public System.Nullable<System.Security.Cryptography.CngExportPolicies> ExportPolicy { get { return default(System.Nullable<System.Security.Cryptography.CngExportPolicies>); } set { } }
-        public System.Security.Cryptography.CngKeyCreationOptions KeyCreationOptions { get { return default(System.Security.Cryptography.CngKeyCreationOptions); } set { } }
-        public System.Nullable<System.Security.Cryptography.CngKeyUsages> KeyUsage { get { return default(System.Nullable<System.Security.Cryptography.CngKeyUsages>); } set { } }
-        public System.Security.Cryptography.CngPropertyCollection Parameters { get { return default(System.Security.Cryptography.CngPropertyCollection); } }
-        public System.IntPtr ParentWindowHandle { get { return default(System.IntPtr); } set { } }
-        public System.Security.Cryptography.CngProvider Provider { get { return default(System.Security.Cryptography.CngProvider); } set { } }
-        public System.Security.Cryptography.CngUIPolicy UIPolicy { get { return default(System.Security.Cryptography.CngUIPolicy); } set { } }
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyHandleOpenOptions
-    {
-        EphemeralKey = 1,
-        None = 0,
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyOpenOptions
-    {
-        MachineKey = 32,
-        None = 0,
-        Silent = 64,
-        UserKey = 0,
-    }
-    [System.FlagsAttribute]
-    public enum CngKeyUsages
-    {
-        AllUsages = 16777215,
-        Decryption = 1,
-        KeyAgreement = 4,
-        None = 0,
-        Signing = 2,
-    }
-    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
-    public partial struct CngProperty : System.IEquatable<System.Security.Cryptography.CngProperty>
-    {
-        public CngProperty(string name, byte[] value, System.Security.Cryptography.CngPropertyOptions options) { throw new System.NotImplementedException(); }
-        public string Name { get { return default(string); } }
-        public System.Security.Cryptography.CngPropertyOptions Options { get { return default(System.Security.Cryptography.CngPropertyOptions); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngProperty other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public byte[] GetValue() { return default(byte[]); }
-        public static bool operator ==(System.Security.Cryptography.CngProperty left, System.Security.Cryptography.CngProperty right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngProperty left, System.Security.Cryptography.CngProperty right) { return default(bool); }
-    }
-    public sealed partial class CngPropertyCollection : System.Collections.ObjectModel.Collection<System.Security.Cryptography.CngProperty>
-    {
-        public CngPropertyCollection() { }
-    }
-    [System.FlagsAttribute]
-    public enum CngPropertyOptions
-    {
-        CustomProperty = 1073741824,
-        None = 0,
-        Persist = -2147483648,
-    }
-    public sealed partial class CngProvider : System.IEquatable<System.Security.Cryptography.CngProvider>
-    {
-        public CngProvider(string provider) { }
-        public static System.Security.Cryptography.CngProvider MicrosoftSmartCardKeyStorageProvider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public static System.Security.Cryptography.CngProvider MicrosoftSoftwareKeyStorageProvider { get { return default(System.Security.Cryptography.CngProvider); } }
-        public string Provider { get { return default(string); } }
-        public override bool Equals(object obj) { return default(bool); }
-        public bool Equals(System.Security.Cryptography.CngProvider other) { return default(bool); }
-        public override int GetHashCode() { return default(int); }
-        public static bool operator ==(System.Security.Cryptography.CngProvider left, System.Security.Cryptography.CngProvider right) { return default(bool); }
-        public static bool operator !=(System.Security.Cryptography.CngProvider left, System.Security.Cryptography.CngProvider right) { return default(bool); }
-        public override string ToString() { return default(string); }
-    }
-    public sealed partial class CngUIPolicy
-    {
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description, string useContext) { }
-        public CngUIPolicy(System.Security.Cryptography.CngUIProtectionLevels protectionLevel, string friendlyName, string description, string useContext, string creationTitle) { }
-        public string CreationTitle { get { return default(string); } }
-        public string Description { get { return default(string); } }
-        public string FriendlyName { get { return default(string); } }
-        public System.Security.Cryptography.CngUIProtectionLevels ProtectionLevel { get { return default(System.Security.Cryptography.CngUIProtectionLevels); } }
-        public string UseContext { get { return default(string); } }
-    }
-    [System.FlagsAttribute]
-    public enum CngUIProtectionLevels
-    {
-        ForceHighProtection = 2,
-        None = 0,
-        ProtectKey = 1,
-    }
-    public sealed partial class ECDsaCng : System.Security.Cryptography.ECDsa
-    {
-        public ECDsaCng() {}
-        public ECDsaCng(int keySize) {}
-        public ECDsaCng(CngKey key) {}
-        public System.Security.Cryptography.CngKey Key { get { return default(System.Security.Cryptography.CngKey); } }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        protected override void Dispose(bool disposing) {}
-        protected override byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        protected override byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public override byte[] SignHash(byte[] hash) { return default(byte[]); }
-        public override bool VerifyHash(byte[] hash, byte[] signature) { return default(bool); }
-    }
-    public sealed partial class RSACng : System.Security.Cryptography.RSA
-    {
-        public RSACng() { }
-        public RSACng(int keySize) { }
-        public RSACng(System.Security.Cryptography.CngKey key) { }
-        public System.Security.Cryptography.CngKey Key { get { return default(System.Security.Cryptography.CngKey); } }
-        public override byte[] Decrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding) { return default(byte[]); }
-        protected override void Dispose(bool disposing) { }
-        public override byte[] Encrypt(byte[] data, System.Security.Cryptography.RSAEncryptionPadding padding) { return default(byte[]); }
-        public override System.Security.Cryptography.RSAParameters ExportParameters(bool includePrivateParameters) { return default(System.Security.Cryptography.RSAParameters); }
-        protected override byte[] HashData(byte[] data, int offset, int count, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        protected override byte[] HashData(System.IO.Stream data, System.Security.Cryptography.HashAlgorithmName hashAlgorithm) { return default(byte[]); }
-        public override void ImportParameters(System.Security.Cryptography.RSAParameters parameters) { }
-        public override System.Security.Cryptography.KeySizes[] LegalKeySizes { get { return default(System.Security.Cryptography.KeySizes[]); } }
-        public override byte[] SignHash(byte[] hash, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(byte[]); }
-        public override bool VerifyHash(byte[] hash, byte[] signature, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, System.Security.Cryptography.RSASignaturePadding padding) { return default(bool); }
-    }
-}

diff --git a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.csproj b/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.depproj
similarity index 88%
rename from src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.csproj
rename to src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.depproj
index 9ee13b4..352d843 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Algorithms/ref/4.1/System.Security.Cryptography.Algorithms.csproj
+++ b/src/libraries/System.Security.Cryptography.Cng/ref/4.1/System.Security.Cryptography.Cng.depproj
@@ -8,9 +8,6 @@
     <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="System.Security.Cryptography.Algorithms.cs" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="project.json" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

diff --git a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/project.json b/src/libraries/System.Security.Cryptography.Cng/ref/4.1/project.json
index 0692fed..5082023 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/ref/4.1/project.json
+++ b/src/libraries/System.Security.Cryptography.Cng/ref/4.1/project.json
@@ -1,16 +1,8 @@
 {
   "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.IO": "4.0.0",
-    "System.Runtime.Handles": "4.0.0",
-    "System.Security.Cryptography.Algorithms": "4.2.0",
-    "System.Security.Cryptography.Primitives": "4.0.0"
+    "System.Security.Cryptography.Cng": "4.2.0"
   },
   "frameworks": {
-    "netstandard1.4": {
-      "imports": [
-        "dotnet5.5"
-      ]
-    }
+    "netstandard1.4": { }
   }
 }

diff --git a/src/libraries/System.Security.Cryptography.Cng/src/System.Security.Cryptography.Cng.csproj b/src/libraries/System.Security.Cryptography.Cng/src/System.Security.Cryptography.Cng.csproj
index c777f5b..04375f1 100644 (file)
--- a/src/libraries/System.Security.Cryptography.Cng/src/System.Security.Cryptography.Cng.csproj
+++ b/src/libraries/System.Security.Cryptography.Cng/src/System.Security.Cryptography.Cng.csproj
@@ -12,6 +12,8 @@
     <AssemblyVersion Condition="'$(TargetGroup)'=='net46'">4.0.0.0</AssemblyVersion>
     <AssemblyVersion Condition="'$(TargetGroup)'=='net461'">4.1.0.0</AssemblyVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.0.0.0'">..\ref\4.0\System.Security.Cryptography.Cng.depproj</ContractProject>
+    <ContractProject Condition="'$(AssemblyVersion)' == '4.1.0.0'">..\ref\4.1\System.Security.Cryptography.Cng.depproj</ContractProject>
     <IsPartialFacadeAssembly Condition="'$(TargetGroup)' == 'net46' OR '$(TargetGroup)' == 'net461' OR '$(TargetGroup)' == 'net463'">true</IsPartialFacadeAssembly>
     <ResourcesSourceOutputDirectory Condition="'$(IsPartialFacadeAssembly)' == 'true'">None</ResourcesSourceOutputDirectory>
     <PackageTargetFramework Condition="'$(TargetGroup)' == ''">netstandard1.6</PackageTargetFramework>
@@ -20,6 +22,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(TargetGroup)' == 'netcore50'">
     <AssemblyVersion>4.1.0.0</AssemblyVersion>
+    <ContractProject>..\ref\4.1\System.Security.Cryptography.Cng.depproj</ContractProject>
     <PackageTargetFramework>netstandard1.4</PackageTargetFramework>
     <NuGetTargetMoniker>.NETStandard,Version=v1.4</NuGetTargetMoniker>
     <DefineConstants>$(DefineConstants);NETNATIVE</DefineConstants>

diff --git a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.cs b/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.cs
deleted file mode 100644 (file)
index bc15a49..0000000
--- a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.cs
+++ /dev/null
@@ -1,74 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-// ------------------------------------------------------------------------------
-// Changes to this file must follow the http://aka.ms/api-review process.
-// ------------------------------------------------------------------------------
-
-
-namespace System.ServiceProcess
-{
-    public partial class ServiceController : System.IDisposable
-    {
-        public ServiceController(string name) { }
-        public ServiceController(string name, string machineName) { }
-        public bool CanPauseAndContinue { get { return default(bool); } }
-        public bool CanShutdown { get { return default(bool); } }
-        public bool CanStop { get { return default(bool); } }
-        public System.ServiceProcess.ServiceController[] DependentServices { get { return default(System.ServiceProcess.ServiceController[]); } }
-        public string DisplayName { get { return default(string); } }
-        public string MachineName { get { return default(string); } }
-        public System.Runtime.InteropServices.SafeHandle ServiceHandle { get { return default(System.Runtime.InteropServices.SafeHandle); } }
-        public string ServiceName { get { return default(string); } }
-        public System.ServiceProcess.ServiceController[] ServicesDependedOn { get { return default(System.ServiceProcess.ServiceController[]); } }
-        public System.ServiceProcess.ServiceType ServiceType { get { return default(System.ServiceProcess.ServiceType); } }
-        public System.ServiceProcess.ServiceControllerStatus Status { get { return default(System.ServiceProcess.ServiceControllerStatus); } }
-        public void Continue() { }
-        public void Dispose() { }
-        protected virtual void Dispose(bool disposing) { }
-        public static System.ServiceProcess.ServiceController[] GetDevices() { return default(System.ServiceProcess.ServiceController[]); }
-        public static System.ServiceProcess.ServiceController[] GetDevices(string machineName) { return default(System.ServiceProcess.ServiceController[]); }
-        public static System.ServiceProcess.ServiceController[] GetServices() { return default(System.ServiceProcess.ServiceController[]); }
-        public static System.ServiceProcess.ServiceController[] GetServices(string machineName) { return default(System.ServiceProcess.ServiceController[]); }
-        public void Pause() { }
-        public void Refresh() { }
-        public void Start() { }
-        public void Start(string[] args) { }
-        public void Stop() { }
-        public void WaitForStatus(System.ServiceProcess.ServiceControllerStatus desiredStatus) { }
-        public void WaitForStatus(System.ServiceProcess.ServiceControllerStatus desiredStatus, System.TimeSpan timeout) { }
-    }
-    public enum ServiceControllerStatus
-    {
-        ContinuePending = 5,
-        Paused = 7,
-        PausePending = 6,
-        Running = 4,
-        StartPending = 2,
-        Stopped = 1,
-        StopPending = 3,
-    }
-    public enum ServiceStartMode
-    {
-        Automatic = 2,
-        Disabled = 4,
-        Manual = 3,
-    }
-    [System.FlagsAttribute]
-    public enum ServiceType
-    {
-        Adapter = 4,
-        FileSystemDriver = 2,
-        InteractiveProcess = 256,
-        KernelDriver = 1,
-        RecognizerDriver = 8,
-        Win32OwnProcess = 16,
-        Win32ShareProcess = 32,
-    }
-    public partial class TimeoutException : System.Exception
-    {
-        public TimeoutException() { }
-        public TimeoutException(string message) { }
-        public TimeoutException(string message, System.Exception innerException) { }
-    }
-}

diff --git a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.csproj b/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.csproj
deleted file mode 100644 (file)
index 42f1cf7..0000000
--- a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/System.ServiceProcess.ServiceController.csproj
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
-  <PropertyGroup>
-    <AssemblyVersion>4.0.0.0</AssemblyVersion>
-    <OutputType>Library</OutputType>
-    <NuGetTargetMoniker>.NETStandard,Version=v1.0</NuGetTargetMoniker>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="System.ServiceProcess.ServiceController.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="project.json" />
-  </ItemGroup>
-  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
\ No newline at end of file

diff --git a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/project.json b/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/project.json
deleted file mode 100644 (file)
index bec46ac..0000000
--- a/src/libraries/System.ServiceProcess.ServiceController/ref/4.0/project.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "dependencies": {
-    "System.Runtime": "4.0.0",
-    "System.Runtime.Handles": "4.0.0"
-  },
-  "frameworks": {
-    "netstandard1.0": { "imports": "dotnet5.1" }
-  }
-}
\ No newline at end of file