Comment faire pour exporter une Table de données Xml avec TOUTES les colonnes d'attributs?

Question: je suis de l'exportation d'un Système.Les données.DataTable à XML.
Jusqu'à présent, il fonctionne très bien.
Mais je veux avoir toutes les données dans les attributs, qui fonctionne très bien ainsi.
Mais mon problème maintenant, si dans une colonne, toutes les lignes sont NULLES, pas de vide attributs sont écrits.
Donc si j'ai lu le XML retour à une DataTable, il manque de cette colonne...

Comment puis-je la force d'écrire toutes les colonnes, même lorsqu'ils sont vides ?
(DataType pas nécessairement string)

public void ExportTable(string strDirectory, DataTable dtt)
{
    using (System.Data.DataSet ds = new System.Data.DataSet()) {
        string strTable = dtt.TableName;

        ds.Tables.Add(dtt);
        ds.DataSetName = strTable;

        //Move data to attributes 
        foreach (DataTable dt in ds.Tables) {

            foreach (DataColumn dc in dt.Columns) {
                dc.ColumnMapping = MappingType.Attribute;
            }

        }

        System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
        settings.Indent = true;
        //settings.Encoding = System.Text.Encoding.GetEncoding("ISO-8859-1") 
        settings.Encoding = System.Text.Encoding.UTF8;
        settings.CloseOutput = true;
        settings.CheckCharacters = true;
        settings.NewLineChars = "\r\n";
        //vbCr & vbLf 

        //Write as UTF-8 with indentation 
        using (System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(System.IO.Path.Combine(strDirectory, strTable + ".xml"), settings)) {

            //Strip out timezone 
            foreach (DataTable dt in ds.Tables) {

                foreach (DataColumn dc in dt.Columns) {

                    if (object.ReferenceEquals(dc.DataType, typeof(DateTime))) {
                        dc.DateTimeMode = DataSetDateTime.Unspecified;
                    }

                }

            }

            ds.Tables[0].WriteXml(w, XmlWriteMode.IgnoreSchema);
            w.Flush();
            w.Close();
        }
        //w 

    }
    //ds 

}
//ExportTable

VB.NET original:

 Public Sub ExportTable(strDirectory As String, dtt As DataTable)
        Using ds As New System.Data.DataSet()
            Dim strTable As String = dtt.TableName

            ds.Tables.Add(dtt)
            ds.DataSetName = strTable

            ' Move data to attributes
            For Each dt As DataTable In ds.Tables

                For Each dc As DataColumn In dt.Columns
                    dc.ColumnMapping = MappingType.Attribute
                Next dc

            Next dt

            Dim settings As New System.Xml.XmlWriterSettings()
            settings.Indent = True
            'settings.Encoding = System.Text.Encoding.GetEncoding("ISO-8859-1")
            settings.Encoding = System.Text.Encoding.UTF8
            settings.CloseOutput = True
            settings.CheckCharacters = True
            settings.NewLineChars = vbCrLf ' vbCr & vbLf

            ' Write as UTF-8 with indentation
            Using w As System.Xml.XmlWriter = System.Xml.XmlWriter.Create(System.IO.Path.Combine(strDirectory, strTable & ".xml"), settings)

                ' Strip out timezone
                For Each dt As DataTable In ds.Tables

                    For Each dc As DataColumn In dt.Columns

                        If dc.DataType Is GetType(DateTime) Then
                            dc.DateTimeMode = DataSetDateTime.Unspecified
                        End If

                    Next dc

                Next dt

                ds.Tables(0).WriteXml(w, XmlWriteMode.IgnoreSchema)
                w.Flush()
                w.Close()
            End Using ' w

        End Using ' ds

    End Sub ' ExportTable

Utilisation XmlWriteMode.WriteSchema. Avec un schéma fourni, il n'a pas d'importance qu'il n'a pas à ajouter des attributs pour les valeurs null.
Sans schéma serait plus agréable, parce que le résultat doit être facile à lire dans tout langage de programmation, et pas seulement .NET.

OriginalL'auteur Stefan Steiger | 2012-04-19

.net c#datatable vb.net xml

8

Chaque attribut XML doit être affectée une valeur qui est enfermé dans une paire de guillemets simples ou doubles. Il n'y a pas d'équivalent en texte brut pour désigner une valeur NULL. Une paire de guillemets avec aucune valeur pour représenter une chaîne vide n'est pas le même comme une valeur NULL. Par conséquent, le seul moyen de représenter une valeur NULL attribut est d'omettre l'attribut.

Cela signifie que vous aurez besoin soit de définir AllowDBNull de faux et d'attribuer un adapté DefaultValue sur le DataColumn, ou inclure le schéma.

Aussi, voir La manipulation des Valeurs Null (ADO.NET)., en particulier cette section, qui explique le comportement:

En outre, les règles suivantes s'appliquent pour une instance de
DataRow.["nomcolonne"] null affectations:

1.La valeur par défaut valeur par défaut est DbNull.De la valeur pour tous, sauf les fortement typé null colonnes où il est fortement typé
valeur null.

2.Les valeurs Null ne sont jamais écrites au cours de la sérialisation XML fichiers (comme dans "xsi:nil").

3.Toutes les valeurs non null, y compris les paramètres par défaut, sont toujours écrites lors de la sérialisation XML. C'est à l'inverse XSD/XML sémantique où un
valeur nulle (xsi:nil) est explicite et la valeur par défaut est implicite (si
n'est pas présent dans XML, une validation de l'analyseur peut obtenir à partir d'un associé
Schéma XSD). L'inverse est vrai pour un DataTable: une valeur null est
implicite et la valeur par défaut est explicite.

4.Toutes les valeurs de la colonne pour les lignes lues à partir de l'entrée XML en sont affectés NULL. Les lignes créées à l'aide de NewRow ou des méthodes similaires sont affectés à l'
DataColumn la valeur par défaut.

5.Le IsNull méthode renvoie true pour les deux DbNull.Valeur et INullable.La valeur Null.

OriginalL'auteur JamieSee

Essayer le réglage de la colonne de DefaultValue à quelque chose de valable

foreach (DataTable dt in ds.Tables) {

        foreach (DataColumn dc in dt.Columns) {
            dc.ColumnMapping = MappingType.Attribute;
           //If type is DataType string
           dc.DefaultValue = String.Empty;
        }

OriginalL'auteur Anurag Ranjhan

2

Deux points:

Première:
Le ExportTable() a lancé une exception: "DataTable appartient déjà à un autre ensemble de données." Quand j'ai exécuté:
```
ds.Tables.Add(dtt)
```
J'ai corrigé cela en faisant une copie locale de la table:
```
Dim dtX As DataTable = dtt.Copy
ds.Tables.Add(dtX)
ds.DataSetName = strTable
```
Cela a bien fonctionné.

Deuxième:
Si vous utiliser le XML pour créer une instruction SQL dynamique, il n'est pas besoin d'être préoccupé par les colonnes/champs avec la valeur NULL être omis dans l'export XML. Il suffit de marcher à travers l'un des attributs qui sont dans le fichier XML du dossier, construire l'instruction INSERT ou UPDATE et exécuter une commande de connexion. C'est plus rapide que d'utiliser un DataSet.

Pour INSÉRER il a un inconvénient. Si la clé primaire est créé par incrémentation d'une colonne d'identité, un ADO.Net jeu de données sera de retour. SQL dynamique nécessitera une instruction SELECT pour récupérer.

Aussi, ce serait une bonne idée de dissimuler votre code.

OriginalL'auteur Jakester26

C'est un peu vieux thread mais, peut-être que ça peut aider quelqu'un:

Si vous n'êtes pas de l'écriture de gros fichiers xml fréquemment (c'est ok pour l'exportation de paramètres ou quelque chose de similaire), vous pouvez utiliser la fonction ci-dessous, sinon il est préférable d'utiliser cutom schéma xml.

private static void addEmptyElementsToXML(DataSet dataSet)
{
    foreach (DataTable dataTable in dataSet.Tables)
    {
        foreach (DataRow dataRow in dataTable.Rows)
        {
            for (int j = 0; j < dataRow.ItemArray.Length; j++)
            {
                if (dataRow.ItemArray[j] == DBNull.Value)
                    dataRow.SetField(j, string.Empty);
            }
        }
    }
}

Utilisation:

using(DataTable dTable = ..something..)
using(DataSet dS = new DataSet())
using(XmlTextWriter xmlStream = new XmlTextWriter("FILENAME.XML", Encoding.UTF8))
{
    //set xml to be formatted so it can be easily red by human
    xmlStream.Formatting = Formatting.Indented;
    xmlStream.Indentation = 4;

    //add table to dataset
    dS.Tables.Add(dTable);

    //call the mentioned function so it will set all DBNull values in dataset
    //to string.Empty
    addEmptyElementsToXML(dS);

    //write xml to file
    xmlStream.WriteStartDocument();
    dS.WriteXml(xmlStream);
}

OriginalL'auteur Circus Ranger

J'ai été la recherche de tout le monde pour une solution de l'écriture des champs null XML en utilisant un jeu de données.WriteXML(). J'ai trouvé que suite à des travaux dans une performance optimisée. J'ai créé une fonction pour votre commodité. Changer votre jeu de données les tables les unes après les autres en appelant la fonction suivante et remplacer les tables.

private DataTable GetNullFilledDataTableForXML(DataTable dtSource)
{
    //Create a target table with same structure as source and fields as strings
    //We can change the column datatype as long as there is no data loaded
    DataTable dtTarget = dtSource.Clone();
    foreach (DataColumn col in dtTarget.Columns)
        col.DataType = typeof(string);

    //Start importing the source into target by ItemArray copying which 
    //is found to be reasonably fast for null operations. VS 2015 is reporting
    //500-525 milliseconds for loading 100,000 records x 10 columns 
    //after null conversion in every cell 
    //The speed may be usable in many circumstances.
    //Machine config: i5 2nd Gen, 8 GB RAM, Windows 7 64bit, VS 2015 Update 1
    int colCountInTarget = dtTarget.Columns.Count;
    foreach (DataRow sourceRow in dtSource.Rows)
    {
        //Get a new row loaded with data from source row
        DataRow targetRow = dtTarget.NewRow();
        targetRow.ItemArray = sourceRow.ItemArray;

        //Update DBNull.Values to empty string in the new (target) row
        //We can safely assign empty string since the target table columns
        //are all of string type
        for (int ctr = 0; ctr < colCountInTarget; ctr++)
            if (targetRow[ctr] == DBNull.Value)
                targetRow[ctr] = String.Empty;

        //Now add the null filled row to target datatable
        dtTarget.Rows.Add(targetRow);
    }

    //Return the target datatable
    return dtTarget;
}

OriginalL'auteur Rajarshi

Vous devez vous connecter pour publier un commentaire.