AppDNA

Variablen des Effort Calculator in einem Forward Path Szenario verwenden

Dieses Thema enthält eine Einführung in die Verwendung der Variablen des Effort-Rechners in Ihrem Forward Path Szenario. In diesem Thema wird ein Beispiel für die Verwendung dieser Features verwendet.

Informationen zu den Variablen des Effort Calculator

Der Effort Calculator schätzt die Kosten und den Aufwand für die Sanierung Ihres Anwendungsportfolios für eine Zielplattform (dargestellt durch einen der AppDNA-Berichte). Die Berechnung verwendet zwei Hauptarten von Variablen:

  • Benutzerdefinierte Variablen — Diese speichern Werte, wie viel ein Tester, ein Remediator und ein Projektmanager pro Tag kosten, die Anzahl der Stunden in einem typischen Arbeitstag, wie lange es im Durchschnitt dauert, Anwendungen unterschiedlicher Komplexität (einfach, normal und komplex) zu beheben, wobei berücksichtigt wird. die Schwierigkeit der Sanierungsaktion (leicht, mittel oder hart). Sie können diese Variablen separat für jeden AppDNA-Bericht im festlegenBildschirm “Effort Calculator”.
  • Variablen auf Anwendungsebene — Diese werden aus der AppDNA-Analyse abgeleitet und umfassen die Komplexität der Anwendung (dies basiert auf der Anzahl der Dateien und Registrierungseinträge, die die Anwendung hat) und die Schwierigkeit (oder Komplexität) der Aktionen, die ergriffen werden müssen, um die -Anwendung für den ausgewählten Bericht.

Anhand dieser Informationen schätzt der Effort Calculator die erwarteten Kosten für die Migration des gesamten Anwendungsportfolios auf die neue Plattform. Sie können diese Variablen jetzt in Ihrem Forward Path Szenario verwenden, z. B. um die Kosten für die Korrektur jeder Anwendung zu schätzen. In diesem Thema finden Sie ein relativ einfaches Beispiel dafür. Eines der Beispielszenarien, die mit AppDNA geliefert wird, bietet ein komplexeres und anspruchsvolleres Beispiel.

Ausführliche Informationen zu den Variablen des Effort Calculator und ihrer Verwendung finden Sie unterAufwandsrechner.

Abrufen der benutzerdefinierten Variablen des Effort Calculator

Sie können über das EffortCalculatorSettings -Objekt auf die benutzerdefinierten Variablen des Effort CalculatorSettings zugreifen, das Sie über das Host -Objekt abrufen. Das Host-Objekt ist implizit für das gesamte Szenarioskript verfügbar. Hier ist ein Snippet, das das EffortCalculatorSettings -Objekt für den Windows 7-Bericht abruft:

``` pre codeblock Private Dim vars As EffortCalculatorSettings

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


Beachten Sie, dass wir die interne Berichtskennung von Windows 7 verwendet haben, um die Variablen des Effort Calculator für Windows 7 abzurufen. Eine Liste der Berichtsbezeichner finden Sie unter [Erstellen von Verknüpfungen zu Korrekturberichtansichten](/de-de/dna/current-release/configure/forward-path/dna-forward-path-remediation-links.html).

Sie können alle Eigenschaften des EffortCalculatorSettings -Objekts im Property Explorer auf der rechten Seite des sehen[Bildschirm "Forward-Pfadlogik-Editor"](/de-de/dna/current-release/configure/forward-path/dna-forward-path-logic-editor.html). Die Namen der Eigenschaften beziehen sich eng mit dem Text, der für die Variablen im Bildschirm Effort Calculator angezeigt wird. Beispielsweise entspricht die AppStagingHours -Eigenschaft der Zeitvariable Staging im Abschnitt Staffing-Variablen des Bildschirms Aufwand Calculator. Wir werden diese Variable im folgenden Beispiel verwenden.

Es ist möglich, die Werte dieser Variablen in Ihrem Szenario für die Verwendung in diesem Szenario wie folgt festzulegen:

``` pre codeblock
vars.TesterStagerCostPerDay = 23

Hinweis: Dadurch werden die Variablen, die der Effort Calculator verwendet, nicht geändert oder überschrieben.

Über das Beispiel

Um zu veranschaulichen, wie Sie die beiden Typen von Variablen des Effort Calculator verwenden, um die geschätzten Kosten für die Behebung von Anwendungen in Ihrem Forward Path Szenario zu berechnen, gehen wir durch ein Beispielszenario. Wir werden es schrittweise aufbauen, um es leicht zu verstehen.

Hier ist ein Screenshot der Ausgabe, die das Beispiel erstellt:

Ausgabebeispiel

Hinweis: Die Beispiele in diesem Thema verwenden die Unterstriche (_) -Notation, um lange Linien in zwei oder mehr Zeilen zu unterteilen. Dies ist so, dass die Beispielcode-Snippets korrekt dargestellt werden, wenn sie in einer PDF-Datei enthalten sind. Weitere MSDN-Bibliothek Informationen zu dieser Notation finden Sie im.

Initialisieren der Variablen

AppDNA enthält eine Forward Path Szenariofunktion namens Initialize(). Wenn es im Szenario vorhanden ist, ruft AppDNA dies automatisch zu Beginn der Verarbeitung auf. Wir werden dies verwenden, um Variablen zu initialisieren, die wir später im Szenario verwenden werden. Weitere Hinweise zur Funktion Initialize() finden Sie unter Gruppierte Forward-Pfad-Berichte.

Vor der Initialize() -Funktion erklären wir einige Variablen, die wir im gesamten Skript verwenden werden.

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


Hier ist die Initialize() Funktion:

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

Beachten Sie, dass wir die stündlichen Test- und Sanierungskosten berechnen. Wir tun dies, indem wir die Werte, die in den Variablen gespeichert sind, die die Tester- oder Korrekturkosten pro Tag darstellen, durch den Wert in der normalen Anzahl der Arbeitsstunden in einer Tagesvariablen gespeichert.

Am Ende der Funktion Initialize() legen wir die Sortierreihenfolge in absteigender Reihenfolge der Werte in der Spalte Kosten fest. In dieser Spalte werden die berechneten Kosten für die Korrektur der Anwendung und Bereitstellung für UAT angezeigt.

Die Hauptfunktion

Hier ist die Haupt-ForwardPath() Funktion. AppDNA ruft dies automatisch einmal für jede Anwendung auf, die beim Ausführen des Berichts ausgewählt wird. Erklärende Hinweise folgen dem Beispiel.

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


Beachten Sie, dass diese Funktion beginnt mit der Einrichtung von drei benutzerdefinierten Spalten (CustomFieldN genannt) - dies sind die drei am weitesten rechts im Screenshot der Ausgabe oben. Wir verwenden diese wie folgt:

| Spalte  | Anzeigen |
| ---| --- |
| CustomField1 | Die Anwendungskomplexität. Forward Path speichert dies als rot/gelb/grün "RAG". Wir übersetzen diese Werte in komplexe, mittlere und einfache Texte im Skript. |
| CustomField2 | Die Aktion der Anwendung RAG. Wir erhalten den Wert mit der Eigenschaft Application.Modules.Windows7.ActionRAG.|
| CustomField3 | Die Komplexität/Schwierigkeit der Behebung der Anwendung. Wir werden den Wert für diese Spalte später im Skript abrufen.  |

Die Spalte Kosten wird automatisch im Währungsformat angezeigt. Standardmäßig verwendet Forward Path das Währungssymbol für die Ländereinstellungen auf dem Computer des Benutzers. In einem internationalen Umfeld bedeutet dies, dass das Währungssymbol abhängig von den Einstellungen auf dem Gerät der Person, die den Bericht anzeigt, variieren kann. (Es kann z. B. das Eurozeichen für einen Benutzer in Frankreich, das britische Pfundzeichen für einen Benutzer in England und das US-Dollarzeichen für einen Benutzer in den Vereinigten Staaten angezeigt werden.) In diesem Beispiel geben wir daher das US-Dollar-Symbol an, so dass dieses unabhängig von den regionalen Einstellungen des Benutzers immer angezeigt wird. Dazu legen wir die Eigenschaft Kultur in der Spalte Kosten auf "en-US" fest, was die Vereinigten Staaten angibt.

Der Hauptteil der Funktion besteht aus einer Select-Case-Anweisung, die den Windows 7 RAG-Status der Anwendung testet und je nach diesem Status unterschiedliche Verarbeitung bereitstellt. Schauen wir uns an, wie wir mit jedem Wert umgehen:

-  **Grüne RAG** — Die Anwendung kann direkt zu UAC gehen. Wir berechnen also die Kosten für das Staging der Anwendung, indem wir die Testkosten pro Stunde multiplizieren (die wir in Initialize() berechnet haben) mit der Variablen Effort Calculator, die die Anzahl der Stunden speichert, die es dauert, um eine Anwendung zum Testen durchzuführen. Wir setzen die Aktionskomplexität auf "—", da eine Korrektur nicht erforderlich ist, und wir verwenden eine andere Select Case Anweisung, um die Komplexität der Anwendung zu testen und den unfreundlichen "RAG" -Wert in einen Text umzuwandeln.
-  **Bernstein RAG** — Die Anwendung muss korrigiert werden. Wir rufen die Funktion GetCost() auf, um die Korrekturkosten zu berechnen. Wir werden uns das in Kürze ansehen.
-  **Red RAG** — Wir testen zuerst die Aktion RAG. Wenn es rot ist, bedeutet dies, dass die Anwendung nicht korrigiert werden kann und neu entwickelt oder ersetzt werden muss. Anschließend verwenden wir eine Select-Case-Anweisung, um die Anwendungskomplexität wie bei der grünen RAG zu testen. Dieses Mal legen wir jedoch eine willkürliche Ersatzkosten auf der Grundlage der Komplexität der Anwendung fest. Bei Anwendungen, die behoben werden können (d. h. die RAG ist grün oder gelb), rufen wir die Funktion GetCost() auf, um die Behebungskosten zu berechnen.
-  **Andere RAG-Werte** — Wir behandeln alle anderen RAG-Werte mithilfe einer Case Else-Anweisung. Dies behandelt Anwendungen, die nicht analysiert wurden und diejenigen, die gesperrt sind (nicht lizenziert).

## Berechnen der Behebungskosten

Hier ist die Funktion GetCost(), die wir in der Hauptfunktion aufgerufen haben, um die Korrekturkosten von gelben Anwendungen und roten Anwendungen zu berechnen, die behoben werden können. Erklärende Hinweise folgen dem Beispiel.

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

Die folgenden Hinweise beziehen sich auf die Zahlen in den Kommentaren im obigen Beispiel:

1. Wir verwenden die Windows 7-Eigenschaft “TriggeredRules” der aktuellen Anwendung. Diese Eigenschaft ist eine Auflistung von TriggeredRule -Objekten, die alle Algorithmen darstellen, die die Anwendung während der Analyse für Windows 7 ausgelöst hat. Aus dieser Sammlung erhalten wir den Algorithmus, der die härteste Behebungsaktion hat. Wir werden dies verwenden, um die Kosten für die Korrektur der Anwendung zu berechnen.

2. Wir zeigen die Komplexität (Schwierigkeit) der Korrekturaktion des Algorithmus in CustomField3 an.

3. Anschließend verwenden wir erneut eine Select Case-Anweisung, um die Komplexität der Anwendung zu testen. Wir werden für jede Komplexität unterschiedliche Verarbeitung anbieten. Schauen wir uns an, wie wir mit einer komplexen Anwendung umgehen:

  • Zuerst verwenden wir eine andere Select-Case-Anweisung, um die Komplexität (Schwierigkeit) der Aktion zu testen, die mit dem Algorithmus verbunden ist, den wir in Schritt 1 abgerufen haben. Anschließend berechnen wir für jede mögliche Komplexität der Vorgänge die Behebungskosten, indem wir die Behebungskosten pro Stunde (berechnet unter Initialize()) mit der Variablen Aufwand Calculator multiplizieren, die die Zeit darstellt, die für die Wiederherstellung einer komplexen Anwendung der entsprechenden Komplexität erforderlich ist.
  • Wir prüfen dann, ob die Aktion RAG bernsteinfarben ist — denn das bedeutet, dass die Anwendung nach der Implementierung zusätzlicher Tests benötigt. Wenn die RAG gelb ist, berechnen wir die Testkosten, indem wir die Testkosten pro Stunde (berechnet in Initialize()) mit der Variablen Effort Calculator multiplizieren, die die Zeit darstellt, die zum Testen einer komplexen Anwendung benötigt wird.

Der Code für mittlere Komplexität und einfache Anwendungen spiegelt den Code für die komplexe Anwendung wider, aber jedes Mal, wenn wir die Variablen des Effort Calculator für mittlere und einfache Anwendungen auswählen.

4. Schließlich fügen wir die von uns berechneten Korrektur- und Testkosten zu den Kosten für die Bereitstellung der Anwendung für UAT hinzu und setzen diese in den Rückgabewert ein.

Ein Beispiel, das die Behebungskosten berechnet, indem die Aktionen berücksichtigt werden, die mit allen von der Anwendung ausgelösten Algorithmen verknüpft sind, finden Sie im Beispielszenario, das mit AppDNA geliefert wird.

Variablen des Effort Calculator in einem Forward Path Szenario verwenden