No description, website, or topics provided.
Switch branches/tags
Nothing to show
Clone or download
Latest commit a2364a1 May 8, 2018
Type Name Latest commit message Commit time
Failed to load latest commit information.
Project version up. change nuspec document. May 1, 2018
.gitignore add icon May 1, 2018
FriendlyNuget128.png add icon May 1, 2018
LICENSE 作成 Mar 13, 2014 Edit readme. May 8, 2018


Friendly is library for to multiple other process. It support desktop app and UWP. Please read next urls.

For desktop apps.

For UWP.


Friendly is a library for creating integration tests. (The included tools can be useful, but these are only a bonus.) It is currently designed for Windows Applications (WinForms, WPF, and Win32). It can be used to start up a product process and run tests on it.. However, the way of operating the target program is different from conventional automated GUI tests (capture replay tool, etc.).

Features ...

Invoke separate process's API.

It can invoke all methods, properties, and fields. It's like a selenium's javascript execution.

DLL injection.

It can inject .net assembly. And can execute inserted methods.

Getting Started

Install Friendly.Windows from NuGet

PM> Install-Package Codeer.Friendly.Windows


Simple sample

The following samples are from / here downloadable.
Here is some sample code to show how you can get started with Friendly. This is a perfect ordinary Windows Application that is manipulation target. (There is no kind of trick.)

<Window x:Class="Target.MainWindow"
        Title="MainWindow" Height="350" Width="525">
        <TextBox x:Name="_textBox" Text="{Binding Path=TextData}"/>
using System.ComponentModel;
using System.Windows;

namespace Target
    public partial class MainWindow : Window
        public MainWindow()
            this.DataContext = new VM();

        string MyFunc(int value)
            return value.ToString();

    class VM : INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged = (_, __) => { };

        string _textData;
        public string TextData
            get { return _textData; }
                _textData = value;
                PropertyChanged(this, new PropertyChangedEventArgs(nameof(TextData)));

This is a test application (using VSTest):

using Codeer.Friendly.Dynamic;
using Codeer.Friendly.Windows;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Diagnostics;
using System.IO;
using System.Windows;

namespace Sample
    public class Test
        WindowsAppFriend _app;

        public void TestInitialize()
            //attach to target process!
            var path = Path.GetFullPath("../../../Target/bin/Debug/Target.exe");
            _app = new WindowsAppFriend(Process.Start(path));

        public void TestCleanup()
            Process process = Process.GetProcessById(_app.ProcessId);

        public void Manipulate()
            //static method
            dynamic window = _app.Type<Application>().Current.MainWindow;

            //instance method
            string value = window.MyFunc(5);
            Assert.AreEqual("5", value);

            //instance property
            window.DataContext.TextData = "abc";

            //instance field.
            string text = window._textBox.Text;
            Assert.AreEqual("abc", text);

Match the Processor Architecture. (x86 or x64)

The target and test processes must use the same processor architectue. If you are using VSTest, you can set this by using the Visual Studio menus as shown below. Match the Processor Architecture

Using Statements

using Codeer.Friendly;
using Codeer.Friendly.Dynamic;
using Codeer.Friendly.Windows;

Connection to Execution Thread

Attach using WindowsAppFriend. Operations can be executed on the main window thread:

public WindowsAppFriend(Process process);

Operation can also be executed on a specified window thread:

public WindowsAppFriend(IntPtr windowHandle);

Invoking Static Operations(Any OK)

dynamic sampleForm1 = _app.Type<Application>().Current.MainWindow;

dynamic sampleForm2 = _app.Type(typeof(Application)).Current.MainWindow;

dynamic sampleForm3 = _app.Type().System.Windows.Forms.Application.Current.MainWindow;

dynamic sampleForm4 = _app.Type("System.Windows.Forms.Application").Current.MainWindow;

dynamic sampleForm5 = _app.Type<Control>().FromHandle(handle);

Invokeing Instance Operations

string value = window.MyFunc(5);

window.DataContext.TextData = "abc";

string text = window._textBox.Text;

Variables are referenced from the target process. You can access public and private members.

Instantiating New Objects(Any OK)

dynamic listBox1 = _app.Type<ListBox>()();

dynamic listBox2 = _app.Type(typeof(ListBox))();

dynamic listBox3 = _app.Type().System.Windows.Controls.ListBox();

dynamic listBox4 = _app.Type(" System.Windows.Controls.ListBox")();

dynamic list = _app.Type<List<int>>()(new int[]{1, 2, 3, 4, 5});

Rules for Arguments

You can use serializable objects and reference them in the target process. If you use serializable objects, they will be serialized and a copy will be sent to the target process. // get SampleForm reference from the target process. dynamic sampleForm = _app.Type().OpenForms[0];

// serializable object
window.DataContext.TextData = "abc";

// new instance in target process.
dynamic textBox = _app.Type<TextBox>()();

// reference to target process

Rules for Return Values

// referenced object exists in target process' memory. 
dynamic reference = window._textBox.Text;

// when you perform a cast, it will be marshaled from the target process.
string text = reference;

Note the Casting Behavior

// OK
string cast = (string)reference;

// OK
string substitution = reference;

// No good. Result is false.
bool isString = reference is string;

// No good. Result is null.
string textAs = reference as string;

// No good. Throws an exception.

// OK

Special Casts


foreach (var w in _app.Type<Application>().Current.Windows)


dynamic window = _app.Type<Application>().Current.MainWindow;

AppVar appVar = window;

AppVar is part of the old style interface. You will need to use AppVar if you use the old interface or if you can't use the .NET framework 4.0. The old style sample code is pending translation, but the code is in C#. Please have a look here if you are interested.

Async Friendly operations are executed synchronously. But you can use the Async class to execute them asynchronously.

// Async can be specified anywhere among the arguments.
var async = new Async();
window.MyFunc(async, 5);

// You can check whether it has completed.
if (async.IsCompleted)

// You can wait for it to complete.

Return Values

// Invoke getter.
var async = new Async();

// Text will obtain its value when the operation completes.
var text = window.MyFunc(async, 5);

// When the operation finishes, the value will be available.
string textValue = (string)text;

Copy() and Null()

Dictionary<int, string> dic = new Dictionary<int, string>();
dic.Add(1, "1");

// Object is serialized and a copy will be sent to the target process 
dynamic dicInTarget = _app.Copy(dic);
// Null is useful for out arguments
dynamic value = _app.Null();
dicInTarget.TryGetValue(1, value);
Assert.AreEqual("1", (string)value);

Dll injection.

public void DllInjection()
    dynamic window = _app.Type<Application>().Current.MainWindow;
    dynamic textBox = window._textBox;

    //The code let tasrget process load current assembly.
    WindowsAppExpander.LoadAssembly(_app, GetType().Assembly);

    //You can use class defined in current assembly.
    dynamic observer = _app.Type<Observer>()(textBox);

    //Check change text.
    textBox.Text = "abc";

class Observer
    internal bool TextChanged { get; set; }
    internal Observer(TextBox textBox)
        textBox.TextChanged += delegate { TextChanged = true; };

Native dll methods.

public void DllInjectionPInvoke()
    WindowsAppExpander.LoadAssembly(_app, GetType().Assembly);

    Process process = Process.GetProcessById(_app.ProcessId);
    _app.Type(GetType()).MoveWindow(process.MainWindowHandle, 0, 0, 200, 200, true);

    dynamic rectInTarget = _app.Type<RECT>()();
    _app.Type(GetType()).GetWindowRect(process.MainWindowHandle, rectInTarget);
    RECT rect = (RECT)rectInTarget;

    Assert.AreEqual(0, rect.left);
    Assert.AreEqual(200, rect.right);
    Assert.AreEqual(200, rect.bottom);

static extern bool MoveWindow(IntPtr handle, int x, int y, int width, int height, bool redraw);

[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect);

internal struct RECT
    public int left;
    public int top;
    public int right;
    public int bottom;

Upper Librarys

Upper Librarys

We win 2nd place at MVP Showcase. Thank you!