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 dall'input (sto importando 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? Oppure dovrei forzare e controllarli 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 quindi il codice risultante sarebbe:

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

Answer 2

AFAIK, non esiste un metodo che faccia ciò nel framework. Anche se ci fosse un supporto per qualcosa di simile nel framework, sarebbe essenzialmente fare la stessa cosa. E quello guarderebbe ogni cella nel DataRow per vedere se è vuoto.

Answer 3

è possibile utilizzare questo:

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

IsNotEmpty(cell) sarebbe la tua implementazione, controllando se i dati sono nulli o vuoti, in base al tipo di dati presenti 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 
} 

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

Answer 4

Forse una soluzione migliore sarebbe aggiungere una colonna aggiuntiva che viene automaticamente impostata su 1 su ogni riga. Non appena v'è un elemento che non è il cambiamento nulla 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();) 
} 

Answer 5

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 6

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 7

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; 

Suppongo che questo approccio sia più semplice e chiaro.

Answer 8

DataTable.NewRow inizializza ogni campo a:

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

• tranne che per le colonne incremento automatico (DataColumn.AutoIncrement == true), che verrà inizializzato alla prossima auto -incremento del valore.

• e colonne di espressione (DataColumn.Expression.Length > 0) sono anche un caso speciale; il valore predefinito dipenderà dai valori predefiniti delle colonne su cui viene calcolata l'espressione.

Così 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 un esercizio :)

Answer 9

So che questo è stato già risposto ed è un vecchio domanda, 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 si utilizza in questo modo:

if (dr.AreAllCellsEmpty()) 
// etc 

Answer 10

ho creato un aiutante (in una classe statica ho chiamato DataRowHelpers, inventiva, lo so) 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 che il mio ha prestato brevità nel suo uso succinto di Linq to Objects. A proposito, questo è davvero utile in combinazione con l'analisi di Excel, in quanto gli utenti possono virare su una riga in giù nella pagina (migliaia di righe) senza riguardo a come questo influisce sull'analisi dei dati.

Nella stessa classe, ho messo tutti gli altri helper che ho trovato utili, come i parser in modo che se il campo contiene del testo che tu sai dovrebbe essere un numero, puoi analizzarlo fluentemente. Suggerimento per i meno esperti per chiunque sia nuovo all'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 altra , pure. Si potrebbe estendere questo per includere cose come "n/a" o "TBD" se si sa che i tuoi dati hanno segnaposto del genere.