Conseils sur la création d'une recherche de code d'erreur en C #

Question

Je suis nouveau dans C # et donc pardonnez-moi si j'ai des concepts biaisés. Je travaille avec le canon EDSDK, et pour faciliter la vie, je voudrais pouvoir voir des messages d'erreur comme des valeurs de texte plutôt que hexadécimales. Le fichier edsdk.cs contient une longue liste d'erreurs telles que:

public const uint EDS_ERR_TAKE_PICTURE_CARD_NG = 0x00008D07;
public const uint EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG = 0x00008D08;

Idéalement, j'aimerais mettre tous ces éléments dans une sorte de table de recherche afin que je puisse saisir un code d'erreur hexagonal et renvoyer le message réel en tant que chaîne. Par exemple

Hashtable EDSDKErrorCodes = new Hashtable();

EDSDKErrorCodes.Add("0x00008D01", "EDS_ERR_TAKE_PICTURE_AF_NG");
EDSDKErrorCodes.Add("0x00008D08", "EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG");
etc etc...

Plus tard dans mon code, je pouvais récupérer le message d'erreur renvoyé de l'une des méthodes EDSDK et l'afficher sous une forme lisible par humaine:

errorcode= EDSDK.EdsInitializeSDK();

MessageBox.Show(Convert.ToString(EDSDKErrorCodes[errorcode]));

Ma question est ... est-ce une bonne façon de gérer tous ces codes d'erreur ou y a-t-il un moyen meilleur et plus efficace que les gens recommanderaient? Si oui, comment je pourrais remplir ma table de hachage comme une série de constantes plutôt que d'avoir à utiliser la méthode ADD?

Answer 1

Vous pouvez utiliser une énumération pour cela.

public enum ErrorCodes : uint
{
    EDS_ERR_TAKE_PICTURE_CARD_NG = 0x00008D07,
    EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG = 0x00008D08
}

Ensuite, votre utilisation pourrait être quelque chose comme ce qui suit:

ErrorCodes error = (ErrorCodes)EDSDK.EdsInitializeSDK();
MessageBox.Show(Enum.GetName(typeof(ErrorCodes), error));

Answer 2

Une autre façon de le faire est de créer une énumération avec un attribut description. Voir ici pour tous les détails. Cela résume à quoi cela ressemblerait:

public enum ErrorCodes : uint
{
    [Description("Description for EDS_ERR_TAKE_PICTURE_CARD_NG")]
    EDS_ERR_TAKE_PICTURE_CARD_NG = 0x00008D07,
    [Description("Description for EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG")]
    EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG = 0x00008D08
}

Au plus simple, si vous ne vous souciez pas d'une description, vous pouvez convertir le nom d'énumération en chaîne en utilisant Enum.getName

Answer 3

Je pense que faire une énumération serait supérieur:

public enum CanonErrorCode
{
    SomeErrorDescription = 14,
    SomeOtherErrorDescription = 15
    // .. etc
}

Vous faites simplement la conversion de Hex en entier. Ensuite, vous pouvez simplement l'appeler comme ça:

// Samples
var myErrorCode = (CanonErrorCode)someIntegerValue;
var myErrorCode = CanonErrorCode.SomeOtherErrorDescription;

Si vous voulez des descriptions d'erreurs formatées humaines, je suggère une sorte de mappage comme:

static Dictionary<int, string> errorlookups = new Dictionary<int, string>();

errorLookups.Add(10, "This is the human readable error message.");
errorLookups.Add(17, "Create this guy once in a static constructor.");

Answer 4

Vous pouvez utiliser un dictionnaire générique au lieu d'un hashtable

Dictionary<uint, String> myDict = new Dictionary<uint, String>();

Vous pouvez ensuite récupérer la valeur que vous souhaitez en faisant

MessageBox.Show(myDict[errorCode]);

Pour ajouter, je pense que vous pourriez être en mesure de faire quelque chose avec réflexion pour réfléchir sur la classe EDSDK et trouver tous les membres constants de l'UINT. Ensuite, parcourez cette liste en ajoutant la valeur et le nom constant.

Answer 5

Ok, une autre prise depuis que nous roulons :-)
Cette solution produit également une chaîne d'erreur lisible par l'homme si le code d'erreur actuel n'est pas défini.

Créé un Enum ainsi:

public enum ErrorCode : uint
{
    EDS_ERR_TAKE_PICTURE_CARD_NG = 0x00008D07,
    EDS_ERR_TAKE_PICTURE_CARD_PROTECT_NG = 0x00008D08
}

Ensuite, créez un Méthode d'extension Pour le type d'énumération comme ceci:

public static class ErrorHandler
{
    public static string ToErrorString(this ErrorCode errorCode)
    {
        return Enum.IsDefined(typeof(ErrorCode), errorCode) ? 
            errorCode.ToString() : "Undefined error code";
    }
}

Et enfin, utilisez-le comme ça:

var errorCode = (ErrorCode)EDSDK.EdsInitializeSDK();
MessageBox.Show(errorCode.ToErrorString());

Answer 6

Tout d'abord, vous devez utiliser un dictionnaire générique au lieu d'un hashtable. Deuxièmement, je ne sais rien sur le canon EDSDK, mais il semble étrange qu'il renvoie un code d'erreur comme une chaîne hexagonale plutôt que simplement un UInt à mesure que les constantes sont définies. Est-ce vraiment ainsi qu'ils sont retournés? Si c'est le cas, c'est bizarre, mais vous devriez être en mesure de les convertir en un entier, sinon, vous pouvez ignorer cette étape.

Si vous souhaitez créer le tableau à l'aide de la réflexion, vous pouvez faire quelque chose comme ceci:

Dictionary<int,String> EDSDKErrorCodes = new Dictionary<int,String>;
System.Reflection.FieldInfo[] fields = typeof(EDSDK).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
foreach (System.Reflection.FieldInfo field in fields) {
  EDSDKErrorCodes[(uint)field.GetValue(null)] = field.Name;
}

Et vous pouvez ensuite y accéder en utilisant:

MessageBox.Show(EDSDKErrorCodes[errorCode]);

Si ErrorCode est une chaîne, convertissez-la d'abord en utilisant:

uint errorNumber = uint.Parse(errorCode.Substring(2), System.Globalization.NumberStyle.HexNumber);