Hey guys! Ever wondered how to figure out if your .NET MAUI app is running on Android or iOS? It's a common task when you need to tweak your code for specific platforms. Let's dive into how you can easily detect the operating system in your .NET MAUI applications.

Why Detect the Operating System?

Before we get into the code, let's quickly chat about why you might need to do this. Imagine you're building a cool app that uses platform-specific features. For example, you might want to use unique Android APIs or iOS functionalities. Knowing which platform your app is running on allows you to execute the right code, ensuring the best user experience. Plus, it helps you handle any quirky platform differences gracefully. Detecting the operating system is super useful for:

• Implementing platform-specific features
• Handling UI differences between platforms
• Optimizing performance for each OS
• Using platform-specific APIs

Using the DeviceInfo Class

The easiest way to determine the operating system in .NET MAUI is by using the DeviceInfo class. This class provides a bunch of useful information about the device your app is running on, including the platform. Here’s how you can use it:

Accessing Platform Information

To get started, you'll need to access the DeviceInfo.Platform property. This property returns an enum value that tells you which platform your app is running on. Here’s a simple example:

using Microsoft.Maui.Devices;

public class MyViewModel
{
    public string GetPlatform()
    {
        var platform = DeviceInfo.Platform;

        switch (platform)
        {
            case DevicePlatform.Android:
                return "Android";
            case DevicePlatform.iOS:
                return "iOS";
            default:
                return "Unknown";
        }
    }
}

In this snippet, we're using a switch statement to check the value of DeviceInfo.Platform. If it's DevicePlatform.Android, we return "Android". If it's DevicePlatform.iOS, we return "iOS". And if it's anything else, we return "Unknown". Pretty straightforward, right?

Example in a .NET MAUI App

Let's put this into a real .NET MAUI app. Suppose you want to display the platform name in a label. Here’s how you can do it in your XAML file:

<VerticalStackLayout
    Padding="30,0"
    VerticalOptions="Start">

    <Label
        Text="Welcome to .NET MAUI!"
        SemanticProperties.HeadingLevel="Level1"
        FontSize="32"
        HorizontalOptions="Center" />

    <Label
        Text="Platform: {Binding PlatformName}"        
        FontSize="18"
        HorizontalOptions="Center" />

</VerticalStackLayout>

And here’s the corresponding C# code:

using Microsoft.Maui.Devices;
using Microsoft.Maui.Controls;

namespace MauiApp1
{
    public partial class MainPage : ContentPage
    {
        public string PlatformName { get; set; }

        public MainPage()
        {
            InitializeComponent();
            PlatformName = GetPlatform();
            BindingContext = this;
        }

        public string GetPlatform()
        {
            var platform = DeviceInfo.Platform;

            switch (platform)
            {
                case DevicePlatform.Android:
                    return "Android";
                case DevicePlatform.iOS:
                    return "iOS";
                default:
                    return "Unknown";
            }
        }
    }
}

In this example, we've created a property called PlatformName in our MainPage class. We set this property to the result of our GetPlatform() method, which uses DeviceInfo.Platform to determine the operating system. Then, we bind this property to a label in our XAML file, so the platform name is displayed on the screen. This is a simple and effective way to show the platform your app is running on.

Using Conditional Compilation

Another way to detect the operating system is by using conditional compilation. This involves using preprocessor directives to include or exclude code based on the platform. It’s a bit more advanced, but it can be very useful for platform-specific code.

Preprocessor Directives

Preprocessor directives are special instructions that are processed by the compiler before the code is compiled. In C#, you can use directives like #if, #elif, #else, and #endif to conditionally include code. Here’s an example:

#if ANDROID
    // Android-specific code here
    string platform = "Android";
#elif IOS
    // iOS-specific code here
    string platform = "iOS";
#else
    // Default code here
    string platform = "Unknown";
#endif

    Console.WriteLine($"Running on {platform}");

In this example, the code inside the #if ANDROID block will only be compiled if the ANDROID symbol is defined. Similarly, the code inside the #elif IOS block will only be compiled if the IOS symbol is defined. If neither symbol is defined, the code inside the #else block will be compiled.

Setting Conditional Compilation Symbols

To use conditional compilation effectively, you need to set the appropriate symbols for each platform. In .NET MAUI, these symbols are usually defined automatically based on the target platform. However, you can also define them manually in your project file.

To manually define a symbol, open your project file (the .csproj file) and add a <PropertyGroup> element with a <DefineConstants> element inside it. Here’s an example:

<PropertyGroup>
  <TargetFrameworks>net7.0-android;net7.0-ios</TargetFrameworks>
  <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net7.0-windows10.0.19041.0</TargetFrameworks>
  <!-- Add the following line -->
  <DefineConstants Condition="$(TargetFramework.Contains('-android'))">ANDROID</DefineConstants>
  <DefineConstants Condition="$(TargetFramework.Contains('-ios'))">IOS</DefineConstants>
  <Nullable>enable</Nullable>
  <ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>

In this example, we’re defining the ANDROID symbol if the target framework contains -android, and the IOS symbol if the target framework contains -ios. This ensures that the correct code is compiled for each platform.

Example in a .NET MAUI App

Let's see how you can use conditional compilation in a .NET MAUI app. Suppose you want to use different code for displaying a message on Android and iOS. Here’s how you can do it:

public partial class MainPage : ContentPage
{
    public MainPage()
    {
        InitializeComponent();

        string message;

#if ANDROID
        message = "Hello from Android!";
#elif IOS
        message = "Hello from iOS!";
#else
        message = "Hello from another platform!";
#endif

        MyLabel.Text = message;
    }
}

In this example, we’re using conditional compilation to set the message variable based on the platform. If the app is running on Android, the message will be "Hello from Android!". If it’s running on iOS, the message will be "Hello from iOS!". And if it’s running on any other platform, the message will be "Hello from another platform!".

Platform-Specific Folders

Another cool way to organize your code is by using platform-specific folders. .NET MAUI allows you to create folders with special names that automatically include code based on the target platform. This can be super handy for managing platform-specific UI elements or logic.

Creating Platform-Specific Folders

To create a platform-specific folder, simply name it with the platform name as a suffix. For example, if you want to create a folder for Android-specific code, you would name it Android. For iOS-specific code, you would name it iOS. Here are some examples:

• MyClass.Android.cs
• MyView.iOS.xaml
• Services/MyService.Android.cs

Any code files placed in these folders will only be included when building for the corresponding platform. This helps keep your codebase clean and organized.

Example in a .NET MAUI App

Let's say you want to create a custom button that looks different on Android and iOS. You can create two separate files for this button, one for each platform:

• CustomButton.cs (shared code)
• CustomButton.Android.cs (Android-specific code)
• CustomButton.iOS.cs (iOS-specific code)

Here’s an example of what the CustomButton.Android.cs file might look like:

#if ANDROID
using Android.Content; 
using Android.Widget;
using Microsoft.Maui.Controls.Platform;
using Microsoft.Maui.Controls;
using Microsoft.Maui;
using MauiApp1;
using View = Android.Views.View;

[assembly: ExportRenderer(typeof(CustomButton), typeof(CustomButtonRenderer))] 
namespace MauiApp1
{
    public class CustomButtonRenderer : Microsoft.Maui.Controls.Handlers.Platform.ButtonHandler
    {
        public CustomButtonRenderer(IContext context) : base(context)
        {
        }

        protected override void ConnectHandler(View virtualView) 
        {
            base.ConnectHandler(virtualView);
            var nativeButton = (global::Android.Widget.Button)Control; 
            nativeButton.SetBackgroundColor(global::Android.Graphics.Color.Red);
        }
    }
}
#endif

And here’s an example of what the CustomButton.iOS.cs file might look like:

#if IOS
using UIKit;
using Microsoft.Maui.Controls.Platform;
using Microsoft.Maui.Controls;
using Microsoft.Maui;
using MauiApp1;
using CoreGraphics;

[assembly: ExportRenderer(typeof(CustomButton), typeof(CustomButtonRenderer))] 
namespace MauiApp1
{
    public class CustomButtonRenderer : Microsoft.Maui.Controls.Handlers.Platform.ButtonHandler
    {
        protected override void ConnectHandler(UIKit.UIView virtualView)
        {
            base.ConnectHandler(virtualView);
            var nativeButton = (UIButton)Control;          
            nativeButton.BackgroundColor = UIColor.Green;
            nativeButton.Layer.BorderWidth = 3f;
            nativeButton.Layer.BorderColor = UIColor.Black.CGColor;
        }
    }
}
#endif

In these examples, we're using platform-specific code to customize the appearance of the button. On Android, we're setting the background color to red. On iOS, we're setting the background color to green and adding a black border. This allows you to create a truly native look and feel for your app on each platform.

Conclusion

So, there you have it! Detecting the operating system in .NET MAUI is a breeze with the DeviceInfo class, conditional compilation, and platform-specific folders. Each method has its own advantages, so choose the one that best fits your needs. Whether you're implementing platform-specific features or optimizing performance, knowing how to detect the operating system is a valuable skill for any .NET MAUI developer. Happy coding, and have fun building awesome cross-platform apps!