Trying to be MVVM compliant is not always easy.

Take the following scenario:

There is a model with a property “Status”. This property changes values according to some logic in the model. This property should now be presented in the view. To have correct MVVM, the ViewModel has also a property “Status”, which is bound to the view.
So, now how can the model inform the viewmodel when the “Status” of the model changed?

The best bet is to have a StatusChanged event on the model and let the viewmodel subscribe to it and fire the viewmodel’s own propertychanged for it’s “Status” property. This can get quite tedious so I created a small helper: PropertyChangedProxy

For this, the model and the viewmodel need to implement INotifyPropertyChanged. Then on the viewmodel, you can create new a new instance of the PropertyChangedProxy for each property of the model where you want the viewmodel to be notified, in a typesafe way.

Such an instance would look like this:

var statusPropertyChangedProxy = new PropertyChangedProxy<MainModel, StatusType>(
	_model, m => m.Status,
	newValue => OnPropertyChanged("Status"));

So as you see, you just need to give the source (which is the model), the property of the source (as a nice expression) and an action, that should be called when the source’s property changes (which in this case is just to fire a OnPropertyChanged on the ViewModel itself).

Here’s a complete small example of a model and viewmodel, where the viewmodel is automatically notified when the model’s “Status” changes so that the viewmodel can forward this to the view:

public class MyModel : INotifyPropertyChanged
{
	private string _status;
	public string Status
	{
		get { return _status; }
		set { _status = value; OnPropertyChanged(); }
	}

	// Default INotifyPropertyChanged
	public event PropertyChangedEventHandler PropertyChanged;
	protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
	{
		var handler = PropertyChanged;
		if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
	}
}

public class MyViewModel : INotifyPropertyChanged
{
	public string Status
	{
		get { return _model.Status; }
	}

	private PropertyChangedProxy<MyModel, string> _statusPropertyChangedProxy;
	private MyModel _model;
	public MyViewModel(MyModel model)
	{
		_model = model;
		_statusPropertyChangedProxy = new PropertyChangedProxy<MyModel, string>(
			_model, myModel => myModel.Status, s => OnPropertyChanged("Status")
		);
	}

	// Default INotifyPropertyChanged
	public event PropertyChangedEventHandler PropertyChanged;
	protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
	{
		var handler = PropertyChanged;
		if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
	}
}

Here’s the source of the PropertyChangedProxy:

/// <summary>
/// Proxy class to easily take actions when a specific property in the "source" changed
/// </summary>
/// Last updated: 20.01.2015
/// <typeparam name="TSource">Type of the source</typeparam>
/// <typeparam name="TPropType">Type of the property</typeparam>
public class PropertyChangedProxy<TSource, TPropType> where TSource : INotifyPropertyChanged
{
	private readonly Func<TSource, TPropType> _getValueFunc;
	private readonly TSource _source;
	private readonly Action<TPropType> _onPropertyChanged;
	private readonly string _modelPropertyname;

	/// <summary>
	/// Constructor for a property changed proxy
	/// </summary>
	/// <param name="source">The source object to listen for property changes</param>
	/// <param name="selectorExpression">Expression to the property of the source</param>
	/// <param name="onPropertyChanged">Action to take when a property changed was fired</param>
	public PropertyChangedProxy(TSource source, Expression<Func<TSource, TPropType>> selectorExpression, Action<TPropType> onPropertyChanged)
	{
		_source = source;
		_onPropertyChanged = onPropertyChanged;
		// Property "getter" to get the value
		_getValueFunc = selectorExpression.Compile();
		// Name of the property
		var body = (MemberExpression)selectorExpression.Body;
		_modelPropertyname = body.Member.Name;
		// Changed event
		_source.PropertyChanged += SourcePropertyChanged;
	}

	private void SourcePropertyChanged(object sender, PropertyChangedEventArgs e)
	{
		if (e.PropertyName == _modelPropertyname)
		{
			_onPropertyChanged(_getValueFunc(_source));
		}
	}
}

Sometimes you want to output multiple lines in a kind of table form to the console or a file. The main problem here is, that you need to know for each column the maximum number of characters any element has so that you can pad them correctly.

So take this example:

Title Name Street
Mr. Roman Sesamstreet
Mrs. Claudia Abbey Road

wouldn’t it be nicer to look like:

Title   Name       Street
Mr.     Roman      Sesamstreet
Mrs.    Claudia    Abbey Road

To make it easier, I created a small function which helps in doing so:

public static class ConsoleUtility
{
	/// <summary>
	/// Converts a List of string arrays to a string where each element in each line is correctly padded.
	/// Make sure that each array contains the same amount of elements!
	/// - Example without:
	/// Title Name Street
	/// Mr. Roman Sesamstreet
	/// Mrs. Claudia Abbey Road
	/// - Example with:
	/// Title   Name      Street
	/// Mr.     Roman     Sesamstreet
	/// Mrs.    Claudia   Abbey Road
	/// <param name="lines">List lines, where each line is an array of elements for that line.</param>
	/// <param name="padding">Additional padding between each element (default = 1)</param>
	/// </summary>
	public static string PadElementsInLines(List<string[]> lines, int padding = 1)
	{
		// Calculate maximum numbers for each element accross all lines
		var numElements = lines[0].Length;
		var maxValues = new int[numElements];
		for (int i = 0; i < numElements; i++)
		{
			maxValues[i] = lines.Max(x => x[i].Length) + padding;
		}

		var sb = new StringBuilder();
		// Build the output
		bool isFirst = true;
		foreach (var line in lines)
		{
			if (!isFirst)
			{
				sb.AppendLine();
			}
			isFirst = false;

			for (int i = 0; i < line.Length; i++)
			{
				var value = line[i];
				// Append the value with padding of the maximum length of any value for this element
				sb.Append(value.PadRight(maxValues[i]));
			}
		}
		return sb.ToString();
	}
}

A sample on how to use it would be:

var lines = new List<string[]>();
lines.Add(new[] { "What", "Before", "After"});
lines.Add(new[] { "Name:", name1, name2});
lines.Add(new[] { "City:", city1, city2});
lines.Add(new[] { "Zip:", zip1, zip2});
lines.Add(new[] { "Street:", street1, street2});
var output = ConsoleUtility.PadElementsInLines(lines, 3);

An application folder can look quite crowded if you have some assemblies or 3rd party references in use.

Like in this image:

Wouldn’t it be much nicer to have it look like:

When it comes to having dll-files somewhere else than in the “app-folder, things can get quite cumbersome.

Here’s how to achieve this:

Moving files into subfolder

There are multiple ways to achieve this.

One way is to add a solution folder with the desired name of the subfolder and add the assemblies / dependencies as files (best way is to add them as links) there with build action=none and copylocal=true. If you add assemblies there used as references as well, set the copylocal for the references to false.

Another way is to leave the dll’s where they are (just adding dependent dlls as files/links into the project’s root directory) and create a post-build event or (my preferred way) add an AfterBuild task to the project to move all *.dll files into the subfolder.

For the post-build event just edit the project’s properties and add the commands into the post-build in the Build Events.

For the preferred way, just edit the csproj file (unload the project, then right-click and edit, open in any text-editor or use the visual studio addon EditProj) and add the following code at the bottom:

<Target Name="AfterBuild">
	<ItemGroup>
		<FilesToMove Include="$(OutDir)*.dll" />
	</ItemGroup>
	<Move SourceFiles="@(FilesToMove)" DestinationFolder="$(OutDir)Libs" />
</Target>

This example code uses the folder “Libs” for the dlls. Feel free to adjust it to your needs.

Telling the application to search other directories for libraries

This is actually quite simple. The current way of doing this is to edit the app.config and adding the following code into the configuration:

<runtime>
	<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
		<probing privatePath="Libs" />
	</assemblyBinding>
</runtime>

That’s it. With those two things you can have a “clean” application folder where all the assemblies or 3rd-party dependencies (like sqlite or sqlce dlls) are nicely stored in a subfolder