Quickstarters
How to Build a CRUD App with Xamarin?

29min
Overview
This guide will walk you through the creation of a complete CRUD (create, read, update, delete) application using Xamarin. 
We will utilize Back4app as our backend service to effortlessly manage your data. Throughout this tutorial, you'll see how to configure a Back4app project, set up a flexible data schema, and implement CRUD operations in a Xamarin application.
Initially, you'll configure a Back4app project named Basic-CRUD-App-Xamarin. This project will serve as the robust backend for your application. You’ll define your data structures manually through the Back4app dashboard or leverage the built-in AI Agent.
Next, you will harness the intuitive Back4app Admin App to manage your data effortlessly via drag-and-drop functionality. 
Finally, you will integrate your Xamarin app with Back4app using the Parse .NET SDK, which is fully compatible with Xamarin, ensuring secure and efficient data operations.
By the conclusion of this tutorial, you will have developed a production-ready Xamarin application capable of executing basic CRUD operations along with secure user authentication and data management.
﻿
Key Insights
Learn how to construct a Xamarin-based CRUD app integrated with a robust non-relational backend.
Understand how to design a scalable backend and connect it seamlessly with your Xamarin app.
Discover how to manage CRUD operations using the Back4app Admin App.
Explore options for secure user management and backend security using ACLs and CLPs.
﻿
Prerequisites
Before you begin, make sure you have:
A Back4app account with a configured project.
For help, refer to Getting Started with Back4app.
A Xamarin development environment.
Install Visual Studio with Xamarin support and ensure you have the latest .NET SDK.
A basic understanding of C#, object-oriented programming, and REST APIs.
You can review the Microsoft C# documentation if needed.
﻿
Step 1 – Configuring Your Back4app Project
Creating a New Project on Back4app
Log in to your Back4app account.
Click the “New App” button on your dashboard.
Name your project: Basic-CRUD-App-Xamarin and follow the on-screen instructions to complete the setup.
Create New Project
﻿
After your project is successfully created, it will appear on your dashboard, ready for further backend configuration.
﻿
Step 2 – Crafting the Data Schema
Defining Your Data Structures
For this CRUD application, you need to set up several classes (collections) in your Back4app project. Below are examples of the primary classes and their respective fields that you’ll create.
1. Items Class
Field
Data Type
Description
_id
ObjectId
Auto-generated unique identifier.
title
String
The item’s name.
description
String
A brief summary of the item.
createdAt
Date
Timestamp marking creation.
updatedAt
Date
Timestamp marking the last update.
2. Users Class
Field
Data Type
Description
_id
ObjectId
Automatically generated unique ID.
username
String
Unique username for the user.
email
String
Unique email address for account contact.
passwordHash
String
Encrypted password for security.
createdAt
Date
Account creation timestamp.
updatedAt
Date
Timestamp for the last account update.
You can add these classes and fields manually via the Back4app dashboard.
Create New Class
﻿
You can define each field by selecting a data type, entering the field name, setting default values, and marking mandatory fields.
Create Column
﻿
Utilizing the Back4app AI Agent for Schema Generation
The integrated AI Agent in your Back4app dashboard can automatically generate your data schema based on a description. This tool simplifies the setup process and guarantees that your data model is optimized for CRUD operations.
How to Use the AI Agent:
Access the AI Agent:
Open your Back4app dashboard and locate the AI Agent within your project settings.
Describe Your Schema:
Provide a detailed outline of the classes and fields you need.
Review and Implement:
The AI Agent will propose a schema. Examine the suggested configuration and approve it to apply the changes.
Example Prompt:
Text
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
Create the following classes in my Back4app project:

1) Class: Items
- Fields:
  - _id: ObjectId (auto-generated)
  - title: String
  - description: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)

2) Class: Users
- Fields:
  - _id: ObjectId (auto-generated)
  - username: String (unique)
  - email: String (unique)
  - passwordHash: String
  - createdAt: Date (auto-generated)
  - updatedAt: Date (auto-updated)
﻿
This AI-assisted method saves time and ensures a consistent, optimized data structure.
﻿
Step 3 – Enabling the Admin App & Managing CRUD Operations
Overview of the Admin App
The Back4app Admin App provides a no-code interface for easy backend data management. Its drag-and-drop interface simplifies CRUD operations such as creating, reading, updating, and deleting records.
Enabling the Admin App
Open the “More” menu on your Back4app dashboard.
Select “Admin App” and click “Enable Admin App.”
Set up your admin credentials by creating an initial admin account. This process also establishes predefined roles (e.g., B4aAdminUser) and system classes.
Enable Admin App
﻿
Once activated, sign in to the Admin App to begin managing your app’s data.
Admin App Dashboard
﻿
Performing CRUD Operations with the Admin App
Inside the Admin App, you can:
Insert New Data:
Use the “Add Record” feature within any class (e.g., Items) to create new entries.
View and Edit Records:
Select a record to inspect details or modify fields.
Delete Records:
Remove data entries that are no longer required.
This user-friendly interface streamlines the process of managing your backend.
﻿
Step 4 – Connecting Your Xamarin App to Back4app
With your backend ready, the next task is to link your Xamarin application to Back4app.
Option A: Using the Parse .NET SDK in Xamarin
Add the Parse .NET SDK Dependency:
For a Xamarin project, include the Parse .NET SDK via NuGet. Open your NuGet Package Manager and install:
PowerShell
Install-Package Parse
Install-Package Parse
﻿
Initialize Parse in Your Xamarin App:
Create an initialization file (e.g., ParseInitializer.cs) and configure it as follows:
C#
// ParseInitializer.cs
using Parse;
public static class ParseInitializer {
public static void Initialize() {
ParseClient.Initialize(new ParseClient.Configuration {
ApplicationId = "YOUR_APPLICATION_ID",
WindowsKey = "YOUR_XAMARIN_KEY",
Server = "https://parseapi.back4app.com"
});
}
}
// ParseInitializer.cs
using Parse;
public static class ParseInitializer {
public static void Initialize() {
ParseClient.Initialize(new ParseClient.Configuration {
ApplicationId = "YOUR_APPLICATION_ID",
WindowsKey = "YOUR_XAMARIN_KEY",
Server = "https://parseapi.back4app.com"
});
}
}
﻿
﻿
Text

3. **Implement CRUD Operations:**  
For example, create a service class to manage Items:

```csharp
// ItemsService.cs
using Parse;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ItemsService {
 public async Task<List<ParseObject>> GetItemsAsync() {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         return await query.FindAsync();
     } catch (Exception ex) {
         Console.WriteLine($"Error fetching items: {ex.Message}");
         return null;
     }
 }

 public async Task CreateItemAsync(string title, string description) {
     var item = new ParseObject("Items");
     item["title"] = title;
     item["description"] = description;

     try {
         await item.SaveAsync();
         Console.WriteLine("Item created successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error creating item: {ex.Message}");
     }
 }

 public async Task UpdateItemAsync(string objectId, string newTitle, string newDescription) {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         var item = await query.GetAsync(objectId);
         item["title"] = newTitle;
         item["description"] = newDescription;
         await item.SaveAsync();
         Console.WriteLine("Item updated successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error updating item: {ex.Message}");
     }
 }

 public async Task DeleteItemAsync(string objectId) {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         var item = await query.GetAsync(objectId);
         await item.DeleteAsync();
         Console.WriteLine("Item deleted successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error deleting item: {ex.Message}");
     }
 }
}

3. **Implement CRUD Operations:**  
For example, create a service class to manage Items:

```csharp
// ItemsService.cs
using Parse;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ItemsService {
 public async Task<List<ParseObject>> GetItemsAsync() {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         return await query.FindAsync();
     } catch (Exception ex) {
         Console.WriteLine($"Error fetching items: {ex.Message}");
         return null;
     }
 }

 public async Task CreateItemAsync(string title, string description) {
     var item = new ParseObject("Items");
     item["title"] = title;
     item["description"] = description;

     try {
         await item.SaveAsync();
         Console.WriteLine("Item created successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error creating item: {ex.Message}");
     }
 }

 public async Task UpdateItemAsync(string objectId, string newTitle, string newDescription) {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         var item = await query.GetAsync(objectId);
         item["title"] = newTitle;
         item["description"] = newDescription;
         await item.SaveAsync();
         Console.WriteLine("Item updated successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error updating item: {ex.Message}");
     }
 }

 public async Task DeleteItemAsync(string objectId) {
     var query = new ParseQuery<ParseObject>("Items");
     try {
         var item = await query.GetAsync(objectId);
         await item.DeleteAsync();
         Console.WriteLine("Item deleted successfully.");
     } catch (Exception ex) {
         Console.WriteLine($"Error deleting item: {ex.Message}");
     }
 }
}
﻿
Option B: Using REST or GraphQL
If the Parse .NET SDK is not preferred, you can implement CRUD operations via REST calls. For instance, to retrieve items using REST in a Xamarin app:
C#
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class RestClient {
 private static readonly HttpClient client = new HttpClient();

 public async Task FetchItemsAsync() {
     try {
         var request = new HttpRequestMessage(HttpMethod.Get, "https://parseapi.back4app.com/classes/Items");
         request.Headers.Add("X-Parse-Application-Id", "YOUR_APPLICATION_ID");
         request.Headers.Add("X-Parse-REST-API-Key", "YOUR_REST_API_KEY");

         var response = await client.SendAsync(request);
         response.EnsureSuccessStatusCode();
         var responseBody = await response.Content.ReadAsStringAsync();
         Console.WriteLine($"Response: {responseBody}");
     } catch (Exception ex) {
         Console.WriteLine($"Error fetching items: {ex.Message}");
     }
 }
}
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class RestClient {
 private static readonly HttpClient client = new HttpClient();

 public async Task FetchItemsAsync() {
     try {
         var request = new HttpRequestMessage(HttpMethod.Get, "https://parseapi.back4app.com/classes/Items");
         request.Headers.Add("X-Parse-Application-Id", "YOUR_APPLICATION_ID");
         request.Headers.Add("X-Parse-REST-API-Key", "YOUR_REST_API_KEY");

         var response = await client.SendAsync(request);
         response.EnsureSuccessStatusCode();
         var responseBody = await response.Content.ReadAsStringAsync();
         Console.WriteLine($"Response: {responseBody}");
     } catch (Exception ex) {
         Console.WriteLine($"Error fetching items: {ex.Message}");
     }
 }
}
﻿
Integrate these API calls within your Xamarin project as necessary.
﻿
Step 5 – Enhancing Backend Security
Configuring Access Control Lists (ACLs)
Secure your data by setting ACLs on your objects. For example, to create an item accessible only by its owner:
C#
using Parse;
using System;

public async Task CreatePrivateItemAsync(string title, string description, ParseUser owner) {
    var item = new ParseObject("Items");
    item["title"] = title;
    item["description"] = description;

    var acl = new ParseACL(owner);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    item.ACL = acl;

    try {
        await item.SaveAsync();
        Console.WriteLine("Private item created successfully.");
    } catch (Exception ex) {
        Console.WriteLine($"Error saving private item: {ex.Message}");
    }
}
using Parse;
using System;

public async Task CreatePrivateItemAsync(string title, string description, ParseUser owner) {
    var item = new ParseObject("Items");
    item["title"] = title;
    item["description"] = description;

    var acl = new ParseACL(owner);
    acl.PublicReadAccess = false;
    acl.PublicWriteAccess = false;
    item.ACL = acl;

    try {
        await item.SaveAsync();
        Console.WriteLine("Private item created successfully.");
    } catch (Exception ex) {
        Console.WriteLine($"Error saving private item: {ex.Message}");
    }
}
﻿
Setting Class-Level Permissions (CLPs)
Within your Back4app dashboard, configure CLPs to establish default access rules. This ensures that only authenticated users can interact with specific classes.
﻿
Step 6 – Implementing User Authentication in Xamarin
Managing User Accounts
Back4app utilizes the built-in Parse User class for authentication. In your Xamarin app, manage user registration and login as shown below:
C#
using Parse;
using System;

public class AuthService {
    public async Task SignUpAsync(string username, string password, string email) {
        var user = new ParseUser {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User registered successfully!");
        } catch (Exception ex) {
            Console.WriteLine($"Error during sign up: {ex.Message}");
        }
    }

    public async Task LogInAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine($"User logged in: {user.Username}");
        } catch (Exception ex) {
            Console.WriteLine($"Login failed: {ex.Message}");
        }
    }
}
using Parse;
using System;

public class AuthService {
    public async Task SignUpAsync(string username, string password, string email) {
        var user = new ParseUser {
            Username = username,
            Password = password,
            Email = email
        };

        try {
            await user.SignUpAsync();
            Console.WriteLine("User registered successfully!");
        } catch (Exception ex) {
            Console.WriteLine($"Error during sign up: {ex.Message}");
        }
    }

    public async Task LogInAsync(string username, string password) {
        try {
            var user = await ParseUser.LogInAsync(username, password);
            Console.WriteLine($"User logged in: {user.Username}");
        } catch (Exception ex) {
            Console.WriteLine($"Login failed: {ex.Message}");
        }
    }
}
﻿
This approach can be extended to include session management, password recovery, and other authentication-related functionalities.
﻿
Step 7 – Conclusion and Future Directions
Well done! You have successfully developed a Xamarin-based CRUD application integrated with Back4app. In this tutorial, you:
Configured a Back4app project named Basic-CRUD-App-Xamarin.
Designed the necessary data structures for Items and Users.
Leveraged the Back4app Admin App to manage your data.
Connected your Xamarin application via the Parse .NET SDK (or REST/GraphQL) to perform CRUD operations.
Implemented robust security measures including ACLs and CLPs.
Set up user authentication to manage account creation and login.
Next Steps:
Expand the App Functionality:
Consider adding features like advanced filtering, detailed item views, or real-time data updates.
Enhance Backend Capabilities:
Explore cloud functions, third-party integrations, and role-based access controls.
Further Learning:
Visit the Back4app documentation and additional resources to optimize and scale your application.
Happy coding and best of luck with your Xamarin CRUD application!
Field	Data Type	Description
_id	ObjectId	Auto-generated unique identifier.
title	String	The item’s name.
description	String	A brief summary of the item.
createdAt	Date	Timestamp marking creation.
updatedAt	Date	Timestamp marking the last update.
Field	Data Type	Description
_id	ObjectId	Automatically generated unique ID.
username	String	Unique username for the user.
email	String	Unique email address for account contact.
passwordHash	String	Encrypted password for security.
createdAt	Date	Account creation timestamp.
updatedAt	Date	Timestamp for the last account update.
Updated 20 Feb 2025
Did this page help you?
How to Create a CRUD Application with Kotlin?
How to Build a CRUD App with Flutter?