基于 C# 的 Windows 服务 - 尝试在生产中进行 JIT 调试

Question

我在投入生产的服务的事件日志中收到此错误：

发生未处理的 win32 异常 在 RivWorks.FeedHandler.exe [5496] 中。 即时调试此异常 失败并出现以下错误： 调试器无法启动，因为 没有用户登录。

我已安装它并在 Win NT 全局帐户下运行。我不知道为什么它试图进入调试模式。它是在发布模型下构建的。运行在4.0框架上。

当我在我的开发机器上运行时，通过 EXE 入口点而不是 WinSvc 入口点，一切都运行得很好 - 但是 - 我已经处于“调试”模式。

有什么想法要寻找什么吗？

---

2010-10-21 - 注意 - 更改了代码库。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.IO;
using sysIO = System.IO;
using RivWorks.FeedHandler;
using System.Collections;

namespace RivWorks.FeedHandler.Service
{
    public partial class FeedListener : ServiceBase
    {
        #region Declarations
        private List<string> _keys = new List<string>();
        private System.Threading.Timer _clock = null;
        private FileSystemWatcher _watcher;
        private BackgroundWorker _worker;
        private Queue<string> _queue = new Queue<string>();
        private bool _isDequeueing = false;
        #endregion

        #region Constructor
        public FeedListener()
        {
            InitializeComponent();
        }
        #endregion

        #region Start/Stop
        protected override void OnStart(string[] args)
        {
            try
            {
                WriteToEventLog("Enter Start", EventLogEntryType.Information);
                _keys.AddRange(new string[] { "csv", "xml", "zip", "rivx" });

                _worker = new BackgroundWorker();
                _worker.WorkerReportsProgress = true;
                _worker.WorkerSupportsCancellation = true;
                _worker.DoWork += new DoWorkEventHandler(BackgroundWorkerDoWork);
                _worker.ProgressChanged += new ProgressChangedEventHandler(BackgroundWorkerProgressChanged);
                _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerRunWorkerCompleted);

                _watcher = new FileSystemWatcher(AppSettings.Default.FTPRootPath, "*.*");
                _watcher.IncludeSubdirectories = true;
                _watcher.NotifyFilter = sysIO.NotifyFilters.DirectoryName | sysIO.NotifyFilters.FileName | sysIO.NotifyFilters.LastAccess | sysIO.NotifyFilters.CreationTime | sysIO.NotifyFilters.LastWrite;
                _watcher.Created += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
                _watcher.Changed += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
                _watcher.EnableRaisingEvents = true;

                // check every 15 minutes...
                _clock = new System.Threading.Timer(Tick, null, 0, 900000);
                WriteToEventLog("Exit Start", EventLogEntryType.Information);
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
                this.Stop();
            }
        }
        protected override void OnStop()  
        {
            try
            {
                _watcher.Dispose();
                _watcher = null;
                _clock.Dispose();
                _clock = null;
                _worker.Dispose();
                _worker = null;
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Event Handlers
        void fileCreatedOrChanged(object sender, sysIO.FileSystemEventArgs e)
        {
            try
            {
                WriteToEventLog("Enter fileCreatedOrChanged", EventLogEntryType.Information);

                if (!_queue.Contains(e.FullPath))
                    _queue.Enqueue(e.FullPath);
                if (!_isDequeueing)
                    DeQueue();
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Do work on another Thread
        void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                WriteToEventLog("Enter BackgroundWorkerDoWork", EventLogEntryType.Information);
                BackgroundWorker bw = sender as BackgroundWorker;

                WriteToEventLog("Create Handler", EventLogEntryType.Information);
                RivWorks.FeedHandler.Library.Handler handler = new RivWorks.FeedHandler.Library.Handler(Convert.ToBoolean(AppSettings.Default.InProduction), AppSettings.Default.ArchivePath);

                WriteToEventLog("Setup Handler", EventLogEntryType.Information);
                handler.Keys = _keys;
                handler.RootDirectory = AppSettings.Default.RootDirectory;
                handler.FtpPath = AppSettings.Default.FTPRootPath;
                handler.WorkPath = AppSettings.Default.WorkPath;
                handler.ArchivePath = AppSettings.Default.ArchivePath;
                handler.EmailHost = AppSettings.Default.EmailHost;
                handler.EmailPassword = AppSettings.Default.EmailPassword;
                handler.EmailUser = AppSettings.Default.EmailUser;
                handler.ErrorNotificationRecipients = AppSettings.Default.ErrorNotificationRecipients;
                handler.InProduction = Convert.ToBoolean(AppSettings.Default.InProduction);

                Library.DTO.FileHandler fileHandler = new Library.DTO.FileHandler(handler.FtpPath, handler.WorkPath, handler.ArchivePath, (string)e.Argument);

                WriteToEventLog("Call Handler.Execute", EventLogEntryType.Information);
                handler.Execute(bw, e, fileHandler);
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
            finally
            {
                WriteToEventLog("Exit BackgroundWorkerDoWork", EventLogEntryType.Information);
            }
        }
        void BackgroundWorkerProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
                if (e.ProgressPercentage >= 100)
                {
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        void BackgroundWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            try
            {
                if (e.Cancelled)
                {
                    WriteToEventLog("Cancelled.", EventLogEntryType.Warning);
                    if (e.Error != null)
                    {
                        WriteToEventLog(e.Error, EventLogEntryType.Error);
                    }
                }
                else if (e.Error != null)
                {
                    WriteToEventLog(e.Error, EventLogEntryType.Error);
                }
                else
                {
                    WriteToEventLog("Successfully completed.", EventLogEntryType.Information);
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Private Methods
        private void Tick(object data)
        {
            try
            {
                if (!_isDequeueing)
                {
                    WriteToEventLog("Enter Tick.  FTP Root = " + AppSettings.Default.FTPRootPath, EventLogEntryType.Information);

                    foreach (string key in _keys)
                    {
                        List<string> files = Directory.GetFiles(Path.Combine(AppSettings.Default.FTPRootPath), "*." + key, SearchOption.AllDirectories).ToList();
                        foreach (string fileName in files)
                        {
                            if (File.Exists(fileName))
                            {
                                // Toss this file name into the Queue...
                                WriteToEventLog("Call _queue.Enqueue(" + fileName + ")", EventLogEntryType.Information);
                                if (!_queue.Contains(fileName))
                                    _queue.Enqueue(fileName);
                            }
                        }
                    }
                    // Now, start handling the list of files...
                    DeQueue();
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
            finally
            {
                WriteToEventLog("Exit Tick", EventLogEntryType.Information);
            }
        }
        private void DeQueue()
        {
            try
            {
                _isDequeueing = true;

                WriteToEventLog("Enter DeQueue", EventLogEntryType.Information);

                while (_queue.Count > 0)
                {
                    string queuedFile = _queue.Dequeue();
                    WriteToEventLog("DeQueued " + queuedFile, EventLogEntryType.Information);

                    bool isValid = false;
                    foreach (string key in _keys)
                    {
                        if (Path.GetExtension(queuedFile).Replace(".", "").Equals(key, StringComparison.CurrentCultureIgnoreCase))
                            isValid = true;
                    }

                    if (isValid)
                    {
                        // Now, spin up a new thread and do the work on the file, based on file type...
                        WriteToEventLog("Call RunWorkerAsync", EventLogEntryType.Information);
                        string UserName = Path.GetDirectoryName(queuedFile).Replace(AppSettings.Default.FTPRootPath, "").Replace("\\", "");
                        int i = 0;
                        DateTime sTime = DateTime.Now;
                        DateTime eTime = DateTime.Now;
                        _worker.RunWorkerAsync(queuedFile);  // goes to BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) //

                        while(_worker.IsBusy)
                        {
                            System.Threading.Thread.Sleep(5000);
                            i++;
                        }
                        eTime = DateTime.Now;
                        TimeSpan ts = new TimeSpan(eTime.Ticks - sTime.Ticks);
                        string msg = String.Format("Import for {0} started at {1} and ended at {2}.  It took {3} cycles and the elapsed time was {4}:{5}:{6}.", UserName, sTime, eTime, i, ts.Hours, ts.Minutes, ts.Seconds);
                        WriteToEventLog(msg, EventLogEntryType.Information);
                    }
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
            finally
            {
                _isDequeueing = false;
                WriteToEventLog("Exit DeQueue", EventLogEntryType.Information);
            }
        }
        private void WriteToEventLog(Exception ex, EventLogEntryType eventLogEntryType)
        {
            try
            {
                string message = string.Empty;
                string sTrace = ex.StackTrace;
                while (ex != null)
                {
                    message = message + Environment.NewLine + Environment.NewLine + ex.Message;
                    ex = ex.InnerException;
                }
                message = message + Environment.NewLine + Environment.NewLine + sTrace;

                WriteToEventLog(message, eventLogEntryType);
            }
            catch (Exception ex2)
            {
                WriteToEventLog(ex2.Message, EventLogEntryType.Error);
            }
        }
        private void WriteToEventLog(string message, EventLogEntryType eventLogEntryType)
        {
            try
            {
                this.EventLog.WriteEntry(message, eventLogEntryType);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion
    }
}

---

2010-10-20 - 注意 - 添加了服务代码文件。也许这里有一个基本错误？

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.IO;
using sysIO = System.IO;
using RivWorks.FeedHandler;

namespace RivWorks.FeedHandler.Service
{
    public partial class FeedListener : ServiceBase
    {
        #region Declarations
        private List<string> _keys = new List<string>();
        private System.Threading.Timer _clock = null;
        private FileSystemWatcher _watcher;
        private BackgroundWorker _worker;
        static private bool _isBusy = false;
        #endregion

        #region Constructor
        public FeedListener()
        {
            InitializeComponent();
        }
        #endregion

        #region Start/Stop
        protected override void OnStart(string[] args)
        {
            try
            {
                _keys.AddRange(new string[] { "csv", "xml", "zip", "rivx" });

                _worker = new BackgroundWorker();
                _worker.WorkerReportsProgress = true;
                _worker.WorkerSupportsCancellation = true;
                _worker.DoWork += new DoWorkEventHandler(BackgroundWorkerDoWork);
                _worker.ProgressChanged += new ProgressChangedEventHandler(BackgroundWorkerProgressChanged);
                _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BackgroundWorkerRunWorkerCompleted);

                _watcher = new FileSystemWatcher(AppSettings.Default.FTPRootPath, "*.*");
                _watcher.IncludeSubdirectories = true;
                _watcher.NotifyFilter = sysIO.NotifyFilters.DirectoryName | sysIO.NotifyFilters.FileName | sysIO.NotifyFilters.LastAccess | sysIO.NotifyFilters.CreationTime | sysIO.NotifyFilters.LastWrite;
                _watcher.Created += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
                _watcher.Changed += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
                _watcher.EnableRaisingEvents = true;

                // check every 5 minutes...
                _clock = new System.Threading.Timer(Tick, null, 0, 300000);
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
                this.Stop();
            }
        }
        protected override void OnStop()  
        {
            try
            {
                _watcher.Dispose();
                _watcher = null;
                _clock.Dispose();
                _clock = null;
                _worker.Dispose();
                _worker = null;
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Event Handlers
        void fileCreatedOrChanged(object sender, sysIO.FileSystemEventArgs e)
        {
            try
            {
                DTO.BackgroundWorkerEventArgs eventArgs = new DTO.BackgroundWorkerEventArgs();
                sysIO.WatcherChangeTypes myType = e.ChangeType;

                bool isValid = false;
                foreach (string key in _keys)
                {
                    if (Path.GetExtension(e.FullPath).Replace(".", "").Equals(key, StringComparison.CurrentCultureIgnoreCase))
                        isValid = true;
                }

                if (isValid)
                {
                    eventArgs.PathAndFile = e.FullPath;
                    eventArgs.Key = Path.GetExtension(e.FullPath).ToLower().Replace(".", "");
                    eventArgs.FileName = Path.GetFileName(e.FullPath);
                    eventArgs.Path = Path.GetDirectoryName(e.FullPath);
                    eventArgs.UserName = Path.GetDirectoryName(e.FullPath).Replace(AppSettings.Default.FTPRootPath, "").Replace("\\", "");
                    eventArgs.IsRunning = true;

                    System.Threading.Thread.Sleep(30000);

                    // Now, spin up a new thread and do the work on the file, based on file type...
                    _isBusy = true;
                    _worker.RunWorkerAsync(eventArgs);  // goes to BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) //
                    int i = 0;
                    DateTime sTime = DateTime.Now;
                    DateTime eTime = DateTime.Now;
                    while (_isBusy)
                    {
                        System.Threading.Thread.Sleep(5000);
                        i++;
                    }
                    eTime = DateTime.Now;
                    TimeSpan ts = new TimeSpan(eTime.Ticks - sTime.Ticks);
                    string msg = String.Format("Import for {0} started at {1} and ended at {2}.  It took {3} cycles and the elapsed time was {4}:{5}:{6}.", eventArgs.UserName, sTime, eTime, i, ts.Hours, ts.Minutes, ts.Seconds);
                    WriteToEventLog(msg, EventLogEntryType.Information);
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Do work on another Thread
        void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                RivWorks.FeedHandler.Handler handler = new RivWorks.FeedHandler.Handler();
                BackgroundWorker bw = sender as BackgroundWorker;

                handler.Execute(bw, e);
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
            finally
            {
                _isBusy = false;
            }
        }
        void BackgroundWorkerProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
                if (e.ProgressPercentage >= 100)
                {
                    _isBusy = false;
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        void BackgroundWorkerRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            try
            {
                if (e.Cancelled)
                {
                    WriteToEventLog("Cancelled.", EventLogEntryType.Warning);
                    if (e.Error != null)
                    {
                        WriteToEventLog(e.Error, EventLogEntryType.Error);
                    }
                }
                else if (e.Error != null)
                {
                    WriteToEventLog(e.Error, EventLogEntryType.Error);
                }
                else
                {
                    WriteToEventLog("Successfully completed.", EventLogEntryType.Information);
                }
                _isBusy = false;
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion

        #region Private Methods
        private void Tick(object data)
        {
            try
            {
                foreach (string key in _keys)
                {
                    List<string> files = Directory.GetFiles(Path.Combine(AppSettings.Default.FTPRootPath), "*." + key, SearchOption.AllDirectories).ToList();
                    foreach (string fileName in files)
                    {
                        System.Threading.Thread.Sleep(5000);
                        if (File.Exists(fileName))
                        {
                            DateTime lat = File.GetLastWriteTime(fileName);
                            try
                            {
                                File.SetLastWriteTime(fileName, DateTime.Now);
                            }
                            catch
                            {
                                // just catch and ignore with a short pause...
                                System.Threading.Thread.Sleep(5000);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        private void WriteToEventLog(Exception ex, EventLogEntryType eventLogEntryType)
        {
            try
            {
                string message = string.Empty;
                string sTrace = ex.StackTrace;
                while (ex != null)
                {
                    message = message + Environment.NewLine + Environment.NewLine + ex.Message;
                    ex = ex.InnerException;
                }
                message = message + Environment.NewLine + Environment.NewLine + sTrace;

                this.EventLog.WriteEntry(message, eventLogEntryType);
            }
            catch (Exception ex2)
            {
                WriteToEventLog(ex2, EventLogEntryType.Error);
            }
        }
        private void WriteToEventLog(string message, EventLogEntryType eventLogEntryType)
        {
            try
            {
                this.EventLog.WriteEntry(message, eventLogEntryType);
            }
            catch (Exception ex)
            {
                WriteToEventLog(ex, EventLogEntryType.Error);
            }
        }
        #endregion
    }
}

Answer 1

即使它作为发行版 exe 运行，当应用程序崩溃时，您仍然可以选择附加到调试器...您只是看不到调试符号，只看到程序集:)

我相信这是 Dr. Watson 进程捕获应用程序错误以进行调试...因为您的应用程序是一项服务，Dr. Watson 无法与桌面交互，从而给您带来您看到的错误。您可以转到服务属性并标记“允许服务与桌面交互”（位于“登录”选项卡上），当应用程序崩溃时，该选项卡应该会向您显示 Dr. Watson 弹出窗口。

禁用 Dr. Watson 的步骤如下：
http://support.microsoft.com/kb/188296

如果您想在服务器，您可以在服务器上启用远程调试，并将 Visual Studio 附加到进程...如果您想尝试此操作，我可以为您提供更多远程调试 Windows 服务的提示。

哈特哈，
詹姆斯

* 编辑 *
根据您提供的代码，我会查看以下区域：

1. AppSettings.Default.FTPRootPath 在 App.Config 中设置是否正确？

2. 服务启动时该目录是否立即发生变化？您有一个计时器被注释为“每五分钟检查一次”，这有点令人困惑，因为一旦您将 EnableRaisingEvents 设置为 true，FileSystemWatcher 就会开始接收事件。因此，问题实际上可能在于 fileCreatedOrChanged

3. 沿着这些思路，您有一个 BackgroundWorker 为多个事件提供服务，更糟糕的是，您正在异步触发处理程序。这是我最有可能的怀疑，因为如果您在第一个作业运行时再次调用 _worker.RunWorkerAsync()，您将收到 InvalidOperationException。虽然我不确定为什么您不会在日志中看到这一点

4. 您正在使用计时器来更新监视目录中所有文件的上次写入时间，并且每五秒执行一次。这似乎是一个非常糟糕的主意......我不确定你想要完成什么。这将触发您的 FileSystemWatcher 的更改事件，这可以解释为什么您在启动后不到 10 秒就崩溃了（计时器的初始滴答设置为立即触发，这意味着 5 秒后您将崩溃）更改所有文件时间，此后不久多次触发 FileSystemWatcher）

所以我最好的猜测是，在五秒内，您已经开始触发多个 RunWorkAsync() 调用相同的 BackgroundWorker，这是一个禁忌:)

将静态变量 _isBusy 设置为 true/false 是不可靠的，因为您与 BackgroundWorkers 进行多线程...您需要使用互斥锁或其他锁，但这是否真的违背了使用BackgroundWorker 的目的？

另外，如果您想使用 isBusy 标志之类的东西，它必须看起来更像是：

while (_isBusy) {
    System.Threading.Thread.Sleep(5000);
}

_isBusy = true;
_worker.RunWorkerAsync(eventArgs);

在尝试启动后台工作程序之前，您需要 _isBusy 为 false...按照您的方式，如果事件触发 100 次，您将拨打 100 个电话。

解决您的问题的最简单的解决方案是每次事件触发时在 fileCreatedOrChanged 方法中创建一个新的BackgroundWorker...创建如此多的新线程会产生开销，但如果在此方法中完成的工作很重要，那么它将是值得付出的开销。

您也许可以依赖内置的BackgroundWorker.IsBusy 属性，但是，如果您只是要阻塞直到后台工作程序完成，那么我不得不再次质疑异步线程的好处。

** 编辑 **

我现在明白您试图通过初始文件时间戳更改来完成什么...我认为您最好不要保留时间戳，而只需运行启动循环来处理现有文件。您可以为每个线程生成一个后台工作线程，就像在 FileSystemWatcher 通知上所做的那样。你处理它的方式是故意创造一个副作用来触发你想要的结果。

在日益增长的复杂性中，我有点失去了踪迹……整个队列/出队的事情可能是不必要的。或者也许我只是没有看到真正存在的需求。同样，令我印象深刻的是，您异步启动后台工作程序，然后将主线程置于睡眠状态，直到完成。

当您将主线程置于睡眠状态时，不会处理任何事件，因此您真正将多线程限制为一个线程。我看到您想将线程完成所需的时间写入事件日志。如果有机会的话，我将开始第二个答案来解决这个问题，但其要点是传递一个 Stopwatch 类（它将为您提供通过的毫秒或 CPU 滴答的准确计数）在操作期间）添加到 DoWorkEventArgs.Result 属性。

但你要求的代码！基本上，无论您在何处决定调用 _worker.RunWorkerAsync(queuedFile)，而不是每次运行一个类级 BackgroundWorker 都会创建一个新的。为事件处理程序等传递所有相同的参数。您的服务入口点将删除所有 BGW 引用，如下所示：

protected override void OnStart(string[] args)
{
    try
    {
        _keys.AddRange(new string[] { "csv", "xml", "zip", "rivx" });

        _watcher = new FileSystemWatcher(AppSettings.Default.FTPRootPath, "*.*");
        _watcher.IncludeSubdirectories = true;
        _watcher.NotifyFilter = sysIO.NotifyFilters.DirectoryName | sysIO.NotifyFilters.FileName | sysIO.NotifyFilters.LastAccess | sysIO.NotifyFilters.CreationTime | sysIO.NotifyFilters.LastWrite;
        _watcher.Created += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
        _watcher.Changed += new sysIO.FileSystemEventHandler(fileCreatedOrChanged);
        _watcher.EnableRaisingEvents = true;

        WriteToEventLog("Exit Start", EventLogEntryType.Information);
    }

并且异步运行 BGW 的代码将变为：

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.WorkerSupportsCancellation = true;
worker.DoWork += new DoWorkEventHandler(BackgroundWorkerDoWork);
worker.ProgressChanged += BackgroundWorkerProgressChanged;        // Note you don't need
worker.RunWorkerCompleted += BackgroundWorkerRunWorkerCompleted;  // the 'new' here

worker.RunWorkerAsync(queuedFile);  // goes to BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) //

Answer 2

错误消息告诉您它无法附加调试器来让您检查异常。这与这是一个发布版本这一事实完全无关。发布版本和调试版本都可以进行调试（幸运的是！）。

调试服务与调试常规应用程序略有不同。请查看本指南获取一些建议。