Comment configurer une application pour qu'elle fonctionne correctement sur une machine avec un réglage DPI élevé (par exemple 150%) ?

Question

J'ai créé une application Winforms simple en C#. Lorsque je lance l'application sur une machine avec des paramètres DPI élevés (par exemple 150%), l'application est mise à l'échelle. Jusqu'ici, tout va bien ! Mais au lieu de rendre les polices avec une taille de police plus élevée, tous les textes sont également mis à l'échelle. Cela conduit bien sûr à un texte très flou (sur tous les contrôles comme les boutons, etc.).

Windows ne devrait-il pas se charger de rendre les textes correctement ? Par exemple, la barre de titre de mon application est rendue de manière claire et nette.

Answer 1

Lorsque vous dépassez les 100 % (ou 125 % si la case "Mise à l'échelle DPI de style XP" est cochée), Windows prend en charge par défaut la mise à l'échelle de votre interface utilisateur. Pour ce faire, il demande à votre application d'effectuer le rendu de ses résultats dans un bitmap et de dessiner ce bitmap à l'écran. La remise à l'échelle de ce bitmap donne inévitablement un aspect flou au texte. Une fonction appelée "virtualisation DPI" permet aux anciens programmes de rester utilisables sur des écrans à haute résolution.

Vous devez lui faire savoir explicitement que vous pouvez gérer des paramètres DPI plus élevés en ajoutant l'option <dpiAware> à votre manifeste. La page MSDN est ici mais il n'est pas complet car il omet les paramètres UAC. Projet + Ajouter un nouvel élément, choisissez "Application Manifest File". Editez le texte du manifeste ou copiez/collez ceci :

<?xml version="1.0" encoding="utf-8"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" >
    <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
        <security>
            <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
                <requestedExecutionLevel level="asInvoker" uiAccess="false" />
            </requestedPrivileges>
        </security>
    </trustInfo>
    <asmv3:application>
        <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
            <dpiAware>true</dpiAware>
        </asmv3:windowsSettings>
    </asmv3:application>
</assembly>

Vous pouvez également pinvoke SetProcessDPIAware() dans votre méthode Main(), nécessaire par exemple si vous déployez avec ClickOnce :

    [STAThread]
    static void Main() {
        if (Environment.OSVersion.Version.Major >= 6) SetProcessDPIAware();
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());             // Edit as needed
    }

    [System.Runtime.InteropServices.DllImport("user32.dll")]
    private static extern bool SetProcessDPIAware();

---

MISE À JOUR, ce besoin commun est finalement un peu plus facile si vous utilisez VS2015 Update 1 ou plus. Le manifeste ajouté possède déjà la directive correspondante, il suffit de supprimer les commentaires.

---

Mot clé pour la recherche afin que je puisse retrouver ce post : dpiAware

Answer 2

Les applications peuvent être développées selon deux modes différents.

La première consiste à déclarer que notre application n'est pas sensible à l'interface DPI (si nous ne déclarons rien, cela sera le cas par défaut). Dans ce cas, le système d'exploitation rendra notre application sous le format prévu 96 DPI et fera ensuite la mise à l'échelle du bitmap dont nous avons parlé précédemment. Le résultat sera une application à l'aspect flou, mais avec une mise en page correcte.

La deuxième option consiste à déclarer l'application comme étant sensible à l'IAP. Dans ce cas, le système d'exploitation n'effectuera aucune mise à l'échelle et laissera votre application s'afficher en fonction du DPI original de l'écran. Dans le cas d'un environnement DPI par moniteur, votre application sera rendue avec le DPI le plus élevé de tous les écrans, puis ce bitmap sera réduit à la taille appropriée pour chaque moniteur. La réduction d'échelle donne une meilleure expérience visuelle que l'augmentation d'échelle, mais vous pouvez toujours remarquer un certain flou.

Si vous voulez éviter cela, vous devez déclarer votre application comme étant sensible à la DPI par moniteur. Vous devez alors détecter lorsque votre application est déplacée sur différents moniteurs et effectuer le rendu en fonction de la DPI du moniteur actuel.

La déclaration de la sensibilisation à l'IAP se fait dans un fichier manifeste.

consultez le lien suivant stackoverflow

Answer 3

À l'aide de .NET Framework 4.7 et de Windows 10 Creators Update (1703) ou d'une version plus récente, vous devez effectuer les opérations suivantes pour configurer la prise en charge du DPI élevé pour votre application Windows Form :

Déclarer la compatibilité avec Windows 10.

Pour ce faire, ajoutez les éléments suivants à votre manifest archivo:

<compatibility xmlns="urn:schemas-microsoft.com:compatibility.v1">
  <application>
    <!-- Windows 10 compatibility -->
    <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
  </application>
</compatibility>

Activez la prise en compte de l'IAP par moniteur dans l'interface de l'utilisateur. app.config archivo.

Windows Forms introduit une nouvelle Section de configuration de l'application (System.Windows.Forms.ApplicationConfigurationSection) pour prendre en charge les nouvelles fonctionnalités et personnalisations ajoutées à partir de la version 4.7 de .NET Framework. Pour tirer parti des nouvelles fonctionnalités qui prennent en charge le DPI élevé, ajoutez ce qui suit au fichier de configuration de votre application.

<System.Windows.Forms.ApplicationConfigurationSection>
  <add key="DpiAwareness" value="PerMonitorV2" />
</System.Windows.Forms.ApplicationConfigurationSection>

Important

Dans les versions précédentes de .NET Framework, vous utilisiez le manifeste pour ajouter la prise en charge de l'indice DPI élevé. Cette approche n'est plus recommandée, car elle remplace les paramètres définis dans le fichier app.config.

Appelez la méthode statique EnableVisualStyles.

Il doit s'agir du premier appel de méthode dans le point d'entrée de votre application. Par exemple :

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form1());   
}

L'avantage de ce système est la prise en charge de scénarios DPI dynamiques dans lesquels l'utilisateur modifie le DPI ou le facteur d'échelle après le lancement d'une application Windows Forms.

Fuente: Support du DPI élevé dans Windows Forms

Answer 4

Aucune de ces suggestions n'a fonctionné pour moi, mais il s'est passé quelque chose après que j'ai retiré le Form.Font = new ... de la Form.Design.cs le formulaire a commencé à être redimensionné correctement, cela fonctionne si la police est définie dans le constructeur ou pas du tout. Pourquoi ? Quelqu'un d'autre peut être en mesure d'expliquer, je peux juste parler de la modification que j'ai faite et il m'a fallu quelques minutes pour comprendre que c'était la cause fondamentale pour le formulaire sur lequel je travaillais. J'espère que cela vous aidera.

Answer 5

Depuis au moins Visual Studio 2017, il suffit d'ajouter un fichier manifest et de décommenter cette section :

<application xmlns="urn:schemas-microsoft-com:asm.v3">
    <windowsSettings>
        <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
    </windowsSettings>
</application>