Сбой запуска программы WPF: как отладить?

Question

У меня есть программа WPF, которая отлично работает на ПК разработчика и на клиентском ПК 1. Но на клиентском ПК 2 она сразу падает при запуске с окном Отправить отчет в Microsoft. Буду признателен за несколько советов о том, как отследить, что не так. Вот что я попробовал:

1. Вставлен трик-поймать в моем классе главного окна:

   public MainWindow()
   {
     try
     {
        MessageBox.Show("Before InitComp()");
        InitializeComponent();
        MessageBox.Show("Before Sub1()");
        Subroutine1();
        MessageBox.Show("Before Sub2()");
        Subroutine2();
        ... etc ...
     }
     catch (Exception ex)
     {  ... code for MessageBox display error here ... }
   }
   

Идея состоит в том, чтобы попытаться изолировать, какая часть последовательности запуска дает сбой, но первое сообщение отладки "Before InitComp ()" даже не отображается. Так что кажется, что приложение не работает даже до запуска моего кода.

1. Одна из возможностей - установить весь VS2008 на клиентском ПК 2, загрузить исходный код и использовать отладчик IDE для отслеживания проблемы. Это, вероятно, наиболее эффективно в поиске проблемы. Но я не хочу этого делать, потому что а) клиентский ПК 2 не принадлежит мне, б) он не масштабируется: я должен сделать то же самое для клиентского ПК 3/4/5 / ... и в) он нарушает мой лицензия фирмы VS2008.

Как мне отладить эту проблему?

Answer 1

В заголовке вашего App.xaml добавьте:

<Application DispatcherUnhandledException="App_DispatcherUnhandledException" />

, а в вашем App.xaml.cs добавьте что-то вроде:

    void App_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs args)
    {
        log.Fatal("An unexpected application exception occurred", args.Exception);

        MessageBox.Show("An unexpected exception has occurred. Shutting down the application. Please check the log file for more details.");

        // Prevent default unhandled exception processing
        args.Handled = true;

        Environment.Exit(0);
    }

Answer 2

Подход старой школы: Подобный тяжелый сбой, вероятно, выливается в нечто, что вы можете увидеть через Event Viewer в Windows.Вы уже проверили там?Много раз это говорит мне ответ без каких-либо дополнительных проблем.

Answer 3

Скачать ProcDump.Запустите procdump -t -w app.exe ... или, возможно, procdump -e -w app.exe ....Исследуйте и другие флаги.Затем откройте файл дампа в вашем любимом отладчике (Visual Studio / WinDbg) и посмотрите на трассировку стека.

Answer 4

Трассировка / регистрация очень мощная, особенно когда проблема возникает с клиентом. Вы не всегда можете отлаживать, и дамп может не дать полного представления о том, что привело к этому моменту. Это определенно дополняет дамп или отладку.

Вы также можете включать и выключать его и даже переключать уровни.

DebugView - хорошая программа для захвата следов:

http://technet.microsoft.com/en-us/sysinternals/bb896647

Трассировка:

http://msdn.microsoft.com/en-us/library/3at424ac.aspx

Например, вот пример класса трассировки с переключаемыми уровнями:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Globalization;
using System.Threading;

namespace Sample
{
    public class Tracer
    {
        //
        // supports holding many trace switches.
        //
        static Dictionary<string, TraceSwitch> s_switches = new Dictionary<string, TraceSwitch>();
        static TraceSwitch s_switch = new TraceSwitch("trace", "Default tracing switch");
        static object s_locker = new object();

        private static TraceSwitch GetSwitch (string category)
        {
            // only pay the lock penalty if it doesn't exist
            if (!s_switches.ContainsKey (category))
            {
                lock (s_locker)
                {
                    if (!s_switches.ContainsKey (category))
                    {
                        TraceSwitch traceSwitch = new TraceSwitch(category,
                                    String.Format("Tracing switch for category '{0}'", category));
                        s_switches.Add (category, traceSwitch);
                    }
                }
            }

            return s_switches[category];
        }

        //
        // No level overloads
        //
        public static void Output(string message)
        {
            WriteLine("None", TraceLevel.Info, message);
        }

        public static void OutputIf(bool condition, string message)
        {
            if (condition)
            {
                Output(message);
            }
        }

        public static void Output(string format, params object[] args)
        {
            Debug.Assert(format != null);
            Output(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void OutputIf(bool condition, string format, params object[] args)
        {
            if (condition)
            {
                Output(format, args);
            }
        }

        //
        // Error level overloads
        //
        public static void Error(string message)
        {
            if (s_switch.TraceError)
            {
                WriteLine(String.Empty, TraceLevel.Error, message);
            }
        }

        public static void Error(string category, string message)
        {
            if (GetSwitch(category).TraceError)
            {
                WriteLine(category, TraceLevel.Error, message);
            }
        }

        public static void ErrorIf(bool condition, string message)
        {
            if (condition)
            {
                Error(message);
            }
        }

        public static void ErrorIf(string category, bool condition, string message)
        {
            if (condition)
            {
                Error(category, message);
            }
        }

        public static void Error(string format, params object[] args)
        {
            Debug.Assert(format != null);
            Error(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void Error(string category, string format, params object[] args)
        {
            Debug.Assert(format != null);
            Error(category, string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void ErrorIf(bool condition, string format, params object[] args)
        {
            if (condition)
            {
                Error(format, args);
            }
        }

        public static void ErrorIf(string category,
                                   bool condition,
                                   string format,
                                   params object[] args)
        {
            if (condition)
            {
                Error(category, format, args);
            }
        }

        //
        // Warning level overloads
        //
        public static void Warning(string message)
        {
            if (s_switch.TraceWarning)
            {
                WriteLine(String.Empty, TraceLevel.Warning, message);
            }
        }

        public static void Warning(string category, string message)
        {
            if (GetSwitch(category).TraceWarning)
            {
                WriteLine(category, TraceLevel.Warning, message);
            }
        }

        public static void WarningIf(bool condition, string message)
        {
            if (condition)
            {
                Warning(message);
            }
        }

        public static void WarningIf(string category, bool condition, string message)
        {
            if (condition)
            {
                Warning(category, message);
            }
        }

        public static void Warning(string format, params object[] args)
        {
            Debug.Assert(format != null);
            Warning(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void Warning(string category, string format, params object[] args)
        {
            Debug.Assert(format != null);
            Warning(category, string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void WarningIf(bool condition, string format, params object[] args)
        {
            if (condition)
            {
                Warning(format, args);
            }
        }

        public static void WarningIf(string category,
                                     bool condition,
                                     string format,
                                     params object[] args)
        {
            if (condition)
            {
                Warning(category, format, args);
            }
        }

        //
        // Info level overloads
        //
        public static void Info(string message)
        {
            if (s_switch.TraceInfo)
            {
                WriteLine(String.Empty, TraceLevel.Info, message);
            }
        }

        public static void Info(string category, string message)
        {
            if (GetSwitch(category).TraceInfo)
            {
                WriteLine(category, TraceLevel.Info, message);
            }
        }

        public static void InfoIf(bool condition, string message)
        {
            if (condition)
            {
                Info(message);
            }
        }

        public static void InfoIf(string category, bool condition, string message)
        {
            if (condition)
            {
                Info(category, message);
            }
        }

        public static void Info(string format, params object[] args)
        {
            Debug.Assert(format != null);
            Info(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void Info(string category, string format, params object[] args)
        {
            Debug.Assert(format != null);
            Info(category, string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void InfoIf(bool condition, string format, params object[] args)
        {
            if (condition)
            {
                Info(format, args);
            }
        }

        public static void InfoIf(string category,
                                  bool condition,
                                  string format,
                                  params object[] args)
        {
            if (condition)
            {
                Info(category, format, args);
            }
        }

        //
        // Verbose level overloads
        //
        public static void Verbose(string message)
        {
            try
            {
                if (s_switch.TraceVerbose)
                {
                    WriteLine(String.Empty, TraceLevel.Verbose, message);
                }
            }catch{}
        }

        public static void Verbose(string category, string message)
        {
            if (GetSwitch(category).TraceVerbose)
            {
                WriteLine(category, TraceLevel.Verbose, message);
            }
        }

        public static void VerboseIf(bool condition, string message)
        {
            if (condition)
            {
                Verbose(message);
            }
        }

        public static void VerboseIf(string category, bool condition, string message)
        {
            if (condition)
            {
                Verbose(category, message);
            }
        }

        public static void Verbose(string format, params object[] args)
        {
            Debug.Assert(format != null);
            Verbose(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void Verbose(string category, string format, params object[] args)
        {
            Debug.Assert(format != null);
            Verbose(category, string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public static void VerboseIf(bool condition, string format, params object[] args)
        {
            if (condition)
            {
                Verbose(format, args);
            }
        }

        public static void VerboseIf(string category,
                                     bool condition,
                                     string format,
                                     params object[] args)
        {
            if (condition)
            {
                Verbose(category, format, args);
            }
        }

        //
        // Trace Output Format:
        // [category:level]PID|ThreadID|08:16:15.134| message.
        //
        private static void WriteLine(string category,
                                      System.Diagnostics.TraceLevel level,
                                      string message)
        {
            Debug.Assert(message != null);

            string traceLine = string.Format(
                CultureInfo.InvariantCulture,
                "[{0}:{1}]{2}|{3}|{4:HH}:{4:mm}:{4:ss}.{4:fff}|{5}",
                category,
                level.ToString(),
                Process.GetCurrentProcess().Id,
                Thread.CurrentThread.ManagedThreadId,
                DateTime.Now,
                message);

            Trace.WriteLine(traceLine);
        }
    }
}