Probleme mit Nullable-Typen, DBNulls-und Daten-Zeilen

Sah ich dieser thread auf Stack Overflow bezüglich der Konvertierung zwischen DBNull und nullable-Typen, aber ich bin immer noch verwirrt. Ich habe code geschrieben, wie dies mit einigen hack-code zum Umgang mit nullable-Typen für DateTime-und int-Werte, die ich unten zeigen werde, aber es ist eine Sauerei, und ich will verwenden von auf null festlegbaren Typen:

 DataTable dt = ds.Tables[0];
 List<RON> list = (from dr in dt.AsEnumerable()
                              select new RON
                              {
                                  RONId = dr[0].ToString(),
                                  StaffNumber = dr[1].ToString(),
                                  CheckInDate = GetCheckInDate(dr[2]),
                                  NonMissionIndicator = dr[3].ToString(),
                                  Comments = dr[4].ToString(),
                                  NonComplyIndicator = dr[5].ToString(),
                                  LOAirport = dr[6].ToString(),
                                  RONAirport = dr[7].ToString(),
                                  PropertyId = GetPropertyId(dr[8]),
                                  PropertyChain = dr[9].ToString(),
                                  PropertyName = dr[10].ToString(),
                                  PropertyStreet = dr[11].ToString(),
                                  PropertyStreet2 = dr[12].ToString(),
                                  PropertyCity = dr[13].ToString(),
                                  PropertyState = dr[14].ToString(),
                                  PropertyPostalCode = dr[15].ToString(),
                                  PropertyPhone = dr[16].ToString(),
                                  FAX = dr[17].ToString(),
                                  PropertyCountry = dr[18].ToString(),
                                  PropertyLongitude = GetPropertyLongitude(dr[19]),
                                  PropertyLatitude = GetPropertyLatitude(dr[20]),
                                  PropertyAirport = dr[21].ToString(),
                                  ReportedBy = dr[22].ToString(),
                                  ReportedDTS= GetReportedByDate(dr[23]),
                                  CanceledBy = dr[24].ToString(),
                                  CanceledDTS = GetCanceledByDate(dr[25])
                              }).ToList();
            return list;
        }

        //TODO: Change Defaukt date
        private static DateTime GetCheckInDate(object checkInDate)
        {
            return checkInDate == DBNull.Value ? new DateTime(2000, 1, 1, 00, 00, 00) : Convert.ToDateTime(checkInDate);
        }

        //TODO: Change Defaukt date
        private static DateTime GetReportedByDate(object reportedByDate)
        {
            return reportedByDate == DBNull.Value ? new DateTime(2000, 1, 1, 00, 00, 00) : Convert.ToDateTime(reportedByDate);
        }

        //TODO: Change Defaukt date
        private static DateTime GetCanceledByDate(object canceledByDate)
        {
            return canceledByDate == DBNull.Value ? new DateTime(2000, 1, 1, 00, 00, 00) : Convert.ToDateTime(canceledByDate);
        }

        private static Int32 GetPropertyId(object propertyId)
        {
            return propertyId == DBNull.Value ? 0 : Convert.ToInt32(propertyId);
        }

        private static double GetPropertyLongitude(object propertyLongitude)
        {
            return propertyLongitude == DBNull.Value ? 0.0 : Convert.ToDouble(propertyLongitude);
        }

        private static double GetPropertyLatitude(object propertyLatitude)
        {
            return propertyLatitude == DBNull.Value ? 0.0 : Convert.ToDouble(propertyLatitude);
        }

RON ist nun definiert als:

public class RON
    {
        public string RONId { get; set; }
        public string StaffNumber { get; set; }
        public DateTime CheckInDate { get; set; }
        public string NonMissionIndicator { get; set; }
        public string NonComplyIndicator { get; set; }
        public string LOAirport { get; set; }
        public string RONAirport { get; set; }
        public int PropertyId { get; set; }
        public string PropertyChain { get; set; }
        public string PropertyName { get; set; }
        public string PropertyStreet { get; set; }
        public string PropertyStreet2 { get; set; }
        public string PropertyCity { get; set; }
        public string PropertyState { get; set; }
        public string PropertyPostalCode { get; set; }
        public string PropertyCountry { get; set; }
        public string PropertyPhone { get; set; }
        public string FAX { get; set; }
        public double PropertyLongitude { get; set; }
        public double PropertyLatitude { get; set; }
        public string PropertyAirport { get; set; }
        public string ReportedBy { get; set; }
        public DateTime ReportedDTS { get; set; }
        public string CanceledBy { get; set; }
        public DateTime CanceledDTS { get; set; }
        public string Comments { get; set; }

Den Datenbank-Typ erzählt mir, dass dies die Rückkehr von Oracle in das DataSet/cursor:

 RON_ID                                    NOT NULL VARCHAR2(40)
 STAFF_NUM                                 NOT NULL VARCHAR2(12)
 CHECKIN_DATE                              NOT NULL DATE
 NONMISSION_IND                            NOT NULL VARCHAR2(1)
 COMMENTS                                           VARCHAR2(4000)
 NONCOMPLY_IND                                      VARCHAR2(4000)
 PROPERTY_ID                               NOT NULL NUMBER(38)
 PROPERTY_CHAIN                                     VARCHAR2(2)
 PROPERTY_NAME                                      VARCHAR2(255)
 RON_AIRPORT                               NOT NULL VARCHAR2(3)
 PROPERTY_STREET                                    VARCHAR2(255)
 PROPERTY_STREET2                                   VARCHAR2(255)
 PROPERTY_CITY                                      VARCHAR2(255)
 PROPERTY_STATE                                     VARCHAR2(3)
 PROPERTY_POSTALCODE                                VARCHAR2(255)
 PROPERTY_PHONE                                     VARCHAR2(20)
 PROPERTY_FAX                                       VARCHAR2(20)
 PROPERTY_COUNTRY                                   VARCHAR2(2)
 PROPERTY_LONGITUDE                                 NUMBER
 PROPERTY_LATITUDE                                  NUMBER
 PROPERTY_AIRPORT                                   VARCHAR2(3)
 REPORTED_BY                                        VARCHAR2(50)
 REPORTED_DTS                              NOT NULL DATE
 CANCELED_BY                                        VARCHAR2(50)
 CANCELED_DTS                                       DATE

Wie kann ich erklären RON mit Nullable-Typen, und wie kann ich Vorgänge mit Nullable-Termine und so? Tun Zeichenfolgen überprüft werden?

InformationsquelleAutor Sam Gentile | 2010-10-28

c#dataset nullable

7

Definieren Sie einen Wert-Typ (wie DateTime) als null...führen Sie einen der folgenden Schritte aus:
```
DateTime? ReportedDTS
```
ODER
```
Nullable<DateTime> ReportedDTS
```
Referenz-Typen (wie string) sind bereits "nullable".

Bekommen eine null-Wert aus einer DataRow Sie können die Feld-Erweiterung-Methode:
```
DateTime? nullableDate = dataRow.Field<DateTime?>("ColumnName");
```
Wird automatisch konvertieren DBNull zu null.

Also für dein Beispiel etwas wie:
```
select new RON
           {
               RONId = dr.Field<string>("RON_ID"),
               //snip...
               CheckInDate = dr.Field<DateTime?>("CHECKIN_DATE"),
               //snip...
           };
```
- Danke! So DateTime? nullableDate = dataRow.Feld<DateTime?>("ColumnName"); was wäre das in meinem Beispiel?
- Aktualisiert mein Beispiel....
- Ich habe eine "Angegebene Umwandlung ist ungültig."} [System.InvalidCastException]: {"Angegebene Umwandlung ist ungültig."} Data: {System.Sammlungen.ListDictionaryInternal} HelpLink: null InnerException: null Meldung: "die Angegebene Umwandlung ist ungültig." Quelle: "System.Daten.DataSetExtensions" StackTrace: "bei System.Daten.DataRowExtensions.UnboxT`1.NullableField[TElem](Object value)\\r \ \ n bei System.Daten.DataRowExtensions.Feld[T](Da
- ...wenn Sie versuchen zu tun CheckInDate = DZ.Feld<DateTime?>("CHECKIN_DATE") nach der Definition der Feld als DateTime?
- Naja...auf der Suche näher an Ihrem Beispiel das schema sagt CHECKIN_DATE als not NULL definiert ist. Keine Notwendigkeit zu ändern, dass man auf eine null-da kann es nie NULL in die Datenbank.
- So Canceled_DTS ist das einzige Feld, das ich zu befürchten, dass nach
- Ich würde diese Abstimmung bis zweimal, wenn ich könnte. Lebensretter!
InformationsquelleAutor Dismissile
1

Bei der Beurteilung Ihres ursprünglichen Frage, ich sehe, dass ein Fehler tritt auf, wenn .ToString() genannt wird, auf einen null-Wert.
```
Dies geschieht, wenn das dataset-Feld einen Wert DBNULL. 
Der Beste Ansatz ist, um auf null zu testen, zuerst vor dem Aufruf von beliebigen Methoden für das Objekt. 
also
```
DataTable dt = ds.Tables[0]; List<RON> list = (from dr in dt.AsEnumerable() select new RON { RONId = dr.IsNull("RONid") ? "0" : dr.Field<String>("RONid"), StaffNumber = dr.IsNull("StaffNumber") ? "0" : dr.Field<String>("StaffNumber"), ... etc, ... etc }).ToList(); return list; }

PS:
- Probe-dataset für den Bereich Werte zu entsprechen. Hier nahm ich an, dass Ihr dataset "ColumnName" hatte den gleichen Namen wie die variable übergeben wird, aber das ist nicht immer der Fall.
- Wort der Beratung, verwenden Sie "ColumnName" anstelle von index, da der index kann sich ändern, wenn db-änderungen, gespeicherte Prozedur oder die Abfrage ändert.
InformationsquelleAutor Mambo
0

Als nur Wert-Typen gemacht werden können Nullable, werden Sie nicht haben, etwas zu tun spezielle für Streicher. Primitive Typen (und DateTime), erklärt werden kann null-Werte zulässt, indem ein Fragezeichen hinter Ihren Namen eingeben, wie int? NullableNumber { get; set; }.
- Danke, das ist was ich dachte
InformationsquelleAutor Ben

Müssen Sie möglicherweise zu vergleichen mit DBNull vor der Zuweisung entweder zu einem DateTime-oder null -

myNullableDate = (DBNull.Value == list.Field<object>("FOO"))
          ? null 
          : (DateTime?)list.Field<DateTime?>("FOO");

InformationsquelleAutor Arduinerd

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.