How to register Plugin Dynamically?

Problem Definition

How to register the steps of the plugin Dynamically (programmatically).

Introduction

Generally, after the plugin development, users register the plugin and steps using plugin registration tool provided by the CRM SDK.

But, in certain cases it is possible that the user may need to register the step in the plugin dynamically.

For example: Whenever a new entity is added it should have an auto number step registered automatically for that entity.

Description

Here I have created a sample plugin with no logic. I will register this plugin programmatically using console app.

To register the plugin programmatically. We need the following steps to be executed.

1. Connect to CRM
2. Create a record of type “pluginassembly”
3. Create a record of type “plugintype”
4. Create a record of type “sdkmessageprocessingstep”

Connect to CRM

Since we are registering the plugin using console application we need to connect the CRM instance before processing the steps. Organization service is required to create a record in CRM.

Please make sure you add the below references to the code.

using Microsoft.Crm.Sdk.Messages;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Tooling.Connector;
using System;
using System.IO;
using System.Reflection;

You can refer the below code the connect with CRM

public void ConnectCRM()
        {
            string connectionString = "Url=https://XXXX.crm.dynamics.com; Username=XXXX.onmicrosoft.com; Password=**********; authtype=Office365";

       // Connect to the CRM web service using a connection string.
            CrmServiceClient conn = new CrmServiceClient(connectionString);

       // Cast the proxy client to the IOrganizationService interface.
            _orgService = (IOrganizationService)conn.OrganizationWebProxyClient != null ? (IOrganizationService)conn.OrganizationWebProxyClient : (IOrganizationService)conn.OrganizationServiceProxy;

       // Obtain information about the logged on user from the web service.
            Guid userid = ((WhoAmIResponse)_orgService.Execute(new WhoAmIRequest())).UserId;
        }

Create a record of type “pluginassembly”

Once the connection is successful, we need to register the Plugin Assembly. Here, we need to provide the physical path of the .dll that we need to register.

While creating a record we need to provide the required field value which are listed below.

You can find list of attributes required, by looking into the excel sheet provided by Microsoft. You can find this excel sheet in the SDK with the name “EntityMetadata”

Attributes required:

Code:

        public Guid RegisterAssembly()
        {
            string filePath = @"D:\Plugin_Dynamically\Sample.Plugin.Dynamically\Sample.Plugin.Dynamically\bin\Debug\Sample.Plugin.Dynamically.dll";
            Guid assemblyId = Guid.Empty;
            try
            {
                var assembly = Assembly.LoadFile(filePath);

                string[] props = assembly.GetName().FullName.Split(",=".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

                Entity assemb = new Entity("pluginassembly");
                assemb["name"] = props[0];
                assemb["culture"] = props[4];
                assemb["version"] = props[2];
                assemb["publickeytoken"] = props[6];
                assemb["sourcetype"] = new OptionSetValue(0); // 0= database;
                assemb["isolationmode"] = new OptionSetValue(2); // 1= none, 2=sandbox
                assemb["content"] = Convert.ToBase64String(File.ReadAllBytes(filePath));
                assemblyId = _orgService.Create(assemb);
            }
            catch (Exception)
            {
                throw;
            }
            return assemblyId;
        }

Once the Assembly is registered you will able to see the below steps in plugin

Creating the plugintype record

A plugintype record must be created for each plugin inside the assembly. This can be done dynamically using reflection.

We need to specify the below required field

You can refer the below code for the registration of Plugin Type. The assemblyId is the Guid created on the earlier step.

public Guid CreatePluginType(Guid assemblyId)
        {
            Guid pluginTypeId = Guid.Empty;

            Entity pluginType = new Entity("plugintype");
            pluginType["pluginassemblyid"] = new EntityReference("pluginassembly", assemblyId);
            pluginType["typename"] = "Sample.Plugin.Dynamically.Dynamic";
            pluginType["friendlyname"] = "Sample Plugin Dynamically";
            pluginType["name"] = "Register Plugin";
            pluginType["description"] = " Sample Plugin Dynamically";
            pluginTypeId = _orgService.Create(pluginType);
            return pluginTypeId;
        }

This is how it will look like

Creating the sdkmessageprocessingstep record

At the end we need to create the step to process the request. For example, if you want to register the plugin for the create of the account entity.

You need to have two id retrieved from CRM separately.

Sdkmessageid: you will get this in from the sdkmessage entity you need to provide name as shown below.

Sdkmessagefilterid: You will find this id using Query shown in the below screen shot

You can refer the below code to perform the operation

public void SdkMessageStep(Guid pluginTypeId)
        {
            Guid messageId = new Guid("9EBDBB1B-EA3E-DB11-86A7-000A3A5473E8");

            Guid messageFitlerId = new Guid("C2C5BB1B-EA3E-DB11-86A7-000A3A5473E8");
           
            Entity step = new Entity("sdkmessageprocessingstep");
            step["name"] = "Sdk Message";
            step["configuration"] = "Create account record";

            step["invocationsource"] = new OptionSetValue(0);
            step["sdkmessageid"] = new EntityReference("sdkmessage", messageId);

            step["supporteddeployment"] = new OptionSetValue(0);
            step["plugintypeid"] = new EntityReference("plugintype", pluginTypeId);
            
            step["mode"] = new OptionSetValue(0);
            step["rank"] = 1;
            step["stage"] = new OptionSetValue(20);

            step["sdkmessagefilterid"] = new EntityReference("sdkmessagefilter", messageFitlerId);
            Guid stepId = _orgService.Create(step);
        }

Once the above step is executed successfully you will see the plugin as shown below

Conclusion

Even though we have plugin registration tool available to register the plugin using plugin registration tool we can also register the plugin programmatically in certain scenario.