C# SqlClient.SqlErrorCollection类代码示例

        static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion, Guid conId, Exception innerException = null) {
            Debug.Assert(null != errorCollection && errorCollection.Count > 0, "no errorCollection?");
            
            // concat all messages together MDAC 65533
            StringBuilder message = new StringBuilder();
            for (int i = 0; i < errorCollection.Count; i++) {
                if (i > 0) {
                    message.Append(Environment.NewLine);
                }
                message.Append(errorCollection[i].Message);
            }

            if (innerException == null && errorCollection[0].Win32ErrorCode != 0 && errorCollection[0].Win32ErrorCode != -1) {
                innerException = new Win32Exception(errorCollection[0].Win32ErrorCode);
            }

            SqlException exception = new SqlException(message.ToString(), /*errorCollection, */innerException/*, conId*/);

            exception.Data.Add("HelpLink.ProdName",    "Microsoft SQL Server");

            if (!ADP.IsEmpty(serverVersion)) {
                exception.Data.Add("HelpLink.ProdVer", serverVersion);
            }
            exception.Data.Add("HelpLink.EvtSrc",      "MSSQLServer");
            exception.Data.Add("HelpLink.EvtID",       errorCollection[0].Number.ToString(CultureInfo.InvariantCulture));
            exception.Data.Add("HelpLink.BaseHelpUrl", "http://go.microsoft.com/fwlink");
            exception.Data.Add("HelpLink.LinkId",      "20476");

            return exception;
        }

 internal SqlMessageEventArgs(SqlErrorCollection errors, string message, string source, object context)
 {
     mErrors = errors;
     mMessage = message;
     mSource = source;
     mContext = context;
 }

		internal SqlException (string message, Exception inner, SqlError sqlError)
			: base (message == null ? DEF_MESSAGE : message, inner)
		{
			HResult = -2146232060;
			errors = new SqlErrorCollection ();
			if (sqlError != null)
				errors.Add (sqlError);
		}

 // runtime will call even if private...
 private SqlException(SerializationInfo si, StreamingContext sc) : base(si, sc) {
     _errors = (SqlErrorCollection) si.GetValue("Errors", typeof(SqlErrorCollection));
     HResult = HResults.SqlException;
     foreach (SerializationEntry siEntry in si) {
         if ("ClientConnectionId" == siEntry.Name) {
             _clientConnectionId = (Guid)siEntry.Value;
             break;
         }
     }
         
 }

        private SqlException CreateException(SqlErrorCollection errorCollection)
        {
            // Create instance via reflection...
            var ctor = typeof(SqlException).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
            SqlException sqlException = ctor.Invoke(
                new object[]
            {
                // With message and error collection...
                this.errorMessage,
                errorCollection,
                null,
                Guid.NewGuid()
            }) as SqlException;

            return sqlException;
        }

 private static SqlException CreateLocalDBException(string errorMessage, string instance = null, int localDbError = 0, int sniError = 0)
 {
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     int infoNumber = (localDbError == 0) ? sniError : localDbError;
     if (sniError != 0)
     {
         string name = string.Format(null, "SNI_ERROR_{0}", new object[] { sniError });
         errorMessage = string.Format(null, "{0} (error: {1} - {2})", new object[] { errorMessage, sniError, Res.GetString(name) });
     }
     errorCollection.Add(new SqlError(infoNumber, 0, 20, instance, errorMessage, null, 0));
     if (localDbError != 0)
     {
         errorCollection.Add(new SqlError(infoNumber, 0, 20, instance, GetLocalDBMessage(localDbError), null, 0));
     }
     SqlException exception = SqlException.CreateException(errorCollection, null);
     exception._doNotReconnect = true;
     return exception;
 }

        protected SqlException ProcessMessages(bool ignoreWarnings)
        {
            SqlException result = null;
            SqlErrorCollection temp = null;  // temp variable to store that which is being thrown - so that local copies can be deleted

            if (null != _errors)
            {
                Debug.Assert(0 != _errors.Count, "empty error collection?"); // must be something in the collection

                {
                    if (null != _warnings)
                    {
                        // When we throw an exception we place all the warnings that
                        // occurred at the end of the collection - after all the errors.
                        // That way the user can see all the errors AND warnings that
                        // occurred for the exception.
                        foreach (SqlError warning in _warnings)
                        {
                            _errors.Add(warning);
                        }
                    }
                    temp = _errors;
                }

                _errors = null;
                _warnings = null;
            }
            else
            {
                Debug.Assert(null == _warnings || 0 != _warnings.Count, "empty warning collection?");// must be something in the collection

                if (!ignoreWarnings)
                {
                    temp = _warnings;
                }
                _warnings = null;
            }

            if (null != temp)
            {
                result = SqlException.CreateException(temp, ServerVersion);
            }
            return result;
        }

 private bool AddSqlErrorToCollection(ref SqlErrorCollection temp, ref SqlErrorCollection InputCollection)
 {
     if (InputCollection == null)
     {
         return false;
     }
     bool flag = false;
     if (temp == null)
     {
         temp = new SqlErrorCollection();
     }
     for (int i = 0; i < InputCollection.Count; i++)
     {
         SqlError error = InputCollection[i];
         temp.Add(error);
         if (error.Class >= 20)
         {
             flag = true;
         }
     }
     InputCollection = null;
     return (flag && (TdsParserState.Closed != this._state));
 }

 internal static SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion)
 {
     StringBuilder builder = new StringBuilder();
     for (int i = 0; i < errorCollection.Count; i++)
     {
         if (i > 0)
         {
             builder.Append(Environment.NewLine);
         }
         builder.Append(errorCollection[i].Message);
     }
     SqlException exception = new SqlException(builder.ToString(), errorCollection);
     exception.Data.Add("HelpLink.ProdName", "Microsoft SQL Server");
     if (!ADP.IsEmpty(serverVersion))
     {
         exception.Data.Add("HelpLink.ProdVer", serverVersion);
     }
     exception.Data.Add("HelpLink.EvtSrc", "MSSQLServer");
     exception.Data.Add("HelpLink.EvtID", errorCollection[0].Number.ToString(CultureInfo.InvariantCulture));
     exception.Data.Add("HelpLink.BaseHelpUrl", "http://go.microsoft.com/fwlink");
     exception.Data.Add("HelpLink.LinkId", "20476");
     return exception;
 }

 private void AddErrorsToCollection(SqlErrorCollection inCollection, ref SqlErrorCollection collectionToAddTo, ref bool broken)
 {
     if (inCollection != null)
     {
         foreach (SqlError error in inCollection)
         {
             collectionToAddTo.Add(error);
             broken |= (error.Class >= TdsEnums.FATAL_ERROR_CLASS);
         }
     }
 }

        /// <summary>
        /// Gets the full list of errors and warnings (including the pre-attention ones), then wipes all error and warning lists
        /// </summary>
        /// <param name="broken">If true, the connection should be broken</param>
        /// <returns>An array containing all of the errors and warnings</returns>
        internal SqlErrorCollection GetFullErrorAndWarningCollection(out bool broken)
        {
            SqlErrorCollection allErrors = new SqlErrorCollection();
            broken = false;

            lock (_errorAndWarningsLock)
            {
                _hasErrorOrWarning = false;

                // Merge all error lists, then reset them
                AddErrorsToCollection(_errors, ref allErrors, ref broken);
                AddErrorsToCollection(_warnings, ref allErrors, ref broken);
                _errors = null;
                _warnings = null;

                // We also process the pre-attention error lists here since, if we are here and they are populated, then an error occured while sending attention so we should show the errors now (otherwise they'd be lost)
                AddErrorsToCollection(_preAttentionErrors, ref allErrors, ref broken);
                AddErrorsToCollection(_preAttentionWarnings, ref allErrors, ref broken);
                _preAttentionErrors = null;
                _preAttentionWarnings = null;
            }

            return allErrors;
        }

 static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion) {
     return CreateException(errorCollection, serverVersion, Guid.Empty);
 }

 private static void AddError(SqlErrorCollection collection, Error infoNumber, byte errorState, byte errorClass, string server, string errorMessage, string procedure, int lineNumber)
 {
     var error = Ctor.New<SqlError>((int)infoNumber, errorState, errorClass, server, errorMessage, procedure, lineNumber);
     var add = typeof(SqlErrorCollection).GetMethod("Add", BindingFlags.Instance | BindingFlags.NonPublic);
     add.Invoke(collection, new object[] { error });
 }

        // Fires a single InfoMessageEvent
        private void FireInfoMessageEvent(SqlConnection connection, TdsParserStateObject stateObj, SqlError error)
        {
            string serverVersion = null;

            Debug.Assert(connection != null && _connHandler.Connection == connection);

            if (_state == TdsParserState.OpenLoggedIn)
            {
                serverVersion = _connHandler.ServerVersion;
            }

            SqlErrorCollection sqlErs = new SqlErrorCollection();

            sqlErs.Add(error);

            SqlException exc = SqlException.CreateException(sqlErs, serverVersion, _connHandler);

            bool notified;
            connection.OnInfoMessage(new SqlInfoMessageEventArgs(exc), out notified);
            if (notified)
            {
                // observable side-effects, no retry
                stateObj._syncOverAsync = true;
            }
            return;
        }

		static internal SqlException CreateException(SqlErrorCollection errorCollection, string serverVersion, Guid conId, Exception innerException = null)
		{
			throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
		}