Megosztás:

Megoldások használata Dataverse SDK-val

Az éles életciklus fejlesztésének részeként érdemes lehet egyéni automatizálást létrehozni bizonyos feladatok kezeléséhez. Például a DevOps projektfolyamatban célszerű lehet néhány egyéni programkódot vagy parancsfájlt végrehajtani, amely tesztkörnyezetet hoz létre, importál egy nem felügyelt megoldást, exportálja ezt a nem felügyelt megoldást felügyelt megoldásként, végül pedig törli a környezetet. Ezeket a műveleteket és még sok mást is elvégezhet az Ön számára elérhető API-k használatával. Íme néhány példa arra, hogy mit érhet el a Dataverse .NET SDK és az egyéni kód használatával.

Feljegyzés

Ugyanezeket a műveleteket a webes API segítségével is végrehajthatja. A kapcsolódó műveletek a következők: ImportSolution, ExportSolution, CloneAsPatch és CloneAsSolution.

A cikkben szereplő kódminták a CrmSvcUtil vagy a PAC CLI használatával létrehozott korai kötésű entitástípusokat használnak. További információ: Késői és korai kötésű programozás a .NET SDK-val

Nem felügyelt megoldás létrehozása, exportálása vagy importálása

Megtudhatja, hogyan hajthat végre néhány gyakori megoldási műveletet C#-kóddal. Az ilyen típusú megoldási műveleteket bemutató teljes működő C#-kódminta és egyebek megtekintéséhez lépjen a Minta: Megoldások használata című témakörre.

Közzétevő létrehozása

Minden megoldáshoz szükség van egy közzétevőre, amelyet a Publisher tábla képvisel. A közzétevőknek a következő tulajdonságokra van szükségük:

  • Testreszabási előtag
  • Egyedi név
  • Felhasználóbarát név

Feljegyzés

A kifogástalan alkalmazás-életciklus-kezelési (ALM) megközelítés érdekében a testreszabások üzembe helyezéséhez mindig egyéni közzétevőt és megoldást használjon, ne az alapértelmezett megoldást és közzétevőt.

Az alábbi kódminta először meghatároz egy közzétevőt, majd ellenőrzi, hogy a közzétevő létezik-e már az egyedi név alapján. Ha már létezik, előfordulhat, hogy a testreszabási előtag módosult. Ez a minta az aktuális testreszabási előtagot kívánja rögzíteni. A PublisherId is rögzítésre kerül, hogy a közzétevői rekord törölhető legyen. Ha a közzétevő nem található, egy új közzétevő jön létre az IOrganizationService.Create módszer használatával.

// Define a new publisher
Publisher _myPublisher = new Publisher
{
   UniqueName = "contoso-publisher",
   FriendlyName = "Contoso publisher",
   SupportingWebsiteUrl =
      "https://learn.microsoft.com/powerapps/developer/data-platform/overview",
   CustomizationPrefix = "contoso",
   EMailAddress = "someone@contoso.com",
   Description = "This publisher was created from sample code"
};

// Does the publisher already exist?
QueryExpression querySamplePublisher = new QueryExpression
{
   EntityName = Publisher.EntityLogicalName,
   ColumnSet = new ColumnSet("publisherid", "customizationprefix"),
   Criteria = new FilterExpression()
};

querySamplePublisher.Criteria.AddCondition("uniquename", ConditionOperator.Equal,
   _myPublisher.UniqueName);

EntityCollection querySamplePublisherResults =
   _serviceProxy.RetrieveMultiple(querySamplePublisher);

Publisher SamplePublisherResults = null;

// If the publisher already exists, use it
if (querySamplePublisherResults.Entities.Count > 0)
{
   SamplePublisherResults = (Publisher)querySamplePublisherResults.Entities[0];
   _publisherId = (Guid)SamplePublisherResults.PublisherId;
   _customizationPrefix = SamplePublisherResults.CustomizationPrefix;
}

// If the publisher doesn't exist, create it
if (SamplePublisherResults == null)
{
   _publisherId = _serviceProxy.Create(_myPublisher);

   Console.WriteLine(String.Format("Created publisher: {0}.",
   _myPublisher.FriendlyName));

   _customizationPrefix = _myPublisher.CustomizationPrefix;
}

Nem felügyelt megoldás létrehozása

Ha van elérhető egyéni közzétevő, akkor ezt követően létrehozhatja a nem felügyelt megoldást. Az alábbi táblázat felsorolja a megoldás által tartalmazott leírásokat tartalmazó oszlopokat.

Oszlop címke Leírás
Megjelenít. név A megoldás neve.
Name A Microsoft Dataverse egyedi nevet hoz létre a Megjelenítendő név alapján. Az egyedi név szerkeszthető. Az egyedi név csak alfanumerikus karaktereket és aláhúzást tartalmazhat.
Kiadó A Közzétevő keresése segítségével társíthatja a megoldást egy közzétevőhöz.
Verzió Adjon meg egy verziót a formátum használatával: major.minor.build.revision, például 1.0.0.0.
Konfigurációs oldal Ha a megoldásba HTML-alapú weberőforrást foglal bele, akkor a keresés segítségével hozzáadhatja azt a kijelölt mogoldás konfigurációs oldalhoz.
Description Ebben az oszlopban megadhatja a megoldással kapcsolatos releváns részleteket.

Az alábbi mintakód egy nem felügyelt megoldás létrehozásához használható, amely az előző szakaszban létrehozott közzétevőt használja.

// Create a solution
Solution solution = new Solution
{
   UniqueName = "sample-solution",
   FriendlyName = "Sample solution",
   PublisherId = new EntityReference(Publisher.EntityLogicalName, _publisherId),
   Description = "This solution was created by sample code.",
   Version = "1.0"
};

// Check whether the solution already exists
QueryExpression queryCheckForSampleSolution = new QueryExpression
{
   EntityName = Solution.EntityLogicalName,
   ColumnSet = new ColumnSet(),
   Criteria = new FilterExpression()
};

queryCheckForSampleSolution.Criteria.AddCondition("uniquename",
   ConditionOperator.Equal, solution.UniqueName);

// Attempt to retrieve the solution
EntityCollection querySampleSolutionResults =
   _serviceProxy.RetrieveMultiple(queryCheckForSampleSolution);

// Create the solution if it doesn't already exist
Solution SampleSolutionResults = null;

if (querySampleSolutionResults.Entities.Count > 0)
{
   SampleSolutionResults = (Solution)querySampleSolutionResults.Entities[0];
   _solutionsSampleSolutionId = (Guid)SampleSolutionResults.SolutionId;
}

if (SampleSolutionResults == null)
{
   _solutionsSampleSolutionId = _serviceProxy.Create(solution);
}

A nem felügyelt megoldás létrehozása után adjon hozzá megoldás-összetevőket a megoldás környezetében vagy más megoldások meglévő összetevőinek hozzáadásával. További információ: Új megoldás-összetevő hozzáadása és Meglévő megoldás-összetevő hozzáadása

Nem felügyelt megoldás exportálása

Ez a mintakód azt mutatja be, hogyan exportálható a nem felügyelt megoldás vagy csomagolható egy felügyelt megoldás. A kód az ExportSolutionRequest osztály segítségével exportálja a nem felügyelt megoldást képviselő tömörített fájlt. A felügyelt megoldás létrehozására szolgáló beállítás a Managed tulajdonság használatával állítható be. Ez a példa egy samplesolution.zip nevű fájlt ment a kimeneti mappába.

// Export a solution
ExportSolutionRequest exportSolutionRequest = new ExportSolutionRequest();
exportSolutionRequest.Managed = false;
exportSolutionRequest.SolutionName = solution.UniqueName;

ExportSolutionResponse exportSolutionResponse =
   (ExportSolutionResponse)_serviceProxy.Execute(exportSolutionRequest);

byte[] exportXml = exportSolutionResponse.ExportSolutionFile;
string filename = solution.UniqueName + ".zip";

File.WriteAllBytes(outputDir + filename, exportXml);

Console.WriteLine("Solution exported to {0}.", outputDir + filename);

Nem felügyelt megoldás importálása

A megoldások kód használatával történő importálása (vagy frissítése) az ImportSolutionRequest segítségével végezhető el.

// Install or upgrade a solution
byte[] fileBytes = File.ReadAllBytes(ManagedSolutionLocation);

ImportSolutionRequest impSolReq = new ImportSolutionRequest()
{
   CustomizationFile = fileBytes
};

_serviceProxy.Execute(impSolReq);

Az importálás sikerességének nyomon követése

Az ImportJob táblával rögzítheti a megoldás importálásának sikerességével kapcsolatos adatokat. Ha megad egy értéket ImportJobId az ImportSolutionRequest mezőben, ezzel az értékkel lekérdezheti a táblát ImportJob az importálás állapotáról. Az ImportJobId használható az importálási naplófájl letöltésére is a RetrieveFormattedImportJobResultsRequest üzenet használatával.

// Monitor solution import success
byte[] fileBytesWithMonitoring = File.ReadAllBytes(ManagedSolutionLocation);

ImportSolutionRequest impSolReqWithMonitoring = new ImportSolutionRequest()
{
   CustomizationFile = fileBytes,
   ImportJobId = Guid.NewGuid()
};

_serviceProxy.Execute(impSolReqWithMonitoring);

ImportJob job = (ImportJob)_serviceProxy.Retrieve(ImportJob.EntityLogicalName,
   impSolReqWithMonitoring.ImportJobId, new ColumnSet(new System.String[] { "data",
   "solutionname" }));

System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
doc.LoadXml(job.Data);

String ImportedSolutionName =
   doc.SelectSingleNode("//solutionManifest/UniqueName").InnerText;

String SolutionImportResult =
   doc.SelectSingleNode("//solutionManifest/result/\@result").Value;

Console.WriteLine("Report from the ImportJob data");

Console.WriteLine("Solution Unique name: {0}", ImportedSolutionName);

Console.WriteLine("Solution Import Result: {0}", SolutionImportResult);

Console.WriteLine("");

// This code displays the results for Global Option sets installed as part of a
// solution.

System.Xml.XmlNodeList optionSets = doc.SelectNodes("//optionSets/optionSet");

foreach (System.Xml.XmlNode node in optionSets)
{
   string OptionSetName = node.Attributes["LocalizedName"].Value;
   string result = node.FirstChild.Attributes["result"].Value;

   if (result == "success")
   {
      Console.WriteLine("{0} result: {1}",OptionSetName, result);
   }
   else
   {
      string errorCode = node.FirstChild.Attributes["errorcode"].Value;
      string errorText = node.FirstChild.Attributes["errortext"].Value;

      Console.WriteLine("{0} result: {1} Code: {2} Description: {3}",OptionSetName,
      result, errorCode, errorText);
   }
}

A Data tulajdonság tartalma a megoldás XML-fájlját jelképező karakterlánc.

Megoldás-összetevők hozzáadása vagy eltávolítása

Megismerheti, hogyan adhat hozzá és távolíthat el megoldás-összetevőket programkód használatával.

Új megoldás-összetevők hozzáadása

Ez a példa azt mutatja be, hogyan lehet létrehozni egy adott megoldáshoz társított megoldás-összetevőt. Ha a létrehozáskor nem társítja a megoldás-összetevőt egy adott megoldáshoz, akkor csak az alapértelmezett megoldáshoz lesz hozzáadva, és manuálisan vagy a Meglévő megoldás hozzáadása összetevőben található kóddal kell hozzáadnia a megoldáshoz.

Ez a kód új globális értékkészlet hoz létre, és azt a megoldáshoz adja a _primarySolutionName értékkel megegyező egyedi névvel.

OptionSetMetadata optionSetMetadata = new OptionSetMetadata()
{
   Name = _globalOptionSetName,
   DisplayName = new Label("Example Option Set", _languageCode),
   IsGlobal = true,
   OptionSetType = OptionSetType.Picklist,
   Options =
{
   new OptionMetadata(new Label("Option 1", _languageCode), 1),
   new OptionMetadata(new Label("Option 2", _languageCode), 2)
}
};
CreateOptionSetRequest createOptionSetRequest = new CreateOptionSetRequest
{
   OptionSet = optionSetMetadata                
};

createOptionSetRequest.SolutionUniqueName = _primarySolutionName;
_serviceProxy.Execute(createOptionSetRequest);

Meglévő megoldás-összetevő hozzáadása

Ez a példa azt mutatja be, hogyan lehet egy meglévő megoldás-összetevőt hozzáadni egy megoldáshoz.

A következő kód a táblát AddSolutionComponentRequest megoldás-összetevőként adja hozzá Account egy nem felügyelt megoldáshoz.

// Add an existing Solution Component
// Add the Account entity to the solution
RetrieveEntityRequest retrieveForAddAccountRequest = new RetrieveEntityRequest()
{
   LogicalName = Account.EntityLogicalName
};
RetrieveEntityResponse retrieveForAddAccountResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrieveForAddAccountRequest);
AddSolutionComponentRequest addReq = new AddSolutionComponentRequest()
{
   ComponentType = (int)componenttype.Entity,
   ComponentId = (Guid)retrieveForAddAccountResponse.EntityMetadata.MetadataId,
   SolutionUniqueName = solution.UniqueName
};
_serviceProxy.Execute(addReq);

Megoldás-összetevő eltávolítása

Ez a példa azt mutatja be, hogyan lehet egy meglévő megoldás-összetevőt eltávolítani egy nem felügyelt megoldásból. A következő kód a táblamegoldás-összetevő RemoveSolutionComponentRequest eltávolítására szolgál egy nem felügyelt megoldásból. A solution.UniqueName a Nem felügyelt megoldás létrehozása részben létrehozott megoldásra hivatkozik.

// Remove a Solution Component
// Remove the Account entity from the solution
RetrieveEntityRequest retrieveForRemoveAccountRequest = new RetrieveEntityRequest()
{
   LogicalName = Account.EntityLogicalName
};
RetrieveEntityResponse retrieveForRemoveAccountResponse = (RetrieveEntityResponse)_serviceProxy.Execute(retrieveForRemoveAccountRequest);

RemoveSolutionComponentRequest removeReq = new RemoveSolutionComponentRequest()
{
   ComponentId = (Guid)retrieveForRemoveAccountResponse.EntityMetadata.MetadataId,
   ComponentType = (int)componenttype.Entity,
   SolutionUniqueName = solution.UniqueName
};
_serviceProxy.Execute(removeReq);

Megoldás törlése

A következő példa azt mutatja be, hogyan lehet a uniquename megoldás segítségével lekérni a megoldást, majd az eredményből kibontani a solutionid elemet. A minta ezt követően a solutionid elemet használja a IOrganizationService elemmel. Delete metódussal törölheti a megoldást.

// Delete a solution

QueryExpression queryImportedSolution = new QueryExpression
{
    EntityName = Solution.EntityLogicalName,
    ColumnSet = new ColumnSet(new string[] { "solutionid", "friendlyname" }),
    Criteria = new FilterExpression()
};


queryImportedSolution.Criteria.AddCondition("uniquename", ConditionOperator.Equal, ImportedSolutionName);

Solution ImportedSolution = (Solution)_serviceProxy.RetrieveMultiple(queryImportedSolution).Entities[0];

_serviceProxy.Delete(Solution.EntityLogicalName, (Guid)ImportedSolution.SolutionId);

Console.WriteLine("Deleted the {0} solution.", ImportedSolution.FriendlyName);

Klónozás, javítás és frissítés

A rendelkezésre álló API-k segítségével további megoldásműveleteket hajthat végre. Klónozási és javítási megoldásokhoz használja a CloneAsPatchRequest és aCloneAsSolutionRequest parancsot. A klónozással és a javítással kapcsolatban lásd: Megoldásjavítások létrehozása.

A megoldások frissítéseinek végrehajtásakor használja a StageAndUpgradeRequest és a DeleteAndPromoteRequest elemet. Az előkészítés és a frissítés folyamatával kapcsolatos további információkért látogasson el a Megoldás frissítése vagy frissítése című témakörre.

Megoldások függőségeinek észlelése

Ez a példa azt mutatja be, hogyan lehet létrehozni egy jelentést, amely bemutatja a megoldás-összetevők közötti függőségeket.

Ez a kód a következő műveleteket hajtja végre:

  • A megoldáshoz tartozó összes összetevő lekérése.

  • Az egyes összetevőkhöz tartozó összes függőség lekérése.

  • Minden megtalált függőségnél a függőséget leíró jelentés jeleníti meg.

// Grab all Solution Components for a solution.
QueryByAttribute componentQuery = new QueryByAttribute
{
    EntityName = SolutionComponent.EntityLogicalName,
    ColumnSet = new ColumnSet("componenttype", "objectid", "solutioncomponentid", "solutionid"),
    Attributes = { "solutionid" },

    // In your code, this value would probably come from another query.
    Values = { _primarySolutionId }
};

IEnumerable<SolutionComponent> allComponents =
    _serviceProxy.RetrieveMultiple(componentQuery).Entities.Cast<SolutionComponent>();

foreach (SolutionComponent component in allComponents)
{
    // For each solution component, retrieve all dependencies for the component.
    RetrieveDependentComponentsRequest dependentComponentsRequest =
        new RetrieveDependentComponentsRequest
        {
            ComponentType = component.ComponentType.Value,
            ObjectId = component.ObjectId.Value
        };
    RetrieveDependentComponentsResponse dependentComponentsResponse =
        (RetrieveDependentComponentsResponse)_serviceProxy.Execute(dependentComponentsRequest);

    // If there are no dependent components, we can ignore this component.
    if (dependentComponentsResponse.EntityCollection.Entities.Any() == false)
        continue;

    // If there are dependencies upon this solution component, and the solution
    // itself is managed, then you will be unable to delete the solution.
    Console.WriteLine("Found {0} dependencies for Component {1} of type {2}",
        dependentComponentsResponse.EntityCollection.Entities.Count,
        component.ObjectId.Value,
        component.ComponentType.Value
        );
    //A more complete report requires more code
    foreach (Dependency d in dependentComponentsResponse.EntityCollection.Entities)
    {
        DependencyReport(d);
    }
}

A DependencyReport módszer a következő kódmintában található.

Függőségi jelentés

A DependencyReport módszer a függőségben található információk alapján felhasználóbarátabb üzenetet biztosít.

Feljegyzés

Ebben a példában a módszer csak részben kerül megvalósításra. Csak attribútum és értékkészlet megoldás-összetevőkhöz jeleníti meg az üzeneteket.

/// <summary>
/// Shows how to get a more friendly message based on information within the dependency
/// <param name="dependency">A Dependency returned from the RetrieveDependentComponents message</param>
/// </summary> 
public void DependencyReport(Dependency dependency)
{
 // These strings represent parameters for the message.
    String dependentComponentName = "";
    String dependentComponentTypeName = "";
    String dependentComponentSolutionName = "";
    String requiredComponentName = "";
    String requiredComponentTypeName = "";
    String requiredComponentSolutionName = "";

 // The ComponentType global Option Set contains options for each possible component.
    RetrieveOptionSetRequest componentTypeRequest = new RetrieveOptionSetRequest
    {
     Name = "componenttype"
    };

    RetrieveOptionSetResponse componentTypeResponse = (RetrieveOptionSetResponse)_serviceProxy.Execute(componentTypeRequest);
    OptionSetMetadata componentTypeOptionSet = (OptionSetMetadata)componentTypeResponse.OptionSetMetadata;
 // Match the Component type with the option value and get the label value of the option.
    foreach (OptionMetadata opt in componentTypeOptionSet.Options)
    {
     if (dependency.DependentComponentType.Value == opt.Value)
     {
      dependentComponentTypeName = opt.Label.UserLocalizedLabel.Label;
     }
     if (dependency.RequiredComponentType.Value == opt.Value)
     {
      requiredComponentTypeName = opt.Label.UserLocalizedLabel.Label;
     }
    }
 // The name or display name of the component is retrieved in different ways depending on the component type
    dependentComponentName = getComponentName(dependency.DependentComponentType.Value, (Guid)dependency.DependentComponentObjectId);
    requiredComponentName = getComponentName(dependency.RequiredComponentType.Value, (Guid)dependency.RequiredComponentObjectId);

 // Retrieve the friendly name for the dependent solution.
    Solution dependentSolution = (Solution)_serviceProxy.Retrieve
     (
      Solution.EntityLogicalName,
      (Guid)dependency.DependentComponentBaseSolutionId,
      new ColumnSet("friendlyname")
     );
    dependentComponentSolutionName = dependentSolution.FriendlyName;
    
 // Retrieve the friendly name for the required solution.
    Solution requiredSolution = (Solution)_serviceProxy.Retrieve
      (
       Solution.EntityLogicalName,
       (Guid)dependency.RequiredComponentBaseSolutionId,
       new ColumnSet("friendlyname")
      );
    requiredComponentSolutionName = requiredSolution.FriendlyName;

 // Display the message
     Console.WriteLine("The {0} {1} in the {2} depends on the {3} {4} in the {5} solution.",
     dependentComponentName,
     dependentComponentTypeName,
     dependentComponentSolutionName,
     requiredComponentName,
     requiredComponentTypeName,
     requiredComponentSolutionName);
}

Annak észlelése, hogy egy megoldás-összetevő törölhető-e

Az RetrieveDependenciesForDeleteRequest üzenet segítségével azonosíthat minden egyéb megoldás-összetevőt, amely megakadályozná egy adott megoldás-összetevő törlését. Az alábbi kódminta egy ismert globális választási oszlop használatával keresi az attribútumokat. A globális választást használó bármely attribútum megakadályozza a globális választás törlését.

// Use the RetrieveOptionSetRequest message to retrieve  
// a global option set by it's name.
RetrieveOptionSetRequest retrieveOptionSetRequest =
    new RetrieveOptionSetRequest
    {
     Name = _globalOptionSetName
    };

// Execute the request.
RetrieveOptionSetResponse retrieveOptionSetResponse =
    (RetrieveOptionSetResponse)_serviceProxy.Execute(
    retrieveOptionSetRequest);
_globalOptionSetId = retrieveOptionSetResponse.OptionSetMetadata.MetadataId;
if (_globalOptionSetId != null)
{ 
 // Use the global OptionSet MetadataId with the appropriate componenttype
 // to call RetrieveDependenciesForDeleteRequest
 RetrieveDependenciesForDeleteRequest retrieveDependenciesForDeleteRequest = new RetrieveDependenciesForDeleteRequest 
{ 
 ComponentType = (int)componenttype.OptionSet,
 ObjectId = (Guid)_globalOptionSetId
};

 RetrieveDependenciesForDeleteResponse retrieveDependenciesForDeleteResponse =
  (RetrieveDependenciesForDeleteResponse)_serviceProxy.Execute(retrieveDependenciesForDeleteRequest);
 Console.WriteLine("");
 foreach (Dependency d in retrieveDependenciesForDeleteResponse.EntityCollection.Entities)
 {

  if (d.DependentComponentType.Value == 2)//Just testing for Attributes
  {
   String attributeLabel = "";
   RetrieveAttributeRequest retrieveAttributeRequest = new RetrieveAttributeRequest
   {
    MetadataId = (Guid)d.DependentComponentObjectId
   };
   RetrieveAttributeResponse retrieveAttributeResponse = (RetrieveAttributeResponse)_serviceProxy.Execute(retrieveAttributeRequest);

   AttributeMetadata attmet = retrieveAttributeResponse.AttributeMetadata;

   attributeLabel = attmet.DisplayName.UserLocalizedLabel.Label;
  
    Console.WriteLine("An {0} named {1} will prevent deleting the {2} global option set.", 
   (componenttype)d.DependentComponentType.Value, 
   attributeLabel, 
   _globalOptionSetName);
  }
 }
}
  • Last updated on