System windows automation dll

Файл System.Management.Automation.dll считается разновидностью DLL-файла. DLL-файлы, такие как System.Management.Automation.dll, по сути являются справочником, хранящим информацию и инструкции для исполняемых файлов (EXE-файлов), например appidpolicyconverter.exe. Данные файлы были созданы для того, чтобы различные программы (например, Microsoft Office Access 2010) имели общий доступ к файлу System.Management.Automation.dll для более эффективного распределения памяти, что в свою очередь способствует повышению быстродействия компьютера.

К сожалению, то, что делает файлы DLL настолько удобными и эффективными, также делает их крайне уязвимыми к различного рода проблемам. Если что-то происходит с общим файлом DLL, то он либо пропадает, либо каким-то образом повреждается, вследствие чего может возникать сообщение об ошибке выполнения. Термин «выполнение» говорит сам за себя; имеется в виду, что данные ошибки возникают в момент, когда происходит попытка загрузки файла System.Management.Automation.dll — либо при запуске приложения Microsoft Office Access 2010, либо, в некоторых случаях, во время его работы. К числу наиболее распространенных ошибок System.Management.Automation.dll относятся:

• Нарушение прав доступа по адресу — System.Management.Automation.dll.
• Не удается найти System.Management.Automation.dll.
• Не удается найти C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0__31bf3856ad364e35\System.Management.Automation.dll.
• Не удается зарегистрировать System.Management.Automation.dll.
• Не удается запустить Microsoft Office Access 2010. Отсутствует требуемый компонент: System.Management.Automation.dll. Повторите установку Microsoft Office Access 2010.
• Не удалось загрузить System.Management.Automation.dll.
• Не удалось запустить приложение, потому что не найден System.Management.Automation.dll.
• Файл System.Management.Automation.dll отсутствует или поврежден.
• Не удалось запустить это приложение, потому что не найден System.Management.Automation.dll. Попробуйте переустановить программу, чтобы устранить эту проблему.

Файл System.Management.Automation.dll может отсутствовать из-за случайного удаления, быть удаленным другой программой как общий файл (общий с Microsoft Office Access 2010) или быть удаленным в результате заражения вредоносным программным обеспечением. Кроме того, повреждение файла System.Management.Automation.dll может быть вызвано отключением питания при загрузке Microsoft Office Access 2010, сбоем системы при загрузке System.Management.Automation.dll, наличием плохих секторов на запоминающем устройстве (обычно это основной жесткий диск) или, как нередко бывает, заражением вредоносным программным обеспечением. Таким образом, крайне важно, чтобы антивирус постоянно поддерживался в актуальном состоянии и регулярно проводил сканирование системы.

In this blog we will discuss about how to empower GUI Automation and integrate it into Powershell framework. In general, Powershell scripts are mainly used for automating the middleware and backend system functionality.

But, in order to get end-to-end automation, we will have to integrate the frontend GUI Automation too. GUI Automation can be used as a validation point, soon after performing the middleware and backend system API execution.

This can be achieved by using binary module [Using C# .Net Automation Libraries] through which UI automation can be bridged with middleware and backend system automation.
Let’s take a look at “How binary module integration is done”

What is Powershell Binary Module?

Importing a dll [Using C# .Net libraries] into powershell is referred to as Binary Module. A binary module can be any assembly (.dll) that contains cmdlet classes. A dll which contains cmdlet classes can be imported into powershell. By default, all the cmdlets in the assembly are imported when the binary module is imported.
Binary Module integration is segregated into two divisions,

1. Creating library file using C#.
2. Loading the dll into powershell

1. Creating library file using C#.

STEP 1 : Creating a New Project

Select the Visual C# from the installed Templates list and then pick Class Library since compiled modules in PowerShell are in DLL format. Let’s name this project as DemoModule.

Картинка с сайта: www.msystechnologies.com

STEP 2 : Navigate to Properties

Select the Debug option in the menu and select DemoModule Properties.

STEP 3 : Choose .NET framework

Go to Application and choose the appropriate (suitable for powershell version) .NET framework version under “Target framework”.

Картинка с сайта: www.msystechnologies.com

In Visual Studio 2012 the assembly will be built using .NET 4.5, but you’ll need to switch it to use the older framework, so that Powershell can load the assembly.
Note : Select the .NET Framework depending on the lowest version of PowerShell to support. You can use the following as reference:
                PowerShell 2.0 – .NET Framework 3.5
                PowerShell 3.0 – .NET Framework 4
                PowerShell 4.0 – .NET Framework 4.5

STEP 4: Adding reference.

Right click on Reference in the Solution Explorer and select Add Reference.

Картинка с сайта: www.msystechnologies.com

Loading the following UI Automation library as reference

Картинка с сайта: www.msystechnologies.com

Need to load the System.Management.Automation library as a reference to our project to make the PowerShell API calls available.

Select browse under Reference manager.

Navigate to location
C:\Windows\assembly\GAC_MSIL\System.Management.Automation\1.0.0.0__31bf3856ad364e35 and select the file System.Management.Automation.dll

Картинка с сайта: www.msystechnologies.com

After adding the following library in references.

STEP 5 : Import “System.Windows.Automation” library

Include the “System.Windows.Automation” reference to the class to get access to API calls in order to build a PowerShell module.

Картинка с сайта: www.msystechnologies.com

STEP 6 : Converting the class into a single Powershell cmdlet

Creating Powershell cmdlet using dataanotation. “[System.Management.Automation.Cmdlet(System.Management.Automation.VerbsCommon.Get, ”DemoName”)]”

Картинка с сайта: www.msystechnologies.com

STEP 7 : Build the Project to dll

Build solution is done either by hitting F7 or selecting “Build Solution” from the BUILD menu. After build succeeds, collect the dll from the path displayed in Output pane.

Картинка с сайта: www.msystechnologies.com

2. Loading the dll into powershell :

STEP 1: Navigate the location of dll with Import-Module along with -Verbose to load the module and give output. It shows that Get-DemoName is loaded.
DLL received from .Net environment is been loaded into Windows powershell prompt using cmdlet “Import-Module”

STEP 2: Get-Module displays the module information which in turn implies that DLL gets loaded successfully.

Картинка с сайта: www.msystechnologies.com

Powershell cmdlet “Get-help Get-DemoName” shows the detailed information of the cmdlet

Conclusion

Importing binary modules written in C# helps achieve GUI automation through Powershell.

A few weeks ago I published an article about White, an open-source framework to automate Windows applications. Now I found out that the Windows Presentation Foundation (WPF) also provides a new Accessibility API called Microsoft UI Automation.

• http://msdn.microsoft.com/en-us/library/ms753388.aspx
• http://msdn.microsoft.com/en-us/library/system.windows.automation.aspx

AutomationElements and control patterns

The UI Automation framework enables you to automate Win32, Windows Forms and WPF applications. Every part of a UI (window, button, menu, …) is represented as an AutomationElement. An AutomationElement is not really a control; it is an object that represents the accessible properties of a control. Elements are contained in a tree structure, with the desktop as the root element.

By passing conditions to the FindFirst() method you can access all controls in another Windows application. You still need tools like UI Spy or WinSpector to find the AutomationId of controls.

AutomationElements also expose control patterns which provide properties for specific control types (window, button, menu, …). These patterns can also be used to call methods. There are several interesting patterns like InvokePattern (click), ExpandCollapsePattern, WindowPattern (close), TextPattern (manipulate text), … When using UI Spy you will see that all available patterns will be listed in the Properties window.

Картинка с сайта: www.scip.be

Automate Windows Calculator

To compare the features and performance of WPF UIAutomation to White, I have implemented the same example as in my previous article. So the demo application will start the Windows Calculator, calculate a sum and display the decimal and binary result in a WPF window. Because this example will demonstrate several techniques, not everything is optimal. There will probably be better and shorter ways to accomplish the same.

Картинка с сайта: www.scip.be

I have created a small WPF application but the UIAutomation libraries are not restricted to WPF. You could also use them in a WinForms or Console application.

First you need to add a reference to the UIAutomationClient.dll, UIAutomationTypes.dll and UIAutomationProviders.dll assemblies.

<Window x:Class="ScipBe.Demo.UIAutomation.WindowUIAutomation"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="UI Automation" Height="400" Width="400">
    <DockPanel LastChildFill="True">
        <Button DockPanel.Dock="Top" Click="ButtonAutomate_Click">Automate Calculator</Button>
        <Button DockPanel.Dock="Top" Click="ButtonAutomateHelper_Click">Automate Calculator (helper class)</Button>
        <TextBox DockPanel.Dock="Top" Name="textBoxResult1"></TextBox>
        <TextBox DockPanel.Dock="Top" Name="textBoxResult2"></TextBox>
        <Button DockPanel.Dock="Top" Click="ButtonEvents_Click">Subscribe to events</Button>
        <ListBox DockPanel.Dock="Top" Name="listBoxEventLog"></ListBox>
    </DockPanel>
</Window>

using System.Windows;
using System.Windows.Automation;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;
using System.Windows.Threading;
 
namespace ScipBe.Demo.UIAutomation
{
  public partial class WindowUIAutomation : Window
  {
    public WindowUIAutomation()
    {
      InitializeComponent();
    }
 
    private void ButtonAutomate_Click(object sender, RoutedEventArgs e)
    {
      // Launch Windows Calculator (calc.exe) and find the main window
      Process.Start("calc");
      Thread.Sleep(500);
      PropertyCondition findWindow = new PropertyCondition(AutomationElement.ClassNameProperty, "SciCalc");
      AutomationElement window = AutomationElement.RootElement.FindFirst(TreeScope.Children, findWindow);
 
      // Get a reference to the Edit TextBox (AutomationId = "403")
      PropertyCondition findTextBox = new PropertyCondition(AutomationElement.AutomationIdProperty, "403");
      AutomationElement textBox = window.FindFirst(TreeScope.Descendants, findTextBox);
 
      // Get a reference to the RadioButton "Dec" (AutomationId = "307")
      PropertyCondition findRadioButtonDecimal = new PropertyCondition(AutomationElement.AutomationIdProperty, "307");
      AutomationElement radioButtonDecimal = window.FindFirst(TreeScope.Descendants, findRadioButtonDecimal);
      // If this RadioButton can not be found, the calculator uses the Standard view
      // Call the Scientfic/Wetenschappelijk menu to make more options visible
      if (radioButtonDecimal == null)
      {  
        AutomationElement menuItemView = window.FindFirst(TreeScope.Descendants, 
          new PropertyCondition(AutomationElement.AutomationIdProperty, "Item 2"));
        if (menuItemView != null)
        {
          ExpandCollapsePattern pattern = menuItemView.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern;
          pattern.Expand();
        }
        AutomationElement menuItemScientific = window.FindFirst(TreeScope.Descendants,
          new PropertyCondition(AutomationElement.AutomationIdProperty, "Item 304"));
        if (menuItemScientific != null)
        {
          InvokePattern pattern = menuItemScientific.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;
          pattern.Invoke();
        }
      }
 
      // Press F6 to make sure we are using the decimal numerical system
      SendKeys.SendWait("{F6}");
 
      // Focus the Edit TextBox and enter the text 54 
      textBox.SetFocus();
      Thread.Sleep(100);
      SendKeys.SendWait("45");
 
      // Press button "3" (AutomationId = "127") so the value will be 543
      AutomationElement button3 = window.FindFirst(TreeScope.Descendants, 
        new PropertyCondition(AutomationElement.AutomationIdProperty, "127"));
      if (button3 != null)
      {
        InvokePattern pattern = button3.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;
        pattern.Invoke();
      }
 
      // Press the "+" button (AutomationId = "92")
      AutomationElement buttonPlus = window.FindFirst(TreeScope.Descendants, 
        new PropertyCondition(AutomationElement.AutomationIdProperty, "92"));
      if (buttonPlus != null)
      {
        InvokePattern pattern = buttonPlus.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;
        pattern.Invoke();
      }
 
      // Enter the second value. Press button "6" (AutomationId = "130")
      AutomationElement button6 = window.FindFirst(TreeScope.Descendants, 
        new PropertyCondition(AutomationElement.AutomationIdProperty, "130"));
      (button6.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern).Invoke();
 
      // Enter the second value. Press button "7" (AutomationId = "131")
      AutomationElement button7 = window.FindFirst(TreeScope.Descendants,
        new PropertyCondition(AutomationElement.AutomationIdProperty, "131"));
      (button7.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern).Invoke();
 
      // Press the "=" button to calculate the result (AutomationId = "112")
      AutomationElement buttonEquals = window.FindFirst(TreeScope.Descendants,
        new PropertyCondition(AutomationElement.NameProperty, "="));
      (buttonEquals.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern).Invoke();
 
      // Focus the Edit TextBox again and copy the result to the clipboard
      // by sending the keyboard combination CTRL+C
      textBox.SetFocus();
      Thread.Sleep(100);
      SendKeys.SendWait("^C");
 
      // Press F8 to change the numerical system from decimal to binary
      SendKeys.SendWait("{F8}");
 
      // Show the decimal result via the text on the clipboard
      // and the corresponding binary value by accessing the text of the Edit TextBox
      textBoxResult1.Text = "543 + 67 = " + System.Windows.Forms.Clipboard.GetText() + " (dec)";
      textBoxResult2.Text = "543 + 67 = " + (textBox.GetCurrentPattern(TextPattern.Pattern) as TextPattern).DocumentRange.GetText(-1) + " (bin)";
 
      // Close the Calculator application
      (window.GetCurrentPattern(WindowPattern.Pattern) as WindowPattern).Close();
    }
  }
}

The UI Automation framework does not support sending keystrokes, but it still can be done by calling the Send() or SendWait() methods of the SendKeys class which is a part of the System.Windows.Forms namespace.

UIAutomationHelper

As you have noticed, a lot of code is repeated when accessing controls. I’m not a big fan of helper classes but in this case it looks interesting to create a helper class with static methods to isolate some code.

Картинка с сайта: www.scip.be

public static class UIAutomationHelper
{
  public static AutomationElement LaunchApplication(string fileName)
  {
    return LaunchApplication(fileName, "");
  }
 
  public static AutomationElement LaunchApplication(string fileName, string arguments)
  {
    Process process = new Process();
    process.StartInfo.FileName = fileName;
    process.StartInfo.Arguments = arguments;
    process.Start();
    process.WaitForInputIdle(1000);
    return (AutomationElement.FromHandle(process.MainWindowHandle));
  }
 
  public static AutomationElement GetElementByName(AutomationElement window, string name)
  {
    if (window == null)
      return null;
 
    return window.FindFirst(TreeScope.Descendants,
      new PropertyCondition(AutomationElement.NameProperty, name));
  }
 
  public static AutomationElement GetElementById(AutomationElement window, string id)
  {
    if (window == null)
      return null;
 
    return window.FindFirst(TreeScope.Descendants,
      new PropertyCondition(AutomationElement.AutomationIdProperty, id));
  }
 
  public static bool InvokeElementByName(AutomationElement window, string name)
  {
    return InvokeElement(window, new PropertyCondition(AutomationElement.NameProperty, name)); 
  }
 
  public static bool InvokeElementById(AutomationElement window, string id)
  {
    return InvokeElement(window, new PropertyCondition(AutomationElement.AutomationIdProperty, id)); 
  }
 
  public static bool InvokeElement(AutomationElement window, System.Windows.Automation.Condition condition)
  {
    if (window == null)
      return false;
 
    AutomationElement element = window.FindFirst(TreeScope.Descendants, condition);
    if (element != null)
    {
      InvokePattern pattern = element.GetCurrentPattern(InvokePattern.Pattern) as InvokePattern;
      pattern.Invoke();
      return true;
    }
 
    return false;
  }
}

The next example shows the source code when using my UIAutomationHelper class. The code is more compact and more readable. Of course the final result is still the same.

private void ButtonAutomateHelper_Click(object sender, RoutedEventArgs e)
{
  // Launch Windows Calculator (calc.exe) and find the main window
  AutomationElement window = UIAutomationHelper.LaunchApplication("calc");
 
  // Get a reference to the Edit TextBox (AutomationId = "403")
  AutomationElement textBox = UIAutomationHelper.GetElementById(window, "403");
 
  // Get a reference to the RadioButton "Dec" (AutomationId = "307")
  AutomationElement radioButtonDecimal = UIAutomationHelper.GetElementById(window, "307");
  // If this RadioButton can not be found, the calculator uses the Standard view
  // Call the Scientfic/Wetenschappelijk menu to make more options visible
  if (radioButtonDecimal == null)
  {
    AutomationElement menuItemView = UIAutomationHelper.GetElementById(window, "Item 2");
    if (menuItemView != null)
    {
      ExpandCollapsePattern pattern = menuItemView.GetCurrentPattern(ExpandCollapsePattern.Pattern) as ExpandCollapsePattern;
      pattern.Expand();
    }
    UIAutomationHelper.InvokeElementById(window, "Item 304");
  }
 
  // Press F6 to make sure we are using the decimal numerical system
  SendKeys.SendWait("{F6}");
 
  // Focus the Edit TextBox and enter the text 54 
  textBox.SetFocus();
  Thread.Sleep(100);
  SendKeys.SendWait("45");
 
  // Press button "3" (AutomationId = "127") so the value will be 543
  UIAutomationHelper.InvokeElementById(window, "127");
 
  // Press the "+" button (AutomationId = "92")
  UIAutomationHelper.InvokeElementById(window, "92");
 
  // Enter the second value. Press button "6" (AutomationId = "130")
  UIAutomationHelper.InvokeElementById(window, "130");
 
  // Enter the second value. Press button "7" (AutomationId = "131")
  UIAutomationHelper.InvokeElementById(window, "131");
 
  // Press the "=" button to calculate the result (AutomationId = "112")
  UIAutomationHelper.InvokeElementByName(window, "=");
 
  // Focus the Edit TextBox again and copy the result to the clipboard
  // by sending the keyboard combination CTRL+C
  textBox.SetFocus();
  Thread.Sleep(100);
  SendKeys.SendWait("^C");
 
  // Press F8 to change the numerical system from decimal to binary
  SendKeys.SendWait("{F8}");
 
  // Show the decimal result via the text on the clipboard
  // and the corresponding binary value by accessing the text of the Edit TextBox
  textBoxResult1.Text = "543 + 67 = " + System.Windows.Forms.Clipboard.GetText() + " (dec)";
  textBoxResult2.Text = "543 + 67 = " + (textBox.GetCurrentPattern(TextPattern.Pattern) as TextPattern).DocumentRange.GetText(-1) + " (bin)";
 
  // Close the Calculator application
  (window.GetCurrentPattern(WindowPattern.Pattern) as WindowPattern).Close();
}

Compared to the White example, this application is a lot faster. The UI Automation framework is more complex but also more advanced. Furthermore it supports some very nice features like subscribing to events.

Subscribing to events

The AddAutomationEventHandler() and RemoveAutomationEventHandler() methods of the static Automation class can be used to subscribe or unsubscribe to events like InvokePattern.InvokedEvent, AutomationElement.MenuOpenedEvent, TextPattern.TextChangedEvent, WindowPattern.WindowOpenedEvent, WindowPattern.WindowClosedEvent, …

The next example will demonstrate how to subscribe to events of the Calculator. The log in our WPF Window will be updated when clicking the operator buttons (+, -, /, *, =) or when closing the Calculator application.

private void ButtonEvents_Click(object sender, RoutedEventArgs e)
{
  listBoxEventLog.Items.Clear();
 
  AutomationElement window = UIAutomationHelper.LaunchApplication("calc");
 
  // Subscribe to WindowClosedEvent. OnApplicationClose will be triggered
  Automation.AddAutomationEventHandler(WindowPattern.WindowClosedEvent, 
    window, TreeScope.Element, OnApplicationClose);
 
  // Subscribe to InvokedEvent of '=' button. OnEqualsClick will be triggered
  Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, 
    UIAutomationHelper.GetElementByName(window, "="), TreeScope.Element, OnEqualsClick);
 
  // Subscribe to InvokedEvent of operator buttons. OnUIAutomationEvent will be triggered
  Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, 
    UIAutomationHelper.GetElementByName(window, "+"), TreeScope.Element, OnUIAutomationEvent);
  Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, 
    UIAutomationHelper.GetElementByName(window, "-"), TreeScope.Element, OnUIAutomationEvent);
  Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, 
    UIAutomationHelper.GetElementByName(window, "*"), TreeScope.Element, OnUIAutomationEvent);
  Automation.AddAutomationEventHandler(InvokePattern.InvokedEvent, 
    UIAutomationHelper.GetElementByName(window, "/"), TreeScope.Element, OnUIAutomationEvent);
}
 
private void OnApplicationClose(object sender, AutomationEventArgs e)
{
  // Use the Dispatcher Invoke method to access the UI thread.
  // If you don't use this, a System.InvalidOperationException 
  // (The calling thread cannot access this object because a different thread owns it)
  // will be raised
  this.Dispatcher.Invoke(DispatcherPriority.Normal, (MethodInvoker)(() =>
  {
    listBoxEventLog.Items.Add("Close window");
  }));
}
 
private void OnEqualsClick(object sender, AutomationEventArgs e)
{ 
  this.Dispatcher.Invoke(DispatcherPriority.Normal, (MethodInvoker)(() =>
  {
    listBoxEventLog.Items.Add("Click button '=' ");
  }));
}
 
private void OnUIAutomationEvent(object sender, AutomationEventArgs e)
{
  // Get source element
  AutomationElement sourceElement = sender as AutomationElement;
 
  if (e.EventId == InvokePattern.InvokedEvent)
  {
    this.Dispatcher.Invoke(DispatcherPriority.Normal, (MethodInvoker)(() =>
    {
      // Log some info like ControlType, AutomationId, Name and Event
      listBoxEventLog.Items.Add(string.Format("ControlType={0} - AutomationId={1} - Name='{2}' - Event={3}",
        sourceElement.Current.ControlType.LocalizedControlType,
        sourceElement.Current.AutomationId,
        sourceElement.Current.Name,
        e.EventId.ProgrammaticName));
    }));
  }
}

Картинка с сайта: www.scip.be

I hope you like these examples and that this will encourage you to take a closer look at WPF UIAutomation. The UI Automation framework can be very useful when integrating your application with other applications which do no have a COM interface.

It is also used a lot in automated test frameworks. If you’re interested in UI testing, then you have to take a look at the open-source UI Automation Verify (UIA Verify) Test Automation Framework

Remarks or ideas, just let me know.