How to set PerMonitor DpiAwareness for .NET 8 Windows desktop application in WPF?

MERUN KUMAR MAITY 576

Hi,

I am having problem setting WPF window based desktop .NET 8 application to work as PerMonitor DpiAware.

System default automatic scaling schema...

When user changes Windows 10 display setting scale, WPF-Window is being scaled accordingly.
Also, when window is dragged to another display, that has different scale, window is being scaled.

I want to prevent these automatic scaling because I'm using my own scaling schema.

Before .NET 6, when application was using WPF 4.8, following two items together were preventing such automatic behavior:

A) @ app.manifest

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

B) @ app.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.8"/>
    </startup>
  <runtime>
    <AppContextSwitchOverrides value="Switch.System.Windows.DoNotScaleForDpiChanges=true"/>
  </runtime>
</configuration>

Now, @ .NET 8, that is not working anymore!

After a lots of hard work finally I find the solution...trick was ... app.config file is not NET 8 compatible.

So, AppContextSwitchOverrides … Switches like...

Switch.System.Windows.DoNotScaleForDpiChanges

are transferred from

"appname".config => "appname".runtimeconfig.json

In order to control these switches ... I had to put new item group into *.csproj

<Project>  
   ...  
   <ItemGroup>  
      <RuntimeHostConfigurationOption Include="Switch.System.Windows.DoNotScaleForDpiChanges" Value="true" />  
      <RuntimeHostConfigurationOption Include="Switch.System.IO.UseLegacyPathHandling" Value="false" />  
   </ItemGroup>  
   ...  
   </Project>

So, now the PerMonitor DpiAwareness is working as expected. But there a little bit problem arise, When I start my Application on a different monitor which have different screen resolution and different screen scaling, my App is unable to re-scale it's UI.

But the app runs perfectly when I change the screen DPI and screen resolutions at the time of running and if I close the app and run again on that different screen DPI and screen resolution it's not working as expected.

youzeliang 480 Reputation points

2024-09-03T15:41:58.7766667+00:00

ok, you may try to another way
MERUN KUMAR MAITY 576 Reputation points

2024-09-03T16:33:39.4233333+00:00

I assume that you previously worked with PerMonitor DpiAwareness, I hope you able to solve this issue in your project.

you may try to another way

What another way I should try so that I can achieve that. Can you please help me?

Hui Liu-MSFT 48,506 Microsoft Vendor

Hi,@MERUN KUMAR MAITY. Welcome to Microsoft Q&A.

I tried the solution in the following example but it doesn't resize its UI when I change the scale at runtime. I'm still working on it.
Am I missing something? Did I misunderstand something? Could you share your minimal sample code that can reproduce your problem? .csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <UseWPF>true</UseWPF>
    <ApplicationManifest>app.manifest</ApplicationManifest>
  </PropertyGroup>
	<ItemGroup>

		<RuntimeHostConfigurationOption Include="Switch.System.Windows.DoNotScaleForDpiChanges" Value="true" />
		<RuntimeHostConfigurationOption Include="Switch.System.IO.UseLegacyPathHandling" Value="false" />
	</ItemGroup>
</Project>

app.manifest:

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

test.runtimeconfig.json:

{
  "runtimeOptions": {

    "configProperties": {

      "System.Windows.DoNotScaleForDpiChanges": true,

      "System.IO.UseLegacyPathHandling": false

    }
  }
}

AssemblyInfo.cs:

using System.Windows;
using System.Windows.Media;

[assembly: ThemeInfo(
    ResourceDictionaryLocation.None,           
    ResourceDictionaryLocation.SourceAssembly  
)]

[assembly:DisableDpiAwareness]

App.xaml.cs:

 public partial class App : Application
 {
     protected override void OnStartup(StartupEventArgs e)

     {

         if (Environment.OSVersion.Version >= new Version(6, 3, 0)) // win 8.1 added support for per monitor dpi

         {

             if (Environment.OSVersion.Version >= new Version(10, 0, 15063)) // win 10 creators update added support for per monitor v2

             {

                 NativeMethods.SetProcessDpiAwarenessContext((int)NativeMethods.DPI_AWARENESS_CONTEXT.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);

             }

             else NativeMethods.SetProcessDpiAwareness(NativeMethods.PROCESS_DPI_AWARENESS.Process_Per_Monitor_DPI_Aware);

         }

         else NativeMethods.SetProcessDPIAware();



         base.OnStartup(e);

     }
 }

MainWindow.xaml:

<Window x:Class="WpfApp4.MainWindow"
      ...
        mc:Ignorable="d"  x:Name="MyWindow"
       >
    <Viewbox Stretch="Fill">

        <Canvas Width="800" Height="450" Background="#666666">

            <TextBlock x:Name="My_Control_1" Text="{Binding CurrentDpi_X}" Canvas.Top="20" Canvas.Left="30" Width="400" Height="30"></TextBlock>

            <TextBlock x:Name="My_Control_2" Text="{Binding CurrentDpi_X}" Canvas.Top="60" Canvas.Left="30" Width="400" Height="30"></TextBlock>

            <Button x:Name="My_Control_3" Content="I am Button" Canvas.Top="120" Canvas.Left="30" Width="400" Height="30" ></Button>

          
        </Canvas>

    </Viewbox>

</Window>

    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        private double scaleX = 800;
        private double scaleY = 450;
        private string currentDpi_X;
        private string currentDpi_Y;
        public string CurrentDpi_X { get { return currentDpi_X; } set { currentDpi_X = value; OnPropertyChanged("CurrentDpi_X"); } }

        public string CurrentDpi_Y { get { return currentDpi_Y; } set { currentDpi_Y = value; OnPropertyChanged("CurrentDpi_Y"); } }

        public event PropertyChangedEventHandler PropertyChanged;

        public MainWindow()
        {
            InitializeComponent();

            this.DataContext = this;
        }
        protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
        {
            new Thread(ScaleWindow).Start();

        }
        public void ScaleWindow()

        {

            this.Dispatcher.Invoke(() =>

            {

                DpiScale Dpi = VisualTreeHelper.GetDpi(this);

                CurrentDpi_X = "Current DPI_X:  " + Dpi.DpiScaleX + "  The various elements of the Window should scale_x:  " + 1 / Dpi.DpiScaleX;

                CurrentDpi_Y = "Current DPI_Y:  " + Dpi.DpiScaleY + "  The various elements of the Window should scale_y:  " + 1 / Dpi.DpiScaleY;

                MyWindow.Width = scaleX / Dpi.DpiScaleX;

                MyWindow.Height = scaleY / Dpi.DpiScaleY;

            });

        }
        public void OnPropertyChanged(string name)
        {
            PropertyChanged.Invoke(this, new PropertyChangedEventArgs(name));

        }
    }
    internal static class NativeMethods

    {
        [DllImport("user32.dll", SetLastError = true)]

        internal static extern bool SetProcessDpiAwarenessContext(int dpiFlag);

        [DllImport("SHCore.dll", SetLastError = true)]

        internal static extern bool SetProcessDpiAwareness(PROCESS_DPI_AWARENESS awareness);

        [DllImport("user32.dll")]

        internal static extern bool SetProcessDPIAware();

        internal enum PROCESS_DPI_AWARENESS
        {
            Process_DPI_Unaware = 0,

            Process_System_DPI_Aware = 1,

            Process_Per_Monitor_DPI_Aware = 2
        }
        internal enum DPI_AWARENESS_CONTEXT

        {

            DPI_AWARENESS_CONTEXT_UNAWARE = 16,

            DPI_AWARENESS_CONTEXT_SYSTEM_AWARE = 17,

            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE = 18,

            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = 34

        }

    }

MERUN KUMAR MAITY 576 Reputation points

2024-09-14T18:21:10.9966667+00:00

Thanks for trying, I suggest you to watch this link : https://developercommunity.visualstudio.com/t/dpiawareness-donotscalefordpichanges-not-working-f/1605189
Hui Liu-MSFT 48,506 Reputation points Microsoft Vendor

2024-09-17T09:42:09.85+00:00

Hi,@MERUN KUMAR MAITY. It seems that this cannot be achieved using the method in the link.

You could try the Task Manager DPI Awareness column or searching third-party tool using keyword for google to verify your application’s DPI awareness status.

Make sure you’ve properly handled the WM_DPICHANGED message in your WPF application to dynamically adjust scaling when DPI changes.

Double-check that your app’s manifest file has the correct DPI settings (true/pm) for per-monitor awareness.

Use tools like Windows Display Settings to test different DPI configurations on Windows 11.
MERUN KUMAR MAITY 576 Reputation points

2024-09-17T13:05:45.7+00:00

Thanks for your comment. I already tried to verify my application’s DPI awareness status using Task manager and what I see is, my Application perfectly working as expected in the Task Manager DPI Awareness column.

This DPI Awareness showing as Per Monitor & Per Monitor v2 depending upon what manifest option I give their.

But their only one last problem is, if I restart my application at different screen scaling and different screen resolution My app does not perform like previous. Though I already verified that it get the Per Monitor DPI Awareness but still able to perform.

Though I have already found a solution, in a GitHub repository someone solve the problem in Windows Form Application. It need some tweaking because I am unable to Run that project on my Visual Studio 2022, but I assume that you are an experience developer you definitely solve that issue.

Here is the project link please try to run on your Computer / Laptop :

https://github.com/chjfth/window-finder-control

Share via

How to set PerMonitor DpiAwareness for .NET 8 Windows desktop application in WPF?

Your answer