C# DBNull und nullable-Typen - die sauberste form der Umwandlung

Ich habe eine DataTable, die eine Anzahl von Spalten. Einige dieser Spalten null-Werte zulassen.

DataTable dt;  //Value set. 
DataRow dr;  //Value set. 

//dr["A"] is populated from T-SQL column defined as: int NULL

Was ist dann die reinste form der Umwandlung von einem Wert in einer DataRow, an eine null-variable.

Im Idealfall würde ich in der Lage sein, etwas zu tun:

int? a = dr["A"] as int?;

Bearbeiten: Stellt sich heraus, KÖNNEN Sie dies tun, wird der Nebeneffekt, dass, wenn Sie Ihre Schema-Typen sorglosen ints, dann ist dies IMMER null zurück. Die Antwort von Ruben mit dr.Field<int?>("A") sorgt type mismatch nicht im hintergrund fehl. Dies ist natürlich abgeholt werden, durch eine umfassende unit-tests.

Stattdessen bin ich in der Regel die Eingabe etwas entlang der Linien von:

int? a = dr["A"] != DBNull.Value ? (int)dr["A"] : 0;

Dies ist ein paar Tastenanschläge, aber noch wichtiger ist, es gibt mehr Raum für jemanden, der Sachen etwas mit einem falschen Tastendruck.
Ja, ein Unit-Test wird das abholen, aber ich würde lieber aufhören, es insgesamt.

Was ist die sauberste und am wenigsten fehleranfällig Muster für diese situation.

InformationsquelleAutor der Frage | 2009-11-10

c#datatable nullable types

52

Die LINQ to DataSets Kapitel von LINQ in Action ist gut zu Lesen.

Eine Sache, die Sie sehen werden, ist die Field<T> Erweiterung Methode wird wie folgt verwendet:-
```
int? x = dr.Field<int?>( "Field" );
```
Oder
```
int y = dr.Field<int?>( "Field" ) ?? 0;
```
Oder
```
var z = dr.Field<int?>( "Field" );
```
InformationsquelleAutor der Antwort Ruben Bartelink
11

Dies ist der Zweck der DataRowExtensions Klasse .NET 3.5, bietet statische Field<T> und SetField<T> Methoden für die "round-tripping" nullable (und ungleich null) Daten zwischen den DataRow und .NET-Typen.
```
int? fld = row.Field<int?>("ColumnA")
```
wird festgelegt fld zu null wenn row["ColumnA"] enthält DBNull.Valueum seinen Wert, wenn es enthält ein integer, und eine Ausnahme werfen, wenn er etwas anderes enthält. Und auf dem Weg zurück,
```
row.SetField("ColumnA", fld);
```
tut das gleiche in umgekehrter Richtung: wenn fld enthält null setzt row["ColumnA"] zu DBNull.Value wird, und andernfalls setzt es auf den Wert der fld.

Es gibt überladungen der Field und SetField für alle die Wert-Typen, die DataRow unterstützt (einschließlich non-nullable-Typen), so können Sie verwenden Sie den gleichen Mechanismus für den Zugriff und die Einstellung der Felder unabhängig Ihre Daten geben.

InformationsquelleAutor der Antwort Robert Rossney
4
```
int? a = (int?)dr["A"]
```
InformationsquelleAutor der Antwort bniwredyc
1

Warum nicht mit LINQ? Es führt die Konvertierung für Sie.

InformationsquelleAutor der Antwort stepanian

Folgenden arbeiten würde, sicher:

Snip:

public static class SqlDataReaderEx
{
    public static int TryParse(SqlDataReader drReader, string strColumn, int nDefault)
    {
        int nOrdinal = drReader.GetOrdinal(strColumn);
        if (!drReader.IsDbNull(nOrdinal))
            return drReader.GetInt32(nOrdinal);
        else
            return nDefault;
    }
}

Verwendung:

SqlDataReaderEx.TryParse(drReader, "MyColumnName", -1);

InformationsquelleAutor der Antwort KMån

Erweiterung Methoden!

Etwas wie die folgenden:

public static class DataRowExtensions
{
    public static Nullable<T> GetNullableValue<T>(this DataRow row, string columnName)
        where T : struct
    {
        object value = row[columnName];
        if (Convert.IsDBNull(value))
            return null;

        return (Nullable<T>)value;
    }

    public static T GetValue<T>(this DataRow row, string columnName)
        where T : class
    {
        object value = row[columnName];
        if (Convert.IsDBNull(value))
            return null;

        return (T)value;
    }
}

Verwenden Sie es wie so:

int? a = dr.GetNullableValue<int>("A");

oder

string b = dr.GetValue<string>("B");

InformationsquelleAutor der Antwort Brannon

-1

public static object GetColumnValue(this DataRow row, string columnName)
{
    if (row.Table.Columns.Contains(columnName))
    {
        if (row[columnName] == DBNull.Value)
        {
            if (row.Table.Columns[columnName].DataType.IsValueType)
            {
                return Activator.CreateInstance(row.Table.Columns[columnName].DataType);
            }
            else
            {
                return null;
            }
        }
        else
        {
            return row[columnName];
        }
    }
    return null;
}

Aufruf der Funktion, die Sie schreiben konnte

var dt = new DataTable();
dt.Columns.Add("ColumnName");
....
Add rows in Datatable.
....
dt.Rows[0].GetColumnValue("ColumnName);

InformationsquelleAutor der Antwort Chetan Mandhania

-4

   Chart.data = new List < int ?> ();
   Chart.data = (from DataRow DR in _dtChartData.Rows
    select(int ? )((DR[_ColumnName] == DBNull.Value) ? (int ? ) null : (int ? ) DR[_ColumnName])).ToList();

InformationsquelleAutor der Antwort Nilesh S

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.