AppDNA

Utiliser les variables de Effort Calculator dans un scénario Forward Path

Cette rubrique fournit une introduction à l’utilisation des variables Calculatrice d’effort dans votre scénario Forward Path. Cette rubrique utilise un exemple pour introduire l’utilisation de ces fonctionnalités.

À propos des variables du calculateur d’effort

Effort Calculator estime le coût et l’effort de correction de votre portefeuille d’applications pour une plate-forme cible (représenté par l’un des rapports AppDNA). Le calcul utilise deux types principaux de variables :

  • Variables définies par l’utilisateur : ces valeurs stockent, telles que le coût par jour d’un testeur, d’un correcteur et d’un gestionnaire de projet, le nombre d’heures d’une journée de travail typique, le temps qu’il faut en moyenne pour résoudre des applications de différentes complexités (simples, normales et complexes), en tenant compte des la difficulté de la mesure d’assainissement (facile, moyen ou difficile). Vous pouvez définir ces variables séparément pour chaque rapport AppDNA dans leÉcran Calculatrice d’effort.
  • Variables au niveau de l’application — Ces variables sont dérivées de l’analyse AppDNA et comprennent la complexité de l’application (ceci est basé sur le nombre de fichiers et d’entrées de registre que l’application possède), ainsi que la difficulté (ou la complexité) des mesures à prendre pour corriger la pour le rapport sélectionné.

L’utilisation de cette information Effort Calculator estime le coût attendu de la migration de l’ensemble du portefeuille d’applications vers la nouvelle plate-forme. Vous pouvez désormais utiliser ces variables dans votre scénario Forward Path (par exemple, pour estimer le coût de la correction de chaque application). Cette rubrique fournit un exemple relativement simple de la façon de procéder. L’un des exemples de scénarios fournis avec AppDNA fournit un exemple plus complexe et sophistiqué.

Pour plus d’informations sur les variables du Calculateur d’effort et leur utilisation, reportez-vous à la sectionOutil de calcul des efforts.

Récupération des variables du calculateur d’effort définies par l’utilisateur

Vous pouvez accéder aux variables de Calculatrice d’effort définies par l’utilisateur via l’objet EffortCalculatorSettings, que vous récupérez via l’objet Host. L’objet Host est implicitement disponible pour l’ensemble du script de scénario. Voici un extrait qui récupère l’objet EffortCalculatorSettings pour le rapport Windows 7 :

``` pre codeblock Private Dim vars As EffortCalculatorSettings

’ Get the Windows 7 Effort Calculator settings object. vars = Host.GetEffortCalculatorSettings(“Win7Module”)


Notez que nous avons utilisé l'identifiant de rapport interne de Windows 7 pour récupérer les variables du Calculateur d'effort pour Windows 7. Pour obtenir la liste des identificateurs de rapport, reportez-vous à la section [Créer des liens vers des vues de rapport de correction](/en-us/dna/current-release/configure/forward-path/dna-forward-path-remediation-links.html).

Vous pouvez voir toutes les propriétés de l'objet EffortCalculatorSettings dans l'Explorateur de propriétés sur le côté droit de la[Écran de l'éditeur de logique Forward Path](/en-us/dna/current-release/configure/forward-path/dna-forward-path-logic-editor.html). Les noms des propriétés sont étroitement liés au texte affiché pour les variables dans l'écran Calculateur d'effort. Par exemple, la propriété AppStagingHours correspond à la variable Temps intermédiaire de la section Variables de dotation de l'écran Calculateur d'effort. Nous allons utiliser cette variable dans l'exemple qui suit.

Il est possible de définir les valeurs de ces variables dans votre scénario pour une utilisation dans ce scénario, comme ceci :

``` pre codeblock
vars.TesterStagerCostPerDay = 23

Remarque : Cela ne change pas ou n’écrase pas les variables utilisées par le Calculateur d’effort.

A propos de l’exemple

Pour illustrer comment utiliser les deux types de variables Calculatrice d’effort pour calculer les coûts estimés des applications de correction dans votre scénario Forward Path, nous allons parcourir un exemple de scénario. Nous allons le construire par étapes, afin de le rendre facile à comprendre.

Voici une capture d’écran de la sortie que l’exemple crée :

Exemple de sortie

Remarque : Les exemples de cette rubrique utilisent la notation de soulignement (_) pour diviser les longues lignes en deux lignes ou plus. Ainsi, les extraits de code d’exemple s’affichent correctement lorsqu’ils sont inclus dans un PDF. Voir la Bibliothèque MSDN pour plus d’informations sur cette notation.

Initialiser les variables

AppDNA inclut une fonction de scénario Forward Path appelée Initialize (). S’il est présent dans le scénario, AppDNA l’appelle automatiquement au début du traitement. Nous utiliserons ceci pour initialiser les variables que nous utiliserons plus tard dans le scénario. Pour plus d’informations sur la fonction Initialize (), reportez-vous à la section Rapports Forward Path groupés.

Avant la fonction Initialize (), nous déclarons certaines variables que nous utiliserons tout au long du script.

``` pre codeblock ‘ Declare variables for use throughout the script. Private Dim vars As EffortCalculatorSettings Private Dim testingPerHour As Decimal = 0 Private Dim remediationPerHour As Decimal = 0


Voici la fonction Initialize () :

``` pre codeblock
Public Overrides Sub Initialize()

   ' Get the Windows 7 Effort Calculator settings object.
   vars = Host.GetEffortCalculatorSettings("Win7Module")

   ' Calculate the testing and remediation cost per hour.
   testingPerHour = vars.TesterStagerCostPerDay / _
      vars.NormalAppTestingHours
   remediationPerHour = vars.RemediatorCostPerDay / _
      vars.NormalAppTestingHours

   ' Sort the report in descending order of cost.
   Settings.ApplicationSortBy = "Cost"
   Settings.ApplicationSortDescending = true
End Sub

Notez que nous calculons les coûts horaires de test et de correction. Nous le faisons en divisant les valeurs stockées dans les variables qui représentent le coût du testeur ou du remédiateur par jour par la valeur stockée dans le nombre normal d’heures de travail dans une variable journalière.

A la fin de la fonction Initialize (), nous définissons l’ordre de tri dans l’ordre décroissant des valeurs de la colonne Coût. Dans cette colonne, nous allons afficher le coût calculé de la correction de l’application et de la mise en scène pour UAT.

La fonction principale

Voici la fonction principale ForwardPath (). AppDNA l’appelle automatiquement une fois pour chaque application sélectionnée lorsque vous exécutez le rapport. Les notes explicatives suivent l’exemple.

``` pre codeblock Public Function ForwardPath(ByVal currentApplication _ As Application) As Output

Dim result As New Output()

’ We will use three custom columns. result.CustomField1.Name = “Application Complexity” result.CustomField2.Name = “Action RAG” result.CustomField2.Value = _ currentApplication.Modules.Windows7.ActionRAG result.CustomField3.Name = “Action Complexity”

’ Set the culture on the Cost column to US English, ‘ so that the US dollar currency symbol is used. result.Display.Cost.Culture = “en-US”

’ Test the application’s main RAG status, because ‘ the remediation depends on this. Select Case currentApplication.Modules.Windows7.RAG

  Case Rag.Green

     ' The RAG is green, so no remediation is necessary
     ' and the application can be staged for UAT.
     result.Outcome = "Stage UAT"
     result.RAG = RAG.Green

     ' No remediation is required, so the cost is of
     ' the staging only.
     result.Cost = testingPerHour * vars.AppStagingHours
     result.CustomField3.Value = "--"

     ' Convert the unfriendly application complexity
     ' "RAG" to a text.
     Select Case currentApplication.Complexity
        Case RAG.Red
           result.CustomField1.Value = "Complex"
        Case RAG.Amber
           result.CustomField1.Value = "Medium"
        Case RAG.Green
           result.CustomField1.Value = "Simple"
     End Select

  Case Rag.Amber

     ' The RAG is amber, so the application needs
     ' remediation.
     result.RAG = RAG.Amber
     result.Outcome = "Remediate"

     ' The cost calculation is more complicated,
     ' so we will do it in a separate "GetCost()"
     ' function.
     result.Cost = GetCost(currentApplication, result)

  Case Rag.Red

     ' The RAG is red - we need to check the action
     ' RAG to see if remdiation is possible.
     result.RAG = RAG.Red

     ' If the action RAG is red, the application
     ' cannot be remediated.
     If (currentApplication.Modules.Windows7.ActionRAG = _
        RAG.Red) Then

        result.Outcome = "Redevelop"
        result.CustomField3.Value = "Hard"

        ' Convert the unfriendly application complexity
        ' "RAG" to a text and set an arbitrary
        ' replacement/redevelopment cost.
        Select Case currentApplication.Complexity
           Case RAG.Red
              result.CustomField1.Value = "Complex"
              result.Cost = 3000
           Case RAG.Amber
              result.CustomField1.Value = "Medium"
              result.Cost = 2000
           Case RAG.Green
              result.CustomField1.Value = "Simple"
              result.Cost = 1000
        End Select

     ' The action RAG is not red, so remediation is
     ' possible.
     Else
        result.Outcome = "Remediate"
        result.Cost = GetCost(currentApplication, result)
     End If

  Case Else

     ' Catch all for applications that have not been
     ' analyzed or that are locked.
     result.Outcome = "Unknown"
     result.RAG = RAG.Unknown
     result.CustomField1.Value = "--"
     result.CustomField3.Value = "--"
     result.Cost = 0

End Select

result.Display.SourcePath.Visible = false

ForwardPath = result

End Function


Notez que cette fonction commence par la configuration de trois colonnes personnalisées (appelées CustomFieldN) - ce sont les trois colonnes les plus à droite dans la capture d'écran de la sortie ci-dessus. Nous les utilisons comme suit :

| Colonne  | Affichages |
| ---| --- |
| CustomField1 | La complexité de l'application. Forward Path stocke ceci sous la forme d'un « RAG » rouge/ambre/vert. Nous traduisons ces valeurs en textes complexes/moyens/simples dans le script. |
| CustomField2 | L'action de l'application RAG. Nous obtenons la valeur en utilisant la propriété Application.Modules.Windows7.ActionRag.|
| CustomField3 | Complexité/difficulté de la mesure de correction de l'application. Nous allons récupérer la valeur de cette colonne plus tard dans le script.  |

La colonne Coût s'affiche automatiquement au format devise. Par défaut, Forward Path utilise le symbole monétaire pour les paramètres régionaux sur l'ordinateur de l'utilisateur. Dans un environnement international, cela signifie que le symbole monétaire peut varier en fonction des paramètres de l'appareil de la personne qui consulte le rapport. (Par exemple, il peut afficher le signe euro pour un utilisateur en France, le signe livre britannique pour un utilisateur en Angleterre et le signe dollar américain pour un utilisateur aux États-Unis.) Dans cet exemple, nous allons donc spécifier le symbole dollar américain afin qu'il soit toujours affiché indépendamment des paramètres régionaux de l'utilisateur. Pour ce faire, nous définissons la propriété Culture de la colonne Coût sur « en-US », ce qui indique les États-Unis.

Le corps principal de la fonction se compose d'une instruction Select Case qui teste l'état de Windows 7 RAG de l'application et fournit un traitement différent en fonction de cet état. Regardons comment nous gérons chaque valeur :

-  **Green RAG** — L'application peut aller directement à UAC. Nous calculons donc le coût de la mise en scène de l'application en multipliant le coût du test par heure (que nous avons calculé dans Initialize ()) par la variable Calculatrice d'effort qui stocke le nombre d'heures nécessaire pour mettre en scène une application pour le test. Nous définissons la complexité de l'action sur « — » car la correction n'est pas nécessaire, et nous utilisons une autre instruction Select Case pour tester la complexité de l'application et convertir la valeur « RAG » hostile en texte.
-  **Amber RAG** — L'application doit être corrigée. Nous appelons la fonction getCost () pour calculer le coût de correction. Nous allons examiner cette question sous peu.
-  **Rouge RAG** — Nous testons d'abord l'action RAG. S'il est rouge, cela signifie que l'application ne peut pas être corrigée et doit être redéveloppée ou remplacée. Nous utilisons ensuite une instruction Select Case pour tester la complexité de l'application comme nous l'avons fait pour le RAG vert. Cependant, cette fois, nous avons fixé un coût de remplacement arbitraire en fonction de la complexité de l'application. Pour les applications qui peuvent être corrigées (c'est-à-dire que leur action RAG est verte ou ambre), nous appelons la fonction getCost () pour calculer le coût de correction.
-  **Autres valeurs RAG** — Nous gérons toutes les autres valeurs RAG à l'aide d'une instruction Case Else. Cela gérera les applications qui n'ont pas été analysées et celles qui sont verrouillées (sans licence).

## Calculer le coût de correction

Voici la fonction getCost (), que nous avons appelée dans la fonction principale pour calculer les coûts de correction des applications ambrées et rouges qui peuvent être corrigées. Les notes explicatives suivent l'exemple.

``` pre codeblock
Private Function GetCost(app As Application, _
   cols As Output) As Decimal

   Dim remediationCost As Decimal = 0
   Dim testingCost As Decimal = 0

   ' 1. Using the triggered algorithms, get the
   ' algorithm with the hardest action. We will use this
   ' in our calculations.
   Dim maxAlgorithm As TriggeredRule = _
      (From r in app.TriggeredRules _
      Where r.ModuleIdentifier = "Win7Module" _
      Where r.Action.Complexity = ActionComplexity.Hard Or _
      r.Action.Complexity = ActionComplexity.Medium Or _
      r.Action.Complexity = ActionComplexity.Easy _
      Order By r.Action.Complexity Descending _
      Select r).FirstOrDefault()

   ' 2. Display the algorithm's action complexity.
   cols.CustomField3.Value = maxAlgorithm.Action.Complexity

   ' 3. The remediation cost depends on the application
   ' complexity.
   Select Case app.Complexity

      ' A complex application.
      Case RAG.Red

         cols.CustomField1.Value = "Complex"

         ' The remediation cost also depends on
         ' the complexity of the action. So we will
         ' calculate the time based on the number of
         ' hours held in the Effort Calculator matrix.
         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.ComplexAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.ComplexAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.ComplexAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.ComplexAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.ComplexAppTestingHours

         End If

      ' A medium-complexity application.
      Case RAG.Amber

         cols.CustomField1.Value = "Medium"

         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.NormalAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.NormalAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.NormalAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.NormalAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.NormalAppTestingHours

         End If

      ' A simple application.
      Case RAG.Green

         cols.CustomField1.Value = "Simple"

         Select Case maxAlgorithm.Action.Complexity
            Case ActionComplexity.Easy
               remediationCost = remediationPerHour * _
                  vars.SimpleAppEasyRemediationHours
            Case ActionComplexity.Medium
               remediationCost = remediationPerHour * _
                  vars.SimpleAppMediumRemediationHours
            Case ActionComplexity.Hard
               remediationCost = remediationPerHour * _
                  vars.SimpleAppHardRemediationHours
            Case Else
               remediationCost = remediationPerHour * _
                  vars.SimpleAppMediumRemediationHours
         End Select

         If app.Modules.Windows7.ActionRAG = RAG.Amber Then

            ' Add the additional post-remediation testing
            ' because the application has an amber action RAG.
            testingCost = testingPerHour * _
               vars.SimpleAppTestingHours

         End If

   End Select

   ' 4. Add the remediation and testing costs,
   ' and the cost of staging for UAT.
   GetCost = remediationCost + testingCost + _
      (testingPerHour * vars.AppStagingHours)

End Function

Les notes suivantes se rapportent aux chiffres dans les commentaires de l’exemple ci-dessus :

1. Nous utilisons la propriété TriggeRedRules de Windows 7 de l’application actuelle. Cette propriété est une collection d’objets TriggeredRule, qui représentent tous les algorithmes déclenchés par l’application lors de l’analyse pour Windows 7. De cette collection, nous obtenons l’algorithme qui a l’action de correction la plus difficile. Nous allons l’utiliser pour calculer le coût de la correction de l’application.

2. Nous affichons la complexité (difficulté) de l’action de correction de l’algorithme dans CustomField3.

3. Nous utilisons ensuite une instruction Select Case à nouveau pour tester la complexité de l’application. Nous fournirons un traitement différent pour chaque complexité. Regardons comment nous gérons une application complexe :

  • Nous utilisons d’abord une autre instruction Select Case pour tester la complexité (difficulté) de l’action associée à l’algorithme que nous avons récupéré à l’étape 1. Ensuite, pour chacune des complexités d’action possibles, nous calculons le coût de correction en multipliant le coût de correction par heure (calculé dans Initialize ()) par la variable Calculatrice d’effort qui représente le temps nécessaire pour corriger une application complexe de la complexité d’action correspondante.
  • Nous vérifions ensuite si l’action RAG est ambre, car cela signifie que l’application a besoin de tests supplémentaires après la mise en œuvre de la correction. Si l’action RAG est orange, nous calculons le coût de test en multipliant le coût de test par heure (calculé dans Initialize ()) par la variable Calculatrice d’effort qui représente le temps nécessaire pour tester une application complexe.

Le code pour les applications de complexité moyenne et simples reflète le code de l’application complexe, mais chaque fois que nous sélectionnons les variables Calculatrice d’effort pour les applications moyennes et simples, respectivement.

4. Enfin, nous ajoutons les coûts de correction et de test que nous avons calculés au coût de mise en scène de l’application pour UAT et définissons ceci dans la valeur de retour.

Pour obtenir un exemple qui calcule les coûts de correction en prenant en compte les actions associées à tous les algorithmes déclenchés par l’application, consultez l’exemple de scénario fourni avec AppDNA.

Utiliser les variables de Effort Calculator dans un scénario Forward Path