Comment puis-je obtenir le répertoire de l’application à partir de mon application WPF, au moment de la conception?

D’après votre description, il semblerait que votre code soit exécuté dans le concepteur WPF dans Visual Studio, par exemple qu’il fasse partie d’une bibliothèque de contrôles personnalisés utilisée pour la conception.

Dans ce cas, Assembly.GetEntryAssembly() renvoie la valeur null, mais le code suivant obtient le chemin d’access au répertoire de l’application:

  ssortingng applicationDirectory = ( from assembly in AppDomain.CurrentDomain.GetAssemblies() where assembly.CodeBase.EndsWith(".exe") select System.IO.Path.GetDirectoryName(assembly.CodeBase.Replace("file:///", "")) ).FirstOrDefault(); 

Les étapes suivantes peuvent être utilisées pour démontrer que cela fonctionne dans l’outil WPF Designer de VS.NET 2008:

1. Placez ce code dans un projet “Bibliothèque de contrôles personnalisés WPF” ou “Bibliothèque de classes”.
2. Ajoutez le code nécessaire pour lire la firebase database et renvoyer les données à afficher (dans mon cas, je viens de renvoyer le répertoire de l’application lui-même sous forme de chaîne).
3. Référencez le projet de bibliothèque à partir du projet que vous concevez
4. Utilisez les contrôles personnalisés ou les classes d’un fichier XAML pour remplir votre DataContext ou pour fournir des données à votre interface utilisateur (dans mon cas, j’ai lié DataContext à l’aide de x: Static)
5. Modifiez ce fichier XAML à l’aide du “Concepteur Windows Presentation Foundation”. Pour ce faire, il suffit de double-cliquer sauf si vous avez modifié votre éditeur par défaut. Dans ce cas, utilisez “Ouvrir avec …”.

Lorsque vous suivez ces étapes, l’object que vous regardez sera rempli avec les données de votre firebase database de la même manière à l’exécution et à la conception.

Il existe d’autres scénarios dans lesquels cette même technique fonctionne aussi bien, et d’autres solutions sont disponibles en fonction de vos besoins. S’il vous plaît laissez-nous savoir si vos besoins sont différents de ceux que j’ai assumés ci-dessus. Par exemple, si vous écrivez un complément VS.NET, vous êtes dans un jeu de balle complètement différent.

Essayez-vous de soutenir un concepteur (tel que le concepteur de studio visuel ou Blend)?

Si tel est le cas, il existe différentes manières d’aborder ce problème. En règle générale, vous ne voulez pas vous fier à un chemin relatif à partir d’un fichier exécutable, car il peut être hébergé dans différents outils de conception (VS, Expression Blend, etc.).

Peut-être pouvez-vous expliquer plus en détail le problème que vous essayez de résoudre afin que nous puissions fournir une meilleure réponse?

Je ne pense pas que cela soit possible – vous demandez l’emplacement d’un assemblage qui n’a pas encore été potentiellement construit. Votre code au moment de la conception ne s’exécute pas dans votre application et doit émettre certaines hypothèses sur l’EDI. Cela me semble faux et fragile. Réfléchissez aux questions suivantes:

• Le projet a-t-il déjà été construit?
• Sinon, il n’y a pas d’exécutable pour obtenir le chemin, alors quoi?
• Les autres fichiers seront-ils présents s’il n’a pas été construit, ou sont-ils des objects fabriqués?
• S’il a été construit, où a-t-il été construit?
• Avez-vous besoin de considérer d’autres IDE?

Dans cette situation, vous devriez probablement demander à l’utilisateur, au moment de la conception, de fournir ou de rechercher un chemin en ajoutant une propriété sur votre object à modifier. Votre code temporel de conception peut ensuite utiliser la valeur de la propriété pour trouver ce dont il a besoin.

Si vous travaillez beaucoup sur des concepteurs WPF utilisant adorner, etc., veuillez utiliser la propriété / type “Context”

Détails: – Au moment de la conception, vous avez une instance de modelItem (je suppose, vous le connaissez). Sinon, vous pouvez l’instancier dans l’implémentation de remplacement de la méthode Activate.

// dans la classe DesignAdorner

 public class DesignAdorner : PrimarySelectionAdornerProvider { protected override void Activate(ModelItem item) { modelItem = item; } } 

Vous pouvez maintenant accéder au chemin d’access actuel de l’application à l’aide du code à ligne unique suivant

 ssortingng aplicationPathDir = System.IO.Directory.GetParent(modelItem.Context.ToSsortingng()).FullName; 

Faites le moi savoir, si cela ne vous aide pas.

Ok, étant donné les précisions supplémentaires que voici, je le ferais.

Pour restr en phase avec les préoccupations exprimées par GraemeF, faire ce que vous voulez est fragile et susceptible de se rompre au mieux.

Pour cette raison, la pratique générale est de traiter le support de données au moment de la conception comme une approche totalement différente du support de données à l’exécution. Très simplement, le couplage que vous créez entre votre environnement de conception et cette firebase database est une mauvaise idée.

Pour simplement fournir des données de conception à des fins de visualisation, je préfère utiliser une classe fictive qui adhère à une interface commune en tant que classe d’exécution. Cela me donne un moyen de montrer que les données que je peux assurer sont du bon type et sont conformes au même contrat que mon object d’exécution. Pourtant, il s’agit d’une classe totalement différente utilisée pour la prise en charge du temps de conception (et souvent utilisée pour les tests unitaires).

Donc par exemple. Si j’avais un cours d’exécution qui doit montrer les détails de la personne tels que le prénom, le nom de famille et le courrier électronique:

 public class Person() { public Ssortingng FirstName { get; set;} public Ssortingng LastName {get; set;} public Email EmailAddress {get; set;} } 

et je remplissais cet object à partir d’une firebase database au moment de l’exécution, mais je devais également fournir une visualisation au moment du design. Je voudrais introduire une interface IPerson qui définit le contrat à respecter, c’est-à-dire que les getters de propriétés existent:

 public interface IPerson() { Ssortingng FirstName { get; } Ssortingng LastName { get; } Email EmailAddress { get; } } 

Ensuite, je mettrais à jour ma classe Person d’exécution pour implémenter l’interface:

 public class Person() : IPerson { public Ssortingng FirstName { get; set;} public Ssortingng LastName {get; set;} public Email EmailAddress {get; set;} } 

Ensuite, je créerais une classe fictive qui implémenterait la même interface et fournirait des valeurs sensibles pour l’utilisation du temps de conception.

 public MockPerson() : IPerson { public Ssortingng FirstName { get { return "John"; } } public Ssortingng LastName { get { return "Smith"; } } public Email EmailAddress { get { return new Email("[email protected]"); } } } 

Ensuite, je mettrais en œuvre un mécanisme pour fournir l’object MockPerson au moment de la conception et le véritable object Personne au moment de l’exécution. Quelque chose comme ceci ou ceci . Cela fournit une prise en charge des données au moment de la conception sans la dépendance absolue entre les environnements d’exécution et de conception.

Ce modèle est beaucoup plus flexible et vous permettra de fournir un support cohérent des données relatives au temps de conception dans l’ensemble de votre application.