App Center Crashes

App Center Crashes will automatically generate a crash log every time your app crashes. The log is first written to the device's storage and when the user starts the app again, the crash report will be sent to App Center.

The App Center SDK collects only crashes caused by unhandled .NET exceptions. It does not collect native crashes e.g. when using C or C++.

Follow the WPF/WinForms Getting Started if you haven't set up the SDK in your application yet.

Generate a test crash

App Center Crashes provides you with an API to generate a test crash for easy testing of the SDK. This API checks for debug vs release configurations. So you can only use it when debugging as it won't work for release apps.

Crashes.GenerateTestCrash();

Get more information about a previous crash

App Center Crashes has two APIs that give you more information in case your app has crashed.

Did the app crash in the previous session?

At any time after starting the SDK, you can check if the app crashed in the previous launch:

bool didAppCrash = await Crashes.HasCrashedInLastSessionAsync();

This comes in handy in case you want to adjust the behavior or UI of your app after a crash has occurred. Some developers choose to show additional UI to apologize to their users, or want a way to get in touch after a crash has occurred.

Note

This method must only be used after Crashes has been started, it will always return false before start.

Details about the last crash

If your app crashed previously, you can get details about the last crash.

ErrorReport crashReport = await Crashes.GetLastSessionCrashReportAsync();

Note

This method must only be used after Crashes has been started, it will always return null before start.

There are numerous use cases for this API, the most common one is people who call this API and implement their custom Crashes delegate or listener.

Customize your usage of App Center Crashes

App Center Crashes provides callbacks for developers to perform additional actions before and when sending crash logs to App Center.

Note

You must set callbacks before calling AppCenter.Start(), since App Center starts processing crashes immediately after the start.

Should the crash be processed?

Implement this callback if you'd like to decide if a particular crash needs to be processed or not. For example, there could be a system level crash that you'd want to ignore and that you don't want to send to App Center.

Crashes.ShouldProcessErrorReport = (ErrorReport report) => {
    return true; // return true if the crash report should be processed, otherwise false.
};

If user privacy is important to you, you might want to get user confirmation before sending a crash report to App Center. The SDK exposes a callback that tells App Center Crashes to await user confirmation before sending any crash reports.

If you chose to do so, you are responsible for obtaining the user's confirmation, e.g. through a dialog prompt with one of the following options: Always Send, Send, and Don't send. Based on the input, you will tell App Center Crashes what to do and the crash will then be handled accordingly.

Note

The SDK does not display a dialog for this, the app must provide its own UI to ask for user consent.

The following callback shows how to tell the SDK to wait for user confirmation before sending crashes:

Crashes.ShouldAwaitUserConfirmation = () => {
	// Build your own UI to ask for user consent here. SDK does not provide one by default.

	// Return true if you just built a UI for user consent and are waiting for user input on that custom UI, otherwise false.
	return true;
};

If you return true, your app must obtain (using your own code) the user's permission and message the SDK with the result using the following API:

// Depending on the user's choice, call Crashes.NotifyUserConfirmation() with the right value.
Crashes.NotifyUserConfirmation(UserConfirmation.DontSend);
Crashes.NotifyUserConfirmation(UserConfirmation.Send);
Crashes.NotifyUserConfirmation(UserConfirmation.AlwaysSend);

Get information about the sending status for a crash log

At times, you would like to know the status of your app crash. A common use case is that you might want to show UI that tells the users that your app is submitting a crash report, or, in case your app is crashing very quickly after the launch, you want to adjust the behavior of the app to make sure the crash logs can be submitted. App Center Crashes has three different callbacks that you can use in your app to be notified of what is going on:

The following callback will be invoked before the SDK sends a crash log

Crashes.SendingErrorReport += (object sender, SendingErrorReportEventArgs e) => {
	// Your code, e.g. to present a custom UI.
}

The following callback will be invoked after the SDK sent a crash log successfully

Crashes.SentErrorReport += (object sender, SentErrorReportEventArgs e) => {
	// Your code, e.g. to hide a custom UI.
};

The following callback will be invoked if the SDK failed to send a crash log

Crashes.FailedToSendErrorReport += (object sender, FailedToSendErrorReportEventArgs e) => {
	// Your code goes here.
};

Add attachments to a crash report

You can add one binary and one text attachment to a crash report. The SDK will send it along with the crash so that you can see it in App Center portal. The following callback will be invoked right before sending the stored crash from previous application launches. It will not be invoked when the crash happens. Here is an example of how to attach text and an image to a crash:

Crashes.GetErrorAttachments = (ErrorReport report) => {

    // Attach some text.
    ErrorAttachmentLog textLog = ErrorAttachmentLog.AttachmentWithText("This is a text attachment.", "text.txt");

    // Attach binary data.
    var fakeImage = System.Text.Encoding.Default.GetBytes("Fake image");
    ErrorAttachmentLog binaryLog = ErrorAttachmentLog.AttachmentWithBinary(fakeImage, "ic_launcher.jpeg", "image/jpeg");

    return new List<ErrorAttachmentLog> { textLog, binaryLog };
};

Note

The size limit is currently 7 MB. Attempting to send a larger attachment will trigger an error.

Enable or disable App Center Crashes at runtime

You can enable and disable App Center Crashes at runtime. If you disable it, the SDK will not do any crash reporting for the app.

Crashes.SetEnabledAsync(false);

To enable App Center Crashes again, use the same API but pass true as a parameter.

Crashes.SetEnabledAsync(true);

You don't need to await this call to make other API calls (such as IsEnabledAsync) consistent.

The state is persisted in the device's storage across application launches.

Check if App Center Crashes is enabled

You can also check if App Center Crashes is enabled or not:

bool isEnabled = await Crashes.IsEnabledAsync();

Handled Errors

App Center also allows you to track errors by sending handled exceptions; to do so, use the TrackError method:

try {
    // your code goes here.
} catch (Exception exception) {
    Crashes.TrackError(exception);
}

An app can optionally attach properties to a handled error report to provide further context. Pass the properties as a dictionary of key/value pairs (strings only) as shown in the example below.

try {
    // your code goes here.
} catch (Exception exception) {
    var properties = new Dictionary<string, string>
    {
        { "Category", "Music" },
        { "Wifi", "On"}
    };
    Crashes.TrackError(exception, properties); 
}