Awesome DotNet移动开发：Xamarin到MAUI跨平台方案

你是否曾面临这样的困境？需要为iOS、Android和Windows三大平台分别开发原生应用，维护三套代码库，团队技能要求分散，开发周期漫长，成本居高不下。移动应用市场的碎片化让开发者疲于奔命，而用户却期望获得一致性的体验。**.NET跨平台移动开发方案正是解决这一痛点的最佳答案**。从Xamarin到MAUI（.NET Multi-platform App UI），微软为开发者提供了一套完整..

邴坤鸿Jewel

1085人浏览 · 2025-09-01 23:46:53

邴坤鸿Jewel · 2025-09-01 23:46:53 发布

Awesome DotNet移动开发：Xamarin到MAUI跨平台方案

【免费下载链接】awesome-dotnet quozd/awesome-dotnet: 这个资源列表集合了.NET开发领域的优秀工具、库、框架和软件等，是.NET开发者的一个宝库，有助于发现和学习.NET生态系统中的各种有用资源。项目地址: https://gitcode.com/GitHub_Trending/aw/awesome-dotnet

痛点：移动开发的碎片化挑战

你是否曾面临这样的困境？需要为iOS、Android和Windows三大平台分别开发原生应用，维护三套代码库，团队技能要求分散，开发周期漫长，成本居高不下。移动应用市场的碎片化让开发者疲于奔命，而用户却期望获得一致性的体验。

.NET跨平台移动开发方案正是解决这一痛点的最佳答案。从Xamarin到MAUI（.NET Multi-platform App UI），微软为开发者提供了一套完整的解决方案，让你用C#和.NET技术栈就能构建高性能的原生移动应用。

读完本文你能得到

🚀 跨平台开发完整图谱：Xamarin、MAUI、Avalonia、UNO Platform等技术对比
📱 核心工具链详解：从Xamarin.Essentials到FFImageLoading的实用库指南
🏗️ 架构最佳实践：MVVM模式在移动开发中的具体实现
🔧 实战代码示例：多个完整的功能模块实现代码
📊 性能优化策略：内存管理、启动优化、渲染性能提升技巧
🔮 未来技术趋势：MAUI的演进路线和生态发展

技术选型：四大跨平台方案深度对比

mermaid

技术方案对比表

特性	Xamarin.Forms	.NET MAUI	Avalonia	UNO Platform
支持平台	iOS, Android, Windows	iOS, Android, macOS, Windows	Windows, Linux, macOS, iOS, Android	Windows, WebAssembly, iOS, Android, macOS
渲染方式	原生控件	原生控件 + 自定义渲染	Skia自定义渲染	原生控件 + 自定义渲染
性能表现	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
学习曲线	平缓	平缓	中等	较陡
生态成熟度	非常成熟	快速成长	成熟	企业级
推荐场景	现有项目维护	新项目开发	定制化UI需求	大型企业应用

Xamarin技术栈核心组件详解

Xamarin.Essentials：跨平台API统一访问

Xamarin.Essentials提供了一套简洁的API，让开发者能够以统一的方式访问各平台的本地功能：

// 设备信息获取
var deviceName = DeviceInfo.Name;
var platform = DeviceInfo.Platform;
var version = DeviceInfo.VersionString;

// 网络状态监测
var current = Connectivity.NetworkAccess;
if (current == NetworkAccess.Internet)
{
    // 有网络连接
}

// 地理位置获取
try
{
    var location = await Geolocation.GetLastKnownLocationAsync();
    if (location != null)
    {
        Console.WriteLine($"纬度: {location.Latitude}, 经度: {location.Longitude}");
    }
}
catch (FeatureNotSupportedException fnsEx)
{
    // 设备不支持地理位置
}
catch (PermissionException pEx)
{
    // 权限未授予
}

// 文件系统操作
var cacheDir = FileSystem.CacheDirectory;
var appDataDir = FileSystem.AppDataDirectory;

FFImageLoading：高性能图像加载库

FFImageLoading解决了移动应用中图像加载的性能和内存管理问题：

// 基本图像加载
new FFImageLoading.Image()
    .Source("https://example.com/image.jpg")
    .LoadingPlaceholder("loading.png")
    .ErrorPlaceholder("error.png")
    .CacheKey("unique_key")
    .Into(imageView);

// 高级配置：内存和磁盘缓存
var config = new FFImageLoading.Config.Configuration
{
    MaxMemoryCacheSize = 30 * 1024 * 1024, // 30MB内存缓存
    DiskCacheDuration = TimeSpan.FromDays(30), // 磁盘缓存30天
    FadeAnimationEnabled = true,
    FadeAnimationDuration = 250
};

// 自定义转换器
public class BlurredTransformation : ITransformation
{
    public string Key => "blurred";
    
    public Task<Bitmap> Transform(Bitmap source)
    {
        return Task.Run(() => 
        {
            // 实现模糊效果
            return ApplyBlurEffect(source);
        });
    }
}

// 使用转换器
imageView.Transform(new BlurredTransformation());

Realm数据库：移动端高性能数据存储

Realm提供了比SQLite更高效的移动端数据库解决方案：

// 定义数据模型
public class Person : RealmObject
{
    [PrimaryKey]
    public string Id { get; set; } = Guid.NewGuid().ToString();
    
    public string Name { get; set; }
    public int Age { get; set; }
    public IList<Dog> Dogs { get; }
}

public class Dog : RealmObject
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// 数据库操作
var realm = Realm.GetInstance();
realm.Write(() =>
{
    var person = realm.Add(new Person
    {
        Name = "John",
        Age = 30
    });
    
    person.Dogs.Add(new Dog { Name = "Rex", Age = 3 });
});

// 查询操作
var people = realm.All<Person>()
    .Filter("Age > 25")
    .OrderBy(p => p.Name)
    .ToList();

// 实时数据监听
var token = people.SubscribeForNotifications((sender, changes, error) =>
{
    if (changes != null)
    {
        // 数据变化处理
    }
});

MAUI：下一代跨平台UI框架

MAUI项目结构和配置

<!-- .csproj项目文件配置 -->
<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFrameworks>net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>
        <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">
            $(TargetFrameworks);net8.0-windows10.0.19041.0
        </TargetFrameworks>
        
        <OutputType>Exe</OutputType>
        <RootNamespace>MyMauiApp</RootNamespace>
        <UseMaui>true</UseMaui>
        <SingleProject>true</SingleProject>
        
        <!-- 平台特定配置 -->
        <SupportedOSPlatformVersion Condition="'$(TargetFramework)' == 'net8.0-ios'">14.2</SupportedOSPlatformVersion>
        <SupportedOSPlatformVersion Condition="'$(TargetFramework)' == 'net8.0-android'">21.0</SupportedOSPlatformVersion>
    </PropertyGroup>
</Project>

MAUI界面开发示例

// MainPage.xaml
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MyMauiApp.MainPage">
    
    <ScrollView>
        <VerticalStackLayout Spacing="25" Padding="30">
            
            <Image Source="dotnet_bot.png"
                   HeightRequest="200"
                   HorizontalOptions="Center" />
            
            <Label Text="Hello, .NET MAUI!"
                   FontSize="32"
                   HorizontalOptions="Center" />
            
            <Label Text="Welcome to .NET Multi-platform App UI"
                   FontSize="18"
                   HorizontalOptions="Center" />
            
            <Button Text="Click me"
                    Clicked="OnCounterClicked"
                    HorizontalOptions="Center" />
            
            <Label x:Name="CounterLabel"
                   Text="Count: 0"
                   FontSize="18"
                   HorizontalOptions="Center" />
            
        </VerticalStackLayout>
    </ScrollView>
</ContentPage>

// MainPage.xaml.cs
public partial class MainPage : ContentPage
{
    private int _count = 0;
    
    public MainPage()
    {
        InitializeComponent();
    }
    
    private void OnCounterClicked(object sender, EventArgs e)
    {
        _count++;
        CounterLabel.Text = $"Count: {_count}";
        
        SemanticScreenReader.Announce(CounterLabel.Text);
    }
}

MAUI依赖注入和生命周期管理

// MauiProgram.cs
public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
            })
            .ConfigureServices(services =>
            {
                // 注册服务
                services.AddSingleton<IDataService, DataService>();
                services.AddTransient<MainPage>();
                services.AddTransient<DetailsPage>();
            })
            .ConfigureEssentials(essentials =>
            {
                essentials.UseVersionTracking();
            });
        
        return builder.Build();
    }
}

// 平台特定代码示例
#if ANDROID
[Activity(Theme = "@style/Maui.SplashTheme", 
          MainLauncher = true, 
          ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode)]
public class MainActivity : MauiAppCompatActivity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        // Android特定初始化
    }
}
#endif

MVVM架构在移动开发中的实践

现代MVVM框架选择

框架	特点	适用场景	学习成本
Community Toolkit MVVM	官方推荐，轻量级，源码生成器	新项目，小型应用	低
ReactiveUI	响应式编程，强大的数据流处理	复杂数据流应用	中高
Prism	企业级，模块化，导航强大	大型企业应用	中
MVVMCross	老牌框架，功能全面	Xamarin传统项目	中

Community Toolkit MVVM示例

// ViewModel基类
public partial class BaseViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(IsNotBusy))]
    private bool _isBusy;
    
    [ObservableProperty]
    private string _title;
    
    public bool IsNotBusy => !IsBusy;
    
    public BaseViewModel()
    {
        // 初始化逻辑
    }
}

// 具体ViewModel实现
public partial class UserViewModel : BaseViewModel
{
    private readonly IUserService _userService;
    
    [ObservableProperty]
    private ObservableCollection<User> _users;
    
    [ObservableProperty]
    private User _selectedUser;
    
    public UserViewModel(IUserService userService)
    {
        _userService = userService;
        Title = "用户管理";
        LoadUsersCommand = new AsyncRelayCommand(LoadUsersAsync);
    }
    
    [RelayCommand]
    private async Task LoadUsersAsync()
    {
        if (IsBusy) return;
        
        try
        {
            IsBusy = true;
            Users = new ObservableCollection<User>(
                await _userService.GetUsersAsync());
        }
        catch (Exception ex)
        {
            await Shell.Current.DisplayAlert("错误", ex.Message, "确定");
        }
        finally
        {
            IsBusy = false;
        }
    }
    
    partial void OnSelectedUserChanged(User value)
    {
        if (value != null)
        {
            // 导航到详情页
            Shell.Current.GoToAsync($"{nameof(UserDetailPage)}?id={value.Id}");
        }
    }
}

// 数据模型
public partial class User : ObservableObject
{
    [ObservableProperty]
    private string _name;
    
    [ObservableProperty]
    private string _email;
    
    [ObservableProperty]
    private DateTime _createdAt;
}

依赖注入配置

// 服务注册
services.AddSingleton<IUserService, UserService>();
services.AddSingleton<IApiService, ApiService>();
services.AddTransient<UserViewModel>();
services.AddTransient<UserDetailViewModel>();

// 服务接口定义
public interface IUserService
{
    Task<IEnumerable<User>> GetUsersAsync();
    Task<User> GetUserByIdAsync(string id);
    Task<bool> UpdateUserAsync(User user);
}

// 具体服务实现
public class UserService : IUserService
{
    private readonly HttpClient _httpClient;
    
    public UserService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }
    
    public async Task<IEnumerable<User>> GetUsersAsync()
    {
        var response = await _httpClient.GetAsync("/api/users");
        response.EnsureSuccessStatusCode();
        
        var content = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<IEnumerable<User>>(content);
    }
}

网络通信与API集成

Refit：声明式REST客户端

// API接口定义
public interface IUserApi
{
    [Get("/users")]
    Task<IEnumerable<User>> GetUsersAsync();
    
    [Get("/users/{id}")]
    Task<User> GetUserByIdAsync(string id);
    
    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
    
    [Put("/users/{id}")]
    Task UpdateUserAsync(string id, [Body] User user);
    
    [Delete("/users/{id}")]
    Task DeleteUserAsync(string id);
}

// 服务配置
services.AddRefitClient<IUserApi>()
    .ConfigureHttpClient(client =>
    {
        client.BaseAddress = new Uri("https://api.example.com");
        client.DefaultRequestHeaders.Add("User-Agent", "MyMauiApp");
    })
    .AddHttpMessageHandler<AuthHandler>()
    .AddPolicyHandler(GetRetryPolicy());

// 认证处理器
public class AuthHandler : DelegatingHandler
{
    private readonly IAuthService _authService;
    
    public AuthHandler(IAuthService authService)
    {
        _authService = authService;
    }
    
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, 
        CancellationToken cancellationToken)
    {
        var token = await _authService.GetTokenAsync();
        if (!string.IsNullOrEmpty(token))
        {
            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
        }
        
        return await base.SendAsync(request, cancellationToken);
    }
}

// 重试策略
private static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .OrResult(msg => msg.StatusCode == HttpStatusCode.NotFound)
        .WaitAndRetryAsync(3, retryAttempt => 
            TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
}

性能优化与最佳实践

内存管理优化策略

// 图像资源优化
public static class ImageOptimizer
{
    public static ImageSource OptimizeImage(string imagePath, int maxWidth = 800)
    {
        // 使用FFImageLoading进行图像优化
        return new FileImageSource
        {
            File = imagePath,
            // 配置缓存和压缩选项
        };
    }
    
    public static void ClearMemoryCache()
    {
        // 清理图像内存缓存
        ImageService.Instance.InvalidateMemoryCache();
        ImageService.Instance.InvalidateDiskCacheAsync();
    }
}

// 列表性能优化
<CollectionView ItemsSource="{Binding Users}"
                SelectionMode="Single"
                SelectedItem="{Binding SelectedUser}"
                ItemSizingStrategy="MeasureFirstItem">
    
    <CollectionView.ItemTemplate>
        <DataTemplate x:DataType="model:User">
            <Grid Padding="10">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                
                <Image Source="{Binding AvatarUrl}"
                       WidthRequest="50"
                       HeightRequest="50"
                       Aspect="AspectFill"/>
                
                <VerticalStackLayout Grid.Column="1" Padding="10,0">
                    <Label Text="{Binding Name}" 
                           FontSize="16"
                           FontAttributes="Bold"/>
                    <Label Text="{Binding Email}"
                           FontSize="14"
                           TextColor="Gray"/>
                </VerticalStackLayout>
            </Grid>
        </DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

启动性能优化

// 延迟加载优化
public class LazyLoadingService
{
    private readonly Lazy<Task<List<string>>> _lazyData = new Lazy<Task<List<string>>>(
        async () => await LoadDataAsync());
    
    public async Task<List<string>> GetDataAsync()
    {
        return await _lazyData.Value;
    }
    
    private static async Task<List<string>> LoadDataAsync()
    {
        // 模拟耗时操作
        await Task.Delay(2000);
        return new List<string> { "Item1", "Item2", "Item3" };
    }
}

// AOT编译配置
<PropertyGroup>
    <PublishAot>true</PublishAot>
    <TrimMode>full</TrimMode>
    <IlcOptimizationPreference>Speed</IlcOptimizationPreference>
</PropertyGroup>

调试与测试策略

单元测试配置

// ViewModel测试示例
[TestFixture]
public class UserViewModelTests
{
    private UserViewModel _viewModel;
    private Mock<IUserService> _userServiceMock;
    
    [SetUp]
    public void Setup()
    {
        _userServiceMock = new Mock<IUserService>();
        _viewModel = new UserViewModel(_userServiceMock.Object);
    }
    
    [Test]
    public async Task LoadUsersCommand_ShouldPopulateUsers()
    {
        // 准备
        var expectedUsers = new List<User>
        {
            new User { Id = "1", Name = "Test User" }
        };
        
        _userServiceMock.Setup(x => x.GetUsersAsync())
                       .ReturnsAsync(expectedUsers);
        
        // 执行
        await _viewModel.LoadUsersCommand.ExecuteAsync(null);
        
        // 断言
        Assert.That(_viewModel.Users, Is.Not.Null);
        Assert.That(_viewModel.Users.Count, Is.EqualTo(1));
        Assert.That(_viewModel.Users[0].Name, Is.EqualTo("Test User"));
    }
}

// UI测试配置
[TestFixture]
public class MainPageTests
{
    [Test]
    public async Task MainPage_ShouldDisplayWelcomeMessage()
    {
        // 准备
        var page = new MainPage();
        
        // 执行
        await page.InitializeComponentAsync();
        
        // 断言
        var label = page.FindByName<Label>("WelcomeLabel");
        Assert.That(label.Text, Is.EqualTo("Welcome to .NET MAUI!"));
    }
}

部署与发布流程

多平台构建配置

# GitHub Actions构建配置
name: Build and Deploy

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: windows-latest
    
    strategy:
      matrix:
        platform: [android, ios, windows]
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'
    
    - name: Restore dependencies
      run: dotnet restore
      
    - name: Build
      run: dotnet build -c Release
      
    - name: Test
      run: dotnet test -c Release --no-build
      
    - name: Publish Android
      if: matrix.platform == 'android'
      run: dotnet publish -c Release -f net8.0-android
      
    - name: Publish iOS
      if: matrix.platform == 'ios'
      run: dotnet publish -c Release -f net8.0-ios

未来展望与技术趋势

MAUI生态系统发展

mermaid

技术选型建议

根据项目需求和团队情况，推荐以下选择策略：

新项目开发：优先选择.NET MAUI，享受最新的技术特性和官方支持
现有Xamarin项目：逐步迁移到MAUI，利用兼容性保证平稳过渡
高性能需求：考虑Avalonia，获得更好的渲染性能和自定义能力
企业级应用：UNO Platform提供最完整的平台支持和企业级特性

总结

开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

Flutter 三方库 file_manager 鸿蒙化文件管理器实战

本文基于 OpenHarmony TPC 仓库的 `file_manager` 项目适配版本，详细讲解在 OpenHarmony 设备上构建完整文件管理器应用的全流程。核心采用 **File Access Framework**（`@ohos.file.fileAccess`）访问设备真实文件系统，实现目录浏览、文件创建、删除、重命名等核心功能，并附真实设备运行截图验证。

开源鸿蒙跨平台开发者社区

Flutter 三方库 cached_network_image 的 OpenHarmony 鸿蒙化适配实践

本文介绍了Flutter三方库cached_network_image在OpenHarmony平台的适配实践。主要内容包括：1）环境准备与项目初始化，创建支持OpenHarmony的Flutter项目；2）集成cached_network_image依赖，添加必要的缓存管理库；3）核心功能实现，包括网络图片加载、占位符显示、错误处理和缓存管理；4）完整示例应用展示，演示如何在实际项目中使用该库进行

开源鸿蒙跨平台开发者社区

Flutter 三方库 video_player 的 OpenHarmony 鸿蒙化适配实践

本文介绍了Flutter视频播放插件video_player在OpenHarmony平台上的适配实践。主要内容包括：1）创建Flutter-OH项目并集成video_player依赖；2）核心功能实现，如视频控制器创建、初始化、播放控制和状态监听；3）完整示例应用展示，包含播放/暂停、音量调节、视频切换等功能。