Lösningslagring, med asynkron import och export

Har du någon gång kört på situationen under importen eller exporten av en stor lösning där åtgärden är ett annat fel? I så fall kan du välja att utföra lösningsimporten/-exporten asynkront. Det här avsnittet beskriver hur du initierar den asynkrona importen eller exporten med hjälp av Dataverse SDK för .NET och Web API.

Skapa en lösning

I jämförelse med att importera en lösning där lösningen importeras och är tillgänglig i miljön på en gång, bryts importen till mer kontrollerbara faser. Mellanlagringsprocessen importerar lösningen som en "intryckt"-lösning där administratören kan bestämma när den stegvisa lösningen ska göras tillgänglig för användarna, eller för att utföra en uppgradering (i fallet med en lösningsuppgradering) i målmiljön. En del av mellanlagringsprocessen är validering av den mellanlagrade lösningen. På så sätt kan du arrangera lösningen, känna till att lösningen är giltig och schemalägga när lösningen ska tillämpas eller uppgradera till målmiljön.

Operation	Webb-API	Dataverse SDK för .NET
Mellanlagra en lösning	StageSolution (på engelska)	StageSolutionRequest (på engelska)

Resultatet av testlösningen blir en samling med valideringsresultat som anger framgång eller fel och (om det lyckas) en StageSolutionUploadId som ska användas i samtalet ImportSolutionAsync. Se exempelkoden för webb-API för importlösningen ovan för ett exempel på hur du gör.

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);
}

Lösningsimport

ImportSolution är den åtgärd (eller det meddelande) som utför den synkrona importåtgärden. För att utföra importoperationen asynkront använd ImportSolutionAsync.

Operation	Webb-API	Dataverse SDK för .NET
Importera en lösning	ImportSolutionAsync	ImportSolutionAsyncRequest

Nu ska vi ta en titt på ett exempel på en kod som demonstrerar 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 delar många indataparametrar med ImportSolution men lägger till ComponentParameters och SolutionParameters. ComponentParameters kan användas för att skriva över komponentdata i lösningens XML-anpassningsfil. SolutionParameters kan användas för att skicka en StageSolutionUploadId mellanlagrad lösning som visas i exemplet på webb-API-kod. Mer information: mellanlagra en lösning

Svaret som returneras från ImportSolutionAsync innehåller ImportJobKey och AsyncOperationId. Värdet ImportJobKey kan användas för att hämta importresultatet och värdet AsyncOperationId kan användas för att spåra status för importjobbet.

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
    }
}

Lösningsexport

ExportSolution är den åtgärd (eller det meddelande) som utför den synkrona exportåtgärden. För att utföra exportoperationen asynkront använd ExportSolutionAsync.

Operation	Webb-API	Dataverse SDK för .NET
Exportera en lösning	ExporteraSolutionAsync	ExporteraSolutionAsyncRequest
Hämta en exporterad lösningsfil	Ladda nerLösningExportData	Ladda nerLösningExporteraDataRequest

Nu ska vi ta en titt på ett exempel på en kod som demonstrerar 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);

I svaret finns värdena och AsyncOperationId och ExportJobId parametern. Använd AsyncOperationId i svaret för att kontrollera att det asynkrona jobbet har lyckats (statecode == 3; statuscode == 30). Använd sedan åtgärden DownloadSolutionExportData (eller meddelandet) med värdet ExportJobId från exportsvaret för att hämta den exporterade lösningsfilen, som returneras i parametern 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);

Se även

Exempel: Mellanlagring av lösningar med asynkron import