What is the Difference Between Debugging Synchronous and Asynchronous Plugins in Dynamics 365 CRM?

Understanding the difference between synchronous and asynchronous plugins is essential when debugging Dynamics 365 CRM. While both types of plugins extend the functionality of CRM, they operate differently, and this affects how you approach debugging.

This article focuses on debugging, including a code example to illustrate the process.

1. Understanding Synchronous and Asynchronous Plugins

Synchronous Plugins:
Synchronous plugins execute in real-time, meaning they run immediately as part of the operation they’re registered on. For instance, if a plugin is registered on the Create event of an entity, it will execute before the record is saved. If something goes wrong, the entire operation fails, and the user receives an error message immediately.

Asynchronous Plugins:
Asynchronous plugins, on the other hand, execute in the background. They are queued to run after the main operation completes, allowing the user to continue working without waiting for the plugin to finish. Errors in asynchronous plugins don’t prevent the operation from completing, but they are logged for later review.

2. Debugging Synchronous Plugins

Debugging synchronous plugins is generally more straightforward because they run in real time. Here’s how you can debug a synchronous plugin:

Example: Synchronous Plugin

public class PreAccountCreatePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
        ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));

        try
        {
            // Plugin logic here
            Entity account = (Entity)context.InputParameters["Target"];
            tracingService.Trace("Account name: " + account["name"]);

            // Simulate an error
            throw new InvalidPluginExecutionException("Error: Something went wrong in the synchronous plugin.");
        }
        catch (Exception ex)
        {
            tracingService.Trace("Exception: " + ex.Message);
            throw;
        }
    }
}

Steps to Debug:

1. Attach Debugger: Attach the Visual Studio debugger
2. Trigger the Plugin: Perform the CRM operation that triggers the plugin (e.g., create an account).
3. Step Through Code: The debugger will hit the breakpoint, allowing you to step through the code, inspect variables, and diagnose the issue in real time.

3. Debugging Asynchronous Plugins

Asynchronous plugins are more challenging to debug since they don’t execute immediately. Instead, you rely on logging to track the execution flow. Here’s how you can debug an asynchronous plugin:

Example: Asynchronous Plugin

public class PostAccountCreatePlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
        ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));

        try
        {
            // Plugin logic here
            Entity account = (Entity)context.InputParameters["Target"];
            tracingService.Trace("Asynchronous Plugin - Account name: " + account["name"]);

            // Simulate an error
            throw new InvalidPluginExecutionException("Error: Something went wrong in the asynchronous plugin.");
        }
        catch (Exception ex)
        {
            tracingService.Trace("Exception: " + ex.Message);
            throw;
        }
    }
}

Steps to Debug:

1. Log Tracing Information: Since you can’t attach a debugger, use ITracingService to log detailed information about the plugin’s execution.
2. Monitor System Jobs: After triggering the operation in CRM, go to Settings > System Jobs to find the asynchronous job. If it failed, you can view detailed logs and the exception message.
3. Analyze Logs: Use the logs to trace the execution flow and identify where the error occurred.

4. Key Differences in Debugging

• Real-Time vs. Background Execution: Synchronous plugins allow for real-time debugging with a debugger, while asynchronous plugins require post-execution analysis using logs.
• Immediate Feedback vs. Logged Errors: Errors in synchronous plugins provide immediate feedback to the user, making them easier to diagnose, while asynchronous plugin errors are logged for later review.
• Performance Impact: Poorly optimized synchronous plugins can slow down user operations, while asynchronous plugins are less likely to impact performance since they run in the background.

Conclusion

Understanding the differences between synchronous and asynchronous plugins is crucial for effective debugging in Dynamics 365 CRM. Synchronous plugins offer the advantage of real-time debugging, making them easier to diagnose. In contrast, asynchronous plugins require a more in-depth analysis using logs due to their background execution. By mastering the debugging techniques for both types, you can ensure your plugins run smoothly, enhancing your CRM system’s overall performance.

Reference: https://learn.microsoft.com/en-us/power-apps/developer/data-platform/tutorial-debug-plug-in?tabs=prt