C # DataRow vacío-cheque

Question

Tengo esto:

 DataTable dtEntity = CreateDataTable();
 drEntity = dtEntity.NewRow();

Luego añadir los datos de la fila (o no). Las porciones de código, realmente no saben si hay algo dentro de la fila. Depende de la entrada (Estoy importando de algunos archivos). Me gustaría hacer algo como:

 if (drEntity`s EVERY CELL IS NOT EMPTY)
 {
   dtEntity.Rows.Add(drEntity);
 }
 else
 {
   //don't add, will create a new one (drEntity = dtEntity.NewRow();)
 }

¿Hay alguna buena manera de comprobar si todas las células del DataRow está vacía? O debería foreach, y comprobar uno por uno?

Answer 1

Un método simple a lo largo de las líneas de:

bool AreAllColumnsEmpty(DataRow dr)
{
 if (dr == null)
 {
  return true;
 }
 else
 {
  foreach(var value in dr.ItemArray)
  {
    if (value != null)
    {
      return false;
    }
  }
  return true;
 }
}

En caso de darle lo que está buscando, y para que sea "buena" (ya que no hay nada por lo que yo sé, en el marco), que podría envolverlo como un método de extensión, y entonces su resultante código sería:

if (datarow.AreAllColumnsEmpty())
{
}
else
{
}

Answer 2

He creado un método de extensión (Gosh Me gustaría Java tenía estos) llamada IsEmpty de la siguiente manera:

public static bool IsEmpty(this DataRow row)
{
    return row == null || row.ItemArray.All(i => i is DBNull);
}

Las otras respuestas aquí son correctos. Me dio la sensación de minas prestó brevedad en su uso sucinta de LINQ a Objetos. Por cierto, esto es realmente útil en conjunción con el análisis de Excel ya que los usuarios pueden virar en una fila abajo de la página (miles de líneas) sin tener en cuenta la forma en que afecta a analizar los datos.

En la misma clase, puse otros ayudantes que he encontrado útil, como analizadores de manera que si el campo contiene texto que sepa que debe ser un número, puede analizar con fluidez. consejo PRO menor para cualquier persona nueva en la idea. (Cualquier persona en el SO, realmente Nah!)

Con esto en mente, aquí es una versión mejorada:

public static bool IsEmpty(this DataRow row)
{
    return row == null || row.ItemArray.All(i => i.IsNullEquivalent());
}

public static bool IsNullEquivalent(this object value)
{
    return value == null
           || value is DBNull
           || string.IsNullOrWhiteSpace(value.ToString());
}

Ahora usted tiene otro ayudante útil, IsNullEquivalent que se puede utilizar en este contexto y cualquier otro, también. Se podría extender esto a incluir cosas como "n/a" o "TBD" si sabe que sus datos tiene marcadores de posición así.

Answer 3

Yo prefiero el enfoque de Tommy Carlier, pero con un pequeño cambio.

foreach (DataColumn column in row.Table.Columns)
    if (!row.IsNull(column))
      return false;

  return true;

supongo que este enfoque parece más simple y brillante.

Answer 4

public static bool AreAllCellsEmpty(DataRow row)
{
  if (row == null) throw new ArgumentNullException("row");

  for (int i = row.Table.Columns.Count - 1; i >= 0; i--)
    if (!row.IsNull(i))
      return false;

  return true;
}

Answer 5

Yo sé que esto ya ha sido contestada y que es una vieja pregunta, pero aquí es un método de extensión para hacer lo mismo:

public static class DataExtensions
{
    public static bool AreAllCellsEmpty(this DataRow row)
    {
        var itemArray = row.ItemArray;
        if(itemArray==null)
            return true;
        return itemArray.All(x => string.IsNullOrWhiteSpace(x.ToString()));            
    }
}

Y lo usa de esta manera:

if (dr.AreAllCellsEmpty())
// etc

Answer 6

Se puede usar esto:

if(drEntity.ItemArray.Where(c => IsNotEmpty(c)).ToArray().Length == 0)
{
    // Row is empty
}

IsNotEmpty(cell) sería su propia aplicación, comprobando si los datos es nulo o vacío, sobre la base de qué tipo de datos se encuentran en la célula. Si se trata de una cadena simple, que podría terminar buscando algo como esto:

if(drEntity.ItemArray.Where(c => c != null && !c.Equals("")).ToArray().Length == 0)
{
    // Row is empty
}
else
{
    // Row is not empty
}

Sin embargo, es esencialmente comprueba cada celda de vacío, y le permite saber si todas las celdas de la fila están vacíos.

Answer 7

DataTable.NewRow inicializará cada campo a:

• el valor por defecto para cada DataColumn (DataColumn.DefaultValue)

• excepto para las columnas de incremento automático (DataColumn.AutoIncrement == true), que se inicializan con el siguiente valor de incremento automático.

• y columnas de expresión (DataColumn.Expression.Length > 0) también son un caso especial; el valor por defecto dependerá de los valores predeterminados de columnas sobre las que se calcula la expresión.

Así que probablemente debería estar mirando algo como:

bool isDirty = false;
for (int i=0; i<table.Columns.Count; i++)
{
    if (table.Columns[i].Expression.Length > 0) continue;
    if (table.Columns[i].AutoIncrement) continue;
    if (row[i] != table.Columns[i].DefaultValue) isDirty = true;
}

Voy a dejar la versión de LINQ como un ejercicio:)

Answer 8

Que yo sepa, no existe un método que hace esto en el marco. Incluso si había apoyo para algo como esto en el marco, que, esencialmente, estaría haciendo lo mismo. Y que estaría buscando en cada célula en el DataRow para ver si está vacío.

Answer 9

Lo hice así:

var listOfRows = new List<DataRow>();
foreach (var row in resultTable.Rows.Cast<DataRow>())
{
    var isEmpty = row.ItemArray.All(x => x == null || (x!= null && string.IsNullOrWhiteSpace(x.ToString())));
    if (!isEmpty)
    {
        listOfRows.Add(row);
    }
}

Answer 10

Tal vez una mejor solución sería añadir una columna adicional que se ajusta automáticamente a 1 en cada fila. Tan pronto como hay un elemento que no es nulo el cambio a un 0.

entonces

If(drEntitity.rows[i].coulmn[8] = 1)
{
   dtEntity.Rows.Add(drEntity);
}
 else
 {
   //don't add, will create a new one (drEntity = dtEntity.NewRow();)
 }