SQL (SQLite) et rétrocompatibilité

Question

Un débutant dans SQL/DB ici- Je suis en train de concevoir une application Windows universelle où une base de données peut être utile, donc je lis sur SQL/SQLite et je me demande comment est-ce que la rétrocompatibilité (classes/tables sage) fonctionne? Supposons que j'ajoute ou supprime une propriété d'une classe que j'ai utilisée comme base pour une table. Serai-je toujours capable d'interagir avec les données d'ancienne classe et de les transtyper dans la classe mise à jour? Comment va-t-on surveiller les propriétés ajoutées/supprimées lors de l'interrogation de la base de données?

Nous vous remercions de votre temps. Edit: Scénario - si j'ai un utilisateur avec 2 propriétés - 'Id', 'Nom'.

public class User 
{ 
public int Id {get; set; } 
pubic string Name {get; set;} 
} 

Et j'ai construit une application avec un 'Users' Db et je l'utilise depuis un moment. Ensuite, j'aimerais ajouter une autre propriété à ma classe User. Supposons que c'est l'âge. Puis-je ajouter cette nouvelle propriété à ma classe « User » original et toujours en mesure d'accéder à la table des utilisateurs d'origine avec-

var user = DbConnection.Table<User>().Where(x => x.Id == tId).FirstOrDefault(); 

De toute évidence, une option serait de garder l'utilisateur d'origine et de créer une autre classe UserEx qui sera avoir les propriétés originales + Age. Ensuite, je prends tous les 'utilisateurs, les port sur UserEx et enregistrer dans une nouvelle table.

Cela ne semble un peu lourd à faire pour chaque ajouté/supprimé la propriété si

Answer 1

Puis-je ajouter cette nouvelle propriété à mon original « utilisateur » classe et toujours être en mesure d'accéder à la table des utilisateurs d'origine avec ?

var user = DbConnection.Table<User>().Where(x => x.Id == tId).FirstOrDefault(); 

Est-ce que l'ajout d'une propriété à la mise à jour de la classe utilisateur la table SqlLite sous-jacente? Vous devrez étendre la classe pour maintenir la compatibilité.

public class User 
    { 
     public int Id {get; set; } 
     public string Name {get; set;} 

     public User getUser(int tId) 
     { 
      var user = DbConnection.Table<User>().Where(x => x.Id == tId).FirstOrDefault(); 
      Id = user.Id; 
      Name = user.Name; 
      //age = user.age; // not possible 
     }   
    } 

    public class DetailedUser:User 
    { 
     public int age { get; set; } 

     public DetailedUser getUser(int tId) 
     { 
      var user = DbConnection.Table<User>().Where(x => x.Id == tId).FirstOrDefault(); 
      base.Id = user.Id; 
      base.Name = user.Name; 
      //age = user.age; // not possible 
     } 

     public DetailedUser getDetailedUser(int tId) 
     { 
      var user = DbConnection.Table<DetailedUser>().Where(x => x.Id == tId).FirstOrDefault(); 
      base.Id = user.Id; 
      base.Name = user.Name; 
      age = user.age; 
     } 
    } 

Le processus 'lourd' évident que vous avez décrit est une autre option valide. De toute façon, lorsque vous modifiez la couche de données dans votre application, il y a des conséquences. Deux choses me viennent à l'esprit, à savoir que dans Android SqlLite a une fonction onUpgrade où vous pouvez mettre votre logique de mise à niveau de couche de données "lourde" ou vous pouvez utiliser une solution NoSQL comme MongoDB où la couche de données est beaucoup plus pardonner sur la structure de vos enregistrements sous-jacents (ymmv).

Enfin, mieux vous planifiez votre structure de couche de données, moins vous rencontrerez ce genre de problème.

J'espère que cela aide.