Wirf das Objekt auf T.

Ich analysiere eine XML-Datei mit der XmlReaderKlasse in .NET und dachte, es wäre klug, eine generische Analysefunktion zu schreiben, um verschiedene Attribute generisch zu lesen. Ich habe mir folgende Funktion ausgedacht:

private static T ReadData<T>(XmlReader reader, string value)
{
    reader.MoveToAttribute(value);
    object readData = reader.ReadContentAsObject();
    return (T)readData;
}

Wie mir klar wurde, funktioniert dies nicht ganz so, wie ich es geplant habe. Bei primitiven Typen wie intoder doublewird ein Fehler ausgegeben , da eine Umwandlung nicht von einem stringin einen numerischen Typ konvertiert werden kann . Gibt es eine Möglichkeit für meine Funktion, sich in modifizierter Form durchzusetzen?

Überprüfen Sie zuerst, ob es gegossen werden kann.

if (readData is T) {
    return (T)readData;
} 
try {
   return (T)Convert.ChangeType(readData, typeof(T));
} 
catch (InvalidCastException) {
   return default(T);
}

Haben Sie Convert.ChangeType ausprobiert ?

Wenn die Methode immer eine Zeichenfolge zurückgibt, die ich merkwürdig finde, aber das ist nicht der Punkt, dann würde dieser geänderte Code möglicherweise das tun, was Sie wollen:

private static T ReadData<T>(XmlReader reader, string value)
{
    reader.MoveToAttribute(value);
    object readData = reader.ReadContentAsObject();
    return (T)Convert.ChangeType(readData, typeof(T));
}

Versuchen

if (readData is T)
    return (T)(object)readData;

Möglicherweise muss der Typ ein Referenztyp sein:

 private static T ReadData<T>(XmlReader reader, string value) where T : class
 {
     reader.MoveToAttribute(value);
     object readData = reader.ReadContentAsObject();
     return (T)readData;
 }

Und dann machen Sie eine andere, die Werttypen und TryParse verwendet ...

 private static T ReadDataV<T>(XmlReader reader, string value) where T : struct
 {
     reader.MoveToAttribute(value);
     object readData = reader.ReadContentAsObject();
     int outInt;
     if(int.TryParse(readData, out outInt))
        return outInt
     //...
 }

Tatsächlich ist das Problem hier die Verwendung von ReadContentAsObject. Leider entspricht diese Methode nicht ihren Erwartungen. Während es den am besten geeigneten Typ für den Wert erkennen sollte, gibt es tatsächlich eine Zeichenfolge zurück, egal was passiert (dies kann mit Reflector überprüft werden).

In Ihrem speziellen Fall kennen Sie jedoch bereits den Typ, in den Sie umwandeln möchten, daher würde ich sagen, dass Sie die falsche Methode verwenden.

Versuchen Sie stattdessen, ReadContentAs zu verwenden. Es ist genau das, was Sie brauchen.

private static T ReadData<T>(XmlReader reader, string value)
{
    reader.MoveToAttribute(value);
    object readData = reader.ReadContentAs(typeof(T), null);
    return (T)readData;
}

Vermutlich können Sie als Parameter einen Delegaten übergeben, der von Zeichenfolge in T konvertiert.

Fügen Sie eine 'Klassen'-Einschränkung hinzu (oder detaillierter, wie eine Basisklasse oder eine Schnittstelle Ihrer erwarteten T-Objekte):

private static T ReadData<T>(XmlReader reader, string value) where T : class
{
    reader.MoveToAttribute(value);
    object readData = reader.ReadContentAsObject();
    return (T)readData;
}

oder where T : IMyInterfaceoder where T : new()usw.

Tatsächlich werfen die Antworten eine interessante Frage auf, die Ihre Funktion im Fehlerfall erfüllen soll.

Vielleicht wäre es sinnvoller, es in Form einer TryParse-Methode zu konstruieren, die versucht, in T einzulesen, aber false zurückgibt, wenn dies nicht möglich ist?

    private static bool ReadData<T>(XmlReader reader, string value, out T data)
    {
        bool result = false;
        try
        {
            reader.MoveToAttribute(value);
            object readData = reader.ReadContentAsObject();
            data = readData as T;
            if (data == null)
            {
                // see if we can convert to the requested type
                data = (T)Convert.ChangeType(readData, typeof(T));
            }
            result = (data != null);
        }
        catch (InvalidCastException) { }
        catch (Exception ex)
        {
            // add in any other exception handling here, invalid xml or whatnot
        }
        // make sure data is set to a default value
        data = (result) ? data : default(T);
        return result;
    }

edit: muss ich jetzt, wo ich darüber nachdenke, wirklich den convert.changetype-Test durchführen? versucht die as-Zeile das nicht schon? Ich bin mir nicht sicher, ob dieser zusätzliche Änderungsaufruf tatsächlich etwas bewirkt. Tatsächlich kann dies nur den Verarbeitungsaufwand erhöhen, indem eine Ausnahme generiert wird. Wenn jemand einen Unterschied kennt, der es wert macht, geschrieben zu werden!