Manière pratique de stocker une quantité "raisonnablement large" de données qui ne change guère jamais?
Pensez en termes de tables de recherche pré-calculées ou de quelque chose. À quel moment a-t-il plus de sens d'utiliser une base de données au lieu de valeurs de codage de la technologie dans mon application? Les valeurs ne vont pas changer et ils sont bien séparés des développeurs de maintenance. 100 valeurs, 1k, 10k, 100k? Je veux stocker environ 40 000 valeurs. En ce moment, il s'agit d'une instruction générée par la machine switch (que VS2010 est malheureuse).
éditer:
Si quelqu'un est curieux, voici comment je m'approchai de cela: mes données étaient stockées dans deux tableaux de flotteurs à 100 000 éléments, c'est ce que j'ai fait. Il a fallu environ 20 secondes pour générer les données, donc je l'ai fait une fois et la sérialisée à une ressource intégrée avec un formidateur binaire. Déballage des données prend environ 5 millisecondes au démarrage de l'application et surperformez la mise en œuvre de la base de données que je remplaçait (ces valeurs codées dur étaient stockées là-bas avant) de près de 45 000x.
Personnellement, je suis Ok pour stocker n'importe quelle quantité de données, codé en dur dans l'application, jusqu'à ce qu'il n'y ait pas besoin de le modifier pour un déploiement ou un correctif particulier.
Cependant, stocker et accéder aux données à l'aide de l'instruction de commutation C #, est plutôt une mauvaise pratique, car dans le modèle de stockage de données et d'accès aux données étroitement couple et implique une seule méthode d'accès à une méthode (par paramètre de commutation).
Je préférerais stocker des données dans une hache ou un dictionnaire et fournir des classes séparées pour la récupération des données et une population unique de dictionnaires de recherche.
Récemment, j'ai trouvé plutôt pratique de mettre en œuvre une petite DSL pour spécifier des règles commerciales ( Interface fluide pour le plan du site ou - question d'entretien de la calculatrice fiscale Vérifier la méthode "Calc" pour la défaution de règles) et Fournissez ensuite un objet distinct pour interroger ces règles. Cette technique s'appliquerait bien aux scénarios de cas de commutation.
L'un des bons avantages de cette décomposition est que vous pouvez mettre en œuvre un certain nombre de vues sur vos données, sans toucher XXXK Lines Blob, qui définit ces données.
Un énoncé de commutateur de ligne 40K est un peu discutable. Je suppose que vous avez toujours besoin d'effectuer des opérations de requête? Avez-vous essayé d'encapsuler les données? Ensuite, utilisez LINQ pour effectuer des opérations de requête sur la collection pour tester les performances. Obtenez des moments concrets en exécutant des tests d'unité avec une minuterie comme chronomètre . Ensuite, si vous pensez que cela pourrait simplement fonctionner. Voir si la performance est acceptable pour les utilisateurs.
J'ai eu une exigence comme ça deux fois. Les applications ont été conçues pour être autonomes sans configuration/accès à la base de données requis. Dans les deux cas, j'ai utilisé des fichiers XML pour stocker les données. Dans la première, qui se trouvait sur le cadre 2.0, j'ai utilisé les appels d'analyse XML de style de style ancien pour rechercher des données. Pour le plus récent, sur le cadre 3.5, j'ai utilisé Linq vers XML pour trouver ce dont j'avais besoin. Dans les deux cas, l'accès aux données a été encapsulé dans des classes.
La principale chose ici est de vous assurer que votre interface publique encapsule votre mise en œuvre - mais ce n'est pas votre question et il n'y a aucune raison de penser que vous ne l'avez pas fait. Au-delà de cela, il s'agit simplement d'une question de performance vs chagrin (et les différences de performance risquent de ne pas valoir la peine de soigner). En tant que solution pratique, pour la question du VS 2010, vous pouvez toujours briser la déclaration de cas dans une hiérarchie des déclarations de cas - le niveau supérieur pouvait appeler l'une des 10 autres méthodes, chacune avec une déclaration de cas de 4000 cas, par exemple. Vous pouvez mettre chacun des 10 dans son propre fichier si vous le deviez. Un peu laids, mais vous êtes du code générant de toute façon.
En ce qui concerne le nombre de basculer sur un dB -it's tout simplement chaque fois que l'utilisation d'un DB devient un problème.
Je pense que le mot clé ici est "difficilement"
Si les données jamais changent - par exemple, des valeurs mathamatiques pré-calculées, des constantes de couleur et similaires - alors, tant que la taille est gérable pour vous, conservez-la dans le code. Sachez simplement que si la performance est un problème, les déclarations de cas/commutateur seront très lentes que d'autres options.
Si les données à peine ne change jamais - par exemple, les codes de zone téléphonique, les frontières nationales et similaires - je vais probablement examiner les données de manière externe d'une manière externe. En particulier si cela commençait à être plus qu'un couple de valeurs.
Si vous stockez de gros volumes de données dans votre application, votre programme peut être chargé plus lentement et que vous exposez peut-être le code au risque dans le cas où certains pouvaient jouer avec les fichiers binaires ou exécutables.
En outre, si le programme est édité de plusieurs reprises, qui sait, peut-être que vous puissiez introduire des erreurs en incorrissant un chiffre par erreur ou à la suite d'une commande de changement.
Peut être à l'avenir, certains demandent à exécuter des requêtes sur les données, disent que quelqu'un peut demander la moyenne, d'une colonne, auquel cas vous devrez modifier votre application et ajouter une méthode pour calculer chaque requête votre utilisateur. Avec, puis allez avec toutes les étapes pour promouvoir votre code à la production. Ce n'est vraiment pas bon.
La séparation des données et du code est une bonne pratique spécialement si les données sont grandes.