WriteXML avec Code First

Version imprimable

13/01/2012, 10h12
thlac

WriteXML avec Code First
Bonjour à tous,

Travaillant actuellement au développement d'un soft .NET, j'utilise "Code First" d'Entity Framework pour accéder aux données de ma base.

J'ai besoin de pouvoir Exporter ces données en Xml, et de pouvoir en importer d'autres, depuis Xml. Je devrais également par la suite pouvoir upgrader une base en runtime.

Je sais qu'il existe une méthode WriteXml avec les dataSet, seulement, je suis contraint d'utiliser "CodeFirst".

Avez-vous une solution à cette problématique?

Merci pour votre aide,
Thlac.

PS: Certain des paramètres de cette problématique sont imposés pour ce projet. Ils faudra donc composer avec :
- "Code First"
- L'import export en XML (au minimum) et CSV (pour le bonus)
13/01/2012, 11h04
tomlev

Tu peux toujours sérialiser/désérialiser les entités en XML comme indiquer dans ce tuto
13/01/2012, 11h13
thlac

Citation:

Envoyé par tomlev

Tu peux toujours sérialiser/désérialiser les entités en XML comme indiquer dans ce tuto

Merci TomLev pour ta réponse rapide.

J'ai en effet déjà envisagé cette solution, sauf que j'ai une bonne centaine de tables (donc autant de classes) qui peuvent avoir jusqu'à 50 propriétés pour certaines.

Je ne peux donc pas me permettre de faira "à la mano" la serialization de tous les types :
XmlSerializer xs = new XmlSerializer(typeof(Voiture)).

Peut-être à tu une solution pour automatiser cela?

Thlac
13/01/2012, 11h40
tomlev

Citation:

Envoyé par thlac

Je ne peux donc pas me permettre de faira "à la mano" la serialization de tous les types :
XmlSerializer xs = new XmlSerializer(typeof(Voiture)).

Bah à un moment donné, tu vas quand même devoir faire du code spécifique pour chaque table, pour l'enregistrement... donc ajouter la désérialisation ne fait pas une très grosse différence il me semble.

Sinon, tu peux toujours essayer de passer par la réflexion, mais c'est pas forcément évident.

En fait je viens de penser à un truc... tu pourrais te débrouiller avec une méthode générique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public void ImportEntitiesFromXml<T>(DbSet<T> table, string fileName)
{
    XmlSerializer xs = new XmlSerializer(typeof(List<T>));
    using (var reader = XmlReader.Create(fileName))
    {
        var list = (List<T>)xs.Deserialize(reader);
        foreach (var item in list)
        {
            table.Add(item);
        }
    }
}

Et tu l'utilises comme ça :

Code:

1
2
3
4
5
6
7
8
using (var context = new MyDbContext())
{
    ImportEntitiesFromXml(context.Products, "products.xml");
    ImportEntitiesFromXml(context.Orders, "orders.xml");
    ImportEntitiesFromXml(context.Clients, "clients.xml");
    ...
    context.SaveChanges();
}

Donc au final, même avec beaucoup de tables, ça reste pas trop méchant...

Sinon j'ai pas trop compris ce que le nombre de propriétés vient faire là-dedans ?

13/01/2012, 11h50
thlac

Citation:

Envoyé par tomlev

...tu vas quand même devoir faire du code spécifique pour chaque table...

Ah :?

Je pensais plutôt à un truc du genre:

public void WriteXml()
{
Prend toutes les propriétés, de toutes les entités, de chaque type, se trouvant dans le DbContext.
Les écrit dans un fichier xml en face de leur valeur.
}

Je vie dans un rêve ? 8-)

Thlac

Citation:

Envoyé par thlac

Je vie dans un rêve ? 8-)

Un peu ;)

Sinon, tu as vu ma 2e réponse ? Vu que tu as posté juste après, tu l'as peut-être manquée...

Après, tu peux toujours pousser encore un peu plus loin l'automatisation, mais c'est moche :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void ImportAllEntitiesFromXml(string directory)
{
    using (var context = new MyDbContext())
    {
        var tableProperties = typeof(MyDbContext).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                 .Where(p => p.PropertyType.IsGenericType && p.GetGenericTypeDefinition() == typeof(DbSet<>))
                                                 .ToArray();
        foreach(var prop in tableProperties)
        {
            Type entityType = prop.PropertyType.GetGenericArguments()[0];
            var table = prop.GetProperty(context, null);
            var method = this.GetType().GetMethod("ImportEntitiesFromXml").MakeGenericMethod(entityType);
            string fileName = string.Format("{0}.xml", prop.Name);
            method.Invoke(table, fileName)
        }
        context.SaveChanges();
    }
}

(j'ai pas testé, mais le principe est là...)

J'ai testé avec le méthode générique, mais le <T> a du mal à passer:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public void ImportEntitiesFromXml<T>(DbSet<T> table, string fileName) { XmlSerializer xs = new XmlSerializer(typeof(List<T>)); using (var reader = XmlReader.Create(fileName)) { var list = (List<T>)xs.Deserialize(reader); foreach (var item in list) { table.Add(item); } } }
Citation:

The type 'T' must be a reference type in order to use it as parameter 'TEntity' in the generic type or method 'System.Data.Entity.DbSet<TEntity>

Citation:

Envoyé par thlac

Dans le 3éme méthode, à quoi sert le string directory? tu ne t'en sert pas dans la méthode?

C'est un oubli... voilà ce que je comptais en faire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void ImportAllEntitiesFromXml(string directory)
{
    using (var context = new MyDbContext())
    {
        var tableProperties = typeof(MyDbContext).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                 .Where(p => p.PropertyType.IsGenericType && p.GetGenericTypeDefinition() == typeof(DbSet<>))
                                                 .ToArray();
        foreach(var prop in tableProperties)
        {
            Type entityType = prop.PropertyType.GetGenericArguments()[0];
            var table = prop.GetProperty(context, null);
            var method = this.GetType().GetMethod("ImportEntitiesFromXml").MakeGenericMethod(entityType);
            string fileName = string.Format("{0}.xml", prop.Name);
            method.Invoke(table, Path.Combine(directory, fileName))
        }
        context.SaveChanges();
    }
}

Citation:

Envoyé par thlac

pourquoi dit tu que c'est moche?

Bah disons que c'est un peu bourrin d'utiliser la réflexion comme ça... mais si ça fait le boulot, c'est l'essentiel ;)

13/01/2012, 14h13
thlac

Ok je comprend mieux l'utilité du directory.

je ne sais pas si tu as vu mon post précédent. (j'ai mis le bouzon dans les réponses ...)

j'ai également des erreur avec ta dernière solution :

Citation:

'System.Reflection.PropertyInfo' does not contain a definition for 'GetGenericTypeDefinition' and no extension method 'GetGenericTypeDefinition' accepting a first argument of type 'System.Reflection.PropertyInfo' could be found.

Citation:

'System.Reflection.PropertyInfo' does not contain a definition for 'GetProperty' and no extension method 'Getproperty' accepting a first argument of type 'System.Reflection.PropertyInfo' could be found.

Citation:

Envoyé par thlac

The type 'T' must be a reference type in order to use it as parameter 'TEntity' in the generic type or method 'System.Data.Entity.DbSet<TEntity>

ah oui, il faut ajouter une contrainte sur T :

Code:

1
2
3
4
5
public void ImportEntitiesFromXml<T>(DbSet<T> table, string fileName) where  T : class
{
    ...
}

Citation:

Envoyé par thlac

'System.Reflection.PropertyInfo' does not contain a definition for 'GetGenericTypeDefinition' and no extension method 'GetGenericTypeDefinition' accepting a first argument of type 'System.Reflection.PropertyInfo' could be found.

Citation:

Envoyé par thlac

'System.Reflection.PropertyInfo' does not contain a definition for 'GetProperty' and no extension method 'Getproperty' accepting a first argument of type 'System.Reflection.PropertyInfo' could be found.

arf, voilà ce que c'est quand on écrit du code sans le tester en dehors de l'IDE ;)

Le code corrigé complet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public void ImportEntitiesFromXml<T>(DbSet<T> table, string fileName) where T : class
{
     XmlSerializer xs = new XmlSerializer(typeof(List<T>));
     using (var reader = XmlReader.Create(fileName))
     {
          var list = (List<T>)xs.Deserialize(reader);
          foreach (var item in list)
          {
               table.Add(item);
          }
     }
}
 
public void ImportAllEntitiesFromXml(string directory)
{
    using (var context = new MyDbContext())
    {
        var tableProperties = typeof(MyDbContext).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                 .Where(p => p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>))
                                                 .ToArray();
        foreach(var prop in tableProperties)
        {
            Type entityType = prop.PropertyType.GetGenericArguments()[0];
            var table = prop.GetValue(context, null);
            var method = this.GetType().GetMethod("ImportEntitiesFromXml").MakeGenericMethod(entityType);
            string fileName = string.Format("{0}.xml", prop.Name);
            method.Invoke(table, Path.Combine(directory, fileName))
        }
        context.SaveChanges();
    }
}

13/01/2012, 14h35
thlac

Je suis navré de te poster toutes mes erreurs de compilation, mais je comprend pas bien toutes les subtilités du code que tu me propose. (On ne joue pas dans la même cours :? )

Une dernière petite erreur:

Citation:

The best overloaded method match for 'System.Reflection.MethodBase.Invoke(object, object[])' has some invalid argument.

Citation:

Envoyé par thlac

The best overloaded method match for 'System.Reflection.MethodBase.Invoke(object, object[])' has some invalid argument.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public void ImportEntitiesFromXml<T>(DbSet<T> table, string fileName) where T : class
{
     XmlSerializer xs = new XmlSerializer(typeof(List<T>));
     using (var reader = XmlReader.Create(fileName))
     {
          var list = (List<T>)xs.Deserialize(reader);
          foreach (var item in list)
          {
               table.Add(item);
          }
     }
}
 
public void ImportAllEntitiesFromXml(string directory)
{
    using (var context = new MyDbContext())
    {
        var tableProperties = typeof(MyDbContext).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                 .Where(p => p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>))
                                                 .ToArray();
        foreach(var prop in tableProperties)
        {
            Type entityType = prop.PropertyType.GetGenericArguments()[0];
            var table = prop.GetValue(context, null);
            var method = this.GetType().GetMethod("ImportEntitiesFromXml").MakeGenericMethod(entityType);
            string fileName = string.Format("{0}.xml", prop.Name);
            method.Invoke(table, new object[] { Path.Combine(directory, fileName) });
        }
        context.SaveChanges();
    }
}

On va finir par y arriver :aie:

Merci beaucoup.

D'après se que je comprend du code, method.invoke ... est censé appeler la méthode ImportEntitiesFromXml.

Pourtant, elle n'y passe pas. Aucun fichier Xml n'est donc crée.

A côté de ça, j'ai retouché la méthode ImportEntitiesFromXml pour en faire une méthode ExportEntitiesToXml. et biensur je me retrouve dnas la même situation : on y passe pas lorsqu'on appel ExportAllEntitiestoXml.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 public void ExportEntitiesToXml<T>(DbSet<T> table, string fileName) where T : class
        {
            XmlSerializer xs = new XmlSerializer(typeof(List<T>));
            using (var writer = XmlWriter.Create(fileName))
            {
                try
                {
                    var list = table.ToList<T>();
                    xs.Serialize(writer, list);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        public void ExportAllEntitiesFromXml(string directory)
        {
            using (var context = new CaveAVinsContext())
            {
                var tableProperties = typeof(CaveAVinsContext).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                         .Where(p => p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>))
                                                         .ToArray();
                foreach (var prop in tableProperties)
                {
                    Type entityType = prop.PropertyType.GetGenericArguments()[0];
                    var table = prop.GetValue(context, null);
                    var method = this.GetType().GetMethod("ExportEntitiesToXml").MakeGenericMethod(entityType);
 
                    string fileName = string.Format("{0}.xml", prop.Name);
                    method.Invoke(table, new object[] {Path.Combine(directory, fileName)});
                }
                context.SaveChanges();
            }
        }

13/01/2012, 16h56
tomlev

Tu as essayé de mettre des points d'arrêt et d'exécuter pas à pas pour voir ce qui se passe ? Si ça n'y passe pas, c'est peut-être que tableProperties est vide, et qu'il y a donc une erreur dans la requête Linq qui cherche les tables... Les tables dans CaveAVinsContext sont bien des propriétés publiques de type DbSet<TEntity> ?