C# InvalidOperationException.GetType方法代码示例

		public void TestCreateMatroshika()
		{
			var value = new InvalidOperationException( Guid.NewGuid().ToString(), new Exception() );
			var result = ExceptionDispatchInfo.CreateMatroshika( value );
			Assert.That( result, Is.Not.Null );
			Assert.That( result, Is.TypeOf( value.GetType() ) );
			Assert.That( result.Message, Is.EqualTo( value.Message ) );
			Assert.That( result.InnerException, Is.SameAs( value ) );
		}

        public void SerializesProperties()
        {
            var exception = new InvalidOperationException("Some message") { HelpLink = "http://example.com" };
            var errors = new ErrorSerializer().Serialize(new ApiError(exception))["errors"][0];

            Assert.Equal(exception.Message, errors.Value<string>("title"));
            Assert.Equal(exception.HelpLink, errors["links"].Value<string>("about"));
            Assert.Equal(exception.GetType().FullName, errors.Value<string>("code"));
            Assert.Equal(exception.ToString(), errors.Value<string>("detail"));
        }

        public void Invoke_WithExceptionAndInnerException_ThrowsInnerException(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            int postId,
            string message,
            InvalidOperationException innerException)
        {
            // Given
            var exception = new Exception(message, innerException);
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<Expression<Func<Post, bool>>>())).Throws(exception);
            var sut = new SetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // When
            sut.Id = postId;

            // Then
            Assert.Throws(innerException.GetType(), () => sut.Invoke<Post>().Any());
        }

        public void Should_report_failed_specification_end_to_TeamCity_with_exception()
        {
            Exception exception = new InvalidOperationException();

            using (Mocks.Record())
            {
                _messageProvider.TestStarted(null);
                LastCall.IgnoreArguments();

                _messageProvider.TestFailed(null, null, null, null);
                LastCall.Constraints(Is.Anything(), Is.Equal(exception.Message), Is.Null(), Is.Equal(exception.GetType().FullName));

                _messageProvider.TestFinished(null);
                LastCall.IgnoreArguments();
            }

            _sut.OnContextStart(_contextInfo);

            using (Mocks.Playback())
            {
                _sut.OnSpecificationStart(_specificationInfo);
                _sut.OnSpecificationEnd(_specificationInfo, Result.Failure(exception));
            }
        }

        public void Invoke_WithException_ThrowsSameException(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            InvalidOperationException exception)
        {
            // Given
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Find(It.IsAny<string[]>())).Throws(exception);
            var sut = new GetPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);

            // Then
            Assert.Throws(exception.GetType(), () => sut.Invoke<Post>().Any());
        }

        // -------------------------------------------------------------------
        // Get ValuePattern.Value property
        // -------------------------------------------------------------------
        private void TS_Value(ValuePattern valuePattern, CheckType checkType)
        {
            bool isPassword = m_le.Current.IsPassword;
            string value = "";

            try
            {
                value = valuePattern.Current.Value;
            }
            catch (Exception actualException)
            {
                InvalidOperationException ex = new InvalidOperationException();

                if (Library.IsCriticalException(actualException))
                    throw;

                TestException(ex.GetType(), actualException, "TS_Value", checkType);
            }

            Comment("ValuePattern.Value = " + value);
            m_TestStep++;
        }

        public void TestRemoveFromSelectionMethod51701(TestCaseAttribute testCase)
        {
            HeaderComment(testCase);

            InvalidOperationException ex = new InvalidOperationException("Unused, just need an instance for GetType() below");

            RemoveFromSelectionHelper(ex.GetType());
        }

        public void TestRangeFromChildMethod20302(TestCaseAttribute testCase)
        {
            HeaderComment(testCase);

            InvalidOperationException ex = new InvalidOperationException("Unused, just need an instance for GetType() below");

            RangeFromChildHelper(SampleText.String1, false, AutoElementType.SameAsPattern, ex.GetType());
        }

        /// <summary>
        /// expect packet from transport.<para/>
        /// the transport must be a TcpServer, UdpClient or UdpServer.
        /// </summary>
        /// <param name="filter">
        /// a Filter delegate that specifies the endpoint to receive data.<para/>
        /// if null, receive data from any endpoint.
        /// </param>
        /// <param name="timeout">
        /// a TimeSpan object that indicates the timeout to expect event.
        /// </param>
        /// <param name="removeEvent">
        /// a bool value that indicates whether need to remove the event from buffer.
        /// </param>
        /// <param name="remoteEndPoint">
        /// an object that specifies the remote endpoint expected packet.
        /// </param>
        /// <param name="localEndPoint">
        /// an object that indicates the local endpoint received packet at.
        /// </param>
        /// <returns>
        /// a UdpReceivedBytes object that specifies the received udp packet.<para/>
        /// never return null, if no packets, throw exception.
        /// </returns>
        /// <exception cref="InvalidOperationException">
        /// thrown when the received udp packet is invalid
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// thrown when exception arrived when expect bytes from udp client.
        /// </exception>
        private UdpReceivedBytes GetUdpBytes(
            Filter<UdpReceivedBytes> filter, TimeSpan timeout, bool removeEvent,
            out object remoteEndPoint, out object localEndPoint)
        {
            UdpReceivedBytes bytes = null;

            if (filter == null)
            {
                bytes = this.buffer.Dequeue(timeout);
            }
            else
            {
                bytes = this.buffer.Dequeue(timeout, filter);
            }

            if (bytes == null)
            {
                throw new InvalidOperationException("the received udp packet is invalid");
            }

            remoteEndPoint = bytes.RemoteEndPoint;
            localEndPoint = bytes.LocalEndPoint;

            // exception event arrived
            if (bytes.Packet == null)
            {
                if (!removeEvent)
                {
                    this.buffer.Enqueue(bytes);
                }

                InvalidOperationException exc =
                        new InvalidOperationException("exception arrived when expect bytes from udp client.");

                // identify this exception.
                exc.Data.Add(exc.GetType().Name, true);

                throw exc;
            }

            return bytes;
        }

        /// <summary>operation with exception</summary>
        /// <param name="e">exception object</param>
        /// <param name="response">response object</param>
        private void HandleOperationException(InvalidOperationException e, IODataResponseMessage response)
        {
            Debug.Assert(this.entryIndex >= 0 && this.entryIndex < this.ChangedEntries.Count(), string.Format(System.Globalization.CultureInfo.InvariantCulture, "this.entryIndex = '{0}', this.ChangedEntries.Count = '{1}'", this.entryIndex, this.ChangedEntries.Count()));

            Descriptor current = this.ChangedEntries[this.entryIndex];
            HeaderCollection headers = null;
            HttpStatusCode statusCode = HttpStatusCode.InternalServerError;

            Version responseVersion = null;
            if (null != response)
            {
                headers = new HeaderCollection(response);
                statusCode = (HttpStatusCode)response.StatusCode;

                this.HandleOperationResponseHeaders(statusCode, headers);
                e = BaseSaveResult.HandleResponse(
                    this.RequestInfo,
                    statusCode,
                    response.GetHeader(XmlConstants.HttpODataVersion),
                    response.GetStream,
                    false/*throwOnFailure*/,
                    out responseVersion);
            }
            else
            {
                headers = new HeaderCollection();
                headers.SetHeader(XmlConstants.HttpContentType, XmlConstants.MimeTextPlain);

                // In V2 we used to merge individual responses from a call to SaveChanges() into a single batch response payload and then process that.
                // When we encounter an exception at this point in V2, we used to write the exception to the batch response payload and later on when we
                // process through the batch response, we create a DataServiceClientException for each failed operation.
                // For backcompat reason, we will always convert the exception type to DataServiceClientException here.
                Debug.Assert(e != null, "e != null");
                if (e.GetType() != typeof(DataServiceClientException))
                {
                    e = new DataServiceClientException(e.Message, e);
                }
            }

            // For error scenarios, we never invoke the ReadingEntity event.
            this.cachedResponses.Add(new CachedResponse(current, headers, statusCode, responseVersion, null, e));
            this.perRequest = null;
            this.CheckContinueOnError();
        }

        public void write_log_exception()
        {
            var ex = new InvalidOperationException("Fake Exception");
            //Act

            Logger.ErrorException(UniqueMessage, ex);

            //Assert
            var logItem = Db.Fetch<Log>().Single();

            VerifyLog(logItem, LogLevel.Error);
            logItem.Message.Should().Be(UniqueMessage + ": " + ex.Message);
            logItem.ExceptionType.Should().Be(ex.GetType().ToString());
            logItem.Exception.Should().Be(ex.ToString());

            ExceptionVerification.ExpectedErrors(1);
        }

        /// <summary>
        /// get packet from packet cache or decode from buffer.
        /// </summary>
        /// <param name="timeout">
        /// a TimeSpan object that specifies the timeout
        /// </param>
        /// <param name="removeEvent">
        /// a bool value that indicates whether need to remove the event from buffer.
        /// </param>
        /// <param name="remoteEndPoint">
        /// an object that specifies the remote endpoint.
        /// </param>
        /// <returns>
        /// a StackPacket object that contains the decoded packet.
        /// </returns>
        private StackPacket GetPacket(TimeSpan timeout, bool removeEvent, out object remoteEndPoint)
        {
            // get the packet in packet list.
            IPEndPointStackPacket packet = Utility.GetOne<IPEndPointStackPacket>(this.packetCache, null);
            if (packet != null)
            {
                remoteEndPoint = packet.RemoteEndPoint;

                return packet.Packet;
            }

            UdpReceivedBytes bytes = this.buffer.Dequeue(timeout);

            remoteEndPoint = bytes.RemoteEndPoint;

            // exception event arrived
            if (bytes.Packet == null)
            {
                if (!removeEvent)
                {
                    this.buffer.Enqueue(bytes);
                }

                InvalidOperationException exc =
                    new InvalidOperationException("exception arrived when expect packet from udp.");

                // identify this exception.
                exc.Data.Add(exc.GetType().Name, true);

                throw exc;
            }

            // decode packets using data in buffer.
            int consumedLength = 0;
            int expectedLength = 0;

            StackPacket[] packets = this.decoder(remoteEndPoint, bytes.Packet, out consumedLength, out expectedLength);

            // if no packet, drop the recieved data and continue.
            if (packets == null || packets.Length == 0)
            {
                throw new InvalidOperationException("udp client failed to decode udp packet");
            }

            // if packet arrived, add to packet list, and return the first.
            foreach (StackPacket item in packets)
            {
                this.packetCache.Enqueue(
                    new IPEndPointStackPacket(item, bytes.RemoteEndPoint, bytes.LocalEndPoint));
            }

            // set timeout to zero. when packet is decoded, must not wait.
            return GetPacket(new TimeSpan(), removeEvent, out remoteEndPoint);
        }

        public void Invoke_WithExceptionAndInnerException_ThrowsInnerException(
            Mock<Common.IServiceLocator> serviceLocator,
            Mock<IRepository<Post>> repository,
            string title,
            string message,
            InvalidOperationException innerException)
        {
            // Given
            var exception = new Exception(message, innerException);
            serviceLocator.Setup(s => s.GetInstance<IRepository<Post>>()).Returns(repository.Object);
            repository.Setup(s => s.Save(It.IsAny<Post>())).Throws(exception);
            var sut = new NewPostCommand();
            ServiceLocator.SetCurrentInstance(serviceLocator.Object);
            sut.Title = title;

            // Then
            Assert.Throws(innerException.GetType(), () => sut.Invoke<Post>().Any());
        }

 private void HandleOperationException(InvalidOperationException e, HttpWebResponse response)
 {
     Func<Stream> getResponseStream = null;
     Descriptor descriptor = base.ChangedEntries[base.entryIndex];
     Dictionary<string, string> headers = null;
     HttpStatusCode internalServerError = HttpStatusCode.InternalServerError;
     Version parsedResponseVersion = null;
     if (response != null)
     {
         headers = WebUtil.WrapResponseHeaders(response);
         base.HandleOperationResponseHeaders(response.StatusCode, headers);
         if (getResponseStream == null)
         {
             getResponseStream = () => WebUtil.GetResponseStream(response, (DataServiceContext) this.Source);
         }
         e = BaseSaveResult.HandleResponse(base.RequestInfo, response.StatusCode, response.Headers["DataServiceVersion"], getResponseStream, false, out parsedResponseVersion);
         internalServerError = response.StatusCode;
     }
     else
     {
         headers = new Dictionary<string, string>(StringComparer.Ordinal);
         headers.Add("Content-Type", "text/plain");
         if (e.GetType() != typeof(DataServiceClientException))
         {
             e = new DataServiceClientException(e.Message, e);
         }
     }
     this.cachedResponses.Add(new CachedResponse(descriptor, headers, internalServerError, parsedResponseVersion, null, e));
     base.perRequest = null;
     this.CheckContinueOnError();
 }

        public void BuildThrowsAnyExeptionNotCatched(
            InvalidOperationException exception,
            [Frozen] ICommand<BuildParameters> buildCommand,
            [Greedy] TfsBuilderController sut,
            BuildParameters parameters)
        {
            parameters.PayLoad = "dummy";
            Mock.Get(buildCommand).Setup(x => x.Execute(parameters)).Throws(exception);

            Assert.Throws(exception.GetType(), () => sut.Build(parameters));
        }