Voir PDF
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 :
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.