Dynamics CRM 2011批量更新

Question

運行Dynamics CRM 2011部署3.需要定期更新數百萬個客戶記錄（增量更新）。 使用標准更新（逐個）需要幾周時間。 此外，我們不想直接觸摸數據庫，因為它可能在將來破壞數據。

我們可以使用Dynamics CRM 2011 webservice / REST API中的批量更新方法嗎？ （WhatWhereHow）

Answer 1

我意識到這是2年以上的帖子，但我可以添加它，以防其他人閱讀它並有類似的需求。

Peter Majeed的回答是目標，即CRM流程一次請求一條記錄。 沒有批量修改可以按您要求的方式工作。 如果您需要/希望Microsoft支持，我建議您不要直接觸摸數據庫。

如果您正在查看數百萬條記錄的定期更新，您可以選擇幾種方法。 考慮使用Scribe或使用CRM SDK開發自己的自定義導入實用程序或腳本。

Scribe可能是您的最佳選擇，因為它對數據導入具有成本效益，並且允許您輕松地從同一文件更新和插入。

如果您編寫自己的基於.Net / SDK的實用程序，我建議將其設置為多線程，並以編程方式在內存或磁盤上分解您的輸入文件，並讓每個線程使用自己的數據子集 - 當然，如果執行順序不必按照時間順序根據輸入文件的內容。 如果您可以在多個線程上划分和征服輸入文件，則可以大大減少總體執行時間。 此外，如果您的公司策略允許您訪問其中一個CRM服務器，並且您可以將代碼直接放在服務器上並從那里執行 - 您可以消除運行代碼的工作站與CRM Web服務之間的網絡延遲。

最后但並非最不重要的是，如果此大量導入數據來自另一個系統，您可以編寫CRM插件以在特定實體的CRM中的Retrieve和RetrieveMultiple消息（事件）上運行，以編程方式從中檢索所需數據另一個系統（如果其他系統不可用 - 只需使用CRM中的緩存副本），並實時更新CRM或“最后緩存”。 這肯定是更多的編碼工作，但它可能消除了每隔幾周運行大型同步作業的需要。

Answer 2

是的，不，大多數沒有。 如果我弄錯了，有人可以糾正我，在這種情況下，我很樂意編輯/刪除我的答案，但是在Dynamics CRM中完成的所有事情都是一次完成的。 它甚至沒有嘗試處理基於集合的插入/更新/刪除。 因此，除非您直接進行數據庫操作，否則需要數周時間。

該Web服務並允許進行“批量”插入/刪除/更新 ，但我把引號“散”，因為它所做的就是建立一個異步過程，其中它所有的相關數據操作-是的-一次一個。 SDK的一部分涉及這種數據管理（鏈接）。 要以這種方式更新記錄，您必須首先承擔選擇要更新的所有數據的開銷，然后創建包含數據的xml文件，最后更新數據（記住：一次一行） ）。 因此，循環訪問數據並為每個人發出Update請求實際上會更有效。

（我會注意到我們的組織沒有遇到任何令人難忘的關於直接數據庫訪問以處理SDK沒有的問題，也沒有在我的個人互聯網讀數中看到任何暗示其他人的信息。）

編輯：

有關解決此問題的其他一些優秀方法，請參閱下面的iFirefly 答案 。

Answer 3

我意識到這是一個老問題，但它在“CRM批量更新​​”中出現很高，所以需要在這里提到更新匯總12功能ExecuteMultiple - 它不會解決您的問題（大量）因為iFirefly和Peter點CRM可以一次完成所有工作。 它所做的是將您的所有請求打包到一個信封中，讓CRM處理每個更新的執行，並減少您的應用程序和服務器之間的往返次數，如果您最終為每條記錄發出Update請求。

Answer 4

這是一個相當古老的問題，但是沒有人提到在CRM 201X中更新/創建大量記錄的禁區方式（但也是最具挑戰性的） - 使用內置的導入功能，這完全可以使用CRM SDK。 有一篇關於它的完美MSDN文章： https ： //msdn.microsoft.com/en-us/library/gg328321（v = crm.5）.aspx 。 總之，你必須：

1）構建包含要導入的數據的Excel文件（只需從CRM 201X導出一些數據並檢查結構的外觀，記住前3列是隱藏的）

2）創建導入地圖實體（指定您創建的文件）

3）必要時創建列映射

4）創建Import和ImportFile實體，提供適當的映射

5）使用ParseImportRequest解析數據

6）使用TransformImportRequest轉換數據

7）使用ImportRecordsImportRequest導入數據

這是CRM 2011的步驟，現在2017年我們有更多可用的版本，它們之間略有不同。 檢查MSDN和SDK中提供的示例： https ： //msdn.microsoft.com/en-us/library/hh547396（v = crm.5）.aspx

當然，第1點，將是最困難的部分，因為你必須完全符合CRM期望的XML或docx文件，但我假設你是從外部應用程序做的，所以你可以使用一些很棒的.NET庫這將使事情變得更加簡單。

在更新/創建記錄時，我從未見過比標准CRM導入更快的東西，即使您要求並行和批量更新請求。

如果MSDN站點出現問題，我將在上面的鏈接中發布一個示例，其中顯示了如何以編程方式將數據導入CRM：

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 5

不確定這將如何與數百萬條記錄一起使用，但您可以選擇記錄，然后單擊功能區中的“編輯”按鈕。 這將打開“編輯多個記錄”對話框。 您所做的任何更改都將應用於您的所有記錄。

Answer 6

BulkUpdate API對我很有用; 它比一次更新一個記錄快10倍。 以下是執行批量更新的代碼段：

    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 7

我參與了Dynamics CRM 2011的一個非常大的數據遷移項目。我們需要在一個周末加載大約300萬條記錄。 我最終構建了一個控制台應用程序（單線程）並在多台機器上運行了多個實例。 每個控制台應用程序都有一個id（1,2等），並負責根據與應用程序ID匹配的唯一SQL WHERE子句加載數據段。

你可以用更新做同樣的事情。 每個實例都可以查詢要更新的記錄子集，並可以通過SDK執行更新。 由於我們在一個周末加載了數百萬條記錄，因此我認為您可以在幾個小時內執行數百萬次更新（如果相對較小）。

Answer 8

Microsoft PFE動態CRM團隊編寫了新的另一個 CRM SDK庫 ，它利用並行化來批量執行請求，確保線程安全。

您可以嘗試： 並行執行請求我有興趣知道它是否有效並可擴展到數百萬條記錄。

Answer 9

CRM沒有實現更新批量數據的方法; 有三種方法可以改善批量更新操作性能，但在內部卻無法改變CRM更新記錄的事實。 基本上這些想法是：

• 減少與CRM服務器通信浪費的時間
• 使用並行性來同時執行多個操作
• 確保更新過程不會觸發任何工作流程/插件。 否則你可能永遠不會看到過程的結束......

提高批量運營績效的3種方法：

1. 在RollUp 12之后，有一個ExecuteMultipleRequest功能，允許您一次發送多達1000個請求。 這意味着您可以節省一些時間，從發送1000個請求到CRM Web服務，但是，這些請求是一個接一個地處理。 因此，如果您的CRM服務器配置得很好，那么這種方法很可能無濟於事。
2. 您可以使用OrganizationServiceContext實例進行批量更新。 OrganizationServiceContext實現工作單元模式，因此您可以進行多次更新，並在一次調用中將這些操作傳輸到服務器。 與ExecuteMultipleRequest相比，它對請求數量沒有限制，但如果在更新期間遇到故障，它將回滾所有更改。
3. 使用多線程或多任務。 無論哪種方式都可以提高速度，但它們可能會產生一些連接失敗或SQL錯誤，因此您需要在代碼中添加一些重試邏輯。

Answer 10

我的一個客戶有完全相同的問題。 他通過創建自定義ETL並對兩個前端進行並行攻擊來解決這個問題。 整件事都是用C＃制作的。 現在，有可能使用KingswaySoft或Scribe。