Mondial de la gestion des exceptions dans Xamarin de la Croix-plate-forme

Il n'y a pas un " Xamarin.Les formes à la manière de le faire, que je sache. Vous avez besoin de s'accrocher dans Android et iOS, ce que vous pourriez faire est de créer une méthode qui traite à la fois de la même manière.

Une belle post à ce sujet est par Peter Norman. Il décrit la mise en œuvre dans Android, vous pouvez le faire dans votre MainActivity.cs.

//In MainActivity
protected override void OnCreate(Bundle bundle)
{
    base.OnCreate(bundle);  

    AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
    TaskScheduler.UnobservedTaskException += TaskSchedulerOnUnobservedTaskException;  

    Xamarin.Forms.Forms.Init(this, bundle);  
    DisplayCrashReport();  

    var app = new App();  
    LoadApplication(app);
}  

‪#‎region‬ Error handling
private static void TaskSchedulerOnUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs unobservedTaskExceptionEventArgs)
{
    var newExc = new Exception("TaskSchedulerOnUnobservedTaskException", unobservedTaskExceptionEventArgs.Exception);
    LogUnhandledException(newExc);
}  

private static void CurrentDomainOnUnhandledException(object sender, UnhandledExceptionEventArgs unhandledExceptionEventArgs)
{
    var newExc = new Exception("CurrentDomainOnUnhandledException", unhandledExceptionEventArgs.ExceptionObject as Exception);
    LogUnhandledException(newExc);
}  

internal static void LogUnhandledException(Exception exception)
{
    try
    {
        const string errorFileName = "Fatal.log";
        var libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal); //iOS: Environment.SpecialFolder.Resources
        var errorFilePath = Path.Combine(libraryPath, errorFileName);  
        var errorMessage = String.Format("Time: {0}\r\nError: Unhandled Exception\r\n{1}",
        DateTime.Now, exception.ToString());
        File.WriteAllText(errorFilePath, errorMessage);  

        //Log to Android Device Logging.
        Android.Util.Log.Error("Crash Report", errorMessage);
    }
    catch
    {
        //just suppress any error logging exceptions
    }
}  

///<summary>
//If there is an unhandled exception, the exception information is diplayed 
//on screen the next time the app is started (only in debug configuration)
///</summary>
[Conditional("DEBUG")]
private void DisplayCrashReport()
{
    const string errorFilename = "Fatal.log";
    var libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
    var errorFilePath = Path.Combine(libraryPath, errorFilename);

    if (!File.Exists(errorFilePath))
    {
        return; 
    }

    var errorText = File.ReadAllText(errorFilePath);
    new AlertDialog.Builder(this)
        .SetPositiveButton("Clear", (sender, args) =>
        {
            File.Delete(errorFilePath);
        })
        .SetNegativeButton("Close", (sender, args) =>
        {
            //User pressed Close.
        })
        .SetMessage(errorText)
        .SetTitle("Crash Report")
        .Show();
} 

‪#‎endregion‬

Et pour iOS, vous pouvez ajouter ce type de code dans votre AppDelegate.cs.

//iOS: Different than Android. Must be in FinishedLaunching, not in Main.
//In AppDelegate
public override bool FinishedLaunching(UIApplication uiApplication, NSDictionary options)
{
    AppDomain.CurrentDomain.UnhandledException += CurrentDomainOnUnhandledException;
    TaskScheduler.UnobservedTaskException += TaskSchedulerOnUnobservedTaskException;  
    //Rest of your code...
}  

///<summary>
//If there is an unhandled exception, the exception information is diplayed 
//on screen the next time the app is started (only in debug configuration)
///</summary>
[Conditional("DEBUG")]
private static void DisplayCrashReport()
{
    const string errorFilename = "Fatal.log";
    var libraryPath = Environment.GetFolderPath(Environment.SpecialFolder.Resources);
    var errorFilePath = Path.Combine(libraryPath, errorFilename);

    if (!File.Exists(errorFilePath))
    {
        return;
    }

    var errorText = File.ReadAllText(errorFilePath);
    var alertView = new UIAlertView("Crash Report", errorText, null, "Close", "Clear") { UserInteractionEnabled = true };
    alertView.Clicked += (sender, args) =>
    {
        if (args.ButtonIndex != 0)
        {
            File.Delete(errorFilePath);
        }
    };
    alertView.Show();
}

Il comprend également la possibilité d'afficher le journal lorsque vous êtes débogage de l'application. Bien sûr, vous pouvez mettre en place votre propre exploitation forestière ou de méthodes de manipulation. Une chose que vous pourriez regarder est HockeyApp. Cela gère les exceptions non gérées par défaut et envoie vers vous, entre autres choses.

Mise à jour, puisque c'est encore trouvé sur Google: sur le crash de reporting et d'analyse que vous voulez maintenant commencer à regarder App Center. C'est l'évolution de HockeyApp et Xamarin Idées (parmi d'autres, comme la construction, la distribution et les notifications push) et agit maintenant comme la mission de tableau de bord pour tout ce qui a à faire avec les applications, et pas seulement les Xamarin.

Pour UWP et WinPhone 8.1 il devrait y avoir un UnhandledException gestionnaire dans la Application objet. Découvrez cette réponse pour plus d'informations. Je cite:

Pour XAML applications, vous pouvez utiliser UnhandledException; cependant, que
capture seulement les exceptions qui viennent à travers le XAML (UI) cadre
et vous n'avez pas toujours obtenir beaucoup de renseignements au sujet de ce que la racine
la cause est que, même dans InnerException.

Mise à jour pour Windows 8.1: UnhandledException également capturer
les exceptions qui sont créés par une async void méthode. Dans Windows 8,
de telles exceptions, serait tout simplement le plantage de l'application. LunarFrog a une bonne
discussion de ce sur leur site internet.

Fondamentalement, vous devez ajouter un gestionnaire d'événements dans le constructeur de votre App() dans App.xaml.cs: this.UnhandledException += (o, s) => {}.