Benutzerdefinierte Ausnahmemeldungen: Best Practices

Question

Sie fragen sich, wie viel Mühe ich zu zwingen nützlichen Debug-Informationen gehen sollte, wenn Ausnahme Erstellen von Nachrichten, oder soll ich nur dem Benutzer vertrauen auf die richtigen Informationen zu versorgen, oder die Informationen verschieben zu einem Ausnahmehandler zu sammeln?

Ich sehe eine Menge Leute, die Menschen ihre Ausnahmen wie zu tun:

throw new RuntimeException('MyObject is not an array')

oder die Standard Ausnahmen mit benutzerdefinierten Ausnahmen erstrecken, die nicht viel tun, aber den Namen der Ausnahme ändern:

throw new WrongTypeException('MyObject is not an array')

Aber diese liefern nicht viel Debug-Info ... und erzwingt keine Art von Formatierung mit der Fehlermeldung. So könnte man mit genau den gleichen Fehlern produzieren zwei verschiedene Fehlermeldungen am Ende ... zB „Datenbankverbindung fehlgeschlagen“ vs „Kann keine Verbindung db“

Sicher, wenn es an die Spitze bläst, wird es den Stack-Trace drucken, was nützlich ist, aber es mir nicht immer alles sagen, ich muß wissen, und ich in der Regel am Ende beginnen Var_dump Schießen aus () Aussagen zu entdecken, was schief gelaufen ist und wo ... obwohl dies etwas mit einem anständigen Exception-Handler ausgeglichen werden.

Ich beginne etwas zu denken wie der Code unten, wo I erfordert der Werfer der Ausnahme notwendig args zuzuführen, um die richtige Fehlermeldung zu erzeugen. Ich denke, dies könnte der Weg sein, dass zu gehen:

• Mindestmaß an nützlichen Informationen müssen geliefert werden
• Erzeugt etwas konsistente Fehlermeldungen
• Vorlagen für Ausnahmemeldungen alle in die eine Position (Exception-Klassen), so leichter, um die Nachrichten zu aktualisieren ...

Aber ich sehe, der Nachteil ist, dass sie zu verwenden, sind schwieriger zu (erfordert Sie Ausnahme Definition nachschlagen) und damit andere Programmierer verwenden geliefert Ausnahmen entmutigen auch ...

ich auf dieser Idee, einige Kommentare mag, & Best Practices für einen einheitlichen, flexible Ausnahmemeldung Rahmen.

/**
* @package MyExceptions
* MyWrongTypeException occurs when an object or 
* datastructure is of the incorrect datatype.
* Program defensively!
* @param $objectName string name of object, eg "\$myObject"
* @param $object object object of the wrong type
* @param $expect string expected type of object eg 'integer'
* @param $message any additional human readable info.
* @param $code error code.
* @return Informative exception error message.
* @author secoif
*/
class MyWrongTypeException extends RuntimeException {
    public function __construct($objectName, $object, $expected, $message = '', $code = 0) {
        $receivedType = gettype($object) 
        $message = "Wrong Type: $objectName. Expected $expected, received $receivedType";
        debug_dump($message, $object);
        return parent::__construct($message, $code);
    }
}

....

/**
 * If we are in debug mode, append the var_dump of $object to $message
 */
function debug_dump(&$message, &$object) {
     if (App::get_mode() == 'debug') {
         ob_start();
         var_dump($object);
         $message = $message . "Debug Info: " . ob_get_clean();
    }
}

Dann verwendet wie:

// Hypothetical, supposed to return an array of user objects
$users = get_users(); // but instead returns the string 'bad'
// Ideally the $users model object would provide a validate() but for the sake
// of the example
if (is_array($users)) {
  throw new MyWrongTypeException('$users', $users, 'array')
  // returns 
  //"Wrong Type: $users. Expected array, received string
}

und wir könnten so etwas wie ein nl2br in einem benutzerdefinierten Exception-Handler tun, um die Dinge schön für HTML-Ausgabe zu machen.

gelesen: http://msdn.microsoft.com/en-us/library/cc511859. aspx #

Und es gibt keine Erwähnung von etwas Derartiges, so vielleicht ist es eine schlechte Idee ...

Answer 1

ich den Rat auf Krzysztof Blog wird dringend empfohlen und würde beachten Sie, dass in Ihrem Fall scheinen versuchen zu werden, zu beschäftigen, was er Usage Fehler.

In diesem Fall, was erforderlich ist, ist nicht eine neue Art, um anzuzeigen, aber eine bessere Fehlermeldung darüber, was es verursachte. Als eine solche Hilfsfunktion entweder:

1. erzeugen, um die Textzeichenfolge in die Ausnahme zu platzieren
2. erzeugen, um die ganze Ausnahme und Meldung

Ist das, was erforderlich ist.

Ansatz 1 ist klarer, sondern kann auch auf eine wenig ausführlichen Nutzung führen, 2 ist das Gegenteil, eine knappere Syntax für weniger Klarheit handeln.

Beachten Sie, dass die Funktionen müssen extrem sicher sein (sie sollten niemals eine unabhängige Ausnahme verursachen selbst) und nicht die Bereitstellung von Daten erzwingen, die in bestimmten angemessenen Anwendungen ist optional.

Mit jedem dieser Ansätze verwenden Sie erleichtern die Fehlermeldung später internationalisieren, falls erforderlich.

Ein Stack-Trace auf ein Minimum gibt Ihnen die Funktion und möglicherweise die Zeilennummer, so sollten Sie sich auf die Bereitstellung von Informationen konzentrieren, die nicht leicht zu arbeiten, von dem ist.

Answer 2

Ich werde nicht von der Beratung in Bezug auf Krzysztof Blog ablenken, aber hier ist eine tote einfache Möglichkeit, benutzerdefinierte Ausnahmen zu erstellen.

Beispiel:

<?php
   require_once "CustomException.php";
   class SqlProxyException extends CustomException {}

   throw new SqlProxyException($errorMsg, mysql_errno());     
?>

Der Code dahinter (die ich irgendwo geliehen, Entschuldigungen zu wem auch immer das war)

<?php

interface IException
{
    /* Protected methods inherited from Exception class */
    public function getMessage();                 // Exception message
    public function getCode();                    // User-defined Exception code
    public function getFile();                    // Source filename
    public function getLine();                    // Source line
    public function getTrace();                   // An array of the backtrace()
    public function getTraceAsString();           // Formated string of trace

    /* Overrideable methods inherited from Exception class */
    public function __toString();                 // formated string for display
    public function __construct($message = null, $code = 0);
}

abstract class CustomException extends Exception implements IException
{
    protected $message = 'Unknown exception';     // Exception message
    private   $string;                            // Unknown
    protected $code    = 0;                       // User-defined exception code
    protected $file;                              // Source filename of exception
    protected $line;                              // Source line of exception
    private   $trace;                             // Unknown

    public function __construct($message = null, $code = 0)
    {
        if (!$message) {
            throw new $this('Unknown '. get_class($this));
        }
        parent::__construct($message, $code);
    }

    public function __toString()
    {
        return get_class($this) . " '{$this->message}' in {$this->file}({$this->line})\n"
                                . "{$this->getTraceAsString()}";
    }
}

Answer 3

Siehe Wie Exception Hierarchies zum Design auf der Blog von Krzysztof Cwalina, Co-Autor von "Framework Design Guidelines".

Answer 4

Nie, vertrauen immer einen Benutzer zu ‚das Richtige zu tun‘, und Informationen für die Fehlersuche enthalten. Wenn Sie Informationen wünschen, müssen Sie sie selbst sammeln und speichern sie irgendwo, wo seine zugänglich.

Auch wie gesagt, wenn es schwer (er) ist, etwas zu tun, vermeiden die Benutzer es zu tun, so wieder, hängen nicht von ihrem guten Willen und ihrem Wissen von dem, was sie brauchen, zu senden.

impliziert Dieses Denken eine Methode, mit der Sie die Informationen sammeln und melden Sie es, die irgendwo mit var_dump () impliziert.

Auch, wie der von Mark Harrison, eine Taste, die es einfach macht, irgendwo ist fantastisch für Sie und für die Benutzer eine Fehlermeldung zu senden. Es macht es ihnen leicht, einen Fehler zu melden. Sie (als Empfänger) eine Menge Duplikate, aber doppelte Informationen sind besser als gar keine Informationen.

Answer 5

Allerdings viel Detail, das Sie hinzufügen möchten, sicher sein und entweder

• macht es einfach, die ganze Sache zu schneiden und zu kleben, oder
• haben einen Knopf, der den Fehler für sie berichten