Building console apps for Dynamics 365 automation

Why console applications for Dynamics 365?

Console applications are powerful tools for automating administrative tasks, performing bulk data operations, and running scheduled jobs against Dynamics 365 environments. Unlike plugins that run within the platform's execution pipeline, console apps run externally and can perform operations that would be impractical or impossible within the normal execution context. Learn more about the Dataverse Web API and the Organization service.

Common use cases

Data migration: Bulk import/export of records between systems
Scheduled maintenance: Cleanup of old records, recalculating rollups
Reporting exports: Generate CSV/Excel exports on schedule
Integration sync: Synchronize data with external systems
Environment management: Automate solution deployment and configuration
Testing automation: Create test data, run integration tests

Setting up your project

Project creation

Create a new .NET Framework 4.6.2 Console Application in Visual Studio. This framework version matches the Dynamics 365 SDK requirements.

// Visual Studio → New Project → Console App (.NET Framework)

// Target Framework: .NET Framework 4.6.2

// Project Name: D365AutomationConsole

Required NuGet packages

Install the following NuGet packages to connect to Dynamics 365:

Install-Package Microsoft.CrmSdk.CoreAssemblies

Install-Package Microsoft.CrmSdk.XrmTooling.CoreAssembly

Install-Package Microsoft.CrmSdk.Deployment

Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory

Authentication methods

Connection string authentication

The simplest approach uses a connection string with the CrmServiceClient.

using Microsoft.Xrm.Tooling.Connector;

var connectionString = @"
    AuthType=OAuth;
    Url=https://yourorg.crm.dynamics.com;
    AppId=51f81489-12ee-4a9e-aaae-a2591f45987d;
    RedirectUri=app://58145B91-0C36-4500-8554-080854F2AC97;
    LoginPrompt=Auto";

var client = new CrmServiceClient(connectionString);

if (client.IsReady)
{
    Console.WriteLine("Connected to: " + client.ConnectedOrgFriendlyName);
    IOrganizationService service = client.OrganizationServiceProxy;
    // Use service for operations
}
else
{
    Console.WriteLine("Connection failed: " + client.LastCrmError);
}

Keep usernames and passwords out of connection strings

This example signs in interactively (LoginPrompt=Auto) and never stores a password. Username/password sign-in (ROPC) is blocked by multifactor authentication and Conditional Access and leaves credentials in plain text, so don't use it. For unattended jobs, use the client secret or certificate approach below and keep the secret in Azure Key Vault.

Client ID and secret (recommended for automation)

For unattended automation scenarios, use an Microsoft Entra ID App Registration with client credentials.

var connectionString = @"
    AuthType=ClientSecret;
    Url=https://yourorg.crm.dynamics.com;
    ClientId=your-app-registration-client-id;
    ClientSecret=your-client-secret";

var client = new CrmServiceClient(connectionString);

Important: Register an Application User in Dynamics 365 with appropriate security roles for the app registration.

Certificate-based authentication

For highest security in production scenarios, use certificate authentication.

var connectionString = @"
    AuthType=Certificate;
    Url=https://yourorg.crm.dynamics.com;
    ClientId=your-app-registration-client-id;
    Thumbprint=your-certificate-thumbprint;
    StoreName=My;
    StoreLocation=CurrentUser";

var client = new CrmServiceClient(connectionString);

Common operations

CRUD operations

Perform Create, Retrieve, Update, Delete operations using the Organization Service.

// Create
var account = new Entity("account");
account["name"] = "Contoso Ltd";
account["telephone1"] = "+1-555-0123";
Guid accountId = service.Create(account);
Console.WriteLine($"Created account: {accountId}");

// Retrieve
var retrieved = service.Retrieve("account", accountId,
    new ColumnSet("name", "telephone1", "accountnumber"));
Console.WriteLine($"Retrieved: {retrieved["name"]}");

// Update
var updateAccount = new Entity("account", accountId);
updateAccount["accountnumber"] = "ACC-001";
service.Update(updateAccount);
Console.WriteLine("Account updated");

// Delete
service.Delete("account", accountId);
Console.WriteLine("Account deleted");

Querying data

Use QueryExpression or FetchXML to retrieve data from Dynamics 365.

var query = new QueryExpression("contact")
{
    ColumnSet = new ColumnSet("fullname", "emailaddress1", "parentcustomerid"),
    Criteria = new FilterExpression
    {
        Conditions =
        {
            new ConditionExpression("statecode", ConditionOperator.Equal, 0),
            new ConditionExpression("emailaddress1", ConditionOperator.NotNull)
        }
    },
    Orders = { new OrderExpression("fullname", OrderType.Ascending) },
    TopCount = 100
};

// Add linked entity for account name
var accountLink = query.AddLink("account", "parentcustomerid", "accountid", JoinOperator.LeftOuter);
accountLink.Columns.AddColumn("name");
accountLink.EntityAlias = "parentaccount";

var results = service.RetrieveMultiple(query);
foreach (var contact in results.Entities)
{
    var accountName = contact.GetAttributeValue<AliasedValue>("parentaccount.name")?.Value;
    Console.WriteLine($"{contact["fullname"]} - {accountName ?? "No Account"}");
}

Bulk operations

Use ExecuteMultipleRequest for efficient bulk operations.

public void BulkCreateContacts(IOrganizationService service, List<Entity> contacts)
{
    var batchSize = 100;
    var batches = contacts
        .Select((contact, index) => new { contact, index })
        .GroupBy(x => x.index / batchSize)
        .Select(g => g.Select(x => x.contact).ToList())
        .ToList();

    int totalCreated = 0;
    foreach (var batch in batches)
    {
        var multipleRequest = new ExecuteMultipleRequest
        {
            Settings = new ExecuteMultipleSettings
            {
                ContinueOnError = true,
                ReturnResponses = true
            },
            Requests = new OrganizationRequestCollection()
        };

        foreach (var contact in batch)
        {
            multipleRequest.Requests.Add(new CreateRequest { Target = contact });
        }

        var response = (ExecuteMultipleResponse)service.Execute(multipleRequest);

        int successCount = response.Responses.Count(r => r.Fault == null);
        totalCreated += successCount;

        // Log any failures
        foreach (var item in response.Responses.Where(r => r.Fault != null))
        {
            Console.WriteLine($"Error at index {item.RequestIndex}: {item.Fault.Message}");
        }

        Console.WriteLine($"Batch complete: {successCount}/{batch.Count} created");
    }

    Console.WriteLine($"Total created: {totalCreated}/{contacts.Count}");
}

Best practice:

Batch operations in groups of 100-500 for optimal performance. Handle partial failures gracefully.

Scheduling console apps

Run console applications on a schedule using Windows Task Scheduler or Azure Functions.

Windows Task Scheduler

For on-premises scenarios, use Windows Task Scheduler to run console apps at specified intervals.

Azure Functions

For cloud-hosted automation, convert console app logic to Azure Functions with timer triggers.

Error handling and logging

Implement robust error handling and logging for production automation.

public void ProcessRecord(IOrganizationService service, Guid recordId)
{
    try
    {
        var record = service.Retrieve("account", recordId, new ColumnSet(true));
        // Process record
    }
    catch (FaultException<OrganizationServiceFault> ex)
    {
        // Dynamics 365 specific error
        Console.WriteLine($"D365 Error: {ex.Detail.Message}");
        Console.WriteLine($"Error Code: {ex.Detail.ErrorCode}");

        if (ex.Detail.InnerFault != null)
        {
            Console.WriteLine($"Inner Error: {ex.Detail.InnerFault.Message}");
        }
    }
    catch (TimeoutException ex)
    {
        Console.WriteLine($"Timeout: {ex.Message}");
        // Implement retry logic
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Unexpected error: {ex.Message}");
        throw;
    }
}

Best practices:

Use try-catch blocks around all API operations
Log errors to files, event log, or Application Insights
Implement retry logic for transient failures
Send notifications for critical failures
Track execution metrics for monitoring

Security considerations

Key considerations:

Never hardcode credentials in source code
Use Azure Key Vault for secret management
Implement least-privilege service accounts
Rotate secrets and certificates regularly
Enable audit logging for automated operations

Conclusion

Console applications provide a powerful approach to automating Dynamics 365 tasks that go beyond what's possible with plugins or Power Automate. From data migration to scheduled maintenance, console apps offer full SDK access with the flexibility of external execution.

Focus on proper authentication, error handling, and security practices to build reliable automation solutions that can run unattended in production environments.

Need help with your Dynamics 365 project?

I can help you apply these practices in your own Dynamics 365 environment.