Actualización masiva de Dynamics CRM 2011

dynamics-crm dynamics-crm-2011

Question

Ejecución de la implementación de Dynamics CRM 2011 3. Es necesario actualizar millones de registros de clientes periódicamente (actualizaciones delta). El uso de la actualización estándar (una por una) lleva algunas semanas. Además, no queremos tocar la base de datos directamente, ya que puede romper cosas en el futuro.

¿Existe un método de actualización masiva en el servicio web / API REST de Dynamics CRM 2011 que podamos usar? (¿Cómo?)

Answer 1

CRM no implementa una forma de actualizar datos en masa; Hay 3 formas de mejorar el rendimiento de la operación de actualización masiva, pero internamente no pueden cambiar el hecho de que las actualizaciones de CRM se registran una por una. Básicamente las ideas son:

• reducir el tiempo perdido en la comunicación con el servidor CRM
• Usa el paralelismo para hacer múltiples operaciones al mismo tiempo.
• asegúrese de que el proceso de actualización NO desencadene ningún flujo de trabajo / complementos. De lo contrario, es posible que nunca veas el final del proceso ...

3 formas de mejorar el rendimiento de la operación a granel:

1. Después de RollUp 12 hay una función ExecuteMultipleRequest, que le permite enviar hasta 1000 solicitudes a la vez. Esto significa que puede ahorrar algo de tiempo al enviar 1000 solicitudes al servicio web de CRM, sin embargo, estas solicitudes se procesan una tras otra. Entonces, si su servidor CRM está bien configurado, lo más probable es que este método no ayude demasiado.
2. Puede usar la instancia de OrganizationServiceContext para realizar una actualización masiva. OrganizationServiceContext implementa la unidad de patrón de trabajo para que pueda realizar múltiples actualizaciones y transmitir estas operaciones al servidor en una sola llamada. En comparación con ExecuteMultipleRequest, no tiene un límite en el monto de la solicitud, pero si encuentra una falla durante la actualización, revertirá todos los cambios.
3. Utilice multihilo o multitarea. De cualquier manera, mejoraría la velocidad, pero es probable que generen algunas fallas de conexión o errores de SQL, por lo que deberá agregar un poco de lógica de reintento en el código.

Answer 2

El equipo de Microsoft PFE para la dinámica CRM escribió una nueva biblioteca de CRM SDK que utiliza la paralelización para ejecutar solicitudes de forma masiva y garantizar la seguridad de subprocesos.

Puede intentarlo: Solicitudes de ejecución paralela Me gustaría saber si funciona y se escala a millones de registros.

Answer 3

Esta es una pregunta bastante antigua, pero nadie mencionó la manera rápida (pero también la más desafiante) de actualizar / crear grandes cantidades de registros en CRM 201X: usar la función de importación incorporada, que es totalmente factible con CRM SDK. Hay un artículo perfecto de MSDN sobre eso: https://msdn.microsoft.com/en-us/library/gg328321(v=crm.5).aspx . En resumen tienes que:

1) Cree un archivo de Excel que contenga los datos que desea importar (simplemente exporte algunos datos de CRM 201X y verifique cómo se ve la estructura, recuerde que las primeras 3 columnas están ocultas)

2) crear entidad de Importar Mapa (especifique el archivo que creó)

3) Crear asignaciones de columnas si es necesario

4) Cree la entidad Import e ImportFile, proporcionando las asignaciones adecuadas

5) Analizar datos usando ParseImportRequest

6) Transformar datos utilizando TransformImportRequest

7) Importar datos utilizando ImportRecordsImportRequest

Estos fueron los pasos para CRM 2011, ahora en 2017 tenemos más versiones disponibles y existen ligeras diferencias entre ellas. Compruebe la muestra que está disponible en MSDN y en SDK: https://msdn.microsoft.com/en-us/library/hh547396(v=crm.5).aspx

Por supuesto, el punto 1 será la parte más difícil, ya que tiene que crear un archivo XML o docx que corresponda perfectamente con lo que CRM espera, pero supongo que lo está haciendo desde una aplicación externa, por lo que puede usar algunas bibliotecas .NET excelentes. Eso hará las cosas mucho más simples.

Nunca vi nada más rápido que la importación de CRM estándar cuando se trata de actualizar / crear registros, incluso si se busca el paralelismo y las solicitudes de actualización por lotes.

Si algo sale mal con los sitios de MSDN, estoy publicando aquí un ejemplo del enlace anterior que muestra cómo importar datos a CRM programáticamente:

using System;
using System.ServiceModel;
using System.Collections.Generic;
using System.Linq;

// These namespaces are found in the Microsoft.Xrm.Sdk.dll assembly
// located in the SDK/bin folder of the SDK download.
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using Microsoft.Xrm.Sdk.Client;
using Microsoft.Xrm.Sdk.Messages;
using Microsoft.Xrm.Sdk.Metadata;

// These namespaces are found in the Microsoft.Crm.Sdk.Proxy.dll assembly
// located in the SDK/bin folder of the SDK download.
using Microsoft.Crm.Sdk.Messages;

namespace Microsoft.Crm.Sdk.Samples
{    
    /// <summary>
    /// This sample shows how to define a complex mapping for importing and then use the
    /// Microsoft Dynamics CRM 2011 API to bulk import records with that mapping.
    /// </summary>
    public class ImportWithCreate
    {
        #region Class Level Members

        private OrganizationServiceProxy _serviceProxy;
        private DateTime _executionDate;

        #endregion

        /// <summary>
        /// This method first connects to the organization service. Afterwards,
        /// auditing is enabled on the organization, account entity, and a couple
        /// of attributes.
        /// </summary>
        /// <param name="serverConfig">Contains server connection information.</param>
        /// <param name="promptforDelete">When True, the user will be prompted to delete all
        /// created entities.</param>
        public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
        {
            using (_serviceProxy = ServerConnection.GetOrganizationProxy(serverConfig))
            {
                // This statement is required to enable early bound type support.
                _serviceProxy.EnableProxyTypes();

                // Log the start time to ensure deletion of records created during execution.
                _executionDate = DateTime.Today;
                ImportRecords();
                DeleteRequiredRecords(promptforDelete);
            }
        }

        /// <summary>
        /// Imports records to Microsoft Dynamics CRM from the specified .csv file.
        /// </summary>
        public void ImportRecords()
        {
            // Create an import map.
            ImportMap importMap = new ImportMap()
            {
                Name = "Import Map " + DateTime.Now.Ticks.ToString(),
                Source = "Import Accounts.csv",
                Description = "Description of data being imported",
                EntitiesPerFile =
                    new OptionSetValue((int)ImportMapEntitiesPerFile.SingleEntityPerFile),
                EntityState = EntityState.Created
            };
            Guid importMapId = _serviceProxy.Create(importMap);

            // Create column mappings.

            #region Column One Mappings
            // Create a column mapping for a ''text'' type field.
            ColumnMapping colMapping1 = new ColumnMapping()
            {
                // Set source properties.
                SourceAttributeName = "src_name",
                SourceEntityName = "Account_1",

                // Set target properties.
                TargetAttributeName = "name",
                TargetEntityName = Account.EntityLogicalName,

                // Relate this column mapping with the data map.
                ImportMapId =
                    new EntityReference(ImportMap.EntityLogicalName, importMapId),

                // Force this column to be processed.
                ProcessCode =
                    new OptionSetValue((int)ColumnMappingProcessCode.Process)
            };

            // Create the mapping.
            Guid colMappingId1 = _serviceProxy.Create(colMapping1);
            #endregion

            #region Column Two Mappings
            // Create a column mapping for a ''lookup'' type field.
            ColumnMapping colMapping2 = new ColumnMapping()
            {
                // Set source properties.
                SourceAttributeName = "src_parent",
                SourceEntityName = "Account_1",

                // Set target properties.
                TargetAttributeName = "parentaccountid",
                TargetEntityName = Account.EntityLogicalName,

                // Relate this column mapping with the data map.
                ImportMapId =
                    new EntityReference(ImportMap.EntityLogicalName, importMapId),

                // Force this column to be processed.
                ProcessCode =
                    new OptionSetValue((int)ColumnMappingProcessCode.Process),
            };

            // Create the mapping.
            Guid colMappingId2 = _serviceProxy.Create(colMapping2);

            // Because we created a column mapping of type lookup, we need to specify lookup details in a lookupmapping.
            // One lookupmapping will be for the parent account, and the other for the current record.
            // This lookupmapping is important because without it the current record
            // cannot be used as the parent of another record.

            // Create a lookup mapping to the parent account.  
            LookUpMapping parentLookupMapping = new LookUpMapping()
            {
                // Relate this mapping with its parent column mapping.
                ColumnMappingId =
                    new EntityReference(ColumnMapping.EntityLogicalName, colMappingId2),

                // Force this column to be processed.
                ProcessCode =
                    new OptionSetValue((int)LookUpMappingProcessCode.Process),

                // Set the lookup for an account entity by its name attribute.
                LookUpEntityName = Account.EntityLogicalName,
                LookUpAttributeName = "name",
                LookUpSourceCode =
                    new OptionSetValue((int)LookUpMappingLookUpSourceCode.System)
            };

            // Create the lookup mapping.
            Guid parentLookupMappingId = _serviceProxy.Create(parentLookupMapping);

            // Create a lookup on the current record''s "src_name" so that this record can
            // be used as the parent account for another record being imported.
            // Without this lookup, no record using this account as its parent will be imported.
            LookUpMapping currentLookUpMapping = new LookUpMapping()
            {
                // Relate this lookup with its parent column mapping.
                ColumnMappingId =
                    new EntityReference(ColumnMapping.EntityLogicalName, colMappingId2),

                // Force this column to be processed.
                ProcessCode =
                    new OptionSetValue((int)LookUpMappingProcessCode.Process),

                // Set the lookup for the current record by its src_name attribute.
                LookUpAttributeName = "src_name",
                LookUpEntityName = "Account_1",
                LookUpSourceCode =
                    new OptionSetValue((int)LookUpMappingLookUpSourceCode.Source)
            };

            // Create the lookup mapping
            Guid currentLookupMappingId = _serviceProxy.Create(currentLookUpMapping);
            #endregion

            #region Column Three Mappings
            // Create a column mapping for a ''picklist'' type field
            ColumnMapping colMapping3 = new ColumnMapping()
            {
                // Set source properties
                SourceAttributeName = "src_addresstype",
                SourceEntityName = "Account_1",

                // Set target properties
                TargetAttributeName = "address1_addresstypecode",
                TargetEntityName = Account.EntityLogicalName,

                // Relate this column mapping with its parent data map
                ImportMapId =
                    new EntityReference(ImportMap.EntityLogicalName, importMapId),

                // Force this column to be processed
                ProcessCode =
                    new OptionSetValue((int)ColumnMappingProcessCode.Process)
            };

            // Create the mapping
            Guid colMappingId3 = _serviceProxy.Create(colMapping3);

            // Because we created a column mapping of type picklist, we need to specify picklist details in a picklistMapping
            PickListMapping pickListMapping1 = new PickListMapping()
            {
                SourceValue = "bill",
                TargetValue = 1,

                // Relate this column mapping with its column mapping data map
                ColumnMappingId =
                    new EntityReference(ColumnMapping.EntityLogicalName, colMappingId3),

                // Force this column to be processed
                ProcessCode =
                    new OptionSetValue((int)PickListMappingProcessCode.Process)
            };

            // Create the mapping
            Guid picklistMappingId1 = _serviceProxy.Create(pickListMapping1);

            // Need a picklist mapping for every address type code expected
            PickListMapping pickListMapping2 = new PickListMapping()
            {
                SourceValue = "ship",
                TargetValue = 2,

                // Relate this column mapping with its column mapping data map
                ColumnMappingId =
                    new EntityReference(ColumnMapping.EntityLogicalName, colMappingId3),

                // Force this column to be processed
                ProcessCode =
                    new OptionSetValue((int)PickListMappingProcessCode.Process)
            };

            // Create the mapping
            Guid picklistMappingId2 = _serviceProxy.Create(pickListMapping2);
            #endregion

            // Create Import
            Import import = new Import()
            {
                // IsImport is obsolete; use ModeCode to declare Create or Update.
                ModeCode = new OptionSetValue((int)ImportModeCode.Create),
                Name = "Importing data"
            };
            Guid importId = _serviceProxy.Create(import);

            // Create Import File.
            ImportFile importFile = new ImportFile()
            {
                Content = BulkImportHelper.ReadCsvFile("Import Accounts.csv"), // Read contents from disk.
                Name = "Account record import",
                IsFirstRowHeader = true,
                ImportMapId = new EntityReference(ImportMap.EntityLogicalName, importMapId),
                UseSystemMap = false,
                Source = "Import Accounts.csv",
                SourceEntityName = "Account_1",
                TargetEntityName = Account.EntityLogicalName,
                ImportId = new EntityReference(Import.EntityLogicalName, importId),
                EnableDuplicateDetection = false,
                FieldDelimiterCode =
                    new OptionSetValue((int)ImportFileFieldDelimiterCode.Comma),
                DataDelimiterCode =
                    new OptionSetValue((int)ImportFileDataDelimiterCode.DoubleQuote),
                ProcessCode =
                    new OptionSetValue((int)ImportFileProcessCode.Process)
            };

            // Get the current user to set as record owner.
            WhoAmIRequest systemUserRequest = new WhoAmIRequest();
            WhoAmIResponse systemUserResponse =
                (WhoAmIResponse)_serviceProxy.Execute(systemUserRequest);

            // Set the owner ID.                
            importFile.RecordsOwnerId =
                new EntityReference(SystemUser.EntityLogicalName, systemUserResponse.UserId);

            Guid importFileId = _serviceProxy.Create(importFile);

            // Retrieve the header columns used in the import file.
            GetHeaderColumnsImportFileRequest headerColumnsRequest = new GetHeaderColumnsImportFileRequest()
            {
                ImportFileId = importFileId
            };
            GetHeaderColumnsImportFileResponse headerColumnsResponse =
                (GetHeaderColumnsImportFileResponse)_serviceProxy.Execute(headerColumnsRequest);

            // Output the header columns.
            int columnNum = 1;
            foreach (string headerName in headerColumnsResponse.Columns)
            {
                Console.WriteLine("Column[" + columnNum.ToString() + "] = " + headerName);
                columnNum++;
            }

            // Parse the import file.
            ParseImportRequest parseImportRequest = new ParseImportRequest()
            {
                ImportId = importId
            };
            ParseImportResponse parseImportResponse =
                (ParseImportResponse)_serviceProxy.Execute(parseImportRequest);
            Console.WriteLine("Waiting for Parse async job to complete");
            BulkImportHelper.WaitForAsyncJobCompletion(_serviceProxy, parseImportResponse.AsyncOperationId);
            BulkImportHelper.ReportErrors(_serviceProxy, importFileId);

            // Retrieve the first two distinct values for column 1 from the parse table.
            // NOTE: You must create the parse table first using the ParseImport message.
            // The parse table is not accessible after ImportRecordsImportResponse is called.
            GetDistinctValuesImportFileRequest distinctValuesRequest = new GetDistinctValuesImportFileRequest()
            {
                columnNumber = 1,
                ImportFileId = importFileId,
                pageNumber = 1,
                recordsPerPage = 2,
            };
            GetDistinctValuesImportFileResponse distinctValuesResponse =
                (GetDistinctValuesImportFileResponse)_serviceProxy.Execute(distinctValuesRequest);

            // Output the distinct values.  In this case: (column 1, row 1) and (column 1, row 2).
            int cellNum = 1;
            foreach (string cellValue in distinctValuesResponse.Values)
            {
                Console.WriteLine("(1, " + cellNum.ToString() + "): " + cellValue);
                Console.WriteLine(cellValue);
                cellNum++;
            }

            // Retrieve data from the parse table.
            // NOTE: You must create the parse table first using the ParseImport message.
            // The parse table is not accessible after ImportRecordsImportResponse is called.
            RetrieveParsedDataImportFileRequest parsedDataRequest = new RetrieveParsedDataImportFileRequest()
            {
                ImportFileId = importFileId,
                PagingInfo = new PagingInfo()
                {
                    // Specify the number of entity instances returned per page.
                    Count = 2,
                    // Specify the number of pages returned from the query.
                    PageNumber = 1,
                    // Specify a total number of entity instances returned.
                    PagingCookie = "1"
                }
            };

            RetrieveParsedDataImportFileResponse parsedDataResponse =
                (RetrieveParsedDataImportFileResponse)_serviceProxy.Execute(parsedDataRequest);

            // Output the first two rows retrieved.
            int rowCount = 1;
            foreach (string[] rows in parsedDataResponse.Values)
            {
                int colCount = 1;
                foreach (string column in rows)
                {
                    Console.WriteLine("(" + rowCount.ToString() + "," + colCount.ToString() + ") = " + column);
                    colCount++;
                }
                rowCount++;
            }

            // Transform the import
            TransformImportRequest transformImportRequest = new TransformImportRequest()
            {
                ImportId = importId
            };
            TransformImportResponse transformImportResponse =
                (TransformImportResponse)_serviceProxy.Execute(transformImportRequest);
            Console.WriteLine("Waiting for Transform async job to complete");
            BulkImportHelper.WaitForAsyncJobCompletion(_serviceProxy, transformImportResponse.AsyncOperationId);
            BulkImportHelper.ReportErrors(_serviceProxy, importFileId);

            // Upload the records.
            ImportRecordsImportRequest importRequest = new ImportRecordsImportRequest()
            {
                ImportId = importId
            };
            ImportRecordsImportResponse importResponse =
                (ImportRecordsImportResponse)_serviceProxy.Execute(importRequest);
            Console.WriteLine("Waiting for ImportRecords async job to complete");
            BulkImportHelper.WaitForAsyncJobCompletion(_serviceProxy, importResponse.AsyncOperationId);
            BulkImportHelper.ReportErrors(_serviceProxy, importFileId);
        }

        /// <summary>
        /// Deletes any entity records that were created for this sample.
        /// <param name="prompt">Indicates whether to prompt the user 
        /// to delete the records created in this sample.</param>
        /// </summary>
        public void DeleteRequiredRecords(bool prompt)
        {
            bool toBeDeleted = true;

            if (prompt)
            {
                // Ask the user if the created entities should be deleted.
                Console.Write("/nDo you want these entity records deleted? (y/n) [y]: ");
                String answer = Console.ReadLine();
                if (answer.StartsWith("y") ||
                    answer.StartsWith("Y") ||
                    answer == String.Empty)
                {
                    toBeDeleted = true;
                }
                else
                {
                    toBeDeleted = false;
                }
            }

            if (toBeDeleted)
            {
                // Retrieve all account records created in this sample.
                QueryExpression query = new QueryExpression()
                {
                    EntityName = Account.EntityLogicalName,
                    Criteria = new FilterExpression()
                    {
                        Conditions =
                        {
                            new ConditionExpression("createdon", ConditionOperator.OnOrAfter, _executionDate),
                        }
                    },
                    ColumnSet = new ColumnSet(false)
                };
                var accountsCreated = _serviceProxy.RetrieveMultiple(query).Entities;

                // Delete all records created in this sample.
                foreach (var account in accountsCreated)
                {
                    _serviceProxy.Delete(Account.EntityLogicalName, account.Id);
                }

                Console.WriteLine("Entity record(s) have been deleted.");
            }
        }
        #region Main method

        /// <summary>
        /// Standard Main() method used by most SDK samples.
        /// </summary>
        /// <param name="args"></param>
        static public void Main(string[] args)
        {
            try
            {
                // Obtain the target organization''s web address and client logon 
                // credentials from the user.
                ServerConnection serverConnect = new ServerConnection();
                ServerConnection.Configuration config = serverConnect.GetServerConfiguration();

                var app = new ImportWithCreate();
                app.Run(config, true);
            }

            catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Timestamp: {0}", ex.Detail.Timestamp);
                Console.WriteLine("Code: {0}", ex.Detail.ErrorCode);
                Console.WriteLine("Message: {0}", ex.Detail.Message);
                Console.WriteLine("Trace: {0}", ex.Detail.TraceText);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
            }
            catch (System.TimeoutException ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine("Message: {0}", ex.Message);
                Console.WriteLine("Stack Trace: {0}", ex.StackTrace);
                Console.WriteLine("Inner Fault: {0}",
                    null == ex.InnerException.Message ? "No Inner Fault" : ex.InnerException.Message);
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("The application terminated with an error.");
                Console.WriteLine(ex.Message);

                // Display the details of the inner exception.
                if (ex.InnerException != null)
                {
                    Console.WriteLine(ex.InnerException.Message);

                    FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> fe = ex.InnerException
                        as FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>;
                    if (fe != null)
                    {
                        Console.WriteLine("Timestamp: {0}", fe.Detail.Timestamp);
                        Console.WriteLine("Code: {0}", fe.Detail.ErrorCode);
                        Console.WriteLine("Message: {0}", fe.Detail.Message);
                        Console.WriteLine("Trace: {0}", fe.Detail.TraceText);
                        Console.WriteLine("Inner Fault: {0}",
                            null == fe.Detail.InnerFault ? "No Inner Fault" : "Has Inner Fault");
                    }
                }
            }
            // Additional exceptions to catch: SecurityTokenValidationException, ExpiredSecurityTokenException,
            // SecurityAccessDeniedException, MessageSecurityException, and SecurityNegotiationException.

            finally
            {
                Console.WriteLine("Press <Enter> to exit.");
                Console.ReadLine();
            }
        }
        #endregion Main method
    }
}

Answer 4

La API de BulkUpdate funciona bien para mí; es 10 veces más rápido que actualizar los registros de uno en uno. A continuación se muestra un fragmento de código que realiza una actualización masiva:

    public override ExecuteMultipleResponse BulkUpdate(List<Entity> entities)
    {
        ExecuteMultipleRequest request = new ExecuteMultipleRequest()
        {
            Settings = new ExecuteMultipleSettings()
            {
                ContinueOnError = true,
                ReturnResponses = true
            },
            Requests = new OrganizationRequestCollection()
        };

        for (int i = 0; i < entities.Count; i++)
        {
            request.Requests.Add(new UpdateRequest() { Target = entities[i] });
        }

        return (ExecuteMultipleResponse) ServiceContext.Execute(request);
    }

Answer 5

Me doy cuenta de que esta es una pregunta antigua, pero aparece como "Actualización masiva de CRM", por lo que la característica ExecuteMultiple del paquete acumulativo de actualizaciones 12 debe mencionarse aquí. CRM lo hace todo de uno en uno. Lo que sí hace es empaquetar todas sus solicitudes en un solo sobre, lo que le permite a CRM manejar la ejecución de cada actualización y reducir el número de viajes de ida y vuelta entre su aplicación y el servidor si termina emitiendo una solicitud de Update para cada registro.

Answer 6

Me doy cuenta de que esta publicación tiene más de 2 años, pero puedo agregarla en caso de que alguien más la lea y tenga una necesidad similar.

La respuesta de Peter Majeed es acertada, ya que los procesos de CRM solicitan un registro a la vez. No hay una edición masiva que funcione de la manera que usted está buscando. Le recomiendo que no toque la base de datos directamente si necesita / quiere soporte de Microsoft.

Si está buscando actualizaciones periódicas de millones de registros, tiene algunas opciones. Considere usar Scribe o desarrolle su propia utilidad de importación personalizada o script utilizando el SDK de CRM.

Scribe probablemente será su mejor opción ya que es rentable para la importación de datos y le permitirá actualizar e insertar fácilmente desde el mismo archivo.

Si escribe su propia utilidad basada en .Net / SDK, sugeriría convertirla en multiproceso y dividir mediante programación el archivo de entrada en la memoria o en el disco y hacer que cada subproceso funcione con su propio subconjunto de datos, es decir, por supuesto Si el orden de ejecución no tiene que ser cronológico de acuerdo con el contenido del archivo de entrada. Si puede dividir y conquistar el archivo de entrada en varios subprocesos, puede reducir considerablemente el tiempo total de ejecución. Además, si su política corporativa le permite tener acceso a uno de los Servidores de CRM y puede colocar su código directamente en el servidor y ejecutarlo desde allí, puede eliminar la latencia de la red entre una estación de trabajo que ejecuta el código y los servicios web de CRM. .

Por último, pero no menos importante, si este gran volumen de datos de importación proviene de otro sistema, puede escribir un complemento de CRM para que se ejecute en los mensajes (eventos) de recuperación y recuperación múltiple en CRM para su entidad específica, recupere mediante programación los datos deseados. el otro sistema (y si el otro sistema no está disponible, solo use la copia en caché en CRM) y manténgalo actualizado en tiempo real o en una base de "último almacenamiento en caché". Este es ciertamente un esfuerzo mayor de codificación, pero potencialmente elimina la necesidad de ejecutar un gran trabajo de sincronización cada pocas semanas.

Answer 7

No está seguro de cómo esto iría con millones de registros, pero puede seleccionar sus registros y luego hacer clic en el botón Editar en la cinta. Esto abrirá el cuadro de diálogo "Editar registros múltiples". Cualquier cambio que realice se aplicará a todos sus registros.

Answer 8

Sí y no, en su mayoría no. Alguien puede corregirme si me equivoco, en cuyo caso con gusto editaré / eliminaré mi respuesta, pero todo lo que se hace en Dynamics CRM se hace de uno en uno. Ni siquiera intenta manejar las inserciones / actualizaciones / eliminaciones basadas en conjuntos. Entonces, a menos que vaya directamente a las operaciones directas de DB, le llevará semanas.

El servicio web permite inserciones / eliminaciones / actualizaciones "masivas", pero las comillas "masivas" porque todo lo que hace es configurar un proceso asíncrono en el que realiza todas las operaciones de datos relevantes, sí, una a la vez. Hay una sección del SDK que trata este tipo de gestión de datos (vinculado). Y para actualizar los registros de esta manera, primero tendría que sufrir la sobrecarga de seleccionar todos los datos que desea actualizar, luego crear un archivo xml que contenga los datos y, finalmente, actualizar los datos (recuerde: una fila a la vez ). Entonces, en realidad sería más eficiente simplemente recorrer sus datos y emitir una solicitud de Update para cada uno.

(Observaré que nuestra organización no ha experimentado ningún problema memorable con respecto al acceso directo a la base de datos para manejar lo que no hace el SDK, ni he visto nada en mis lecturas personales de Internet que sugieran que otros lo hayan hecho).

Editar:

Consulte la answer de iFirefly a continuación para conocer otras formas excelentes de abordar este problema.

Answer 9

Trabajé en un proyecto de migración de datos muy grande para Dynamics CRM 2011. Necesitábamos cargar unos 3 millones de registros durante un fin de semana. Terminé creando una aplicación de consola (un solo hilo) y ejecuté varias instancias en múltiples máquinas. Cada aplicación de consola tenía un id (1, 2, etc.) y era responsable de cargar segmentos de los datos basados ​​en una cláusula WHERE de SQL única que coincidía con el id de la aplicación.

Podrías hacer lo mismo con las actualizaciones. Cada instancia puede consultar un subconjunto de los registros para actualizar y puede realizar las actualizaciones a través del SDK. Dado que cargamos millones de registros durante un fin de semana, creo que podría realizar millones de actualizaciones (si son relativamente pequeñas) en unas pocas horas.

Answer 10

Uno de mis clientes tenía exactamente el mismo problema. Lo resolvió creando un ETL personalizado y haciendo paralelismo atacando dos front-end. Todo fue hecho en C #. Hoy en día, podría ser posible con KingswaySoft o Scribe.