C # DataRow Empty-check

J'ai obtenu ceci:

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

Puis-je ajouter des données à la ligne (ou pas).
Beaucoup de code, ne sais vraiment pas si il n'y a rien à l'intérieur de la ligne.
Dépend de l'entrée (je suis l'importation de certains fichiers).
J'aimerais faire quelque chose comme:

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

Est-il une bonne façon de vérifier si le DataRow de chaque cellule est vide?
Ou, devrais-je foreach, et de les vérifier un par un?

source d'informationauteur Ash

c#datarow

Une méthode simple le long des lignes de:

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

Vous donner ce que vous êtes après, et pour le rendre "beau" (comme il n'y a rien d'aussi loin que je suis au courant, dans le Cadre de), vous pouvez l'envelopper comme une extension de la méthode, puis votre code résultant serait:

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

Je préfère l'approche de Tommy Carlier, mais avec un peu de changement.

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

  return true;

Je suppose que cette approche semble plus simple et lumineux.

7

J'ai créé un helper (dans une classe statique, j'ai appelé DataRowHelpersinventif, je sais) appelé IsEmpty comme suit:
```
public static bool IsEmpty(this DataRow row)
{
    return row == null || row.ItemArray.All(i => i is DBNull);
}
```
Les autres réponses sont correctes. J'ai juste senti la mine de carême, de la concision dans ses succincte de l'utilisation de Linq to Objects. BTW, c'est vraiment utile en conjonction avec Excel d'analyse puisque les utilisateurs peuvent ajouter une ligne en bas de la page (en milliers de lignes), sans tenir compte de comment cela influe sur l'analyse des données.

Dans la même classe, j'ai mis tout les autres helpers j'ai trouvé d'utile, comme les analyseurs de sorte que si le champ contient du texte qui doit être un nombre, vous pouvez analyser couramment. Mineur pro astuce pour quelqu'un de nouveau à l'idée. (N'importe qui, DONC, vraiment? Nah!)

Avec cela à l'esprit, ici, c'est une version améliorée:
```
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());
}
```
Maintenant vous avez un autre aide utile, IsNullEquivalent qui peuvent être utilisés dans ce contexte, et tous les autres, aussi. Vous pouvez étendre cela à inclure des choses comme "n/a" ou "TBD" si vous savez que vos données possède des espaces réservés comme ça.

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

Je sais que cela a été déjà répondu et c'est une vieille question, mais voici une méthode d'extension pour faire la même chose:

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

Et vous l'utilisez comme suit:

if (dr.AreAllCellsEmpty())
//etc

2

Vous pouvez utiliser ceci:
```
if(drEntity.ItemArray.Where(c => IsNotEmpty(c)).ToArray().Length == 0)
{
    //Row is empty
}
```
IsNotEmpty(cell) serait votre propre mise en œuvre, de vérifier si les données sont nulles ou vides, basé sur ce type de données dans la cellule. Si c'est une simple chaîne de caractères, il pourrait finir par ressembler à ceci:
```
if(drEntity.ItemArray.Where(c => c != null && !c.Equals("")).ToArray().Length == 0)
{
    //Row is empty
}
else
{
    //Row is not empty
}
```
Encore, il vérifie chaque cellule vide, et vous permet de savoir si toutes les cellules de la ligne sont vides.
1

DataTable.NewRow d'initialiser chaque champ:
- la valeur par défaut pour chaque DataColumn (DataColumn.DefaultValue)
- sauf pour les auto-incrémentation des colonnes (DataColumn.AutoIncrement == true), qui sera initialisé à la prochaine valeur d'incrémentation automatique.
- et colonnes d'expression (DataColumn.Expression.Length > 0) sont également un cas particulier; la valeur par défaut dépend de la valeurs par défaut des colonnes dont l'expression est calculée.
De sorte que vous devriez vérifier quelque chose comme:
```
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;
}
```
Je vais laisser le LINQ version comme un exercice 🙂
0

Autant que je sache, il n'existe pas de méthode qui fait cela dans le cadre. Même si on a quelque chose comme ceci dans le cadre de, cela reviendrait à faire la même chose. Et qui serait à la recherche à chaque cellule dans le DataRow pour voir si elle est vide.

J'ai fait comme ceci:

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

0

Peut-être une meilleure solution serait d'ajouter une colonne supplémentaire qui est automatiquement mis à 1 sur chaque ligne. Dès qu'il y a un élément qui n'est pas nulle de le changer pour un 0.

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

Vous devez vous connecter pour publier un commentaire.