.NET-Code einfügen

UiPath.Core.Activities.InjectDotNetCode

Beschreibung

Fügt .NET-Code in den Haupt-UI-Thread der Zielanwendung ein. Vorgesehen für die Verwendung mit .NET-UI-Anwendungen, die keine herkömmlichen Automatisierungstechnologien verfügbar machen oder mit herkömmlichen Mitteln nicht korrekt angezielt werden können.

Eigenschaften

Allgemein

• BeiFehlerFortfahren (ContinueOnError) - Gibt an, ob die Automatisierung auch bei Auftreten eines Fehlers weiterlaufen soll. Das Feld unterstützt nur Boolesche Werte (Wahr, Falsch). Der Standardwert ist Falsch. Dadurch wird die Ausführung des Projekts beim Auftreten eines Fehlers angehalten, wenn das Feld leer. Wenn der Wert auf Wahr gesetzt ist, wird das Projekt weiter ausgeführt, auch wenn Fehler auftreten.

  Hinweis: Wenn diese Aktivität in Try Catch enthalten ist und der Wert der Eigenschaft BeiFehlerFortsetzen auf „True“ gesetzt ist, wird kein Fehler beim Ausführen des Projekts aufgefangen.
• AnzeigeName (DisplayName) - Der Anzeigename der Aktivität.

Eingabe

• Assembly – Der vollständige Pfad zur kompilierten .NET-Assembly, die Sie einfügen möchten. Dieses Feld unterstützt nur Strings und String-Variablen.

• Methodenname - Der Name der Methode, die Sie ausführen möchten. Nur öffentliche statische Methoden werden unterstützt.

  Hinweis: Ein Typ kann nicht mehrere Methoden mit demselben Namen enthalten. In diesem Fall wird zur Laufzeit ein Fehler ausgegeben.
• Target.ClippingRegion - Definiert das Ausschneide-Rechteck in Pixel im Verhältnis zum UIElement in folgenden Richtungen: links, oben, rechts, unten. Es unterstützt sowohl positive als auch negative Zahlen.
• Ziel.Element (Target.Element) - Verwendet die Variable UIElement, die von einer anderen Aktivität zurückgegeben wird. Die Eigenschaft kann nicht zusammen mit der Auswahleigenschaft verwendet werden. Dieses Feld unterstützt nur Variablen vom Typ UIElement.
• Ziel.Selektor (Target.Selector) - Texteigenschaft zum Suchen eines bestimmten UI-Elements, wenn die Aktivität ausgeführt wird. Die Eigenschaft ist genau genommen ein XML-Fragment, das Attribute des gesuchten GUI-Elements und einige übergeordnete Elemente spezifiziert.
• Target.TimeoutMS – Gibt die Zeit (in Millisekunden) an, die auf die Ausführung der Aktivität gewartet werden soll, bevor der Fehler SelectorNotFoundException ausgegeben wird. Der Standardwert ist 30000 Millisekunden (30 Sekunden).

• Ziel.WartenBisBereit (Target.WaitForReady) - Vor Ausführung der Aktionen warten, bis das Ziel bereit ist. Folgende Optionen sind verfügbar:

  • Keine (None) - Wartet ausschließlich auf das UI-Zielelement, bevor die Aktion ausgeführt wird. Sie können diese Option beispielsweise verwenden, wenn Sie nur Text einer Website abrufen oder eine bestimmte Schaltfläche anklicken möchten, ohne auf das Laden aller UI-Elemente warten zu müssen. Beachten Sie, dass dies ungewünschte Folgen haben kann, wenn die Schaltfläche von Elementen wie Skripten abhängt, die noch nicht geladen sind.

  • Interaktiv/Abgeschlossen – Wartet, bis alle UI-Elemente in der Ziel-App vorhanden sind, bevor die Aktion tatsächlich ausgeführt wird.

    Um zu beurteilen, ob sich eine Anwendung im Status „Interaktiv“ oder „Abgeschlossen“ befindet, werden die folgenden Tags überprüft:

  • Desktop-Anwendungen (Desktop applications) - Eine Nachricht wm_null wird versendet, um zu prüfen, ob die Tags <wnd>, <ctrl>, <java> oder <uia> vorhanden sind. Sind die Tags vorhanden, wird die Aktivität ausgeführt.
  • Webanwendung
  1. Internet Explorer – Das <webctrl>-Tag wird verwendet, um zu überprüfen, ob der Status Bereit des HTML-Dokuments Abgeschlossen ist. Darüber hinaus muss der Status Beschäftigt auf „False“ festgelegt werden.
  2. Andere – Das <webctrl>-Tag wird verwendet, um zu überprüfen, ob der Bereitschafts-Status des HTML-Dokuments Abgeschlossen ist.
  • SAP-Anwendungen (SAP applications) - Zuerst wird geprüft, ob der Tag <wnd> vorhanden ist. Anschließend wird eine SAP-spezifische API verwendet, um zu prüfen, ob die Session verfügbar ist.
• Typname - Der Name der öffentlichen Klasse, die die ausführende Methode enthält. Dieses Feld unterstützt nur Strings und String-Variablen.

Sonstiges

• Privat (Private) - Bei Auswahl werden die Werte von Variablen und Argumenten nicht mehr auf der Stufe Verbose protokolliert.

Ausgabe

• Ergebnis – Das Ergebnis der aufgerufenen Methode, das in einer Object-Variablen gespeichert wird. Dieses Feld unterstützt nur Object-Variablen.

Einfügen von Code in nicht standardmäßige AppDomains

Die Aktivität Inject .NET Code injiziert Code nur in die Standard-AppDomain.

Einige Anwendungen sind so strukturiert, dass sich die Elemente, auf die Sie möglicherweise zugreifen oder die Sie bearbeiten müssen, nicht innerhalb der Standard-AppDomain befinden. Daher reicht das Einfügen von Code in die Standard-AppDomain nicht aus. Wenn sich die UI-Elemente, die Sie anzeigen möchten, also in einer anderen AppDomain befinden, sind sie für den eingefügten Code nicht verfügbar.

Um dies zu beheben, müssen Sie den Injektionsprozess so ändern, dass er auf die genaue AppDomain abzielt, die die UI-Elemente enthält. Genauer gesagt müssen Sie Code aus der Funktion, die in der Standard-AppDomain ausgeführt wird, entweder in alle nicht standardmäßigen AppDomains oder in die spezifische nicht standardmäßige AppDomain einfügen, welche die UI-Elemente enthält, die Sie angeben möchten.

Erstellen eines Cross AppDomain-Runners

Um Code in nicht standardmäßigen AppDomains auszuführen, müssen Sie eine Klasse erstellen, die von MarshalByRefObject abgeleitet ist und die Funktion enthält, die Sie in nicht standardmäßigen AppDomains ausführen möchten:

public class CrossAppDomainRunner : MarshalByRefObject
{
    public void Execute(IntPtr controlHandle)
    {
        // Implementation of the method that will be executed in the target AppDomain
        Trace.WriteLine("Sunt in " + AppDomain.CurrentDomain.FriendlyName);

        Control foundControl = null;
        try
        {
            foundControl = Control.FromHandle(controlHandle);
        }
        catch (Exception controlException)
        {
            int lastWin32Error = Marshal.GetLastWin32Error();
            Trace.WriteLine($"+++++ An exception occurred while getting the control from handle {controlHandle}. The message is: {controlException.Message}, Win32 Error: {lastWin32Error}");
            
        }
        if (foundControl != null)
        {
            Trace.WriteLine($"+++++ Found control {foundControl.Name} from handle {controlHandle}");
            
        }
        else
        {
            int lastWin32Error = Marshal.GetLastWin32Error();
            Trace.WriteLine($"+++++ Control NOT found based on handle {controlHandle}, Win32 Error: {lastWin32Error}");
            
        }
    }
}

Im Grunde haben Sie eine Execute -Funktion, die einen IntPtr -Parameter erhält. Dieser Parameter enthält den Wert des Steuerelements, das Sie suchen. In diesem Beispiel müssen Sie nur einen IntPtr -Parameter übergeben, aber in Ihrer speziellen Situation können Sie so viele Parameter hinzufügen, wie Sie möchten.

Aufzählung und Einfügen von Code in nicht standardmäßige AppDomains

Um die anderen AppDomains aufzulisten, benötigen Sie einen Verweis auf die ICorRuntimeHost -Schnittstelle von mscoree. Dazu müssen Sie diese Schnittstelle deklarieren:

using System;
                using System.Collections.Generic;
                using System.Diagnostics;
                using System.Reflection;
                using System.Runtime.InteropServices;
                
                namespace mscoree
                {
                [CompilerGenerated]
                [Guid("CB2F6722-AB3A-11D2-9C40-00C04FA30A3E")]
                [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
                [TypeIdentifier]
                [ComImport]
                [CLSCompliant(false)]
                public interface ICorRuntimeHost
                {
                void _VtblGap1_11();
                
                void EnumDomains(out IntPtr enumHandle);
                
                void NextDomain([In] IntPtr enumHandle, [MarshalAs(UnmanagedType.IUnknown)] out object appDomain);
                
                void CloseEnum([In] IntPtr enumHandle);
                }
                }

Sie müssen eine Klasse mit nativen Methoden deklarieren, um das Komponentenobjektmodell (COM) zu initialisieren:

public static class NativeMethods
                {
                
                [DllImport("ole32.dll")]
                public static extern int CoInitializeEx(IntPtr pvReserved, COINIT dwCoInit);
                
                public enum COINIT : uint
                {
                /// Initializes the thread for multi-threaded object concurrency.
                COINIT_MULTITHREADED = 0x0,
                /// Initializes the thread for apartment-threaded object concurrency. 
                COINIT_APARTMENTTHREADED = 0x2,
                // ...
                }
                }

Sie benötigen eine Methode, um ein ICorRunttimeHost -Objekt abzurufen:

public static ICorRuntimeHost GetCorRuntimeHost()
                {
                return (ICorRuntimeHost)Activator.CreateInstance(Marshal.GetTypeFromCLSID(new Guid("CB2F6723-AB3A-11D2-9C40-00C04FA30A3E")));
                }

Jetzt haben Sie alles bereit, um die anderen AppDomains aufzulisten und Code darin auszuführen. Die Funktion GetControlData wird von der Aktivität Inject .NET Code in der Standard-AppDomain ausgeführt:

public static void GetControlData(Int64 controlHandle, out string response)
                {
                //initialising COM
                NativeMethods.CoInitializeEx(IntPtr.Zero, NativeMethods.COINIT.COINIT_MULTITHREADED);
                
                mscoree.ICorRuntimeHost host = null;
                try
                {
                host = (ICorRuntimeHost)Activator.CreateInstance(Marshal.GetTypeFromCLSID(new Guid("CB2F6723-AB3A-11D2-9C40-00C04FA30A3E")));
                }
                catch (COMException comEx)
                {
                Trace.WriteLine($"COMException: {comEx.Message}, HRESULT: {comEx.ErrorCode}");
                }
                catch (Exception ex)
                {
                // Handle other exceptions
                Trace.WriteLine($"Exception: {ex.Message}");
                }
                
                
                
                IntPtr enumHandle = IntPtr.Zero;
                
                try
                {
                //now that we have ICorRuntimeHost object we can use it to enumerate the other domains
                host.EnumDomains(out enumHandle);
                object domain = null;
                host.NextDomain(enumHandle, out domain);
                while (domain != null)
                {
                //for each appdomain obtained
                AppDomain appDomain = (AppDomain)domain;
                //appDomain.BaseDirectory; - you might want to copy your dll 
                //in the appDomain.BaseDirectory cause otherwise it might not find 
                //the assembly 
                
                ObjectHandle handle = appDomain.CreateInstance(
                typeof(CrossAppDomainRunner).Assembly.FullName,
                typeof(CrossAppDomainRunner).FullName);
                
                // Unwrap to get the actual object
                
                var runnerProxy = handle.Unwrap();
                
                // Use reflection to call the Execute method
                MethodInfo executeMethod = runnerProxy.GetType().GetMethod("Execute", new Type[] { typeof(IntPtr) });
                //pass parameters as new object[]
                executeMethod.Invoke(runnerProxy, new object[] { new IntPtr(controlHandle) });
                
                //go to next appdomain
                host.NextDomain(enumHandle, out domain);
                if (domain == null)
                break;
                
                }
                }
                finally
                {
                if (host != null)
                {
                if (enumHandle != IntPtr.Zero)
                {
                host.CloseEnum(enumHandle);
                }
                
                Marshal.ReleaseComObject(host);
                }
                
                }
                response = string.Empty;
                }

Im obigen Beispiel wird der Code in alle AppDomains eingefügt. Sobald Sie die AppDomain herausgefunden haben, in der sich die UI-Elemente befinden, die Sie angeben möchten, können Sie alle AppDomains aufzählen, aber Code nur in die erforderliche AppDomain einfügen.