Lancia l'oggetto su T

Sto analizzando un file XML con la XmlReaderclasse in .NET e ho pensato che sarebbe stato intelligente scrivere una funzione di analisi generica per leggere diversi attributi in modo generico. Ho ideato la seguente funzione:

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

Come ho capito, questo non funziona del tutto come avevo pianificato; genera un errore con tipi primitivi come into double, poiché un cast non può convertire da a stringin un tipo numerico. Esiste un modo per far prevalere la mia funzione in forma modificata?

Prima controlla per vedere se può essere lanciato.

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

Hai provato Convert.ChangeType ?

Se il metodo restituisce sempre una stringa, che trovo strano, ma questo è oltre il punto, allora forse questo codice modificato farebbe quello che vuoi:

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

provare

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

Potresti richiedere che il tipo sia un tipo di riferimento:

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

E poi fai un altro che usa i tipi di valore e TryParse ...

 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
     //...
 }

In realtà, il problema qui è l'uso di ReadContentAsObject. Sfortunatamente, questo metodo non è all'altezza delle sue aspettative; mentre dovrebbe rilevare il tipo più appropriato per il valore, in realtà restituisce una stringa, qualunque cosa accada (questo può essere verificato usando Reflector).

Tuttavia, nel tuo caso specifico, conosci già il tipo a cui vuoi eseguire il cast, quindi direi che stai usando il metodo sbagliato.

Prova a usare ReadContentAs invece, è esattamente ciò di cui hai bisogno.

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

È presumibilmente possibile passare, come parametro, un delegato che convertirà da stringa a T.

Aggiungi un vincolo di "classe" (o più dettagliato, come una classe base o un'interfaccia dei tuoi oggetti T previsti):

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

o where T : IMyInterfaceo where T : new(), ecc

In realtà, le risposte sollevano una domanda interessante, che è ciò che vuoi che la tua funzione faccia in caso di errore.

Forse avrebbe più senso costruirlo sotto forma di un metodo TryParse che tenta di leggere in T, ma restituisce false se non può essere fatto?

    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;
    }

modifica: ora che ci penso, ho davvero bisogno di fare il test convert.changetype? la linea as non prova già a farlo? Non sono sicuro che questa chiamata aggiuntiva al changetype realizzi effettivamente qualcosa. In realtà, potrebbe semplicemente aumentare il sovraccarico di elaborazione generando un'eccezione. Se qualcuno sa di una differenza che vale la pena fare, per favore pubblica!