Explain Plugin Execution Context in Dynamics 365 CRM

In Dynamics 365 CRM, plugins are custom business logic that can be executed in response to specific events, such as creating or updating a record. One of the core concepts for developing plugins is the Plugin Execution Context. This blog post will explain what the Plugin Execution Context is, its importance and how to use its properties effectively with clear examples.

What is Plugin Execution Context?

The Plugin Execution Context is an interface that provides information about the execution environment of a plugin. It includes details about the organization, user, message, and entity being processed. Understanding this context is crucial for creating effective and robust plugins.

Why Use Plugin Execution Context?

1. Access to Important Data: The execution context gives you access to the data you need to perform operations, such as the current user ID, organization ID, and the entity being processed.
2. Isolation of Execution: Each plugin runs in its own execution context, ensuring that it operates independently of other plugins. This isolation helps prevent conflicts and unintended data modifications.
3. Control Over Plugin Behavior: You can use the execution context properties to control how your plugin behaves based on the conditions of the current execution.

Key Properties of Plugin Execution Context

The IPluginExecutionContext interface includes several properties that provide essential information. Here are some of the most important properties:

1. MessageName: The name of the message that triggered the plugin (e.g., Create, Update, Delete).
2. PrimaryEntityName: The logical name of the primary entity being processed (e.g., contact).
3. UserId: The ID of the user executing the plugin.
4. OrganizationId: The ID of the organization where the plugin is executing.
5. InputParameters: A collection of input parameters that were passed to the plugin execution.
6. OutputParameters: A collection of output parameters that the plugin can populate to return data.
7. PreEntityImages: A collection of entity images representing the state of the entity before the operation.
8. PostEntityImages: A collection of entity images representing the state of the entity after the operation.

Example Scenario: Preventing Duplicate Contacts

Let’s create a simple plugin that prevents users from creating a contact with the same email address as an existing contact.

Step 1: Setting Up Your Plugin

1. Create a New Class: Start by creating a new class for your plugin.

using System;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;

public class PreventDuplicateContactPlugin : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        // Obtain the execution context from the service provider.
        IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));

        // Ensure that the Target parameter is present
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
        {
            Entity contact = (Entity)context.InputParameters["Target"];

            // Check if the email field is set
            if (contact.Attributes.Contains("emailaddress1"))
            {
                string email = contact["emailaddress1"].ToString();

                // Implement logic to check for existing email addresses
                CheckForDuplicateEmail(serviceProvider, email, context);
            }
        }
    }

    private void CheckForDuplicateEmail(IServiceProvider serviceProvider, string email, IPluginExecutionContext context)
    {
        // Create an organization service to interact with the CRM
        IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
        IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

        // Query to check for existing contacts with the same email
        QueryExpression query = new QueryExpression("contact")
        {
            ColumnSet = new ColumnSet("contactid"),
            Criteria = new FilterExpression
            {
                Conditions =
                {
                    new ConditionExpression("emailaddress1", ConditionOperator.Equal, email)
                }
            }
        };

        // Execute the query
        EntityCollection results = service.RetrieveMultiple(query);

        // If a contact with the same email exists, throw an exception
        if (results.Entities.Count > 0)
        {
            throw new InvalidPluginExecutionException("A contact with this email address already exists.");
        }
    }
}

Step 2: Register Your Plugin

After creating your plugin class, you need to register it in Dynamics 365 CRM using the Plugin Registration Tool. Follow these steps:

1. Open the Plugin Registration Tool.
2. Connect to your Dynamics 365 instance.
3. Add a new assembly and select your plugin assembly.
4. Register the plugin step:
   • Message: Create
   • Primary Entity: Contact
   • Execution Mode: Synchronous
   • Stage: Pre-Operation

Step 3: Testing Your Plugin

To test your plugin:

1. Open Dynamics 365 CRM.
2. Try to create a new contact with an email address that already exists.
3. You should receive an error message preventing the creation of the duplicate contact.

Conclusion

The Plugin Execution Context is a powerful feature in Dynamics 365 CRM that allows developers to interact with the execution environment effectively. By understanding and using its properties, you can create robust plugins that enhance the functionality of your CRM system while maintaining data integrity.