Author: plaroche

Posted on

Hello Medium! I’m Paulin Laroche, Your .NET MAUI Expert👋

Welcome to what I hope will become your go-to resource for everything .NET MAUI! I’m thrilled to join the Medium community and share my passion for cross-platform development with Microsoft’s revolutionary Multi-platform App UI framework.

Who Am I?

I’m Paulin Laroche, a seasoned software developer with deep expertise in the Microsoft ecosystem. My journey has taken me through the entire evolution of Microsoft’s cross-platform story — from the early days of Xamarin to the modern era of .NET MAUI. You can connect with me on LinkedIn where I regularly share insights about the ever-changing landscape of mobile development.

The Life and Times of .NET MAUI: A Developer’s Perspective

Having lived through the entire lifecycle of cross-platform development in the Microsoft world, I want to share the fascinating journey of .NET MAUI — not just as a technology, but as a living, breathing ecosystem that continues to evolve.

The Xamarin Era: Where It All Began

Before we had .NET MAUI, there was Xamarin. I remember the excitement when Microsoft acquired Xamarin in 2016 — suddenly, C# developers had a real path to mobile development. Xamarin.Forms gave us our first taste of “write once, run everywhere,” but it came with its challenges:

  • Performance bottlenecks that required platform-specific optimizations
  • Complex debugging across different platforms
  • Fragmented ecosystem with different approaches for iOS and Android
  • Limited desktop support that left Windows and macOS as afterthoughts

But despite these challenges, Xamarin taught us something crucial: developers wanted unified development experiences without sacrificing native performance.

.NET MAUI: The Natural Evolution

When .NET MAUI was announced, it wasn’t just an upgrade to Xamarin.Forms — it was a complete reimagining of cross-platform development. Here’s what I’ve observed in its evolution:

The Architecture Revolution

MAUI’s single-project approach changed everything. No more separate projects for each platform. No more complex configuration nightmares. One project, multiple targets, infinite possibilities.

Performance Renaissance

The performance improvements weren’t just incremental — they were transformational. Apps that struggled on Xamarin.Forms suddenly flew on MAUI. I’ve seen 40–60% improvements in startup times and memory usage in real-world applications, and with the introduction of AOT (Ahead-of-Time) compilation in .NET 9, the startup performance is just insane. We’re talking about mobile apps that launch faster than many native applications — something that seemed impossible in the early Xamarin days.

The Handler Model: A Stroke of Genius

Moving from renderers to handlers wasn’t just a technical change — it was philosophical. It gave developers unprecedented control over how their apps behave on each platform while maintaining code consistency.

MAUI in the Wild: Real-World Evolution

What fascinates me most about MAUI is how it’s evolving in production environments:

Enterprise Adoption

Large enterprises are migrating from legacy Xamarin apps to MAUI, and the results are remarkable. I’ve worked with companies that have:

  • Reduced their development teams by 40% while increasing output
  • Unified their iOS, Android, Windows, and macOS apps under single codebases
  • Dramatically improved their release cycles

Startup Innovation

Startups are choosing MAUI for rapid prototyping and MVP development. The ability to validate ideas across all platforms simultaneously is changing how quickly new products can reach market.

The Community Explosion

The MAUI community isn’t just growing — it’s thriving. Every week brings new libraries, controls, and innovations from developers worldwide.

The Current State: MAUI Today

As of 2024, .NET MAUI has matured into a robust, production-ready platform. Here’s what I’m seeing:

Stability and Reliability

The early growing pains are largely behind us. MAUI apps are running in app stores worldwide, handling millions of users without breaking a sweat.

Rich Ecosystem

Third-party component libraries have caught up. Whether you need complex charts, advanced UI controls, or specialized platform integrations, the ecosystem has you covered.

Microsoft’s Commitment

The regular updates, new features, and continued investment from Microsoft show this isn’t just a side project — it’s the future of their development platform.

What Makes MAUI Special: My Developer’s Take

After years of working with various cross-platform solutions, here’s why MAUI stands out:

Native Performance, Unified Experience: You get true native performance without the complexity of maintaining separate codebases.

Future-Proof Architecture: Built on .NET’s solid foundation, MAUI grows with the platform rather than fighting against it.

Developer Productivity: The tooling, hot reload, and debugging experience make development genuinely enjoyable.

Platform Integration: Deep integration with platform-specific features without compromising the shared codebase.

A Quick Taste of Modern MAUI

Here’s a simple example that showcases what makes MAUI special — platform-aware UI that adapts automatically:

public partial class AdaptivePage : ContentPage
{
    public AdaptivePage()
    {
        InitializeComponent();
        
        var titleLabel = new Label
        {
            Text = "Welcome to MAUI!",
            FontSize = DeviceInfo.Platform == DevicePlatform.iOS ? 28 : 24,
            HorizontalOptions = LayoutOptions.Center
        };
        
        var platformButton = new Button
        {
            Text = $"Hello from {DeviceInfo.Platform}!",
            BackgroundColor = DeviceInfo.Platform == DevicePlatform.iOS 
                ? Colors.Blue 
                : Colors.Green
        };
        
        platformButton.Clicked += async (s, e) =>
        {
            await DisplayAlert("Platform Info", 
                $"Running on {DeviceInfo.Platform} {DeviceInfo.VersionString}", 
                "Cool!");
        };
        
        Content = new StackLayout
        {
            Padding = 20,
            Children = { titleLabel, platformButton }
        };
    }
}

This simple code demonstrates platform awareness, adaptive UI, and native integration — all hallmarks of modern MAUI development.

The Road Ahead: MAUI’s Future

The evolution continues. Microsoft’s roadmap includes exciting developments like:

  • Enhanced desktop capabilities
  • Improved web integration
  • AI and machine learning integrations
  • Performance optimizations that push the boundaries even further

Join the Journey: From MonoTouch to MAUI’s Future

Whether you’re migrating from Xamarin, exploring cross-platform options, or building your next enterprise-grade solution, .NET MAUI represents the culmination of over a decade of cross-platform evolution. As someone who has followed Miguel de Icaza’s vision from the MonoTouch days and now leads development at Edenred, I’ve seen how far we’ve come and I’m excited about where we’re heading.

I’m here to share this journey with you — drawing from real-world enterprise experience, production applications, and years of living and breathing this ecosystem. From SDK architecture to payment processing apps, from startup MVPs to enterprise solutions, let’s explore the depths of what MAUI can do.

The applications I’ve built, the challenges I’ve solved, and the lessons I’ve learned along the way will form the foundation for the insights I’ll be sharing. This isn’t just theoretical knowledge — it’s battle-tested wisdom from the trenches of real-world development.

Let’s build the future, one app at a time! 🚀

If you found this perspective valuable, please give it a clap 👏 and follow me for more insights into the evolving world of .NET MAUI.

Connect with me:

Tags: #DotNetMAUI #CrossPlatform #Mobile #Xamarin #Microsoft #AppDevelopment #Evolution

Posted on

FuelWatchr

Comment être notifié de la hausse et de la baisse et du prix des carburants de vos stations services proches de chez vous …

L’histoire

Le projet consiste à créer une interface (UI) et une expérience utilisateur (UX) augmentée lors de la recherche de stations service proposant les prix les moins cher.

Plus besoin de se connecter à l’application et de vérifier les tarifs des stations environnantes. Soyez averti automatiquement lors de la baisse et/ ou de l’augmentation de prix par le biais de notifications de vos stations préférées et des stations environnantes disponibles sur votre trajet (en fonctions des prix pratiqués dans vos stations de références).

Rejoignez les stations via Apple Plan, Google Maps et Waze, Apple Car et Android Auto.

Certaines fonctionnalités nécessites un abonnement payant que j’offre à tout souscripteurs.

Risques et défis

Le défi majeur est d’être prêt pour 2024, année ou les prix vont exploser à la pompe. Le 2ème défi est de développer l’algorithme côté serveur qui permet de notifier les baisses et les hausses de tarifs en fonction des stations de préférence des utilisateurs.

Engagements pour l’environnement

Utilisation d’un backend serveur dans le cloud pour limiter les consommations électriques énergivores.

Posted on

Power Meteo

L’application qui présente les risques de coupures d’électricité du réseau RTE sous forme de bulletin météo.

Activez les notifications afin d’être prévenu de tout changement.

Cette application exploite les données d’API “signal” d’EcoWatt.

Application disponible sur iOS, Android.

Confidentialité : Cette application, ne collecte aucune données personnelles.

Android
https://play.google.com/store/apps/details?id=com.mobile_concept.powermeteo

iOS
https://apps.apple.com/fr/app/power-meteo/id6444955379

Posted on

Xamarin.Forms Shell: Customizing the TabBar

Introduction

Xamarin.Forms Shell reduces the complexity of mobile application development by providing the fundamental features that most mobile applications require. 

Customization

This post will offer you a way for customize the TabBar of the Shell on iOS and Android platforms by adding a centered button.

In order to do it, i publish a Nuget Package named ExtendedShellTabBar. This package is available on Nuget.org repository : https://www.nuget.org/packages/ExtendedShellTabBar.

Feel free to use it and don’t hesitate to send me your comments to improve it and adding more functionalities.

My work start from an article published by Andrew Hoefling, the 6/26/2019 on his blog : Xamarin.Forms Shell: Customizing the TabBar (Android) (andrewhoefling.com).

The Design

iOS
Android

Start Project

To achieve to do it like above, first of all, open Visual Studio 2019 and create a “Shell Forms App”

Add the Nuget Package

Click right on the solution and select “Manage Nuget Packages”. In the search box enter “ExtendedShellTabBar” and add it to the whole project in the solution.

The Centered Icon

If like me you have a licence of “MFractor”, add an icon in your project like below. If not, add your icon manually in drawables ressources for Android and XCAssets for iOS.

The XAML Shell

Update your “AppShell.xaml” file like below :

<?xml version="1.0" encoding="UTF-8"?>
<Shell xmlns="http://xamarin.com/schemas/2014/forms" 
       xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
       xmlns:local="clr-namespace:ExtendedShellTabBarSample.Views"
       xmlns:tabbar="clr-namespace:ExtendedShellTabBar.VisualElements;assembly=ExtendedShellTabBar"
       Title="ExtendedShellTabBarSample"
       x:Class="ExtendedShellTabBarSample.AppShell">

    <!--
        The overall app visual hierarchy is defined here, along with navigation.
    
        https://docs.microsoft.com/xamarin/xamarin-forms/app-fundamentals/shell/
    -->

    <Shell.Resources>
        <ResourceDictionary>
            <Style x:Key="BaseStyle" TargetType="Element">
                <Setter Property="Shell.BackgroundColor" Value="{StaticResource Primary}" />
                <Setter Property="Shell.ForegroundColor" Value="White" />
                <Setter Property="Shell.TitleColor" Value="White" />
                <Setter Property="Shell.DisabledColor" Value="#B4FFFFFF" />
                <Setter Property="Shell.UnselectedColor" Value="#95FFFFFF" />
                <Setter Property="Shell.TabBarBackgroundColor" Value="{StaticResource Primary}" />
                <Setter Property="Shell.TabBarForegroundColor" Value="White"/>
                <Setter Property="Shell.TabBarUnselectedColor" Value="#95FFFFFF"/>
                <Setter Property="Shell.TabBarTitleColor" Value="White"/>
            </Style>
            <Style TargetType="TabBar" BasedOn="{StaticResource BaseStyle}" />
            <Style TargetType="FlyoutItem" BasedOn="{StaticResource BaseStyle}" />
        </ResourceDictionary>
    </Shell.Resources>

    <tabbar:ExtendedShellTabBar>
        <tabbar:ExtendedShellTabBar.CenteredTab>
            <tabbar:ExtendedShellCenteredTab 
                Command="{Binding ClickCommand}" 
                BorderColor="White" 
                BorderThickness="2" 
                CornerRadius="30" 
                Icon="centeredadd.png" 
                Width="60" 
                Height="60" />
        </tabbar:ExtendedShellTabBar.CenteredTab>
        <ShellContent Title="About" Icon="icon_about.png" Route="AboutPage" ContentTemplate="{DataTemplate local:AboutPage}" />
        <ShellContent Title="Browse" Icon="icon_feed.png" ContentTemplate="{DataTemplate local:ItemsPage}" />
    </tabbar:ExtendedShellTabBar>

    <!--
        If you would like to navigate to this content you can do so by calling
        await Shell.Current.GoToAsync("//LoginPage");
    -->
    <!--<TabBar>
        <ShellContent Route="LoginPage" ContentTemplate="{DataTemplate local:LoginPage}" />
    </TabBar>-->


</Shell>

The View Model

Add a AppShellViewModel.cs file to handle the “ClickCommand” :

public class AppShellViewModel
{
    public ICommand ClickCommand { get; set; }

    public AppShellViewModel()
    {

        ClickCommand = new Command(async () =>
        {
            await Application.Current.MainPage.DisplayAlert("Click !", "You click the centered button inside the TabBar", "OK");
        });
    }
}

And don’t forget to declare the ViewModel in the code behind , the file “AppShell.xaml.cs” :

public partial class AppShell : Xamarin.Forms.Shell
{
    public AppShell()
    {
        InitializeComponent();

        this.BindingContext = new AppShellViewModel();

        Routing.RegisterRoute(nameof(ItemDetailPage), typeof(ItemDetailPage));
        Routing.RegisterRoute(nameof(NewItemPage), typeof(NewItemPage));
    }
}

The Final Result

iOS
Android

Conclusion

I have the entire code we built from this article available on GitHub. Please follow the link : https://github.com/xamarin-plaroche/ExtendedShellTabBar.

All sources code are available on it :

  • Nuget Package source code
  • Sample App

Enjoy ! 😊

Posted on

RoundedLayouts

Hello, Here is the link to my new package nuget Xamarin.Forms .

This Nuget package, present a collection of xamarin forms layout with the capabilities of rounding all corners or some of them.

The layouts are :

– RoundedStackLayout
– RoundedContentView
– RoundedGrid

I based this development on the CachedImage/ RoundTransformation library developed by Daniel Luberda & Fabien Molinet (https://github.com/luberda-molinet/FFImageLoading)

https://www.nuget.org/packages/RoundedLayouts.NuGet/

© 2018 Mobile Concept. Terms and privacy policy. Powered by WordPress