Applications

public ApplicationsRequestBuilder Applications { get; }

var applications = await graphClient.Applications.GetAsync();

foreach (var app in applications.Value)
{
    Console.WriteLine($"{app.DisplayName}");
    Console.WriteLine($"  App ID: {app.AppId}");
    Console.WriteLine($"  Object ID: {app.Id}");
}

// Filter applications
var filteredApps = await graphClient.Applications.GetAsync(config =>
{
    config.QueryParameters.Filter = "startsWith(displayName,'MyApp')";
    config.QueryParameters.Select = new[] { "id", "appId", "displayName" };
});

// By object ID
var app = await graphClient.Applications["object-id"].GetAsync();

// By app ID (alternate key)
var app = await graphClient.ApplicationsWithAppId("app-id").GetAsync();

Console.WriteLine($"Display Name: {app.DisplayName}");
Console.WriteLine($"App ID: {app.AppId}");
Console.WriteLine($"Sign-in audience: {app.SignInAudience}");

var newApp = new Application
{
    DisplayName = "My Application",
    SignInAudience = "AzureADMyOrg",
    RequiredResourceAccess = new List<RequiredResourceAccess>
    {
        new RequiredResourceAccess
        {
            ResourceAppId = "00000003-0000-0000-c000-000000000000", // Microsoft Graph
            ResourceAccess = new List<ResourceAccess>
            {
                new ResourceAccess
                {
                    Id = Guid.Parse("e1fe6dd8-ba31-4d61-89e7-88639da4683d"), // User.Read
                    Type = "Scope"
                },
                new ResourceAccess
                {
                    Id = Guid.Parse("df021288-bdef-4463-88db-98f22de89214"), // User.Read.All
                    Type = "Role"
                }
            }
        }
    },
    Web = new WebApplication
    {
        RedirectUris = new List<string>
        {
            "https://localhost:5001/signin-oidc"
        },
        ImplicitGrantSettings = new ImplicitGrantSettings
        {
            EnableIdTokenIssuance = true
        }
    },
    Api = new ApiApplication
    {
        Oauth2PermissionScopes = new List<PermissionScope>
        {
            new PermissionScope
            {
                AdminConsentDescription = "Allow app to read data",
                AdminConsentDisplayName = "Read data",
                Id = Guid.NewGuid(),
                IsEnabled = true,
                Type = "User",
                UserConsentDescription = "Allow app to read your data",
                UserConsentDisplayName = "Read your data",
                Value = "Data.Read"
            }
        }
    }
};

var app = await graphClient.Applications.PostAsync(newApp);
Console.WriteLine($"Created app: {app.AppId}");

var updateApp = new Application
{
    DisplayName = "Updated App Name",
    Tags = new[] { "WindowsAzureActiveDirectoryIntegratedApp" }
};

await graphClient.Applications["object-id"].PatchAsync(updateApp);

await graphClient.Applications["object-id"].DeleteAsync();

var owners = await graphClient.Applications["object-id"].Owners.GetAsync();

foreach (var owner in owners.Value)
{
    if (owner is User user)
    {
        Console.WriteLine($"Owner: {user.DisplayName}");
    }
}

var ownerRef = new ReferenceCreate
{
    OdataId = $"https://graph.microsoft.com/v1.0/users/{userId}"
};

await graphClient.Applications["object-id"].Owners.Ref.PostAsync(ownerRef);

await graphClient.Applications["object-id"].Owners["user-id"].Ref.DeleteAsync();

var passwordCredential = new AddPasswordPostRequestBody
{
    PasswordCredential = new PasswordCredential
    {
        DisplayName = "My Client Secret",
        EndDateTime = DateTime.UtcNow.AddMonths(6)
    }
};

var credential = await graphClient.Applications["object-id"]
    .AddPassword
    .PostAsync(passwordCredential);

Console.WriteLine($"Secret: {credential.SecretText}");
Console.WriteLine($"Key ID: {credential.KeyId}");
// Store the secret securely - it's only shown once!

var removePassword = new RemovePasswordPostRequestBody
{
    KeyId = Guid.Parse("key-id")
};

await graphClient.Applications["object-id"]
    .RemovePassword
    .PostAsync(removePassword);

using System.Security.Cryptography.X509Certificates;

var certificate = new X509Certificate2("path/to/cert.pfx", "password");

var keyCredential = new AddKeyPostRequestBody
{
    KeyCredential = new KeyCredential
    {
        Type = "AsymmetricX509Cert",
        Usage = "Verify",
        Key = certificate.RawData,
        DisplayName = "My Certificate"
    },
    PasswordCredential = null,
    Proof = "proof-token" // Required for key verification
};

var key = await graphClient.Applications["object-id"]
    .AddKey
    .PostAsync(keyCredential);

var removeKey = new RemoveKeyPostRequestBody
{
    KeyId = Guid.Parse("key-id"),
    Proof = "proof-token"
};

await graphClient.Applications["object-id"]
    .RemoveKey
    .PostAsync(removeKey);

var extensions = await graphClient.Applications["object-id"]
    .ExtensionProperties
    .GetAsync();

foreach (var ext in extensions.Value)
{
    Console.WriteLine($"{ext.Name}: {ext.DataType}");
}

var extensionProperty = new ExtensionProperty
{
    Name = "customAttribute",
    DataType = "String",
    TargetObjects = new[] { "User" }
};

var ext = await graphClient.Applications["object-id"]
    .ExtensionProperties
    .PostAsync(extensionProperty);

var credentials = await graphClient.Applications["object-id"]
    .FederatedIdentityCredentials
    .GetAsync();

var federatedCred = new FederatedIdentityCredential
{
    Name = "GitHubActions",
    Issuer = "https://token.actions.githubusercontent.com",
    Subject = "repo:organization/repository:environment:production",
    Description = "GitHub Actions deployment",
    Audiences = new[] { "api://AzureADTokenExchange" }
};

await graphClient.Applications["object-id"]
    .FederatedIdentityCredentials
    .PostAsync(federatedCred);

using var logoStream = File.OpenRead("logo.png");

await graphClient.Applications["object-id"]
    .Logo
    .PutAsync(logoStream);

var logoStream = await graphClient.Applications["object-id"]
    .Logo
    .GetAsync();

using var fileStream = File.Create("downloaded-logo.png");
await logoStream.CopyToAsync(fileStream);

var policies = await graphClient.Applications["object-id"]
    .TokenIssuancePolicies
    .GetAsync();

var policies = await graphClient.Applications["object-id"]
    .TokenLifetimePolicies
    .GetAsync();

var webApp = new Application
{
    DisplayName = "My Web App",
    SignInAudience = "AzureADMultipleOrgs",
    Web = new WebApplication
    {
        RedirectUris = new List<string>
        {
            "https://myapp.com/signin-oidc",
            "https://myapp.com/signout-callback-oidc"
        },
        LogoutUrl = "https://myapp.com/signout-oidc"
    }
};

var app = await graphClient.Applications.PostAsync(webApp);

var spaApp = new Application
{
    DisplayName = "My SPA",
    SignInAudience = "AzureADandPersonalMicrosoftAccount",
    Spa = new SpaApplication
    {
        RedirectUris = new List<string>
        {
            "http://localhost:3000",
            "https://myspa.com"
        }
    },
    RequiredResourceAccess = new List<RequiredResourceAccess>
    {
        new RequiredResourceAccess
        {
            ResourceAppId = "00000003-0000-0000-c000-000000000000",
            ResourceAccess = new List<ResourceAccess>
            {
                new ResourceAccess
                {
                    Id = Guid.Parse("e1fe6dd8-ba31-4d61-89e7-88639da4683d"),
                    Type = "Scope"
                }
            }
        }
    }
};

var nativeApp = new Application
{
    DisplayName = "My Mobile App",
    SignInAudience = "AzureADandPersonalMicrosoftAccount",
    PublicClient = new PublicClientApplication
    {
        RedirectUris = new List<string>
        {
            "msauth.com.mycompany.myapp://auth",
            "http://localhost"
        }
    },
    IsFallbackPublicClient = true
};

var delta = await graphClient.Applications.Delta.GetAsync();

foreach (var app in delta.Value)
{
    Console.WriteLine($"Changed: {app.DisplayName}");
}

var deltaLink = delta.OdataDeltaLink;

using Microsoft.Graph.Models.ODataErrors;

try
{
    var app = await graphClient.Applications["object-id"].GetAsync();
}
catch (ODataError error)
{
    if (error.Error.Code == "Request_ResourceNotFound")
    {
        Console.WriteLine("Application not found");
    }
    else if (error.Error.Code == "Authorization_RequestDenied")
    {
        Console.WriteLine("Insufficient permissions");
    }
    else
    {
        Console.WriteLine($"Error: {error.Error.Message}");
    }
}