.NET – Code musings in C#

Always run Visual Studio as administrator on Windows 10

You might be working with a program that always require administrator privileges, such as a service listening on a port. Up to Windows 10, you just right clicked the devenv exe, and checked “always run as administrator” in the compatibility tab. But in Windows 10, the compatibility tab is missing for the Visual Studio exe. Why? No idea. But here’s how to fix it.

To just run the shortcut as admin : right click on the sortcut > in the “properties” tab, click “advanced”, then check “always run as administrator”. Simple, fast, easy.

If you want to run Visual Studio as administrator also when opening a .sln or .csproj file, it’s not so easy. Here are the logical, coherent, and easy to find steps to fix this: (labels translated to english from french, sorry if it doesn’t match)

Open the start menu, type “troubleshoot”, and open “check your computer state and solve problems”
On the bottom left, click “troubleshoot compatibility problems”
Click on “advanced” on the left then “run as administrator”
Click again on “advanced”, then uncheck “automatically fix”, then “next”
Search for Visual Studio in the list, then “next”
Make sure “fix the program” is checked, then “next”
Select “troubleshoot the program” (bottom option)
Check “the program requires additional rights”, then “next”
Click “test the programe” then “next”
Select “save the parameters for the program” then “close”

Easy, logical, simple. Thanks Microsoft!

Unit testing MongoDB queries

When writing unit tests, it’s common to stop at the database access layer.
You might have a “dumb” data access layer that just passes stored procedure names and parameters to the SQL database, for instance.
It’s usually very hard to test this layer, since it requires either that your build server has access to a SQL Server instance, or that a SQL Server is running on the build server.
Plus, we’re getting out of unit tests and are entering integration tests, here.

Using a more advanced tool like Entity Framework, in order to test your complex EF queries, there are usually methods to insert fake data into a fake container, like Test Doubles, InMemory, or Effort.

Using MongoDB, you might encounter the same problem : how do I test that my complex queries are working ?

Here for instance, I get the possible colors of a product; how do I know it works using unit tests?

public IEnumerable<Color> GetColors(string productId) {
	var coll = db.GetCollection<BsonDocument>("products");
	var aggregate = coll.Aggregate(new AggregateOptions { AllowDiskUse = true })
		.Match(new BsonDocument { { "ProductId", productId }, { "Color", new BsonDocument("$ne", "") } })
		.Unwind(new StringFieldDefinition<BsonDocument>("Color"))
		.Group(new BsonDocument { { "_id", "$Color" }, { "Count", new BsonDocument("$sum", 1) } })
		.Sort(Builders<BsonDocument>.Sort.Descending("Count"))
		.Limit(100);

	return aggregate
		.ToList()
		.Select(doc => new Color { ColorValue = doc["_id"].AsString, Count = doc["Count"].AsInt32 });
}

public IEnumerable<Color> GetColors(string productId) {

var coll = db.GetCollection<BsonDocument>("products");

var aggregate = coll.Aggregate(new AggregateOptions { AllowDiskUse = true })

.Match(new BsonDocument { { "ProductId", productId }, { "Color", new BsonDocument("$ne", "") } })

.Unwind(new StringFieldDefinition<BsonDocument>("Color"))

.Group(new BsonDocument { { "_id", "$Color" }, { "Count", new BsonDocument("$sum", 1) } })

.Sort(Builders<BsonDocument>.Sort.Descending("Count"))

.Limit(100);

return aggregate

.ToList()

.Select(doc => new Color { ColorValue = doc["_id"].AsString, Count = doc["Count"].AsInt32 });

}

MongoDB has an “inMemory” storage engine, but it’s reserved to the (paid) Enterprise edition. Fortunately, since 3.2, even the Community edition has a not-very-well-documented “ephemeralForTests” storage engine, which loads up an in-memory Mongo instance, and does not store anything on the hard drive (but has poor performances). Exactly what we need!

Before running the data access layer tests, we will need to fire up an in-memory instance of MongoDB.
This instance will be common to all the tests for the layer, otherwise the test runner will fire up new tests faster than the system releases resources (file and ports locks).

You will have to extract the MongoDB binaries in your sources repository somewhere, and copy them besides your binaries on build.

The following wrapper provides a “Query” method that allows us to access the Mongo instance through command-line, bypassing the data access layer, in order to insert test data or query insertion results.

public class MongoDaemon : IDisposable {
	public const string ConnexionString = "mongodb://localhost:27017";
	public const string DbName = "test";
	public const string Host = "localhost";
	public const string Port = "27017";
	private readonly string assemblyFolder;
	private readonly string dbFolder;
	private readonly string mongoFolder;
	private Process process;

	public MongoDaemon() {
		this.assemblyFolder = Path.GetDirectoryName(new Uri(typeof(MongoDaemon).Assembly.CodeBase).LocalPath);
		this.mongoFolder = Path.Combine(this.assemblyFolder, "mongo");
		this.dbFolder = Path.Combine(this.mongoFolder, "temp");

		// re-create db folder if it exists
		if (Directory.Exists(this.dbFolder)) {
			Directory.Delete(this.dbFolder, true);
			Directory.CreateDirectory(this.dbFolder);
		}

		this.process = new Process();
		process.StartInfo.FileName = Path.Combine(this.mongoFolder, "mongod.exe");
		process.StartInfo.Arguments = "--dbpath " + this.dbFolder + " --storageEngine ephemeralForTest";
		process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
		process.Start();
	}

	public void Dispose() {
		Dispose(true);
		GC.SuppressFinalize(this);
	}

	public string Query(string query) {
		var output = string.Empty;

		var procQuery = new Process {
			StartInfo = new ProcessStartInfo {
				FileName = Path.Combine(this.mongoFolder, "mongo.exe"),
				Arguments = string.Format("--host {0} --port {1} --quiet --eval \"{2}\"", Host, Port, query),
				UseShellExecute = false,
				RedirectStandardOutput = true,
				CreateNoWindow = true
			},
		};

		procQuery.Start();

		// read query output
		while (!procQuery.StandardOutput.EndOfStream) {
			output += procQuery.StandardOutput.ReadLine() + "\n";
		}

		// wait 2 seconds max before killing it
		if (!procQuery.WaitForExit(2000)) {
			procQuery.Kill();
		}

		return output;
	}

	protected virtual void Dispose(bool disposing) {
		if (disposing) {
			// dispose managed resources
		}

		if (process != null && !process.HasExited) {
			process.Kill();
		}
	}
}

public class MongoDaemon : IDisposable {

public const string ConnexionString = "mongodb://localhost:27017";

public const string DbName = "test";

public const string Host = "localhost";

public const string Port = "27017";

private readonly string assemblyFolder;

private readonly string dbFolder;

private readonly string mongoFolder;

private Process process;

public MongoDaemon() {

this.assemblyFolder = Path.GetDirectoryName(new Uri(typeof(MongoDaemon).Assembly.CodeBase).LocalPath);

this.mongoFolder = Path.Combine(this.assemblyFolder, "mongo");

this.dbFolder = Path.Combine(this.mongoFolder, "temp");

// re-create db folder if it exists

if (Directory.Exists(this.dbFolder)) {

Directory.Delete(this.dbFolder, true);

Directory.CreateDirectory(this.dbFolder);

}

this.process = new Process();

process.StartInfo.FileName = Path.Combine(this.mongoFolder, "mongod.exe");

process.StartInfo.Arguments = "--dbpath " + this.dbFolder + " --storageEngine ephemeralForTest";

process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;

process.Start();

}

public void Dispose() {

Dispose(true);

GC.SuppressFinalize(this);

}

public string Query(string query) {

var output = string.Empty;

var procQuery = new Process {

StartInfo = new ProcessStartInfo {

FileName = Path.Combine(this.mongoFolder, "mongo.exe"),

Arguments = string.Format("--host {0} --port {1} --quiet --eval \"{2}\"", Host, Port, query),

UseShellExecute = false,

RedirectStandardOutput = true,

CreateNoWindow = true

};

procQuery.Start();

// read query output

while (!procQuery.StandardOutput.EndOfStream) {

output += procQuery.StandardOutput.ReadLine() + "\n";

}

// wait 2 seconds max before killing it

if (!procQuery.WaitForExit(2000)) {

procQuery.Kill();

}

return output;

}

protected virtual void Dispose(bool disposing) {

if (disposing) {

// dispose managed resources

}

if (process != null && !process.HasExited) {

process.Kill();

}

We’re using the IClassFixture interface of xUnit to fire up a MongoDaemon instance that will be common to all our tests using it.
It means we need to clean up previously inserted test data at each run.

public class MongoDataStoreTests : IClassFixture<MongoDaemon> {
	private readonly MongoDaemon daemon;
	private readonly DataStore sut;

	public MongoDataStoreTests(MongoDaemon daemon) {
		this.daemon = daemon;
		this.sut = new DataStore("localhost", 27017);

		// cleanup previous tests data
		this.daemon.Query("db.products.drop()");
	}

	[Fact]
	public void Colors_are_counted() {
		// arrange : insert test data
		var id = "test";
		var nb = 5;
		for (int i = 0; i < nb; i++) {
			var color = string.Format("{0}{0}{0}", i, i, i);
			var data = "{ ProductId: '" + id + "', Color: '" + color + "' }";
			this.daemon.Query("db.products.insertOne(" + data + ")");
		}

		// act
		var result = this.sut.GetColors(id);

		// assert
		result.Should().HaveCount(nb);
	}
}

public class MongoDataStoreTests : IClassFixture<MongoDaemon> {

private readonly MongoDaemon daemon;

private readonly DataStore sut;

public MongoDataStoreTests(MongoDaemon daemon) {

this.daemon = daemon;

this.sut = new DataStore("localhost", 27017);

// cleanup previous tests data

this.daemon.Query("db.products.drop()");

}

[Fact]

public void Colors_are_counted() {

// arrange : insert test data

var id = "test";

var nb = 5;

for (int i = 0; i < nb; i++) {

var color = string.Format("{0}{0}{0}", i, i, i);

var data = "{ ProductId: '" + id + "', Color: '" + color + "' }";

this.daemon.Query("db.products.insertOne(" + data + ")");

}

// act

var result = this.sut.GetColors(id);

// assert

result.Should().HaveCount(nb);

}

There you have it: a kind-of-easy way to test your Mongo data access layer.

Modify copy/paste format depending on target

Sometimes you want to copy tabular data, and paste it differently depending on the target. For instance, you want CSV when you paste in your text editor, and HTML when you paste it in an email.

Fortunately, some nice fellow has created a helper class to handle all that for you. And it’s even available on GitHub!

To sum it up, the Clipboard class has a SetDataObject method. A DataObject can get multiple contents (with different DataFormats) through multiple calls of the SetData(string, object) method.
So basically, you should create a DataObject, then call SetData once with the HTML, and once with text. The trick is that the HTML needs special formatting to work.

Start a WPF application in the notification area with Caliburn.Micro

Sometimes you’re writing a quick utility app that you wish to start directly in the notification area (near the clock), and not display anything on startup.
It’s actually very simple using Caliburn.Micro.

You probably already have customized your application bootstrapper already. All you have to do is modify the OnStartup method from DisplayRootViewFor<T> to displaying a custom tooltip. Here I’m using the Hardcodet.NotifyIcon.Wpf Nuget package:

protected override void OnStartup(object sender, StartupEventArgs e)
{
	TaskbarIcon tbi = new TaskbarIcon();
	tbi.Icon = Properties.Resources.sql_icon;
	tbi.ToolTipText = Properties.Resources.ToolTip;
}

protected override void OnStartup(object sender, StartupEventArgs e)

{

TaskbarIcon tbi = new TaskbarIcon();

tbi.Icon = Properties.Resources.sql_icon;

tbi.ToolTipText = Properties.Resources.ToolTip;

}

It seems obvious in retrospect, but it took me a while to find this, because I don’t modify the app bootstrapper often, so I forgot about this method.

Don’t forget to add behavior to this icon! Double-click, context menu…

I have created a Caliburn.Micro + MahApps template app if you wish a starting point : https://github.com/cosmo0/Caliburn.MahApps.Metro.Template

Mapping DataTables to domain objects

It’s always a pain to work with DataTables and DataSets. You’re always typing these pesky column names, it doesn’t necessarily represents the actual data model (if there are nested data), there is no type safety until runtime, it’s pretty hard to use Linq on your results… the list goes on.

Fortunately, there is a simple solution: AutoMapper. It’s very simple to cast a DataTable to a list of objects:

public class Person {
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Person> people = AutoMapper.Mapper.DynamicMap<IDataReader, List<Person>>(
    sourceDataTable.CreateDataReader());

public class Person {

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

}

List<Person> people = AutoMapper.Mapper.DynamicMap<IDataReader, List<Person>>(

sourceDataTable.CreateDataReader());

Mocking static methods

I’m working on a pretty old application with no unit tests whatsoever, and I’m trying to write some as I add features and fix bugs.

After successively finding out about MS Fakes, then that it’s only included in VS2012+ Premium/Ultimate and very hard to include in a continuous integration chain, I was pretty stumped until I found this, which works incredibly well.

Another option to transform the static method into a static Func or Action. For instance.

Original code:

C#

class Math { public static int Add(int x, int y) { return x + y; } }

1
2
3
4
5
6
7
8

class Math
{
    public static int Add(int x, int y)
    {
        return x + y;
    }
}

You want to “mock” the Add method, but you can’t. Change the above code to this:

C#

public static Func<int, int, int> Add = (x, y) => { return x + y; };

1
2
3
4
5

public static Func<int, int, int> Add = (x, y) =>
{
    return x + y;
};

Existing client code doesn’t have to change (maybe recompile), but source stays the same.

Now, from the unit-test, to change the behavior of the method, just reassign an in-line function to it:

C#

[TestMethod] public static void MyTest() { Math.Add = (x, y) => { return 11; }; }

1
2
3
4
5
6
7
8
9

[TestMethod]
public static void MyTest()
{
    Math.Add = (x, y) =>
    {
        return 11;
    };
}

Put whatever logic you want in the method, or just return some hard-coded value, depending on what you’re trying to do.

This may not necessarily be something you can do each time, but in practice, I found this technique works just fine.

C, C++ and C++/CLI cheat sheet

No explanation of the basic concepts, just a memory help when you don’t use C/C++ frequently, or if you’re a beginner with some bases.

First question: why pointers? Answers: because functions arguments are passed by value in C and C++. Because arrays and strings are crazy in C.

How to read pointers

Here is a handy way of remembering how pointers syntax works.

In variable declaration

Go from the right to the left of the declaration, from the innermost parenthesis, going back to the right when hitting “)”

Read the name of the declaration
* is “a pointer to”
[] is “an array of”
() is “a function returning”
Finally, read the type

int *p[]; reads “p is an array of pointers to int”.
int *(*foo())(); reads “foo is a function returning a pointer to a function returning a pointer to int”.

In variable usage

Variable usage reads from left to right.

Determine “get” (read variable) or “set” (write variable)
* is “the value pointed to by”
& is “the address of”
[i] is “the element at position i”
Read the variable name

*p = 5;  reads “set the value pointed to by p”.
x = &i;  reads “get the address of i”.
printf("%i", *foo[0]);  reads “get the value pointed to by the element at position 0 of foo”.

C pointers

Manipulating a variable through a pointer is called dereferencing. It is used through an indirection expression.
Manipulating pointers through variables is called decaying.

Given an integer:

int i = 42;

1	int i = 42;

Create an pointer:

int* p = &i; // or int *p = &i; // preferred syntax

1
2
3

int* p = &i;
// or
int *p = &i; // preferred syntax
Get the memory location of the variable:

printf("%i", p); // or printf("%i", &i); // or pritf("%i", &*p); // get the address of the value pointed to by p

1
2
3
4
5

printf("%i", p);
// or
printf("%i", &i);
// or
pritf("%i", &*p); // get the address of the value pointed to by p
Get the value of the variable:

printf("%i", i); // or printf("%i", *p); // or printf("%i", *&*&*&*p); // if you want to be stupid

1
2
3
4
5

printf("%i", i);
// or
printf("%i", *p);
// or
printf("%i", *&*&*&*p); // if you want to be stupid
Set the value of the variable:

i = 42; // or *p = 42;

1
2
3

i = 42;
// or
*p = 42;
Setting a pointer to null allows to assign it to a variable later:

int *p = NULL; if (p) { // use *p }

1
2
3
4

int *p = NULL;
if (p) {
// use *p
}

C arrays

Arrays mostly can’t be manipulated directly, but rather through pointers.
The variable array is, for most intents and purposes, a pointer to the first element of the array (until it’s incremented).

Given an array of integers:

int array[] = { 45, 67, 89 };

1	int array[] = { 45, 67, 89 };

This doesn’t really creates an array. It creates 3 integers side-by-side, and stores the memory location of the first one.
array == &array == &array[0]
When you pass an array as an argument to a function, you really pass a pointer to the array’s first element, because the array decays to a pointer.
Incrementing a pointer to an array really moves the pointer to the next element of the array (the pointer is incremented by the size of the type of the pointer).

array++; // now the "array" pointer points to the second element.

1

array++; // now the "array" pointer points to the second element.
The subscript operator (the [] in array[0]) has nothing to do with arrays themselves, you can also use it on a pointer:

int *ar_p = array; printf("%i", ar_p[0]); // outputs the memory location of the first element printf("%i", *ar_p[0]); // outputs the value of the first element

1
2
3

int *ar_p = array;
printf("%i", ar_p[0]); // outputs the memory location of the first element
printf("%i", *ar_p[0]); // outputs the value of the first element

C structures

Given a structure:

struct foo {
  char name[10];
  int result;
};

struct foo f; // note you have to specify "struct" in the declaration

struct foo {

char name[10];

int result;

};

struct foo f; // note you have to specify "struct" in the declaration

Accessing members of the structure through the variable:

f.result = 42; printf("%i", f.result); // outputs "42"

1
2

f.result = 42;
printf("%i", f.result); // outputs "42"
Accessing the members through a pointer:

struct foo *p = f; (*p).result = 42; // or p->result = 42; // using a pointer-to-member operator

1
2
3
4

struct foo *p = f;
(*p).result = 42;
// or
p->result = 42; // using a pointer-to-member operator

C++ references

C++ is much less in love with pointers than C, and prefers using reference variables. They are mostly used in the same way as pointers, but their address can’t change (they always points to the same variable).
The main usage of a reference variable is for function parameters, to pass the variables by reference (by default it’s by value), which allows to not use pointers.

Given an integer:

int i = 42;

1	int i = 42;

Create a reference to a variable with int &r = i; ; this is called binding a reference to an object
You do not need to dereference a reference to access the variable’s value:

i = 42; // or int &r = i; r = 42; // should generate about the same machine code as int *p = i; *p = 42;

1
2
3
4
5
6
7
8

i = 42;
// or
int &r = i;
r = 42;

// should generate about the same machine code as
int *p = i;
*p = 42;
To make sure the arguments are passed by reference in a method:

void foo(int &bar) { bar = 42; } // call it with the variable itself int i = 0; foo(i); printf("%i", i); // outputs 42

1
2
3
4
5
6
7
8

void foo(int &bar) {
bar = 42;
}

// call it with the variable itself
int i = 0;
foo(i);
printf("%i", i); // outputs 42
On the other hand, the same method using pointers must be passed the variables by reference in the call:

void foo(int *bar) { *bar = 42; } // call it with the references to the variable foo(&i);

1
2
3
4
5
6

void foo(int *bar) {
*bar = 42;
}

// call it with the references to the variable
foo(&i);

Managed instances

Instances of managed objects should be used through handles ( ^ , also called “hat”). It can be read “is a handle to the instance of the managed class”. Then, you use the handle as if it was the actual instance.

Note that, even though you don’t have to use managed objects in C++/CLI, you have to declare instances of managed objects with a handle.

public ref class Foo {
  int result; // native member
  System::String^ name; // managed member
};

// while the convention for pointers is to prefix "*" to the pointer name,
// the convention for handles is to suffix "^" to the class name
Foo^ f = gcnew Foo();
printf("%s", f.name);

public ref class Foo {

int result; // native member

System::String^ name; // managed member

};

// while the convention for pointers is to prefix "*" to the pointer name,

// the convention for handles is to suffix "^" to the class name

Foo^ f = gcnew Foo();

printf("%s", f.name);

Managed pointers

Because of garbage collection (which changes memory addresses), you can’t just use a regular C/C++ pointer to a managed objects. The managed pointers are called interior pointers. A good overview can be found here.

The syntax for interior pointers is very… declarative:

interior_ptr<int> p = &f->result;

1	interior_ptr<int> p = &f->result;

Native pointers are automatically converted to interior pointers (the inverse is not true):

void foo(interior_ptr<int> i) {
  *i = 42;
}

foo(&f->result); // passing a native pointer to the method

void foo(interior_ptr<int> i) {

*i = 42;

}

foo(&f->result); // passing a native pointer to the method

As with pointers in C++, usage interior pointers is not recommended, and you should rather use managed references.

Managed references

A managed reference is called a tracking reference and uses % instead of & .

void foo(int %i) {
  i = 42;
}

foo(f->result);

void foo(int %i) {

i = 42;

}

foo(f->result);

Managed pointers and references have some weirdness, for which this SO post goes into further details.

C++/CLI wrapping a C library: cheatsheet

Because once in a while I write a C++/CLI wrapper around a C library, but since I do it so infrequently I forget everything each time. Here is a list of pointers (haha) for common pitfalls and problems.

Compiling and debugging

You have to wrap the .h into an #ifdef __cplusplus extern “C” :

#ifdef __cplusplus
extern "C" {
#endif

// contents of the .h file

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

extern "C" {

#endif

// contents of the .h file

#ifdef __cplusplus

}

#endif

You also need to remove the /clr option for C files.
Right click your C files > Properties > C/C++ > General > Common Language RunTime Support > No CLR Support.

In your managed class, to include an unmanaged C header, use managed(push|pop)

#pragma managed(push, off)
#include "../../map_packer/packer.h"
#pragma managed(pop)

#pragma managed(push, off)

#include "../../map_packer/packer.h"

#pragma managed(pop)

Because Linux and Windows get along so well, you may also have to redefine a few C methods in your header file.

// Only for Visual C++
#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".
// see: stackoverflow.com/a/24435157/2354542
#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method
// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers
// but there is no security concern in my library, so I don't care much
inline long int random() {
    return rand();
}
#endif

// Only for Visual C++

#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".

// see: stackoverflow.com/a/24435157/2354542

#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method

// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers

// but there is no security concern in my library, so I don't care much

inline long int random() {

return rand();

}

#endif

If you wish to create a C# unit test project (using xUnit for instance), with Visual Studio 2012 and later, you will have to do a few things:

In the C++/CLI project’s properties, in Debugging, choose the Debugger Type “Mixed”
In the Visual Studio options, Debugging, check “Managed C++ Compatibility Mode” (in VS2012) / “Use Managed Compatibility Mode” (in VS2013).

To build using MSBuild, you may have to change the toolset to VS2012: project properties > General > Platform Toolset = Visual Studio 2012 (v110). And set the Configuration Type to Dynamic Library (.dll) while you’re at it.

Managed and unmanaged objects

gcnew instantiates a managed objects, which will be garbage collected. Always use it for the managed objects.

To easily call the native structures through managed classes, use the internal constructor and ToNative methods.

WPF Behaviors: adding mouse-event adorners

This is part 3 of the WPF drag & drop exploration. Part 2 can be found here.

Let’s recap what we have right now. We have a sample application that allow us to freely drag items across an area. Now, since there might be multiple items stacking on top of each other, we want the user to be sure which item will be moved. For that, we want to add a visual indication on the item. This kind of stuff is called an adorner in WPF.

Now, you will see many samples of code-driven adorners implementation. But we don’t want to break the MVVM pattern, and to do that, we want the adorner to be implemented in the view.

So we’ll create an Adorner that allows us to use a DataTemplate. For that, I’ll just copy some existing code :

public class TemplateAdorner : Adorner
{
    private readonly FrameworkElement frameworkElementAdorner;

    public TemplateAdorner(UIElement adornedElement, FrameworkElement frameworkElementAdorner) : base(adornedElement)
    {
        this.frameworkElementAdorner = frameworkElementAdorner;
        this.AddVisualChild(frameworkElementAdorner);
        this.AddLogicalChild(frameworkElementAdorner);
    }

    protected override int VisualChildrenCount { get { return 1; } }

    protected override Size ArrangeOverride(Size finalSize)
    {
        this.frameworkElementAdorner.Arrange(new Rect(new Point(0, 0), finalSize));
        return finalSize;
    }

    protected override Visual GetVisualChild(int index) { return this.frameworkElementAdorner; }

    protected override Size MeasureOverride(Size constraint)
    {
        this.frameworkElementAdorner.Width = constraint.Width;
        this.frameworkElementAdorner.Height = constraint.Height;

        return constraint;
    }
}

public class TemplateAdorner : Adorner

{

private readonly FrameworkElement frameworkElementAdorner;

public TemplateAdorner(UIElement adornedElement, FrameworkElement frameworkElementAdorner) : base(adornedElement)

{

this.frameworkElementAdorner = frameworkElementAdorner;

this.AddVisualChild(frameworkElementAdorner);

this.AddLogicalChild(frameworkElementAdorner);

}

protected override int VisualChildrenCount { get { return 1; } }

protected override Size ArrangeOverride(Size finalSize)

{

this.frameworkElementAdorner.Arrange(new Rect(new Point(0, 0), finalSize));

return finalSize;

}

protected override Visual GetVisualChild(int index) { return this.frameworkElementAdorner; }

protected override Size MeasureOverride(Size constraint)

{

this.frameworkElementAdorner.Width = constraint.Width;

this.frameworkElementAdorner.Height = constraint.Height;

return constraint;

}

We can now use this adorner in the behavior.

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
    // the mouse over adorner template property
    public static readonly DependencyProperty MouseOverAdornerTemplateProperty =
        DependencyProperty.Register(
            "MouseOverAdornerTemplate",
            typeof(DataTemplate),
            typeof(DragOnCanvasBehavior),
            new PropertyMetadata(new PropertyChangedCallback((d, o) =>
            {
                if (((DragOnCanvasBehavior)d).mouseOverAdornerControl != null)
                {
                    ((DragOnCanvasBehavior)d).mouseOverAdornerControl.ContentTemplate = (DataTemplate)o.NewValue;
                }
            })));
    
    // the template
    public DataTemplate MouseOverAdornerTemplate
    {
        get { return (DataTemplate)this.GetValue(MouseOverAdornerTemplateProperty); }
        set { this.SetValue(MouseOverAdornerTemplateProperty, value); }
    }

    // stores the adorner instance
    private TemplateAdorner mouseOverAdorner;

    // stores the visual control
    private ContentControl mouseOverAdornerControl;

    // whether the adorner is initialized
    private bool mouseOverAdornerInitialized = false;

    // whether the adorner is shown
    private bool mouseOverAdornerShown = false;

    // the commands to hide/show the adorner
    public ICommand HideMouseOverAdorner { get; private set; }
    public ICommand ShowMouseOverAdorner { get; private set; }

    // binds the commands with the methods
    public DragOnCanvasBehavior()
    {
        // [...]

        this.ShowMouseOverAdorner = new RelayCommand((o) =>
        {
            this.OnShowMouseOverAdorner();
        });

        this.HideMouseOverAdorner = new RelayCommand((o) =>
        {
            this.OnHideMouseOverAdorner();
        });
    }

    // shows the adorner
    private void OnShowMouseOverAdorner()
    {
        if (this.mouseOverAdornerShown)
        {
            return;
        }

        this.InitializeAdorner(this.MouseOverAdornerTemplate, ref this.mouseOverAdornerControl, ref this.mouseOverAdorner, ref this.mouseOverAdornerInitialized);

        this.mouseOverAdornerControl.Visibility = Visibility.Visible;
        this.mouseOverAdornerShown = true;
    }

    // hides the adorner
    private void OnHideMouseOverAdorner()
    {
        this.mouseOverAdornerControl.Visibility = Visibility.Collapsed;
        this.mouseOverAdornerShown = false;
    }

    // initializes an adorner (we'll need to reuse this later on)
    private void InitializeAdorner(DataTemplate template, ref ContentControl control, ref TemplateAdorner adorner, ref bool initialized)
    {
        if (initialized)
        {
            return;
        }

        if (template != null)
        {
            AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this.AssociatedObject as UIElement);

            if (adornerLayer == null)
            {
                throw new NullReferenceException(string.Format("No adorner found in attached object: {0}", this.AssociatedObject));
            }

            control = new ContentControl();
            adornerLayer.Add(adorner = new TemplateAdorner(this.AssociatedObject as UIElement, control));
            control.Content = template.LoadContent();

            Binding bindingMargin = new Binding("AdornerMargin");
            bindingMargin.Source = this;
            BindingOperations.SetBinding(adorner, ContentControl.MarginProperty, bindingMargin);
        }

        var dataContext = (this.AssociatedObject as FrameworkElement).DataContext;
        if (control.DataContext == null)
        {
            control.DataContext = dataContext;
        }

        control.Visibility = Visibility.Collapsed;

        initialized = true;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

// the mouse over adorner template property

public static readonly DependencyProperty MouseOverAdornerTemplateProperty =

DependencyProperty.Register(

"MouseOverAdornerTemplate",

typeof(DataTemplate),

typeof(DragOnCanvasBehavior),

new PropertyMetadata(new PropertyChangedCallback((d, o) =>

{

if (((DragOnCanvasBehavior)d).mouseOverAdornerControl != null)

{

((DragOnCanvasBehavior)d).mouseOverAdornerControl.ContentTemplate = (DataTemplate)o.NewValue;

}

})));

// the template

public DataTemplate MouseOverAdornerTemplate

{

get { return (DataTemplate)this.GetValue(MouseOverAdornerTemplateProperty); }

set { this.SetValue(MouseOverAdornerTemplateProperty, value); }

}

// stores the adorner instance

private TemplateAdorner mouseOverAdorner;

// stores the visual control

private ContentControl mouseOverAdornerControl;

// whether the adorner is initialized

private bool mouseOverAdornerInitialized = false;

// whether the adorner is shown

private bool mouseOverAdornerShown = false;

// the commands to hide/show the adorner

public ICommand HideMouseOverAdorner { get; private set; }

public ICommand ShowMouseOverAdorner { get; private set; }

// binds the commands with the methods

public DragOnCanvasBehavior()

{

// [...]

this.ShowMouseOverAdorner = new RelayCommand((o) =>

{

this.OnShowMouseOverAdorner();

});

this.HideMouseOverAdorner = new RelayCommand((o) =>

{

this.OnHideMouseOverAdorner();

});

}

// shows the adorner

private void OnShowMouseOverAdorner()

{

if (this.mouseOverAdornerShown)

{

return;

}

this.InitializeAdorner(this.MouseOverAdornerTemplate, ref this.mouseOverAdornerControl, ref this.mouseOverAdorner, ref this.mouseOverAdornerInitialized);

this.mouseOverAdornerControl.Visibility = Visibility.Visible;

this.mouseOverAdornerShown = true;

}

// hides the adorner

private void OnHideMouseOverAdorner()

{

this.mouseOverAdornerControl.Visibility = Visibility.Collapsed;

this.mouseOverAdornerShown = false;

}

// initializes an adorner (we'll need to reuse this later on)

private void InitializeAdorner(DataTemplate template, ref ContentControl control, ref TemplateAdorner adorner, ref bool initialized)

{

if (initialized)

{

return;

}

if (template != null)

{

AdornerLayer adornerLayer = AdornerLayer.GetAdornerLayer(this.AssociatedObject as UIElement);

if (adornerLayer == null)

{

throw new NullReferenceException(string.Format("No adorner found in attached object: {0}", this.AssociatedObject));

}

control = new ContentControl();

adornerLayer.Add(adorner = new TemplateAdorner(this.AssociatedObject as UIElement, control));

control.Content = template.LoadContent();

Binding bindingMargin = new Binding("AdornerMargin");

bindingMargin.Source = this;

BindingOperations.SetBinding(adorner, ContentControl.MarginProperty, bindingMargin);

}

var dataContext = (this.AssociatedObject as FrameworkElement).DataContext;

if (control.DataContext == null)

{

control.DataContext = dataContext;

}

control.Visibility = Visibility.Collapsed;

initialized = true;

}

Now, we just need to create the adorner’s DataTemplate, and wire up the events. We just have to add an AdornerDecorator in the controls tree, otherwise the adorner may get a random behavior (it would be attached to the window), or not work at all.

<ItemsControl.ItemTemplate>
    <DataTemplate>
        <AdornerDecorator>
            <Border
                x:Name="DraggableBorder">
                <!-- contents -->

                <i:Interaction.Behaviors>
                    <behaviors:DragOnCanvasBehavior
                        DraggableItem="{Binding}">
                        <behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>
                            <DataTemplate>
                                <Border
                                    DataContext="DraggableBorder"
                                    BorderBrush="Black"
                                    BorderThickness="3"
                                    Width="{Binding Path=Width}"
                                    Height="{Binding Path=Height}"></Border>
                            </DataTemplate>
                        </behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

                        <i:Interaction.Triggers>
                            <!-- Dragging events -->

                            <i:EventTrigger EventName="MouseEnter">
                                <i:InvokeCommandAction CommandName="ShowMouseOverAdorner" />
                            </i:EventTrigger>
                            <i:EventTrigger EventName="MouseLeave">
                                <i:InvokeCommandAction CommandName="HideMouseOverAdorner" />
                            </i:EventTrigger>
                        </i:Interaction.Triggers>
                    </behaviors:DragOnCanvasBehavior>
                </i:Interaction.Behaviors>
            </Border>
        </AdornerDecorator>
    </DataTemplate>
</ItemsControl.ItemTemplate>

<ItemsControl.ItemTemplate>

<Border

x:Name="DraggableBorder">

<i:Interaction.Behaviors>

<behaviors:DragOnCanvasBehavior

DraggableItem="{Binding}">

<behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

<Border

DataContext="DraggableBorder"

BorderBrush="Black"

BorderThickness="3"

Width="{Binding Path=Width}"

Height="{Binding Path=Height}"></Border>

</DataTemplate>

</behaviors:DragOnCanvasBehavior.MouseOverAdornerTemplate>

<i:Interaction.Triggers>

<i:EventTrigger EventName="MouseEnter">

<i:InvokeCommandAction CommandName="ShowMouseOverAdorner" />

</i:EventTrigger>

<i:EventTrigger EventName="MouseLeave">

<i:InvokeCommandAction CommandName="HideMouseOverAdorner" />

</i:EventTrigger>

</i:Interaction.Triggers>

</behaviors:DragOnCanvasBehavior>

</i:Interaction.Behaviors>

</Border>

</AdornerDecorator>

</DataTemplate>

</ItemsControl.ItemTemplate>

Note that from the adorner’s DataTemplate, we set the DataContext property, so that we can bind the adorner’s properties directly to the ones of the item view model.

Now, on mouse-over, a black border will appear, and will disappear when the mouse leaves. There are a few problems with this method: most notably, the adorner flickers when the mouse stays over it. But we’ll try to tackle them later on.

WPF Behaviors: switching to Windows.Interactivity.Behavior

This is part 2 of the WPF drag & drop exploration. Part 1 can be found here. Among other things, this CodeProject sample helped me much.

Yesterday I created a WPF behavior following WPF conventions for custom dependency properties. While trying to add an adorner to my item (more on that later), I noticed many samples were using System.Windows.Interactivity.Behavior<T>, which I thought was Blend-related, but apparently is not. Because it is much more concise to write and provides useful overridable methods, I decided to switch to it instead.
In addition, with the previous code, I had a problem when defining multiple dependency properties on my behavior, so I needed to find a way to solve this also.

The first thing is of course to inherit from Behavior<T>. You will find it in the System.Windows.Interactivity namespace, which is not included in .Net. You can grab it through the Blend SDK, in a Nuget package, or it’s included in MVVM frameworks like Caliburn.Micro or MVVM Light.

using System.Windows.Interactivity;

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
}

using System.Windows.Interactivity;

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

}

Then, we can remove the Getxxx and Setxxx methods, and replace them with an actual property (that does the same thing). We can also access the behavior instance from the dependency property variable, so we don’t need the instance singleton anymore. We will, however, need to attach the mouse events to the draggable item through ICommands. Since there are no standard ICommand implementation that we can use, we must create one ourselves. I have copied a “standard” implementation from CodeProject, and you will find many similar implementations if you do a quick Google search:

public class RelayCommand : ICommand
{
    private readonly Predicate<object> canExecute;
    private readonly Action<object> execute;

    public RelayCommand(Action<object> execute) : this(execute, DefaultCanExecute)
    {
    }

    public RelayCommand(Action<object> execute, Predicate<object> canExecute)
    {
        if (execute == null)
        {
            throw new ArgumentNullException("execute");
        }

        if (canExecute == null)
        {
            throw new ArgumentNullException("canExecute");
        }

        this.execute = execute;
        this.canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add
        {
            CommandManager.RequerySuggested += value;
        }
        remove
        {
            CommandManager.RequerySuggested -= value;
        }
    }

    public bool CanExecute(object parameter)
    {
        return this.canExecute != null && this.canExecute(parameter);
    }

    public void Execute(object parameter)
    {
        this.execute(parameter);
    }

    private static bool DefaultCanExecute(object parameter)
    {
        return true;
    }
}

public class RelayCommand : ICommand

{

private readonly Predicate<object> canExecute;

private readonly Action<object> execute;

public RelayCommand(Action<object> execute) : this(execute, DefaultCanExecute)

{

}

public RelayCommand(Action<object> execute, Predicate<object> canExecute)

{

if (execute == null)

{

throw new ArgumentNullException("execute");

}

if (canExecute == null)

{

throw new ArgumentNullException("canExecute");

}

this.execute = execute;

this.canExecute = canExecute;

}

public event EventHandler CanExecuteChanged

{

add

{

CommandManager.RequerySuggested += value;

}

remove

{

CommandManager.RequerySuggested -= value;

}

public bool CanExecute(object parameter)

{

return this.canExecute != null && this.canExecute(parameter);

}

public void Execute(object parameter)

{

this.execute(parameter);

}

private static bool DefaultCanExecute(object parameter)

{

return true;

}

This command will be the bridge between the view and the other layers of the application.

Now, on to inheriting from Behavior<T>. You will notice that I have changed a few names here and there, because they weren’t reflecting the reality of the application anymore: IDragDropHandler becomes IDraggable ; the DropHandler property becomes DraggableItem. I also have replaced the mouse event names with descriptive names (OnStartDrag instead of “mouse button down”), especially since we will now be able to bind these handlers to any event.

public class DragOnCanvasBehavior : Behavior<DependencyObject>
{
    // this registers the DraggableItem property on the behavior
    public static readonly DependencyProperty DraggableItemProperty =
        DependencyProperty.RegisterAttached(
            "DraggableItem",
            typeof(IDraggable),
            typeof(DragOnCanvasBehavior),
            new PropertyMetadata(new PropertyChangedCallback((d, e) =>
            {
                ((DragOnCanvasBehavior)d).draggable = (IDraggable)e.NewValue;
            })));

    // stores the draggable item instance for further access
    private IDraggable draggable;

    // replaces the Getxxx and Setxxx methods
    public IDraggable DraggableItem
    {
        get
        {
            return (IDraggable)this.GetValue(DraggableItemProperty);
        }
        set
        {
            this.SetValue(DraggableItemProperty, value);
        }
    }

    // define the commands available to the view
    public ICommand Dragging { get; private set; }
    public ICommand StartDrag { get; private set; }
    public ICommand StopDrag { get; private set; }

    // defines what the available commands will do
    public DragOnCanvasBehavior()
    {
        this.StartDrag = new RelayCommand((o) =>
        {
            this.OnStartDrag();
        });

        this.StopDrag = new RelayCommand((o) =>
        {
            this.OnStopDrag();
        });

        this.Dragging = new RelayCommand((o) =>
        {
            this.OnDragging();
        });
    }

    // actually handle the events
    private void OnDragging() {}
    private void OnStartDrag() {}
    private void OnStopDrag() {}
}

public class DragOnCanvasBehavior : Behavior<DependencyObject>

{

// this registers the DraggableItem property on the behavior

public static readonly DependencyProperty DraggableItemProperty =

DependencyProperty.RegisterAttached(

"DraggableItem",

typeof(IDraggable),

typeof(DragOnCanvasBehavior),

new PropertyMetadata(new PropertyChangedCallback((d, e) =>

{

((DragOnCanvasBehavior)d).draggable = (IDraggable)e.NewValue;

})));

// stores the draggable item instance for further access

private IDraggable draggable;

// replaces the Getxxx and Setxxx methods

public IDraggable DraggableItem

{

get

{

return (IDraggable)this.GetValue(DraggableItemProperty);

}

set

{

this.SetValue(DraggableItemProperty, value);

}

// define the commands available to the view

public ICommand Dragging { get; private set; }

public ICommand StartDrag { get; private set; }

public ICommand StopDrag { get; private set; }

// defines what the available commands will do

public DragOnCanvasBehavior()

{

this.StartDrag = new RelayCommand((o) =>

{

this.OnStartDrag();

});

this.StopDrag = new RelayCommand((o) =>

{

this.OnStopDrag();

});

this.Dragging = new RelayCommand((o) =>

{

this.OnDragging();

});

}

// actually handle the events

private void OnDragging() {}

private void OnStartDrag() {}

private void OnStopDrag() {}

}

You will notice that we don’t attach the commands to any particular item event anymore. This is because it’s handled by the view. It kind of makes sense, because a different device may have a different method of dragging. The rest of the view can be found in part 1.

<ItemsControl.ItemTemplate>
    <DataTemplate>
        <Border>
            <!-- contents -->

            <i:Interaction.Behaviors>
                <behaviors:DragOnCanvasBehavior DraggableItem="{Binding}">
                    <i:Interaction.Triggers>
                        <i:EventTrigger EventName="PreviewMouseLeftButtonDown">
                            <i:InvokeCommandAction CommandName="StartDrag" />
                        </i:EventTrigger>
                        <i:EventTrigger EventName="PreviewMouseLeftButtonUp">
                            <i:InvokeCommandAction CommandName="StopDrag" />
                        </i:EventTrigger>
                        <i:EventTrigger EventName="PreviewMouseMove">
                            <i:InvokeCommandAction CommandName="Dragging" />
                        </i:EventTrigger>
                    </i:Interaction.Triggers>
                </behaviors:DragOnCanvasBehavior>
            </i:Interaction.Behaviors>
        </Border>
    </DataTemplate>
</ItemsControl.ItemTemplate>

<ItemsControl.ItemTemplate>

<i:Interaction.Behaviors>

<behaviors:DragOnCanvasBehavior DraggableItem="{Binding}">

<i:Interaction.Triggers>

<i:EventTrigger EventName="PreviewMouseLeftButtonDown">

<i:InvokeCommandAction CommandName="StartDrag" />

</i:EventTrigger>

<i:EventTrigger EventName="PreviewMouseLeftButtonUp">

<i:InvokeCommandAction CommandName="StopDrag" />

</i:EventTrigger>

<i:EventTrigger EventName="PreviewMouseMove">

<i:InvokeCommandAction CommandName="Dragging" />

</i:EventTrigger>

</i:Interaction.Triggers>

</behaviors:DragOnCanvasBehavior>

</i:Interaction.Behaviors>

</Border>

</DataTemplate>

</ItemsControl.ItemTemplate>

The events handlers are also similar to the ones in part 1. The only difference is that they access the item through Behavior<T> properties. For instance :

private void OnStartDrag()
{
    // use Mouse.GetPosition() to get the mouse coordinates
    this.mouseStartPosition = Mouse.GetPosition(Application.Current.MainWindow);

    // cast this.AssociatedObject to get the item control
    ((UIElement)this.AssociatedObject).CaptureMouse();
}

private void OnStartDrag()

{

// use Mouse.GetPosition() to get the mouse coordinates

this.mouseStartPosition = Mouse.GetPosition(Application.Current.MainWindow);

// cast this.AssociatedObject to get the item control

((UIElement)this.AssociatedObject).CaptureMouse();

}

That’s it! Your behavior event handlers are now linked through the view, which means better testing, and better flexibility.

Category: .NET

Always run Visual Studio as administrator on Windows 10

Unit testing MongoDB queries

Modify copy/paste format depending on target

Start a WPF application in the notification area with Caliburn.Micro

Mapping DataTables to domain objects

Mocking static methods

C, C++ and C++/CLI cheat sheet

How to read pointers

In variable declaration

In variable usage

C pointers

C arrays

C structures

C++ references

Managed instances

Managed pointers

Managed references

Further readings

C++/CLI wrapping a C library: cheatsheet

Compiling and debugging

Managed and unmanaged objects

WPF Behaviors: adding mouse-event adorners

WPF Behaviors: switching to Windows.Interactivity.Behavior