🤔 EF Core in .NET MAUI Mobile Apps: Smart Choice or a Performance Risk? 📱

When building .NET MAUI apps for Android and iOS, the question often arises: should you rely on Entity Framework Core (EF Core) for data management? On one hand, EF Core provides a consistent, developer-friendly approach to managing data models and accessing databases. On the other, mobile apps have unique performance, storage, and efficiency constraints that may raise concerns.

So, is integrating EF Core a good practice in cross-platform mobile apps, or does it introduce complexity and potential performance issues?

Integrating EF Core in .NET MAUI

• Install EF Core Packages: Add the necessary EF Core packages via NuGet:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.Sqlite        

• Define Your Data Model: Create a basic entity class for your data:

public class Item
{
    public int Id { get; set; }
    public string Name { get; set; }
}        

• Create a Database Context: Define a context class that inherits from DbContext:

public class AppDbContext : DbContext
{
    public DbSet<Item> Items { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        string dbPath = Path.Combine(FileSystem.AppDataDirectory, "app.db");
        optionsBuilder.UseSqlite($"Filename={dbPath}");
    }
}        

• Initialize and Use the Context: In your application logic, create an instance of the context and interact with it:

using (var db = new AppDbContext())
{
    db.Database.EnsureCreated();

    // Add a new item
    db.Items.Add(new Item { Name = "Sample Item" });
    db.SaveChanges();

    // Query items
    var items = db.Items.ToList();
}        

Injecting the DbContext via Dependency Injection in .NET MAUI

Configure Services in MauiProgram.cs: .NET MAUI applications use a MauiProgram.cs file to configure services, similar to ASP.NET Core. Here’s how you can register the DbContext:

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureFonts(fonts =>
            {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            });

        // Register DbContext with dependency injection
        builder.Services.AddDbContext<AppDbContext>(options =>
        {
            string dbPath = Path.Combine(FileSystem.AppDataDirectory, "app.db");
            options.UseSqlite($"Filename={dbPath}");
        });

        return builder.Build();
    }
}        

Injecting AppDbContext in Your Pages or Services: Now that the AppDbContext is registered, you can inject it into your pages or services using constructor injection:

public partial class MainPage : ContentPage
{
    private readonly AppDbContext _dbContext;

    public MainPage(AppDbContext dbContext)
    {
        InitializeComponent();
        _dbContext = dbContext;

        // Example usage
        LoadData();
    }

    private void LoadData()
    {
        // Fetch data from the database
        var items = _dbContext.Items.ToList();
        // Handle data as needed
    }
}        

Benefits of Dependency Injection:

• Centralized Configuration: The database context configuration is centralized in MauiProgram.cs.
• Testability: Dependency injection makes it easier to mock the DbContext for testing.
• Lifecycle Management: By default, AddDbContext registers the context with a scoped lifetime, providing one instance per request.

And Migrations?

When working with Entity Framework Core in .NET MAUI applications, you might naturally want to use migrations to manage and evolve your database schema. Migrations allow you to make changes to your data models and apply these changes seamlessly to your underlying database. However, there are some unique challenges with this process in a .NET MAUI context, particularly for Android and iOS platforms:

Lack of Native Support for dotnet ef Commands:

• Running dotnet ef migrations commands directly for .NET MAUI projects isn't straightforward due to the cross-platform nature of MAUI. Unlike standard .NET applications, MAUI apps bundle platform-specific code, which can make EF Core tooling less straightforward.
• As a result, you may find that commands like Add-Migration or Update-Database don't function as expected.

Workarounds and Boilerplate Code:

To address the challenges, developers typically rely on a few workarounds, but these can involve boilerplate and additional complexity:

• Separate .NET Console Project for Migrations: One common solution is to create a separate .NET console or class library project that references your shared data models and DbContext. This project can act as a "migration manager" where you can run EF Core CLI commands. Once migrations are generated, you can copy the migration files back into your main MAUI project.
• Manual Database Initialization Logic: Another approach involves manually applying schema changes or seeding the database directly within your app's code using EnsureCreated() or executing custom SQL scripts. While this approach avoids migrations, it can become tedious and error-prone for complex schema changes.
• Use of Custom Migration Scripts: You can generate SQL scripts for your migrations using dotnet ef migrations script and apply those scripts manually within your MAUI app. This avoids the need to use migrations in the traditional sense but still requires manual execution and management.

Boilerplate Code and Maintenance Overhead:

• Additional Projects for Migration Management: Maintaining a separate project just for migrations can introduce maintenance overhead, as you must keep it synchronized with your main MAUI app.
• Manual Schema Updates: When using manual migration strategies, you risk increased complexity as schema updates grow in number and complexity.

For anyone who's tried using EF Core migrations in .NET MAUI apps, you know it’s not always a smooth journey—especially on Android and iOS. The process often involves complex workarounds, like separate projects for migrations or manual schema updates.

But I’ve been working on a project to simplify and address these challenges head-on. My goal is to make database management in .NET MAUI more intuitive and streamlined, minimizing boilerplate code and reducing complexity.

🌟 If you're interested in exploring these solutions or collaborating, check out the project here:

I’d love to hear your thoughts and experiences. Let’s make EF Core in MAUI a smoother experience together! 💬

#dotnetmaui #xamarin #dotnetdeveloper #dotnet #community #net9