Fases de la solució, amb importació i exportació asíncrones

Alguna vegada us heu trobat en la situació que, durant la importació o exportació d'una solució gran, l'operació supera el temps d'espera? Si és així, potser sereu un candidat per dur a terme la importació/exportació de la solució de manera asíncrona. Aquest tema descriu com s'inicia la importació o exportació asíncrona mitjançant l'SDK del Dataverse per a .NET i les API web.

Definir les fases d'una solució

En comparació amb la importació d'una solució en què la solució s'importa i es troba disponible a l'entorn immediatament, la definició de fases trenca el procés d'importació en fases més controlables. El procés de divisió en fases importa la solució com una solució de "retenció" on l'administrador pot decidir quan ha de fer que la solució per fases estigui disponible per als usuaris o dur a terme una actualització (en el cas d'una actualització de la solució) a l'entorn de destinació. Part del procés de divisió en fases és la validació de la solució en fases. D'aquesta manera podeu dividir en fase la solució, saber que la solució és vàlida i planificar quan s'aplica aquesta solució o actualització a l'entorn de destinació.

Operació	API web	SDK de Dataverse per a .NET
Definir les fases d'una solució	Solució d'escenari	Sol·licitud de solució d'escenari

El resultat de la divisió en fases de la solució serà un conjunt de resultats de validació que indicarà l'èxit o l'error i (en cas d'èxit) un StageSolutionUploadId per utilitzar en la crida de ImportSolutionAsync. Vegeu el codi de mostra de l'API web de la solució d'importació anterior com a exemple de com es fa això.

public static StageSolutionResults StageSolution(
    IOrganizationService service,
    string solutionFilePath)
{
  // Stage the solution
  var req = new StageSolutionRequest();

  byte[] fileBytes = File.ReadAllBytes(solutionFilePath);
  req["CustomizationFile"] = fileBytes;
  var res = service.Execute(req);

  return (res["StageSolutionResults"] as StageSolutionResults);
}

Importació de la solució

ImportSolution és l'acció (o missatge) que realitza l'operació d'importació síncrona. Per executar l'operació d'importació de manera asíncrona, utilitzeu ImportSolutionAsync.

Operació	API web	SDK de Dataverse per a .NET
Importar una solució	ImportSolutionAsync	ImportSolutionAsyncRequest

Fem un cop d'ull a un codi d'exemple que demostra ImportSolutionAsync.

public static ImportSolutionAsyncResponse ImportSolution(
    IOrganizationService service,
    StageSolutionResults stagingResults,
    Dictionary<string,Guid> connectionIds,
    Dictionary<string,string> envarValues )
{
    // Import the staged solution
    var componentDetails = stagingResults.SolutionComponentsDetails;

    // TODO These are not referenced in the code but are useful to explore
    var missingDependencies = stagingResults.MissingDependencies;   // Contains missing dependencies
    var solutionDetails = stagingResults.SolutionDetails;           // Contains solution details

    var connectionReferences = componentDetails.Where(x => string.Equals(x.ComponentTypeName, "connectionreference"));
    var envVarDef = componentDetails.Where(x => string.Equals(x.ComponentTypeName, "environmentvariabledefinition"));
    var envVarValue = componentDetails.Where(x => string.Equals(x.ComponentTypeName, "environmentvariablevalue"));

    var componentParams = new EntityCollection();

    // Add each connection reference to the component parmameters entity collection.
    foreach (var conn in connectionReferences)
    {
        var e = new Entity("connectionreference")
        {
            ["connectionreferencelogicalname"] = conn.Attributes["connectionreferencelogicalname"].ToString(),
            ["connectionreferencedisplayname"] = conn.Attributes["connectionreferencedisplayname"].ToString(),
            ["connectorid"] = conn.Attributes["connectorid"].ToString(),
            ["connectionid"] = connectionIds[conn.ComponentName]
        };
        componentParams.Entities.Add(e);
    }
            
    // Add each environment variable to the component parmameters entity collection.
    foreach (var value in envVarValue)
    {
        var e = new Entity("environmentvariablevalue")
        {
            ["schemaname"] = value.Attributes["schemaname"].ToString(),
            ["value"] = envarValues[value.ComponentName]
        };

        if (value.Attributes.ContainsKey("environmentvariablevalueid"))
        {
            e["environmentvariablevalueid"] = value.Attributes["environmentvariablevalueid"].ToString();
        }
        componentParams.Entities.Add(e);
    }

    // Import the solution
    var importSolutionReq = new ImportSolutionAsyncRequest();
    importSolutionReq.ComponentParameters = componentParams;
    importSolutionReq.SolutionParameters = new SolutionParameters { StageSolutionUploadId = stagingResults.StageSolutionUploadId };
    var response = service.Execute(importSolutionReq) as ImportSolutionAsyncResponse;

    return (response);
}

ImportSolutionAsync comparteix molts paràmetres d'entrada amb ImportSolution però afegeix ComponentParameters i SolutionParameters. ComponentParameters es pot utilitzar per sobreescriure les dades del component al fitxer XML de personalització de la solució. SolutionParameters es pot utilitzar per passar el d'una StageSolutionUploadId solució per etapes, tal com es mostra en el codi d'exemple de l'API web. Més informació: Dividir en fases una solució

La resposta retornada de ImportSolutionAsync conté ImportJobKey i AsyncOperationId. El valor ImportJobKey es pot utilitzar per obtenir el resultat de la importació i el valor AsyncOperationId es pot utilitzar per fer el seguiment de l'estat de la feina d'importació.

public static void CheckImportStatus(
    IOrganizationService service,
    Guid asyncOperationId,
    Guid importJobKey)
{
    // Get solution import status
    var finished = false;
    Entity asyncOperation = null;
    // Wait until the async job is finished
    while (!finished)
    {
        asyncOperation = service.Retrieve("asyncoperation", asyncOperationId, new ColumnSet("statecode", "statuscode"));
        OptionSetValue statecode = (OptionSetValue)asyncOperation["statecode"];
        if (statecode.Value == 3)
        {
            finished = true;
        }
        else
        {
            Thread.Sleep(10000);
        }
    }
    // Solution import completed successfully
    OptionSetValue statuscode = (OptionSetValue)asyncOperation["statuscode"];
    if (statuscode.Value == 30)
    {
        Console.WriteLine("The solution import completed successfully.");
    }
    else if (asyncOperation["statuscode"].ToString() == "31")  // Solution import failed
    {
        Console.WriteLine("The solution import failed.");
        var getLogReq = new RetrieveFormattedImportJobResultsRequest { ImportJobId = importJobKey };
        var importJob = service.Execute(getLogReq) as RetrieveFormattedImportJobResultsResponse;
        // TODO Do something with the import job results
    }
}

Exportació de la solució

ExportSolution és l'acció (o missatge) que realitza l'operació d'exportació síncrona. Per executar l'operació d'exportació de manera asíncrona, utilitzeu ExportSolutionAsync.

Operació	API web	SDK de Dataverse per a .NET
Exportar una solució	ExportSolutionAsync	ExportacióSolucióAsyncRequest
Baixar un fitxer de solució exportada	DescarregarSolucióExportar Dades	DescarregarSolucióExportacióSol·licitud de dades

Fem un cop d'ull a un codi d'exemple que demostra ExportSolutionAsync.

// Where 'service' is a pre-configured IOrganizationService instance.
var service = (OrganizationServiceProxy)xsc.CreateOrganizationService();

var req = new OrganizationRequest("ExportSolutionAsync");
req.Parameters.Add("SolutionName", "ExportSolutionAsyncTest");
req.Parameters.Add("Managed", false);
var response = service.Execute(req);

A la resposta hi ha els valors de paràmetre AsyncOperationId i ExportJobId. Utilitzeu el AsyncOperationId de la resposta per verificar l'èxit (statecode == 3; statuscode == 30) de la feina asíncrona. A continuació, utilitzeu l'acció DownloadSolutionExportData (o missatge) amb el valor ExportJobId de la resposta d'exportació per baixar el fitxer de solució exportat, que es retorna al paràmetre ExportSolutionFile.

// Where 'service' is a pre-configured IOrganizationService instance.
var service = (OrganizationServiceProxy)xsc.CreateOrganizationService();

var req = new OrganizationRequest("DownloadSolutionExportData");
req.Parameters.Add("ExportJobId", Guid.Parse("a9089b53-a1c7-ea11-a813-000d3a14420d");
var response = service.Execute(req);

Vegeu també

Exemple: Emmagatzematge de solucions amb importació asíncrona