{"id":1746,"date":"2025-02-20T18:16:51","date_gmt":"2025-02-20T18:16:51","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/02\/20\/net-maui-performance-features-in-net-9\/"},"modified":"2025-02-20T18:16:51","modified_gmt":"2025-02-20T18:16:51","slug":"net-maui-performance-features-in-net-9","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2025\/02\/20\/net-maui-performance-features-in-net-9\/","title":{"rendered":".NET MAUI Performance Features in .NET 9"},"content":{"rendered":"

.NET Multi-platform App UI (.NET MAUI) continues to evolve with each
\nrelease, and .NET 9 brings a focus on trimming and a new supported
\nruntime: NativeAOT. These features can help you reduce application
\nsize, improve startup times, and ensure your applications run smoothly
\non various platforms. Both developers looking to optimize their .NET
\nMAUI applications and NuGet package authors are able to take advantage
\nof these features in .NET 9.<\/p>\n

We\u2019ll also walk through the options available to you as a developer
\nfor measuring the performance of your .NET MAUI applications. Both CPU
\nsampling and memory snapshots are available via dotnet-trace and
\ndotnet-gcdump respectively. These can give insights into performance
\nproblems in your application, NuGet packages, or even something we
\nshould look into for .NET MAUI.<\/p>\n

Background<\/h2>\n

By default, .NET MAUI applications on iOS and Android use the
\nfollowing settings:<\/p>\n

\u201cSelf-contained\u201d, meaning a copy of the BCL and runtime are included
\nwith the application.<\/p>\n

\n

Note<\/strong><\/p>\n

This makes .NET MAUI applications suitable for running on \u201capp stores\u201d as no prerequisites such as installing a .NET runtime are required.<\/p><\/div>\n

Partially trimmed (TrimMode=partial), meaning that code within
\nyour applications or NuGet packages are not trimmed by default.<\/p>\n

\n

Note<\/strong><\/p>\n

This is a good default, as it is the most compatible with existing code and NuGet packages in the ecosystem.<\/p><\/div>\n

Full Trimming<\/h2>\n

This is where full-trimming (TrimMode=full) can make an impact on
\nyour application\u2019s size. If you have a substantial amount of C# code
\nor NuGet packages, you may be missing out on a significant application
\nsize reduction.<\/p>\n

To opt into full trimming, you can add the following to your .csproj file:<\/p>\n

<PropertyGroup>
\n <TrimMode>full<\/TrimMode>
\n<\/PropertyGroup><\/p>\n

For an idea on the impact of full trimming:<\/p>\n\n

\n

Note<\/strong><\/p>\n

MyPal<\/a> is a sample .NET MAUI application that is a useful comparison because of its usage of several common NuGet packages.<\/p><\/div>\n

See our trimming .NET MAUI documentation<\/a> for more
\ninformation on \u201cfull\u201d trimming.<\/p>\n

NativeAOT<\/h2>\n

Building upon full trimming, NativeAOT both relies on libraries being
\ntrim-compatible and<\/em> AOT-compatible. NativeAOT is a new runtime that
\ncan improve startup time and reduce application size compared to
\nexisting runtimes.<\/p>\n\n

\n

Note<\/strong><\/p>\n

NativeAOT is not yet supported on Android, but is available on iOS, MacCatalyst, and Windows.<\/p><\/div>\n

To opt into NativeAOT:<\/p>\n

<PropertyGroup>
\n <IsAotCompatible>true<\/IsAotCompatible>
\n <PublishAot>true<\/PublishAot>
\n<\/PropertyGroup><\/p>\n

For an idea on the impact of NativeAOT and application size:<\/p>\n\n

And startup performance:<\/p>\n\n

\n

Note<\/strong><\/p>\n

macOS on the above graphs is running on MacCatalyst, the default for .NET MAUI applications running on Mac operating systems.<\/p><\/div>\n

See our NativeAOT deployment documentation<\/a> for more
\ninformation about this newly supported runtime.<\/p>\n

NuGet Package Authors<\/h2>\n

As a NuGet package author, you may wish for your package to run in
\neither fully trimmed or NativeAOT scenarios. This can be useful for
\ndevelopers targeting .NET MAUI, mobile, or even self-contained ASP.NET
\nmicroservices.<\/p>\n

To support NativeAOT, you will need to:<\/p>\n

Mark your assemblies as \u201ctrim-compatible\u201d and \u201cAOT-compatible\u201d.
\nEnable Roslyn analyzers for trimming and NativeAOT.
\nSolve all the warnings.<\/p>\n

Begin with modifying your .csproj file:<\/p>\n

<PropertyGroup>
\n <IsTrimmable>true<\/IsTrimmable>
\n <IsAotCompatible>true<\/IsAotCompatible>
\n<\/PropertyGroup><\/p>\n

These properties will enable Roslyn analyzers as well as include
\n[assembly: AssemblyMetadata] information in the resulting .NET
\nassembly. Depending on your library\u2019s usage of features like
\nSystem.Reflection, you could have either just a few warnings or
\npotentially many<\/em> warnings.<\/p>\n

See the documentation on preparing libraries for
\ntrimming<\/a> for more information.<\/p>\n

XAML and Trimming<\/h2>\n

Sometimes, taking advantage of NativeAOT in your app can be as easy as
\nadding a property to your project file. However, for many .NET MAUI
\napplications, there can be a lot of warnings to solve. The NativeAOT
\ncompiler removes unnecessary code and metadata to make the app smaller
\nand faster. However, this requires understanding which types can be
\ncreated and which methods can and cannot be called at runtime. This is
\noften impossible to do in code which heavily uses System.Reflection.
\nThere are two areas in .NET MAUI which fall into this category: XAML
\nand data-binding.<\/p>\n

Compiled XAML<\/h3>\n

Loading XAML at runtime provides flexibility and enables features like
\nXAML hot reload. XAML can instantiate any class in the whole app, the
\n.NET MAUI SDK, and referenced NuGet packages. XAML can also set values
\nto any property.<\/p>\n

Conceptually, loading a XAML layout at runtime requires:<\/p>\n

Parsing the XML document.
\nLooking up the control types based on the XML element names using Type.GetType(xmlElementName).
\nCreating new instances of the controls using Activator.CreateInstance(controlType).
\nConverting the raw string XML attribute values into the target type of the property.
\nSetting properties based on the names of the XML attributes.<\/p>\n

This process can not only be slow, but it presents a great challenge
\nfor NativeAOT. For example, the trimmer does not know which types
\nwould be looked up using the Type.GetType method. This means that
\neither the compiler would need to keep all the classes from the whole
\n.NET MAUI SDK and all the NuGet packages in the final app, or the
\nmethod might not be able to find the types declared in the XML input
\nand fail at runtime.<\/p>\n

Fortunately, .NET MAUI has a solution \u2013 XAML compilation<\/a>.
\nThis turns XAML into the actual code for the InitializeComponent()
\nmethod at build time. Once the code is generated, the NativeAOT
\ncompiler has all the information it needs to trim your app.<\/p>\n

In .NET 9, we implemented the last remaining XAML features that the
\ncompiler could not handle in previous releases, especially compiling
\nbindings. Lastly, if your app relies on loading XAML at runtime,
\nNativeAOT might not be suitable for your application.<\/p>\n

Compiled Bindings<\/h3>\n

A binding ties together a source property with a target property. When
\nthe source changes, the value is propagated to the target.<\/p>\n

Bindings in .NET MAUI are defined using a string \u201cpath\u201d. This path
\nresembles C# expressions for accessing properties and indexers. When
\nthe binding is applied to a source object, .NET MAUI uses
\nSystem.Reflection to follow the path to access the desired source
\nproperty. This suffers from the same problems as loading XAML at
\nruntime, because the trimmer does not know which properties could be
\naccessed by reflection and so it does not know which properties it can
\nsafely trim from the final application.<\/p>\n

When we know the type of the source object at build time from
\nx:DataType attributes, we can compile the binding path into a simple
\ngetter method (and a setter method for two-way bindings). The compiler
\nwill also ensure that the binding listens to any property changes
\nalong the binding path of properties that implement
\nINotifyPropertyChanged.<\/p>\n

The XAML compiler could already compile most bindings in .NET 8 and
\nearlier. In .NET 9 we made sure any binding in your XAML code can be
\ncompiled. Learn more about this feature in the compiled bindings
\ndocumentation<\/a>.<\/p>\n

Compiled bindings in C#<\/h3>\n

The only supported way of defining bindings in C# code up until .NET 8
\nhas been using a string-based path. In .NET 9, we are adding a new
\nAPI which allows us to compile the binding using a source generator:<\/p>\n

\/\/ .NET 8 and earlier
\nmyLabel.SetBinding(Label.TextProperty, “Text”);<\/p>\n

\/\/ .NET 9
\nmyLabel.SetBinding(Label.TextProperty, static (Entry nameEntry) => nameEntry.Text);<\/p>\n

The Binding.Create() method is also an option, for when you need to
\nsave the Binding instance for later use:<\/p>\n

var nameBinding = Binding.Create(static (Entry nameEntry) => nameEntry.Text);<\/p>\n

.NET MAUI\u2019s source generator will compile the binding the same way the
\nXAML compiler does. This way the binding can be fully analyzed by the
\nNativeAOT compiler.<\/p>\n

Even if you aren\u2019t planning to migrate your application to NativeAOT,
\ncompiled bindings can improve the general performance of the binding.
\nTo illustrate the difference, let\u2019s use BenchmarkDotNet to measure
\nthe difference between the calls to SetBinding() on Android using the
\nMono runtime:<\/p>\n

\/\/ dotnet build -c Release -t:Run -f net9.0-android<\/p>\n

public class SetBindingBenchmark
\n{
\n private readonly ContactInformation _contact = new ContactInformation(new FullName(“John”));
\n private readonly Label _label = new();<\/p>\n

[GlobalSetup]
\n public void Setup()
\n {
\n DispatcherProvider.SetCurrent(new MockDispatcherProvider());
\n _label.BindingContext = _contact;
\n }<\/p>\n

[Benchmark(Baseline = true)]
\n public void Classic_SetBinding()
\n {
\n _label.SetBinding(Label.TextProperty, “FullName.FirstName”);
\n }<\/p>\n

[Benchmark]
\n public void Compiled_SetBinding()
\n {
\n _label.SetBinding(Label.TextProperty, static (ContactInformation contact) => contact.FullName?.FirstName);
\n }<\/p>\n

[IterationCleanup]
\n public void Cleanup()
\n {
\n _label.RemoveBinding(Label.TextProperty);
\n }
\n}<\/p>\n

When I ran the benchmark on Samsung Galaxy S23, I got the following results:<\/p>\n

Method
\nMean
\nError
\nStdDev
\nRatio
\nRatioSD<\/p>\n

Classic_SetBinding
\n67.81 us
\n1.338 us
\n1.787 us
\n1.00
\n0.04<\/p>\n

Compiled_SetBinding
\n30.61 us
\n0.629 us
\n1.182 us
\n0.45
\n0.02<\/p>\n

The classic binding needs to first parse the string-based path and
\nthen use System.Reflection to get the current value of the source.
\nEach subsequent update of the source property will also be faster with
\nthe compiled binding:<\/p>\n

\/\/ dotnet build -c Release -t:Run -f net9.0-android<\/p>\n

public class UpdateValueTwoLevels
\n{
\n ContactInformation _contact = new ContactInformation(new FullName(“John”));
\n Label _label = new();<\/p>\n

[GlobalSetup]
\n public void Setup()
\n {
\n DispatcherProvider.SetCurrent(new MockDispatcherProvider());
\n _label.BindingContext = _contact;
\n }<\/p>\n

[IterationSetup(Target = nameof(Classic_UpdateWhenSourceChanges))]
\n public void SetupClassicBinding()
\n {
\n _label.SetBinding(Label.TextProperty, “FullName.FirstName”);
\n }<\/p>\n

[IterationSetup(Target = nameof(Compiled_UpdateWhenSourceChanges))]
\n public void SetupCompiledBinding()
\n {
\n _label.SetBinding(Label.TextProperty, static (ContactInformation contact) => contact.FullName?.FirstName);
\n }<\/p>\n

[Benchmark(Baseline = true)]
\n public void Classic_UpdateWhenSourceChanges()
\n {
\n _contact.FullName.FirstName = “Jane”;
\n }<\/p>\n

[Benchmark]
\n public void Compiled_UpdateWhenSourceChanges()
\n {
\n _contact.FullName.FirstName = “Jane”;
\n }<\/p>\n

[IterationCleanup]
\n public void Reset()
\n {
\n _label.Text = “John”;
\n _contact.FullName.FirstName = “John”;
\n _label.RemoveBinding(Label.TextProperty);
\n }
\n}<\/p>\n

Method
\nMean
\nError
\nStdDev
\nRatio
\nRatioSD<\/p>\n

Classic_UpdateWhenSourceChanges
\n46.06 us
\n0.934 us
\n1.369 us
\n1.00
\n0.04<\/p>\n

Compiled_UpdateWhenSourceChanges
\n30.85 us
\n0.634 us
\n1.295 us
\n0.67
\n0.03<\/p>\n

The differences for a single binding aren\u2019t that dramatic but they add
\nup. This can be noticeable on complex pages with many bindings or when
\nscrolling lists like CollectionView or ListView.<\/p>\n

The full source code of the above benchmarks<\/a> is available on GitHub.<\/p>\n

Profiling .NET MAUI Applications<\/h2>\n

Attaching dotnet-trace to a .NET MAUI application, allows you to get
\nprofiling information in formats like .nettrace and .speedscope.
\nThese give you CPU sampling information about the time spent in each
\nmethod in your application. This is quite useful for finding where
\ntime is spent in the startup or general performance of your .NET
\napplications. Likewise, dotnet-gcdump can take memory snapshots of
\nyour application that display every managed C# object in memory.
\ndotnet-dsrouter is a requirement for connecting dotnet-trace to a
\nremote device, and so this is not needed for desktop applications.<\/p>\n

You can install these tools with:<\/p>\n

$ dotnet tool install -g dotnet-trace
\nYou can invoke the tool using the following command: dotnet-trace
\nTool ‘dotnet-trace’ was successfully installed.
\n$ dotnet tool install -g dotnet-dsrouter
\nYou can invoke the tool using the following command: dotnet-dsrouter
\nTool ‘dotnet-dsrouter’ was successfully installed.
\n$ dotnet tool install -g dotnet-gcdump
\nYou can invoke the tool using the following command: dotnet-gcdump
\nTool ‘dotnet-gcdump’ was successfully installed.<\/p>\n

From here, instructions differ slightly for each platform, but
\ngenerally the steps are:<\/p>\n

Build your application in Release mode. For Android, toggle
\n<AndroidEnableProfiler>true<\/AndroidEnableProfiler> in your
\n.csproj file, so the required Mono diagnostic components are
\nincluded in the application.
\nIf profiling mobile, run dotnet-dsrouter android (or
\ndotnet-dsrouter ios, etc.) on your development machine.
\nConfigure environment variables, so the application can connect to
\nthe profiler. For example, on Android:
\n$ adb reverse tcp:9000 tcp:9001
\n# no output
\n$ adb shell setprop debug.mono.profile ‘127.0.0.1:9000,nosuspend,connect’
\n# no output<\/p>\n

Run your application.
\nAttach dotnet-trace (or dotnet-gcdump) to the application,
\nusing the PID of dotnet-dsrouter:
\n$ dotnet-trace ps
\n38604 dotnet-dsrouter ~\/.dotnet\/tools\/dotnet-dsrouter.exe ~\/.dotnet\/tools\/dotnet-dsrouter.exe android<\/p>\n

$ dotnet-trace collect -p 38604 –format speedscope
\nNo profile or providers specified, defaulting to trace profile ‘cpu-sampling’<\/p>\n

Provider Name Keywords Level Enabled By
\nMicrosoft-DotNETCore-SampleProfiler 0x0000F00000000000 Informational(4) –profile
\nMicrosoft-Windows-DotNETRuntime 0x00000014C14FCCBD Informational(4) –profile <\/p>\n

Waiting for connection on \/tmp\/maui-app
\nStart an application with the following environment variable: DOTNET_DiagnosticPorts=\/tmp\/maui-app<\/p>\n

For iOS, macOS, and MacCatalyst, see the iOS profiling wiki
\npage<\/a> for more information.<\/p>\n\n

\n

Note<\/strong><\/p>\n

For Windows applications, you might just consider using Visual Studio\u2019s built-in profiling tools, but dotnet-trace collect — C:pathtoanexecutable.exe is also an option.<\/p><\/div>\n

Now that you\u2019ve collected a file containing performance information,
\nopening them to view the data is the next step:<\/p>\n

dotnet-trace by default outputs .nettrace files, which can be
\nopened in PerfView<\/a> or Visual Studio.
\ndotnet-trace collect –format speedscope outputs .speedscope
\nfiles, which can be opened in the Speedscope web app<\/a>.
\ndotnet-gcdump outputs .gcdump files, which can be opened in
\nPerfView<\/a> or Visual Studio. Note that there is not
\ncurrently a good option to open these files on macOS.<\/p>\n

In the future, we hope to make profiling .NET MAUI applications easier
\nin both future releases of the above .NET diagnostic tooling and
\nVisual Studio.<\/p>\n\n

\n

Note<\/strong><\/p>\n

Note that the NativeAOT runtime does not have support for dotnet-trace and performance profiling. You can use the other supported runtimes for this, or use native profiling tools instead such as Xcode\u2019s Instruments.<\/p><\/div>\n

See the profiling .NET MAUI wiki page<\/a> for links to
\ndocumentation on each platform or a profiling demo on
\nYouTube<\/a> for a full walkthrough.<\/p>\n

Conclusion<\/h2>\n

.NET 9 introduces performance enhancements for .NET MAUI applications
\nthrough full trimming and NativeAOT. These features enable developers
\nto create more efficient and responsive applications by reducing
\napplication size and improving startup times. By leveraging tools like
\ndotnet-trace and dotnet-gcdump, developers can gain insights into
\ntheir application\u2019s performance.<\/p>\n

For a full rundown on .NET MAUI trimming and NativeAOT, see the
\n.NET Conf 2024 session<\/a> on the topic.<\/p>\n\n

The post .NET MAUI Performance Features in .NET 9<\/a> appeared first on .NET Blog<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"

.NET Multi-platform App UI (.NET MAUI) continues to evolve with each release, and .NET 9 brings a focus on trimming […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-1746","post","type-post","status-publish","format-standard","hentry","category-dotnet"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/1746","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=1746"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/1746\/revisions"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=1746"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=1746"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=1746"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}