Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "configure-auth0",
title: "Configure Auth0"
}, {
id: "install-the-auth0-sdk",
title: "Install the Auth0 SDK"
}, {
id: "instantiate-the-auth0client",
title: "Instantiate the Auth0Client"
}, {
id: "configure-android",
title: "Configure Android"
}, {
id: "configure-ios",
title: "Configure iOS"
}, {
id: "add-login-to-your-application",
title: "Add login to your application"
}, {
id: "add-logout-to-your-application",
title: "Add logout to your application"
}, {
id: "show-user-profile-information",
title: "Show user profile information"
}];
Auth0 allows you to add authentication to almost any application type quickly. This guide demonstrates how to
integrate Auth0, add authentication, and display user profile information in any .NET Android and iOS application
using the Auth0 SDKs for [Android](https://www.nuget.org/packages/Auth0.OidcClient.AndroidX/) and [iOS](https://www.nuget.org/packages/Auth0.OidcClient.iOS).
This quickstart focuses on .NET Android and iOS, as they are the next generation of
`Xamarin.Android` and `Xamarin.iOS`. If you are still using
`Xamarin.Android` and `Xamarin.iOS`, you can follow this guide as the integration is
identical, and the SDKs are compatible.
To use this quickstart, you’ll need to:
To use Auth0 services, you need to have an application set up in the Auth0 Dashboard. The Auth0 application is
where you will configure how you want authentication to work for your project.
### Configure an application
Use the interactive selector to create a new "Native Application", or select an existing application that
represents the project you want to integrate with. Every application in Auth0 is assigned an alphanumeric, unique
client ID that your application code will use to call Auth0 APIs through the SDK.
Any settings you configure using this quickstart will automatically update for your application in the [Dashboard](https://manage.auth0.com/#/), which is where you
can manage your applications in the future.
If you would rather explore a complete configuration, you can view a sample application instead.
### Configure Callback URLs
A callback URL is a URL in your application that you would like Auth0 to redirect users to after they have
authenticated. If not set, users will not be returned to your application after they log in.
If you are following along with our sample project, set this to one of the following URLs depending on
your platform:
* **Android**: `YOUR_PACKAGE_NAME://{yourDomain}/android/YOUR_PACKAGE_NAME/callback`
* **iOS**: `YOUR_BUNDLE_ID://{yourDomain}/ios/YOUR_BUNDLE_ID/callback`
**Android**: `YOUR_PACKAGE_NAME://{yourDomain}/android/YOUR_PACKAGE_NAME/callback`
**iOS**: `YOUR_BUNDLE_ID://{yourDomain}/ios/YOUR_BUNDLE_ID/callback`
### Configure Logout URLs
A logout URL is a URL in your application that you would like Auth0 to redirect users to after they have logged
out. If not set, users will not be able to log out from your application and will receive an error.
If you are following along with our sample project, set this to one of the following URLs depending on
your platform:
* **Android**: `YOUR_PACKAGE_NAME://{yourDomain}/android/YOUR_PACKAGE_NAME/callback`
* **iOS**: `YOUR_BUNDLE_ID://{yourDomain}/ios/YOUR_BUNDLE_ID/callback`
**Android**: `YOUR_PACKAGE_NAME://{yourDomain}/android/YOUR_PACKAGE_NAME/callback`
**iOS**: `YOUR_BUNDLE_ID://{yourDomain}/ios/YOUR_BUNDLE_ID/callback`
Lastly, be sure that the **Application Type** for your application is set to **Native** in the [Application
Settings](https://manage.auth0.com/#/applications/).
Auth0 provides an [Android](https://www.nuget.org/packages/Auth0.OidcClient.AndroidX/) and [iOS](https://www.nuget.org/packages/Auth0.OidcClient.iOS) SDK to simplify the process of implementing Auth0
authentication in .NET Android and iOS applications.
Use the NuGet Package Manager (Tools -> Library Package Manager -> Package Manager Console) to install the
`Auth0.OidcClient.AndroidX` or `Auth0.OidcClient.iOS` package, depending on whether you are
building an Android or iOS application.
Alternatively, you can use the NuGet Package Manager Console (`Install-Package`) or the
`dotnet` CLI (`dotnet add`).
```
Install-Package Auth0.OidcClient.AndroidX
Install-Package Auth0.OidcClient.iOS
```
```
dotnet add Auth0.OidcClient.AndroidX
dotnet add Auth0.OidcClient.iOS
```
To integrate Auth0 into your application, instantiate an instance of the `Auth0Client` class, passing
an instance of `Auth0ClientOptions` that contains your Auth0 Domain and Client ID.
```csharp theme={null}
using Auth0.OidcClient;
var client = new Auth0Client(new Auth0ClientOptions {
Domain = "{yourDomain}",
ClientId = "{yourClientId}"
}, this);
```
By default, the SDK will leverage Chrome Custom Tabs for Android and ASWebAuthenticationSession for iOS.
##### Checkpoint
Your `Auth0Client` should now be properly instantiated. Run your application to verify that:
* The `Auth0Client`is instantiated correctly in the `Activity`(Android) or
`UIViewController`(iOS).
* Your application is not throwing any errors related to Auth0.
After a user successfully authenticates, they will be redirected to the callback URL you set up earlier in this
quickstart.
To handle the callback on Android devices, you need to register an intent that handles this callback URL. An easy
way to do this is to register the intent on the same activity from which you called the LoginAsync method to
instantiate the authentication flow.
Ensure to replace `YOUR_ANDROID_PACKAGE_NAME` in the code sample with the actual Package Name for your
application, such as `com.mycompany.myapplication`, and ensure that all the text for the
`DataScheme`, `DataHost`, and `DataPathPrefix` is in lowercase. Also, set
`LaunchMode = LaunchMode.SingleTask` for the Activity; otherwise, the system will create a new instance
of the activity every time the Callback URL gets called.
Additionally, you need to handle the intent in the `OnNewIntent` event in your `Activity`
class. You need to notify the Auth0 OIDC Client to finish the authentication flow by calling the `Send`
method of the `ActivityMediator` singleton, passing along the URL that was sent in.
```charp theme={null}
protected override void OnNewIntent(Intent intent)
{
base.OnNewIntent(intent);
ActivityMediator.Instance.Send(intent.DataString);
}
```
After a user successfully authenticates, they will be redirected to the callback URL you set up earlier in this
quickstart.
To handle the callback on iOS devices:
1. Open your application's `Info.plist`file in Visual Studio, and go to the \*\*Advanced \*\*tab.
2. Under **URL Types**, click the \*\*Add URL Type \*\*button.
3. Set the \*\*Identifier \*\*as Auth0, the \*\*URL Schemes \*\*the same as your application's
`Bundle Identifier`, and the \*\*Role \*\*as `None`.
This is an example of the XML representation of your `info.plist` file after you have added the URL
Type:
```xml theme={null}
CFBundleURLTypesCFBundleTypeRoleNoneCFBundleURLNameAuth0CFBundleURLSchemesYOUR_BUNDLE_IDENTIFIER
```
Additionally, you need to handle the Callback URL in the `OpenUrl` event in your
`AppDelegate` class. You need to notify the Auth0 OIDC Client to finish the authentication flow by
calling the `Send` method of the `ActivityMediator` singleton, passing along the URL that
was sent in.
Now that you have configured your Auth0 Application and the Auth0 SDK, you need to set up login for your project.
To do this, you will use the SDK’s `LoginAsync()` method to create a login button that redirects users
to the Auth0 Universal Login page.
```csharp theme={null}
var loginResult = await client.LoginAsync();
```
If there isn't any error, you can access the `User`, `IdentityToken`,
`AccessToken` and `RefreshToken` on the `LoginResult` returned from
`LoginAsync()`.
##### Checkpoint
You should now be able to log in or sign up using a username and password.
Click the login button and verify that:
* Your Android or iOS application redirects you to the Auth0 Universal Login page.
* You can log in or sign up.
* Auth0 redirects you to your application.
Users who log in to your project will also need a way to log out. Create a logout button using the SDK’s
`LogoutAsync()` method. When users log out, they will be redirected to your Auth0 logout endpoint,
which will then immediately redirect them back to the logout URL you set up earlier in this quickstart.
```csharp theme={null}
await client.LogoutAsync();
```
##### Checkpoint
Run your application and click the logout button. Verify that:
* Your Android or iOS application redirects you to the address you specified as one of the Allowed
Logout URLs in your Application Settings.
* You are no longer logged in to your application.
Now that your users can log in and log out, you will likely want to be able to retrieve the profile information associated with authenticated users.
For example, you may want to display a logged-in user’s name or profile picture in your project.
The Auth0 SDK for Android and iOS provides user information through the `LoginResult.User` property.
```csharp theme={null}
if loginResult.IsError == false {
var user = loginResult.User
var name = user.FindFirst(c => c.Type == "name")?.Value
var email = user.FindFirst(c => c.Type == "email")?.Value
var picture = user.FindFirst(c => c.Type == "picture")?.Value
}
```
## Next Steps
Excellent work! If you made it this far, you should now have login, logout, and user profile information running in your application.
This concludes our quickstart tutorial, but there is so much more to explore. To learn more about what you can do with Auth0, check out:
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Learn how to configure and manage your Auth0 tenant and applications
* [auth0-oidc-client-net SDK](https://github.com/auth0/auth0-oidc-client-net) - Explore the SDK used in this tutorial more fully
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Discover integrations you can enable to extend Auth0’s functionality
```cs MainActivity.cs highlight={2-9} lines theme={null}
// Example of a full Android Activity
[Activity(Label = "AndroidSample", MainLauncher = true, Icon = "@drawable/icon",
LaunchMode = LaunchMode.SingleTask)]
[IntentFilter(
new[] { Intent.ActionView },
Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
DataHost = "{yourDomain}",
DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
public class MainActivity : Activity
{
private Auth0Client _auth0Client;
protected override void OnNewIntent(Intent intent)
{
base.OnNewIntent(intent);
ActivityMediator.Instance.Send(intent.DataString);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
Auth0ClientOptions clientOptions = new Auth0ClientOptions
{
Domain = "{yourDomain}"
ClientId = "{yourClientId}"
};
_auth0Client = new Auth0Client(clientOptions, this);
}
private async void LoginButtonOnClick(object sender, EventArgs eventArgs)
{
var loginResult = await _auth0Client.LoginAsync();
if (loginResult.IsError == false)
{
var user = loginResult.User;
var name = user.FindFirst(c => c.Type == "name")?.Value;
var email = user.FindFirst(c => c.Type == "email")?.Value;
var picture = user.FindFirst(c => c.Type == "picture")?.Value;
}
}
private async void LogoutButtonOnClick(object sender, EventArgs e)
{
await _auth0Client.LogoutAsync();
}
}
```
```cs AppDelegate.cs highlight={6-11} lines theme={null}
using Auth0.OidcClient;
[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
{
ActivityMediator.Instance.Send(url.AbsoluteString);
return true;
}
}
```
```cs MyViewController.cs lines theme={null}
// Example of a full iOS UIViewController
public partial class MyViewController : UIViewController
{
private Auth0Client _auth0Client;
public MyViewController() : base("MyViewController", null)
{
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
Auth0ClientOptions clientOptions = new Auth0ClientOptions
{
Domain = "{yourDomain}"
ClientId = "{yourClientId}"
};
_auth0Client = new Auth0Client(clientOptions, this);
}
private async void LoginButton_TouchUpInside(object sender, EventArgs e)
{
var loginResult = await _auth0Client.LoginAsync();
if (loginResult.IsError == false)
{
var user = loginResult.User;
var name = user.FindFirst(c => c.Type == "name")?.Value;
var email = user.FindFirst(c => c.Type == "email")?.Value;
var picture = user.FindFirst(c => c.Type == "picture")?.Value;
}
}
private async void LogoutButton_TouchUpInside(object sender, EventArgs e)
{
await _auth0Client.LogoutAsync();
}
}
```
```cs AppDelegate.cs highlight={6-11} lines theme={null}
using Auth0.OidcClient;
[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
{
ActivityMediator.Instance.Send(url.AbsoluteString);
return true;
}
}
```
```cs MainActivity.cs highlight={2-9} lines theme={null}
// Example of a full Android Activity
[Activity(Label = "AndroidSample", MainLauncher = true, Icon = "@drawable/icon",
LaunchMode = LaunchMode.SingleTask)]
[IntentFilter(
new[] { Intent.ActionView },
Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable },
DataScheme = "YOUR_ANDROID_PACKAGE_NAME",
DataHost = "{yourDomain}",
DataPathPrefix = "/android/YOUR_ANDROID_PACKAGE_NAME/callback")]
public class MainActivity : Activity
{
private Auth0Client _auth0Client;
protected override void OnNewIntent(Intent intent)
{
base.OnNewIntent(intent);
ActivityMediator.Instance.Send(intent.DataString);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
Auth0ClientOptions clientOptions = new Auth0ClientOptions
{
Domain = "{yourDomain}"
ClientId = "{yourClientId}"
};
_auth0Client = new Auth0Client(clientOptions, this);
}
private async void LoginButtonOnClick(object sender, EventArgs eventArgs)
{
var loginResult = await _auth0Client.LoginAsync();
if (loginResult.IsError == false)
{
var user = loginResult.User;
var name = user.FindFirst(c => c.Type == "name")?.Value;
var email = user.FindFirst(c => c.Type == "email")?.Value;
var picture = user.FindFirst(c => c.Type == "picture")?.Value;
}
}
private async void LogoutButtonOnClick(object sender, EventArgs e)
{
await _auth0Client.LogoutAsync();
}
}
```
```cs MyViewController.cs lines theme={null}
// Example of a full iOS UIViewController
public partial class MyViewController : UIViewController
{
private Auth0Client _auth0Client;
public MyViewController() : base("MyViewController", null)
{
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
Auth0ClientOptions clientOptions = new Auth0ClientOptions
{
Domain = "{yourDomain}"
ClientId = "{yourClientId}"
};
_auth0Client = new Auth0Client(clientOptions, this);
}
private async void LoginButton_TouchUpInside(object sender, EventArgs e)
{
var loginResult = await _auth0Client.LoginAsync();
if (loginResult.IsError == false)
{
var user = loginResult.User;
var name = user.FindFirst(c => c.Type == "name")?.Value;
var email = user.FindFirst(c => c.Type == "email")?.Value;
var picture = user.FindFirst(c => c.Type == "picture")?.Value;
}
}
private async void LogoutButton_TouchUpInside(object sender, EventArgs e)
{
await _auth0Client.LogoutAsync();
}
}
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.