C # DataRow Vuoto-check

Question

ho ottenuto questo:

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

poi aggiungo i dati alla riga (o non). Un sacco di codice, davvero non so se c'è qualcosa all'interno della riga. Dipende sull'ingresso (sto importazione da alcuni file). Mi piacerebbe fare qualcosa di simile:

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

C'è qualche bel modo per verificare se il DataRow ogni cella è vuota? O dovrei foreach, e verificare uno per uno?

Answer 1

Un metodo semplice lungo le linee di:

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

dovrebbe darvi quello che stai dopo, e per rendere più "bello" (come non c'è niente per quanto ne sono a conoscenza, nel quadro), si potrebbe avvolgere in su come un metodo di estensione, e poi il tuo risultante codice sarebbe:

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

Answer 2

ho creato un metodo di estensione (Gosh vorrei Java avuto questi) chiamato IsEmpty come segue:

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

Le altre risposte qui sono corrette. Ho appena sentito il mio prestato brevità nel suo uso succinta di LINQ to Objects. BTW, questo è davvero utile in combinazione con l'analisi di Excel poiché gli utenti possono virare su una riga in basso nella pagina (migliaia di linee) senza alcun riguardo per come questo influenzi l'analisi dei dati.

Nella stessa classe, ho messo tutti gli altri aiutanti che ho trovato utile, come parser in modo che se il campo contiene il testo che si sa dovrebbe essere un numero, è possibile analizzare fluentemente. punta pro minore per chiunque di nuovo l'idea. (Chiunque a SO, davvero? Nah!)

Con questo in mente, qui è una versione migliorata:

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

Ora avete un altro aiutante utile, IsNullEquivalent che può essere utilizzato in questo contesto e qualsiasi altro, anche. Si potrebbe estendere questo per includere le cose come "n/a" o "TBD" se si sa che i dati ha segnaposti del genere.

Answer 3

Io preferisco l'approccio di Tommy Carlier, ma con un piccolo cambiamento.

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

  return true;

Credo che questo approccio sembra più semplice e luminoso.

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

So che questo è stato risposto già ed è una vecchia questione, ma qui è un metodo di estensione di fare lo stesso:

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

E lo si utilizza in questo modo:

if (dr.AreAllCellsEmpty())
// etc

Answer 6

È possibile utilizzare questo:

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

IsNotEmpty(cell) sarebbe una propria implementazione, verificare se i dati è nullo o vuoto, in base a quale tipo di dati è nella cella. Se si tratta di una semplice stringa, potrebbe finire cercando qualcosa di simile:

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

Ancora, esso controlla essenzialmente ogni cella per il vuoto, e consente di sapere se tutte le celle della riga sono vuoti.

Answer 7

DataTable.NewRow inizializza ogni campo a:

• il valore di default per ciascun DataColumn (DataColumn.DefaultValue)

• tranne che per le colonne di auto-incremento (DataColumn.AutoIncrement == true), che vengono inizializzati al successivo valore di incremento automatico.

• ed espressione colonne (DataColumn.Expression.Length > 0) sono anche un caso speciale; il valore predefinito dipende i valori predefiniti di colonne su cui viene calcolata l'espressione.

Quindi, si dovrebbe probabilmente essere il controllo qualcosa come:

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

Lascio la versione LINQ come esercizio:)

Answer 8

Per quanto ne sappia, non esiste un metodo che fa questo nel quadro. Anche se ci fosse il supporto per una cosa del genere nel quadro, sarebbe essere essenzialmente facendo la stessa cosa. E che sarebbe in cerca di ogni cellula del DataRow per vedere se è vuota.

Answer 9

L'ho fatto in questo modo:

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

Forse una soluzione migliore sarebbe quella di aggiungere una colonna aggiuntiva che viene impostato automaticamente a 1 per ogni riga. Non appena v'è un elemento che non è nullo cambiamento ad un 0.

poi

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