App Center stürzt ab (iOS)

2025-05-05

Von Bedeutung

Visual Studio App Center wurde am 31. März 2025 eingestellt, mit Ausnahme der Analyse- und Diagnosefeatures, die bis zum 30. Juni 2026 weiterhin unterstützt werden. Weitere Informationen

App Center-Abstürze generieren automatisch ein Absturzprotokoll jedes Mal, wenn Ihre App abstürzt. Das Protokoll wird zuerst in den Speicher des Geräts geschrieben und wenn der Benutzer die App erneut startet, wird der Absturzbericht an das App Center gesendet. Das Sammeln von Abstürze funktioniert sowohl für Beta- als auch für Live-Apps, d. h. für an den App Store übermittelte Apps. Absturzprotokolle enthalten wertvolle Informationen für Sie, um den Absturz zu beheben.

Folgen Sie dem Abschnitt " Erste Schritte ", wenn Sie das SDK noch nicht in Ihrer Anwendung eingerichtet haben.

Außerdem benötigen Absturzprotokolle unter iOS eine Symbolisierung. Sehen Sie sich die App Center-Diagnosedokumentation an, in der erläutert wird, wie Symbole für Ihre App bereitgestellt werden.

Hinweis

Das SDK leitet keine Absturzprotokolle weiter, wenn Sie an den Debugger angefügt sind. Stellen Sie sicher, dass der Debugger beim Abstürzen der App nicht verbunden ist.

Hinweis

Um ordnungsgemäß symbolische Stapelablaufverfolgungen zu erhalten, stellen Sie sicher, dass Bitcode deaktiviert ist. Weitere Informationen zu Bitcode finden Sie in der iOS-Symbolischen Dokumentation von App Center.

Hinweis

In der 4.0.0 Version des App Center wurden bahnbrechende Änderungen eingeführt. Folgen Sie dem Abschnitt "Migrieren zu App Center SDK 4.0.0" und höher , um App Center aus früheren Versionen zu migrieren.

Berichterstattung über Abstürze in Erweiterungen

App Center unterstützt Absturzberichte in iOS-Erweiterungen. Die Verwendung ist identisch mit der Containeranwendung.

Generieren eines Testabsturzes

App Center Crashes bietet Ihnen eine API zum Generieren eines Testabsturzes für einfache Tests des SDK. Diese API kann nur in Test-/Beta-Apps verwendet werden und führt in Produktions-Apps nichts aus.

[MSACCrashes generateTestCrash];

Crashes.generateTestCrash()

Abrufen weiterer Informationen zu einem vorherigen Absturz

App Center Crashes bietet zwei APIs, mit denen Sie weitere Informationen erhalten, falls Ihre App abgestürzt ist.

Hat die App in der vorherigen Sitzung eine Warnung mit geringem Arbeitsspeicher erhalten?

Nach dem Starten des SDK können Sie jederzeit überprüfen, ob die App in der vorherigen Sitzung eine Speicherwarnung erhalten hat:

[MSACCrashes hasReceivedMemoryWarningInLastSession];

Crashes.hasReceivedMemoryWarningInLastSession

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes sie gestartet wurde, sie wird immer zurückgegeben NO oder false vor dem Start.

Hinweis

In einigen Fällen kann ein Gerät mit geringem Arbeitsspeicher keine Ereignisse senden.

Stürzte die App in der vorherigen Sitzung ab?

Nach dem Starten des SDK können Sie jederzeit überprüfen, ob die App beim vorherigen Start abgestürzt ist:

[MSACCrashes hasCrashedInLastSession];

Crashes.hasCrashedInLastSession

Dies ist praktisch, wenn Sie das Verhalten oder die Benutzeroberfläche Ihrer App nach dem Absturz anpassen möchten.

Hinweis

Diese Methode darf nur verwendet werden, nachdem MSACCrashes sie gestartet wurde, sie wird immer zurückgegeben NO oder false vor dem Start.

Details zum letzten Absturz

Wenn Ihre App zuvor abgestürzt ist, können Sie Details zum letzten Absturz abrufen.

MSACErrorReport *crashReport = [MSACCrashes lastSessionCrashReport];

var crashReport = Crashes.lastSessionCrashReport

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde; vor dem Start wird aber immer nil zurückgegeben.

Es gibt zahlreiche Anwendungsfälle für diese API. Der häufigste sind Personen, die diese API aufrufen und ihre benutzerdefinierte CrashesDelegate implementieren.

Passen Sie die Nutzung von App Center Crashes an.

App Center-Abstürze bieten Entwicklern Rückrufe, um zusätzliche Aktionen vor und beim Senden von Absturzprotokollen an App Center auszuführen.

Um Ihr benutzerdefiniertes Verhalten hinzuzufügen, müssen Sie das CrashesDelegate-Protokoll übernehmen, alle zugehörigen Methoden sind optional.

Registrieren als Stellvertretung

[MSACCrashes setDelegate:self];

Crashes.delegate = self

Hinweis

Sie müssen die Stellvertretung vor dem Aufrufen AppCenter.startfestlegen, da die Verarbeitung von App Center unmittelbar nach dem Start abstürzt.

Sollte der Absturz verarbeitet werden?

Implementieren Sie die crashes:shouldProcessErrorReport:-Methode in der Klasse, die das CrashesDelegate-Protokoll verwendet, wenn Sie entscheiden möchten, ob ein bestimmter Absturz verarbeitet werden muss oder nicht. Es könnte zum Beispiel einen Absturz auf Systemebene geben, den Sie ignorieren möchten und nicht an das App Center senden wollen.

- (BOOL)crashes:(MSACCrashes *)crashes shouldProcessErrorReport:(MSACErrorReport *)errorReport {
  return YES; // return YES if the crash report should be processed, otherwise NO.
}

func crashes(_ crashes: Crashes, shouldProcess errorReport: ErrorReport) -> Bool {
  return true; // return true if the crash report should be processed, otherwise false.
}

Behandelte Fehler

App Center ermöglicht Ihnen auch das Nachverfolgen von Fehlern mithilfe von behandelten Ausnahmen über die trackError-Methode. Eine App kann optional Eigenschaften oder/und Anlagen an einen behandelten Fehlerbericht anfügen, um weiteren Kontext bereitzustellen.

@try {
  // Throw error.
} @catch (NSError *error) {

  // Init attachments.
  NSArray<MSACErrorAttachmentLog *> attachments = @[ MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"] ]

  // Init properties.
  NSDictionary *properties = @{ "Category" : "Music", "Wifi" : "On" };

  // Track errors.
  [MSACCrashes trackError:error withProperties:properties attachments:attachments];
  [MSACCrashes trackError:error withProperties:properties attachments:nil];
  [MSACCrashes trackError:error withProperties:nil attachments:attachments];
  [MSACCrashes trackError:error withProperties:nil attachments:nil];
}

do {
  // Throw error.
} catch {

  // Init attachments.
  let attachments = [ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")]

  // Init properties.
  let properties:Dictionary<String, String> = ["Category" : "Music", "Wifi" : "On"]

  // Track errors.
  Crashes.trackError(error, properties: properties, attachments: attachments)
  Crashes.trackError(error, properties: properties, attachments: nil)
  Crashes.trackError(error, properties: nil, attachments: attachments)
  Crashes.trackError(error, properties: nil, attachments: nil)
}

Für Nachverfolgen von Ausnahmen können Sie die Folgende Methode verwenden trackException :

@try {
  // Throw exceptions.
} @catch (NSException *exception) {

  // Init exceptions.
  MSACExceptionModel *customException1 = [MSACExceptionModel initWithType:@"Custom exception" exceptionMessage:"Track custom exception.", stackTrace:exception.callStackSymbols];
  MSACExceptionModel *customException2 = [MSACExceptionModel initWithException:exception];

  // Track exceptions.
  [MSACCrashes trackException:customException1 withProperties:properties attachments:nil];
  [MSACCrashes trackException:customException2 withProperties:properties attachments:nil];
}

do {
  // Throw exception.
} catch {

  // Init exception.
  let exception = ExceptionModel(withType: "Custom exception", exceptionMessage: "Track custom exception.", stackTrace: Thread.callStackSymbols)

  // Track exception.
  Crashes.trackException(exception, properties: properties, attachments: nil)
}

Wenn Ihnen der Datenschutz des Benutzers wichtig ist, sollten Sie die Benutzerbestätigung erhalten, bevor Sie einen Absturzbericht an das App Center senden. Das SDK stellt eine Callback-Funktion bereit, die App Center Crashes angewiesen ist, auf die Bestätigung des Benutzers zu warten, bevor Absturzberichte gesendet werden.

Wenn Sie dies tun, sind Sie dafür verantwortlich, die Bestätigung des Benutzers zu erhalten, z. B. über eine Dialogfeldaufforderung mit einer der folgenden Optionen: "Immer senden", " Senden" und "Nicht senden". Basierend auf der Eingabe geben Sie App Center Crashes Anweisungen, und der Absturz wird dann entsprechend behandelt.

Hinweis

Das SDK zeigt hierfür kein Dialogfeld an, die App muss eine eigene Benutzeroberfläche bereitstellen, um die Zustimmung des Benutzers zu verlangen.

Hinweis

Die App sollte nicht explizit aufgerufen werden notifyWithUserConfirmation , wenn es kein Benutzerbestätigungsdialogfeld implementiert. Das Absturzmodul behandelt implizit das Senden von Protokollen für Sie.

Die folgende Methode zeigt, wie ein Benutzerbestätigungshandler eingerichtet wird:

[MSACCrashes setUserConfirmationHandler:(^(NSArray<MSACErrorReport *> *errorReports) {

  // Your code to present your UI to the user, e.g. an UIAlertController.
  UIAlertController *alertController = [UIAlertController
      alertControllerWithTitle:@"Sorry about that!"
                      message:@"Do you want to send an anonymous crash report so we can fix the issue?"
                preferredStyle:UIAlertControllerStyleAlert];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Don't send"
                                        style:UIAlertActionStyleCancel
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
                                      }]];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Send"
                                        style:UIAlertActionStyleDefault
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
                                      }]];

  [alertController
      addAction:[UIAlertAction actionWithTitle:@"Always send"
                                        style:UIAlertActionStyleDefault
                                      handler:^(UIAlertAction *action) {
                                        [MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];
                                      }]];
  // Show the alert controller.
  [self.window.rootViewController presentViewController:alertController animated:YES completion:nil];
  return YES; // Return YES if the SDK should await user confirmation, otherwise NO.
})];

Crashes.setUserConfirmationHandler({ (errorReports: [ErrorReport]) in

  // Your code to present your UI to the user, e.g. an UIAlertController.
  let alertController = UIAlertController(title: "Sorry about that!",
                                          message: "Do you want to send an anonymous crash report so we can fix the issue?",
                                          preferredStyle:.alert)

  alertController.addAction(UIAlertAction(title: "Don't send", style: .cancel) {_ in
    Crashes.notify(with: .dontSend)
  })

  alertController.addAction(UIAlertAction(title: "Send", style: .default) {_ in
    Crashes.notify(with: .send)
  })

  alertController.addAction(UIAlertAction(title: "Always send", style: .default) {_ in
    Crashes.notify(with: .always)
  })

  // Show the alert controller.
  self.window?.rootViewController?.present(alertController, animated: true)
  return true // Return true if the SDK should await user confirmation, otherwise return false.
})

Falls Sie im obigen Handlerblock zurückkehren YES/true , sollte Ihre App die Benutzerberechtigung abrufen und das SDK mit dem Ergebnis mithilfe der folgenden API melden. Wenn Sie hierfür eine Benachrichtigung verwenden, wie im obigen Beispiel, würden Sie sie innerhalb Ihrer Implementierung des alertView:clickedButtonAtIndex:"-callback" aufrufen.

// Depending on the users's choice, call notifyWithUserConfirmation: with the right value.
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationDontSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationSend];
[MSACCrashes notifyWithUserConfirmation:MSACUserConfirmationAlways];

// Depending on the user's choice, call notify(with:) with the right value.
Crashes.notify(with: .dontSend)
Crashes.notify(with: .send)
Crashes.notify(with: .always)

Abrufen von Informationen zum Sendestatus für ein Absturzprotokoll

Manchmal möchten Sie den Status ihres App-Absturzes kennen. Ein gängiger Anwendungsfall besteht darin, dass Sie die Benutzeroberfläche anzeigen möchten, die den Benutzern sagt, dass Ihre App einen Absturzbericht übermittelt, oder falls ihre App nach dem Start schnell abstürzt, möchten Sie das Verhalten der App anpassen, um sicherzustellen, dass die Absturzprotokolle übermittelt werden können. Das CrashesDelegate-Protokoll definiert drei verschiedene Rückrufe, die Sie in Ihrer App verwenden können, um über die Aktuellen informiert zu werden:

Der folgende Rückruf wird aufgerufen, bevor das SDK ein Absturzprotokoll sendet.

- (void)crashes:(MSACCrashes *)crashes willSendErrorReport:(MSACErrorReport *)errorReport {
  // Your code, e.g. to present a custom UI.
}

func crashes(_ crashes: Crashes, willSend errorReport: ErrorReport) {
  // Your code, e.g. to present a custom UI.
}

Falls Netzwerkprobleme oder ein Ausfall auf dem Endpunkt auftreten und Sie die App neu starten, willSendErrorReport wird nach dem Neustart des Prozesses erneut ausgelöst.

Der folgende Rückruf wird aufgerufen, nachdem das SDK erfolgreich ein Absturzprotokoll gesendet hat.

- (void)crashes:(MSACCrashes *)crashes didSucceedSendingErrorReport:(MSACErrorReport *)errorReport {
  // Your code, e.g. to hide the custom UI.
}

func crashes(_ crashes: Crashes, didSucceedSending errorReport: ErrorReport) {
  // Your code goes here.
}

Der folgende Rückruf wird aufgerufen, wenn das SDK ein Absturzprotokoll nicht senden konnte.

- (void)crashes:(MSACCrashes *)crashes didFailSendingErrorReport:(MSACErrorReport *)errorReport withError:(NSError *)error {
  // Your code goes here.
}

func crashes(_ crashes: Crashes, didFailSending errorReport: ErrorReport, withError error: Error) {
  // Your code goes here.
}

didFailSendingErrorReport Der Empfang bedeutet, dass ein nicht wiederherstellbarer Fehler wie z. B. ein 4xx-Code aufgetreten ist. Beispielsweise bedeutet 401, dass das appSecret falsch ist.

Dieser Rückruf wird nicht ausgelöst, wenn es sich um ein Netzwerkproblem handelt. In diesem Fall führt das SDK fortlaufend Wiederholungen durch (und unterbricht diese, während die Netzwerkverbindung unterbrochen ist).

Hinzufügen von Anlagen zu einem Absturzbericht

Sie können einem Absturzbericht Binärdateien und Textdateien hinzufügen. Das SDK sendet sie zusammen mit dem kritischen Fehler, damit Sie sie im App Center Portal sehen können. Der folgende Rückruf wird direkt vor dem Senden des gespeicherten Absturzes von vorherigen Anwendungsstarts aufgerufen. Er wird nicht aufgerufen, wenn der Absturz auftritt. Hier ist ein Beispiel für das Anfügen von Text und einem Bild an einen Absturz:

- (NSArray<MSACErrorAttachmentLog *> *)attachmentsWithCrashes:(MSACCrashes *)crashes
                                             forErrorReport:(MSACErrorReport *)errorReport {
  MSACErrorAttachmentLog *attachment1 = [MSACErrorAttachmentLog attachmentWithText:@"Hello world!" filename:@"hello.txt"];
  MSACErrorAttachmentLog *attachment2 = [MSACErrorAttachmentLog attachmentWithBinary:[@"Fake image" dataUsingEncoding:NSUTF8StringEncoding] filename:@"fake_image.jpeg" contentType:@"image/jpeg"];
  return @[ attachment1, attachment2 ];
}

func attachments(with crashes: Crashes, for errorReport: ErrorReport) -> [ErrorAttachmentLog]? {
  let attachment1 = ErrorAttachmentLog.attachment(withText: "Hello world!", filename: "hello.txt")
  let attachment2 = ErrorAttachmentLog.attachment(withBinary: "Fake image".data(using: String.Encoding.utf8), filename: nil, contentType: "image/jpeg")
  return [attachment1!, attachment2!]
}

Hinweis

Die Größenbeschränkung beträgt derzeit 7 MB. Beim Versuch, eine größere Anlage zu senden, wird ein Fehler ausgelöst.

Aktivieren oder Deaktivieren von App Center-Abstürzen zur Laufzeit

Sie können App Center-Abstürze zur Laufzeit aktivieren und deaktivieren. Wenn Sie sie deaktivieren, wird im SDK keine Absturzberichterstattung für die App ausgeführt.

[MSACCrashes setEnabled:NO];

Crashes.enabled = false

Um App Center-Abstürze erneut zu aktivieren, verwenden Sie dieselbe API, übergeben YES/true sie aber als Parameter.

[MSACCrashes setEnabled:YES];

Crashes.enabled = true

Der Zustand wird im Speicher des Geräts über Anwendungsstarts hinweg beibehalten.

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde.

Überprüfen, ob App Center Crashes aktiviert ist

Sie können auch überprüfen, ob App Center Crashes aktiviert ist oder nicht:

BOOL enabled = [MSACCrashes isEnabled];

var enabled = Crashes.enabled

Hinweis

Diese Methode darf nur verwendet werden, nachdem Crashes gestartet wurde; vor dem Start wird aber immer false zurückgegeben.

Deaktivieren der Mach-Ausnahmebehandlung

Standardmäßig verwendet App Center Crashes den Mach-Ausnahmehandler, um schwerwiegende Signale, z. B. Stapelüberläufe, über einen Mach-Ausnahmeserver abzufangen.

Die disableMachExceptionHandler-Methode bietet eine Option zum Deaktivieren des Abfangens von schwerwiegenden Signalen über einen Mach-Ausnahmeserver. Wenn Sie den Mach-Ausnahmehandler deaktivieren möchten, sollten Sie diese Methode AUFRUFEN, BEVOR Sie das SDK starten. Ihr typischer Setupcode sieht wie folgt aus:

[MSACCrashes disableMachExceptionHandler];
[MSACAppCenter start:@"{Your App Secret}" withServices:@[[MSACAnalytics class], [MSACCrashes class]]];

Crashes.disableMachExceptionHandler()
AppCenter.start(withAppSecret: "{Your App Secret}", services: [Analytics.self, Crashes.self])

Freigeben über

App Center stürzt ab (iOS)

Berichterstattung über Abstürze in Erweiterungen

Generieren eines Testabsturzes

Abrufen weiterer Informationen zu einem vorherigen Absturz

Hat die App in der vorherigen Sitzung eine Warnung mit geringem Arbeitsspeicher erhalten?

Stürzte die App in der vorherigen Sitzung ab?

Details zum letzten Absturz

Passen Sie die Nutzung von App Center Crashes an.

Registrieren als Stellvertretung

Sollte der Absturz verarbeitet werden?

Behandelte Fehler

Anfordern der Zustimmung des Benutzers zum Senden eines Absturzprotokolls

Abrufen von Informationen zum Sendestatus für ein Absturzprotokoll

Der folgende Rückruf wird aufgerufen, bevor das SDK ein Absturzprotokoll sendet.

Der folgende Rückruf wird aufgerufen, nachdem das SDK erfolgreich ein Absturzprotokoll gesendet hat.

Der folgende Rückruf wird aufgerufen, wenn das SDK ein Absturzprotokoll nicht senden konnte.

Hinzufügen von Anlagen zu einem Absturzbericht

Aktivieren oder Deaktivieren von App Center-Abstürzen zur Laufzeit

Überprüfen, ob App Center Crashes aktiviert ist

Deaktivieren der Mach-Ausnahmebehandlung

Feedback

Zusätzliche Ressourcen