SQL Data Reader - manipulação de valores de coluna nulos

Estou usando um SQLdatareader para criar POCOs a partir de um banco de dados. O código funciona, exceto quando encontra um valor nulo no banco de dados. Por exemplo, se a coluna Nome no banco de dados contiver um valor nulo, uma exceção será lançada.

employee.FirstName = sqlreader.GetString(indexFirstName);

Qual é a melhor maneira de lidar com valores nulos nessa situação?

Você precisa verificar IsDBNull:

if(!SqlReader.IsDBNull(indexFirstName))
{
  employee.FirstName = sqlreader.GetString(indexFirstName);
}

Essa é sua única maneira confiável de detectar e lidar com essa situação.

Eu agrupei essas coisas em métodos de extensão e tendem a retornar um valor padrão se a coluna for realmente null:

public static string SafeGetString(this SqlDataReader reader, int colIndex)
{
   if(!reader.IsDBNull(colIndex))
       return reader.GetString(colIndex);
   return string.Empty;
}

Agora você pode chamar assim:

employee.FirstName = SqlReader.SafeGetString(indexFirstName);

e você nunca precisará se preocupar com uma exceção ou um nullvalor novamente.

Você deve usar o asoperador combinado com o ??operador para valores padrão. Os tipos de valor precisarão ser lidos como anuláveis ​​e receber um padrão.

employee.FirstName = sqlreader[indexFirstName] as string;
employee.Age = sqlreader[indexAge] as int? ?? default(int);

O asoperador lida com a transmissão, incluindo a verificação de DBNull.

Para uma string, você pode simplesmente converter a versão do objeto (acessada usando o operador array) e terminar com uma string nula para valores nulos:

employee.FirstName = (string)sqlreader[indexFirstName];

ou

employee.FirstName = sqlreader[indexFirstName] as string;

Para números inteiros, se você converter para um int nulo, poderá usar GetValueOrDefault ()

employee.Age = (sqlreader[indexAge] as int?).GetValueOrDefault();

ou o operador de coalescência nula ( ??).

employee.Age = (sqlreader[indexAge] as int?) ?? 0;

IsDbNull(int)geralmente é muito mais lento do que usar métodos como GetSqlDateTimee comparar DBNull.Value. Experimente estes métodos de extensão para SqlDataReader.

public static T Def<T>(this SqlDataReader r, int ord)
{
    var t = r.GetSqlValue(ord);
    if (t == DBNull.Value) return default(T);
    return ((INullable)t).IsNull ? default(T) : (T)t;
}

public static T? Val<T>(this SqlDataReader r, int ord) where T:struct
{
    var t = r.GetSqlValue(ord);
    if (t == DBNull.Value) return null;
    return ((INullable)t).IsNull ? (T?)null : (T)t;
}

public static T Ref<T>(this SqlDataReader r, int ord) where T : class
{
    var t = r.GetSqlValue(ord);
    if (t == DBNull.Value) return null;
    return ((INullable)t).IsNull ? null : (T)t;
}

Use-os assim:

var dd = r.Val<DateTime>(ords[4]);
var ii = r.Def<int>(ords[0]);
int nn = r.Def<int>(ords[0]);

Uma maneira de fazer isso é procurar nulos db:

employee.FirstName = (sqlreader.IsDBNull(indexFirstName) 
    ? ""
    : sqlreader.GetString(indexFirstName));

reader.IsDbNull(ColumnIndex) funciona como muitas respostas diz.

E quero mencionar que, se você trabalha com nomes de colunas, apenas comparar tipos pode ser mais confortável.

if(reader["TeacherImage"].GetType() == typeof(DBNull)) { //logic }

Acho que não há um valor de coluna NULL , quando as linhas são retornadas em um datareader usando o nome da coluna.

Se você fizer datareader["columnName"].ToString();isso, sempre fornecerá um valor que pode ser uma sequência vazia ( String.Emptyse você precisar comparar).

Eu usaria o seguinte e não me preocuparia muito:

employee.FirstName = sqlreader["columnNameForFirstName"].ToString();

Esta solução é menos dependente do fornecedor e funciona com um SQL, OleDB e MySQL Reader:

public static string GetStringSafe(this IDataReader reader, int colIndex)
{
    return GetStringSafe(reader, colIndex, string.Empty);
}

public static string GetStringSafe(this IDataReader reader, int colIndex, string defaultValue)
{
    if (!reader.IsDBNull(colIndex))
        return reader.GetString(colIndex);
    else
        return defaultValue;
}

public static string GetStringSafe(this IDataReader reader, string indexName)
{
    return GetStringSafe(reader, reader.GetOrdinal(indexName));
}

public static string GetStringSafe(this IDataReader reader, string indexName, string defaultValue)
{
    return GetStringSafe(reader, reader.GetOrdinal(indexName), defaultValue);
}

O que costumo fazer é substituir os valores nulos na instrução SELECT por algo apropriado.

SELECT ISNULL(firstname, '') FROM people

Aqui substituo todo nulo por uma sequência em branco. Seu código não irá gerar erros nesse caso.

Você pode escrever uma função genérica para verificar nulo e incluir o valor padrão quando for nulo. Chame isso ao ler Datareader

public T CheckNull<T>(object obj)
        {
            return (obj == DBNull.Value ? default(T) : (T)obj);
        }

Ao ler o Datareader, use

                        while (dr.Read())
                        {
                            tblBPN_InTrRecon Bpn = new tblBPN_InTrRecon();
                            Bpn.BPN_Date = CheckNull<DateTime?>(dr["BPN_Date"]);
                            Bpn.Cust_Backorder_Qty = CheckNull<int?>(dr["Cust_Backorder_Qty"]);
                            Bpn.Cust_Min = CheckNull<int?>(dr["Cust_Min"]);
                         }

Verifique sqlreader.IsDBNull(indexFirstName)antes de tentar lê-lo.

Ao influenciar na resposta de getpsyched , criei um método genérico que verifica o valor da coluna pelo nome

public static T SafeGet<T>(this System.Data.SqlClient.SqlDataReader reader, string nameOfColumn)
{
  var indexOfColumn = reader.GetOrdinal(nameOfColumn);
  return reader.IsDBNull(indexOfColumn) ? default(T) : reader.GetFieldValue<T>(indexOfColumn);
}

Uso:

var myVariable = SafeGet<string>(reader, "NameOfColumn")

sobre como criar métodos auxiliares

For String

private static string MyStringConverter(object o)
    {
        if (o == DBNull.Value || o == null)
            return "";

        return o.ToString();
    }

Uso

MyStringConverter(read["indexStringValue"])

Para Int

 private static int MyIntonverter(object o)
    {
        if (o == DBNull.Value || o == null)
            return 0;

        return Convert.ToInt32(o);
    }

Uso

MyIntonverter(read["indexIntValue"])

Para data

private static DateTime? MyDateConverter(object o)
    {
        return (o == DBNull.Value || o == null) ? (DateTime?)null : Convert.ToDateTime(o);
    }

Uso

MyDateConverter(read["indexDateValue"])

Nota: para DateTime, declare varialbe como

DateTime? variable;

Como complemento à resposta de marc_s, você pode usar um método de extensão mais genérico para obter valores do SqlDataReader:

public static T SafeGet<T>(this SqlDataReader reader, int col)
    {
        return reader.IsDBNull(col) ? default(T) : reader.GetFieldValue<T>(col);
    }

Eu acho que você gostaria de usar:

SqlReader.IsDBNull(indexFirstName)

Usamos uma série de métodos estáticos para extrair todos os valores de nossos leitores de dados. Então, neste caso, estaríamos chamandoDBUtils.GetString(sqlreader(indexFirstName)) O benefício de criar métodos estáticos / compartilhados é que você não precisa fazer as mesmas verificações repetidas vezes ...

O (s) método (s) estático (s) conteria código para verificar se há nulos (consulte outras respostas nesta página).

Você pode usar o operador condicional:

employee.FirstName = sqlreader["indexFirstName"] != DBNull.Value ? sqlreader[indexFirstName].ToString() : "";

Há muitas respostas aqui com informações úteis (e algumas informações erradas) espalhadas, eu gostaria de reunir tudo.

A resposta curta para a pergunta é verificar o DBNull - quase todo mundo concorda com esse bit :)

Em vez de usar um método auxiliar para ler valores anuláveis ​​por tipo de dados SQL, um método genérico nos permite abordar isso com muito menos código. No entanto, você não pode ter um único método genérico para os tipos de valor anulável e de referência. Isso é discutido detalhadamente no tipo Nullable como um parâmetro genérico possível. e restrição de tipo genérico C # para tudo que pode ser anulado .

Portanto, seguindo as respostas de @ZXX e @getpsyched, terminamos com dois métodos para obter valores anuláveis ​​e adicionei um terceiro para valores não nulos (ele completa o conjunto com base na nomeação de métodos).

public static T? GetNullableValueType<T>(this SqlDataReader sqlDataReader, string columnName) where T : struct
{
    int columnOrdinal = sqlDataReader.GetOrdinal(columnName);
    return sqlDataReader.IsDBNull(columnOrdinal) ? (T?)null : sqlDataReader.GetFieldValue<T>(columnOrdinal);
}

public static T GetNullableReferenceType<T>(this SqlDataReader sqlDataReader, string columnName) where T : class
{
    int columnOrdinal = sqlDataReader.GetOrdinal(columnName);
    return sqlDataReader.IsDBNull(columnOrdinal) ? null : sqlDataReader.GetFieldValue<T>(columnOrdinal);
}

public static T GetNonNullValue<T>(this SqlDataReader sqlDataReader, string columnName)
{
    int columnOrdinal = sqlDataReader.GetOrdinal(columnName);
    return sqlDataReader.GetFieldValue<T>(columnOrdinal);
}

Eu geralmente uso nomes de colunas, altere-os se você usar índices de colunas. Com base nesses nomes de método, posso dizer se estou esperando que os dados sejam anuláveis ​​ou não, o que é bastante útil quando se olha o código escrito há muito tempo.

Dicas;

• Não ter colunas anuláveis ​​no banco de dados evita esse problema. Se você tiver controle sobre o banco de dados, as colunas deverão ser não nulas por padrão e somente nulas quando necessário.
• Não converta valores de banco de dados com o operador C # 'as' porque, se a conversão estiver incorreta, ela retornará silenciosamente nulo.
• O uso de uma expressão de valor padrão alterará os valores nulos do banco de dados para valores não nulos para tipos de valores como int, datetime, bit etc.

Por fim, ao testar os métodos acima em todos os tipos de dados do SQL Server, descobri que você não pode obter diretamente um char [] de um SqlDataReader; se você quiser um char [], precisará obter uma string e usar ToCharArray ().

Estou usando o código listado abaixo para manipular células nulas em uma planilha do Excel que é lida em uma tabela de dados.

if (!reader.IsDBNull(2))
{
   row["Oracle"] = (string)reader[2];
}

private static void Render(IList<ListData> list, IDataReader reader)
        {
            while (reader.Read())
            {

                listData.DownUrl = (reader.GetSchemaTable().Columns["DownUrl"] != null) ? Convert.ToString(reader["DownUrl"]) : null;
                //没有这一列时，让其等于null
                list.Add(listData);
            }
            reader.Close();
        }

e / ou usar operador ternário com atribuição:

employee.FirstName = rdr.IsDBNull(indexFirstName))? 
                     String.Empty: rdr.GetString(indexFirstName);

substitua o valor padrão (quando nulo) conforme apropriado para cada tipo de propriedade ...

Esse método depende do indexFirstName, que deve ser a coluna ordinal com base em zero.

if(!sqlReader.IsDBNull(indexFirstName))
{
  employee.FirstName = sqlreader.GetString(indexFirstName);
}

Se você não conhece o índice da coluna, mas não deseja verificar um nome, pode usar este método de extensão:

public static class DataRecordExtensions
{
    public static bool HasColumn(this IDataRecord dr, string columnName)
    {
        for (int i=0; i < dr.FieldCount; i++)
        {
            if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase))
                return true;
        }
        return false;
    }
}

E use o método como este:

if(sqlReader.HasColumn("FirstName"))
{
  employee.FirstName = sqlreader["FirstName"];
}

Pergunta antiga, mas talvez alguém ainda precise de uma resposta

na verdade, eu trabalhei em torno desta questão assim

Para int:

public static object GatDataInt(string Query, string Column)
    {
        SqlConnection DBConn = new SqlConnection(ConnectionString);
        if (DBConn.State == ConnectionState.Closed)
            DBConn.Open();
        SqlCommand CMD = new SqlCommand(Query, DBConn);
        SqlDataReader RDR = CMD.ExecuteReader();
        if (RDR.Read())
        {
            var Result = RDR[Column];
            RDR.Close();
            DBConn.Close();
            return Result;
        }
        return 0;
    }

o mesmo para a string, basta retornar "" em vez de 0, pois "" é uma string vazia

então você pode usá-lo como

int TotalPoints = GatDataInt(QueryToGetTotalPoints, TotalPointColumn) as int?;

e

string Email = GatDatastring(QueryToGetEmail, EmailColumn) as string;

muito flexível para que você possa inserir qualquer consulta para ler qualquer coluna e ela nunca retornará com erro

Aqui está a classe auxiliar que outras pessoas podem usar se precisarem, com base na resposta @marc_s:

public static class SQLDataReaderExtensions
    {
        public static int SafeGetInt(this SqlDataReader dataReader, string fieldName)
        {
            int fieldIndex = dataReader.GetOrdinal(fieldName);
            return dataReader.IsDBNull(fieldIndex) ? 0 : dataReader.GetInt32(fieldIndex);
        }

        public static int? SafeGetNullableInt(this SqlDataReader dataReader, string fieldName)
        {
            int fieldIndex = dataReader.GetOrdinal(fieldName);
            return dataReader.GetValue(fieldIndex) as int?;
        }

        public static string SafeGetString(this SqlDataReader dataReader, string fieldName)
        {
            int fieldIndex = dataReader.GetOrdinal(fieldName);
            return dataReader.IsDBNull(fieldIndex) ? string.Empty : dataReader.GetString(fieldIndex);
        }

        public static DateTime? SafeGetNullableDateTime(this SqlDataReader dataReader, string fieldName)
        {
            int fieldIndex = dataReader.GetOrdinal(fieldName);
            return dataReader.GetValue(fieldIndex) as DateTime?;
        }

        public static bool SafeGetBoolean(this SqlDataReader dataReader, string fieldName)
        {
            return SafeGetBoolean(dataReader, fieldName, false);
        }

        public static bool SafeGetBoolean(this SqlDataReader dataReader, string fieldName, bool defaultValue)
        {
            int fieldIndex = dataReader.GetOrdinal(fieldName);
            return dataReader.IsDBNull(fieldIndex) ? defaultValue : dataReader.GetBoolean(fieldIndex);
        }
    }

O Convert lida com DbNull de maneira sensata.

employee.FirstName = Convert.ToString(sqlreader.GetValue(indexFirstName));

você já pode verificar isso também

if(null !=x && x.HasRows)
{ ....}