C# Reflection.TargetInvocationException类代码示例

        public void DontStripIfNoInnerException()
        {
            TargetInvocationException wrapper = new TargetInvocationException(null);

              List<Exception> exceptions = _client.ExposeStripWrapperExceptions(wrapper).ToList();
              Assert.AreEqual(1, exceptions.Count);
              Assert.Contains(wrapper, exceptions);
        }

 internal static void HandleTargetInvocationException(TargetInvocationException exception)
 {
     var innerException = exception.InnerException as SyncServiceException;
     if (innerException != null)
     {
         throw new SyncServiceException(innerException.StatusCode, innerException.ErrorCode, innerException.Message, exception);
     }
 }

 /// <summary>
 /// Returns inner exception, while preserving the stack trace
 /// </summary>
 /// <param name="e">The target invocation exception to unwrap.</param>
 /// <returns>inner exception</returns>
 public static Exception Inner(TargetInvocationException e)
 {
     if (e == null) throw new ArgumentNullException("e");
     if (null != InternalPreserveStackTraceMethod)
     {
         InternalPreserveStackTraceMethod.Invoke(e.InnerException, new object[0]);
     }
     return e.InnerException;
 }

        static void FailedTest(TargetInvocationException ex, ref int counter)
        {
            Console.ForegroundColor = GetColor(Colors.Failed);
            Console.WriteLine(@"Failed");
            Console.WriteLine(ex.InnerException.Message);
            Console.ResetColor();

            counter++;
        }

 private void EvaluateException(bool expression, ExecuteParameters parameters, TargetInvocationException e)
 {
     if (expression) {
         Processor.TestStatus.MarkRight(parameters.Cell);
     }
     else {
         Processor.TestStatus.MarkWrong(parameters.Cell, "exception[" + e.InnerException.GetType().Name + ": \"" + e.InnerException.Message + "\"]");
     }
 }

        public void RemoveWrapperExceptions()
        {
            _client.RemoveWrapperExceptions(typeof(TargetInvocationException));

              TargetInvocationException wrapper = new TargetInvocationException(_exception);

              List<Exception> exceptions = _client.ExposeStripWrapperExceptions(wrapper).ToList();
              Assert.AreEqual(1, exceptions.Count);
              Assert.Contains(wrapper, exceptions);
        }

        public static Exception GetRealExceptionWithStackTrace(TargetInvocationException tiex)
        {
            var remoteStackTraceString = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

            remoteStackTraceString.SetValue(
                tiex.InnerException,
                tiex.StackTrace + Environment.NewLine
                );

            return tiex.InnerException;
        }

        public void GetAdviceForUser_ReturnsIntroTextAsFirstLine_Always()
        {
            var fileNotFoundException = new FileNotFoundException("message about missing styles", "dummyAssemblyStyles.dll");
            var xamlParseException = new XamlParseException("", fileNotFoundException);
            var targetInvocationException = new TargetInvocationException(xamlParseException);
            var missingPreloadException = new MissingPreloadException("", targetInvocationException);

            string adviceForUser = missingPreloadException.GetAdviceForUser();

            string[] lines = adviceForUser.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
            Assert.AreEqual(MissingPreloadException.IntroPartOfAdvice, lines[0]);
        }

        public void StripAggregateExceptionAndTargetInvocationException()
        {
            _client.AddWrapperExceptions(typeof(AggregateException));

              OutOfMemoryException exception2 = new OutOfMemoryException("Ran out of Int64s");
              TargetInvocationException innerWrapper = new TargetInvocationException(exception2);
              AggregateException wrapper = new AggregateException(_exception, innerWrapper);

              List<Exception> exceptions = _client.ExposeStripWrapperExceptions(wrapper).ToList();
              Assert.AreEqual(2, exceptions.Count);
              Assert.Contains(_exception, exceptions);
              Assert.Contains(exception2, exceptions);
        }

        public static void Cozy()
        {
            Console.WriteLine("\n-----------------------------------------------");
            Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName);
            Console.WriteLine("-----------------------------------------------");

            System.Exception e1 = new Exception();
            System.ApplicationException e2 = new ApplicationException();
            e2 = null;
            System.Reflection.TargetInvocationException e3 = new TargetInvocationException(e1);
            System.SystemException e4 = new SystemException();
            e4 = null;
            System.StackOverflowException e5 = new StackOverflowException();
            e5 = null;
        }

        /// <summary>
        /// Handles a subscriber method exception by passing it to all extensions and re-throwing the inner exception in case that none of the
        /// extensions handled it.
        /// </summary>
        /// <param name="targetInvocationException">The targetInvocationException.</param>
        /// <param name="eventTopic">The event topic.</param>
        protected void HandleSubscriberMethodException(TargetInvocationException targetInvocationException, IEventTopicInfo eventTopic)
        {
            Ensure.ArgumentNotNull(targetInvocationException, "targetInvocationException");

            var innerException = targetInvocationException.InnerException;
            innerException.PreserveStackTrace();

            var context = new ExceptionHandlingContext();

            this.ExtensionHost.ForEach(extension => extension.SubscriberExceptionOccurred(eventTopic, innerException, context));
                
            if (!context.Handled)
            {
                throw innerException;
            }
        }

        public static Exception ResolveTargetInvocationException(TargetInvocationException ex)
        {
            if (SecurityManager.IsGranted(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess)))
            {
                FieldInfo remoteStackTrace = typeof (Exception).GetField("_remoteStackTraceString",
                                                                         BindingFlags.Instance | BindingFlags.NonPublic);

                remoteStackTrace.SetValue(ex.InnerException, ex.InnerException.StackTrace + "\r\n");

                return ex.InnerException;
            }
            else
            {
                return ex;
            }
        }

 /// <summary>
 /// Unwraps the TargetInvocationException that reflection methods helpfully give us.
 /// </summary>
 /// <param name="tie">Exception to unwrap</param>
 /// <returns>A copy of the inner exception, for a few cases.</returns>
 public static Exception UnwrapTargetInvokationException(TargetInvocationException tie)
 {
     if (tie.InnerException.GetType() == typeof(DataStoreCastException))
     {
         DataStoreCastException orig = (DataStoreCastException)tie.InnerException;
         return new DataStoreCastException(orig.FromType, orig.ToType, tie);
     }
     else if (tie.InnerException.GetType() == typeof(DataNode.ValueNotInitialized))
     {
         DataNode.ValueNotInitialized orig = (DataNode.ValueNotInitialized)tie.InnerException;
         throw new DataNode.ValueNotInitialized(orig.key, tie);
     }
     else if (tie.InnerException.GetType() == typeof(NotSupportedException))
     {
         NotSupportedException orig = (NotSupportedException)tie.InnerException;
         throw new NotSupportedException(orig.Message, tie);
     }
     return null;
 }

        public void StripMultipleWrapperExceptions()
        {
            HttpUnhandledException wrapper = new HttpUnhandledException("Something went wrong", _exception);
              TargetInvocationException wrapper2 = new TargetInvocationException(wrapper);

              RaygunMessage message = _client.CreateMessage(wrapper2);
              Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName);
        }

        public void StripTargetInvocationExceptionByDefault()
        {
            TargetInvocationException wrapper = new TargetInvocationException(_exception);

              RaygunMessage message = _client.CreateMessage(wrapper);
              Assert.AreEqual("System.NullReferenceException", message.Details.Error.ClassName);
        }