Generate Early Bound Class for specific entities

Generate Early Bound Class for specific entities:

As a crm developer we need to write plug-in, workflows, console application for migration purpose. Writing the code is not a matter but while executing the code we may get some field miss spelling issues or before writing the code we need to waste our time to get the details of fields in order to work properly . These things may waste the time . To save the time MS team has given the feature to generate the ear ly bound classes for each entity.

Using these early bound classes we may not get the error’s like misspelling field names and also it provides the intelligence.

But while generating early bound classes crm will generate all the classes for all entities , it may cause increase the class file size.

To overcome this i am goanna show you how to generate the early bound classes only for specific entities.

Step 1: 

Create one Class Library project and add CrmSvcUtil.exe(which will find in Crm Sdk) as References.

Step 2: 

Add the below class to the project which you created recently.

using System;

using System.Collections.Generic;

using System.Xml.Linq;

using Microsoft.Crm.Services.Utility;

using Microsoft.Xrm.Sdk.Metadata;

namespace GenerateSpecificEntityClasses

{

    public class CodeWriterFilter : ICodeWriterFilterService

    {

        //list of entity names to generate classes for.

        private HashSet<string> _validEntities = new HashSet<string>();

        //reference to the default service.

        private ICodeWriterFilterService _defaultService = null;

        /// <summary>

        /// constructor

        /// </summary>

        /// <param name="defaultService">default implementation</param>

        public CodeWriterFilter(ICodeWriterFilterService defaultService)

        {

            this._defaultService = defaultService;

            LoadFilterData();

        }

        /// <summary>

        /// loads the entity filter data from the filter.xml file

        /// </summary>

        private void LoadFilterData()

        {

            XElement xml = XElement.Load("filter.xml");

            XElement entitiesElement = xml.Element("entities");

            foreach (XElement entityElement in entitiesElement.Elements("entity"))

            {

                _validEntities.Add(entityElement.Value.ToLowerInvariant());

            }

        }

        /// <summary>

        /// /Use filter entity list to determine if the entity class should be generated.

        /// </summary>

        public bool GenerateEntity(EntityMetadata entityMetadata, IServiceProvider services)

        {

            return (_validEntities.Contains(entityMetadata.LogicalName.ToLowerInvariant()));

        }

        //All other methods just use default implementation:

        public bool GenerateAttribute(AttributeMetadata attributeMetadata, IServiceProvider services)

        {

            return _defaultService.GenerateAttribute(attributeMetadata, services);

        }

        public bool GenerateOption(OptionMetadata optionMetadata, IServiceProvider services)

        {

            return _defaultService.GenerateOption(optionMetadata, services);

        }

        public bool GenerateOptionSet(OptionSetMetadataBase optionSetMetadata, IServiceProvider services)

        {

            return _defaultService.GenerateOptionSet(optionSetMetadata, services);

        }

        public bool GenerateRelationship(RelationshipMetadataBase relationshipMetadata, EntityMetadata otherEntityMetadata, IServiceProvider services)

        {

            return _defaultService.GenerateRelationship(relationshipMetadata, otherEntityMetadata, services);

        }

        public bool GenerateServiceContext(IServiceProvider services)

        {

            return _defaultService.GenerateServiceContext(services);

        }

    }

}

Step 3:

For now I just want to be able to determine which entities are generated, so in the constructor I read from an XML file (filter.xml) that holds the list of entities to generate and put the list in a Hashset.  The format of the xml is this:

<filter>

  <entities>

    <entity>systemuser</entity>

    <entity>team</entity>

    <entity>role</entity>

    <entity>businessunit</entity>

  </entities>

</filter>

Note:create xml file and give the name what ever you wish . but that name should pass in above method LoadFilterData()  

In above Xml file i just given four entities you can include as many entities as you want.

Take a look at the methods in the class. In the GenerateEntity method, we can simply check the EntityMetadata parameter against our list of valid entities and return true if it's an entity that we want to generate.

For all of the other methods we want to just do whatever the default implementation of the utility is.  Notice how the constructor of the class accepts a defaultService parameter.  We can just save a reference to this default service and use it whenever we want to stick with the default behavior.  All of the other methods in the class just call the default service.

To use our extension when running the utility, we just have to make sure the compiled DLL and the filter.xml file are in the same folder as CrmSvcUtil.exe, and set the /codewriterfilter command-line argument when running the utility (as described in the SDK):

Step 4:

Now we have class library project and xml file . All we have to do is build the project and copy the xml file and paste it in bin folder of project which we compiled now.

Step 5:

Now we need to run the CrmSvcUtil.exe as

Open command prompt and change the directory to the class project library bin->debug folder and execte the command as like :

CrmSvcUtil.exe  /url:<Url>    /out:<OutputFileName>.cs /username:<UserName> /password:<password> /namespace:<Nampespace> /serviceContextName:<servicecontext> /codewriterfilter:<ClasslibraryProjectNameSpace>.<ClassName>,<ClasslibraryProjectNameSpace>

That’s all we have to generate the early bound classes .