About the Author

Kevin is a Senior Software Engineer at Interknowlogy who moved from Germany to San Diego in beautiful Southern California in January 2012. He has switched from native C++ Developments to the .NET world in 2006 with a main focus on WPF. The release of ASP.NET MVC made him discover his passion for Web Application projects. Since the Windows 8 Customer Preview he enjoys exploring the new WinRT world whenever he finds time...

PDFx – Property Dependency Framework – Part VI, External Property Dependencies

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

External Property Dependencies

Declarative Usage

The declarative PDFx API allows you to register a dependency on a property that resides in any INotifyPropertyChanged-instance different from the owner of the dependent Property:

class SourceClass : INotifyPropertyChanged
{
	private AnyType _sourceProperty;
	public AnyType SourceProperty
	{
		get { return _sourceProperty; }
		set
		{
			_sourceProperty = value;
			OnPropertyChanged("SourceProperty");
		}
	}
}

class DestinationClass : BindableExt
{
	SourceClass Source { get; set; }

	public AnyOtherType TargetProperty
	{
		get
		{
			Property(() => TargetProperty)
				.Depends(p => p.On(Source, k => k.SourceProperty));

			//Source.SourceProperty has changed. Do Something with it and return.
		}
	}
}

Overloads of the methods On and AndOn both allow you to pass in an INotifyPropertyChanged instance as the first parameter and point to any property of that instance in the Lambda Expression you pass in as the second parameter.

Example

The source code of this example can be found in ViewModel ExternalDependencyVM which is part of the WPFSample’s source code.

Let’s assume we are required to implement the following graph:

ExternalPropertyDependencies.png
Green circles stand for Input Properties while purple circles indicate calculated properties. The arrows show the underlying math operations as well as the property dependencies.

Using the PDFx, we can easily represent the depicted graph in C#:

public class DestinationVM : BindableExt
{
	public DestinationVM()
	{
		ExternalSource1 = new ExternalSource1();
		ExternalSource2 = new ExternalSource2();
	}

	public ExternalSource1 ExternalSource1 { get; private set; }
	public ExternalSource2 ExternalSource2 { get; private set; }

	public int A1
	{
		get
		{
			Property(() => A1)
				.Depends(p => p.On(() => B1)
						.AndOn(ExternalSource1, k => k.A1)
						.AndOn(ExternalSource2, k => k.A1));

			return B1 + ExternalSource1.A1 - ExternalSource2.A1;
		}
	}

	private int _b1;
	public int B1
	{
		get { return _b1; }
		set { _b1 = value; NotifyPropertyChanged(() => B1); }
	}
}

public class ExternalSource1 : BindableExt
{
	public int A1
	{
		get
		{
			Property(() => A1)
				.Depends(p => p.On(() => B1));

			return 3 * B1;
		}
	}

	private int _b1;
	public int B1
	{
		get { return _b1; }
		set { _b1 = value; NotifyPropertyChanged(() => B1); }
	}
}

public class ExternalSource2 : BindableExt
{
	private int _a1;
	public int A1
	{
		get { return _a1; }
		set { _a1 = value; NotifyPropertyChanged(() => A1); }
	}
}

PDFx – Property Dependency Framework – Part V, Simple Property Dependencies

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

Simple Property Dependencies

After you’ve followed the instructions from Getting Started, you are ready to use the PDFx.

Declarative Usage

The declarative PDFx API allows you to register a property dependency from within a property getter’s implementation following this pattern:

class MyClass : BindableExt
{

    AnyType MyTargetProperty
    {
       get 
       {
             Property(() => MyTargetProperty)
                 .Depends(p => p.On(() => FirstSourceProperty)
                                  .AndOn(() => SecondSourceProperty)
                                  .AndOn(() => LastSourceProperty));

            //Do something with the values of those 3 Properties and return a result     
        }       
    }

    AnyType FirstSourceProperty { get { } set { } }
    AnyType SecondSourceProperty { get { } set { } }
    AnyType LastSourceProperty { get { } set { } }

}

The call to method Property expects a lambda expression which points to the Property in which your code resides. The PDFx will use this expression to resolve the property’s name.
The returned object of method Property allows you to call the method Depends which expects a delegate that accepts a parameter of the fluent interface type IPropertyDependencyExt (or IPropertyDependency in the case of the PCL’s Bindable class).
This parameter allows you to specify source properties your current target property depends on by calling the On and AndOn methods. Both methods always return the very same instance of the interface type IPropertyDependencyExt, thereby allowing you to register the entire property registration in a single execution.

Example

The source code of this example can be found in ViewModel SimplePropertyDependencyVM which is part of the WPFSample’s source code.

Let’s assume we are required to implement the following graph:

SimplePropertyDependenciesPicture.png
Green circles stand for Input Properties while purple circles indicate calculated properties. The arrows show the underlying math operations as well as the property dependencies.

Using the PDFx’s Simple Property Dependencies feature, we can easily represent the depicted graph in a ViewModel similar to this:

class SimplePropertyDependencyVM : BindableExt
{
	public int A1
	{
		get
		{
			Property(() => A1)
				.Depends(p => p.On(() => B1)
						.AndOn(() => B2));

			return B1 + B2;
		}
	}

	public int B1
	{
		get
		{
			Property(() => B1)
				.Depends(p => p.On(() => C1)
						.AndOn(() => C2));

			return 2 * C1 - C2;
		}
	}

	public int B2
	{
		get
		{
			Property(() => B2)
				.Depends(p => p.On(() => C2)
						.AndOn(() => C3));

			return -C2 + C3;
		}
	}

	public int C1
	{
		get
		{
			Property(() => C1)
				.Depends(p => p.On(() => D1)
						.AndOn(() => D2));

			return D1 + D2;
		}
	}

	public int C2
	{
		get
		{
			Property(() => C2)
				.Depends(p => p.On(() => D3));

			return 3 * D3;
		}
	}

	public int C3
	{
		get
		{
			Property(() => C3)
				.Depends(p => p.On(() => D4)
						.AndOn(() => D5));

			return D4 + D5;
		}
	}

	private int _d1;
	public int D1
	{
		get { return _d1; }
		set
		{
			_d1 = value; 
			NotifyPropertyChanged(() => D1);
		}
	}

	private int _d2;
	public int D2
	{
		get { return _d2; }
		set
		{
			_d2 = value;
			NotifyPropertyChanged(() => D2);
		}
	}

	private int _d3;
	public int D3
	{
		get { return _d3; }
		set
		{
			_d3 = value;
			NotifyPropertyChanged(() => D3);
		}
	}

	private int _d4;
	public int D4
	{
		get { return _d4; }
		set
		{
			_d4 = value;
			NotifyPropertyChanged(() => D4);
		}
	}

	private int _d5;
	public int D5
	{
		get { return _d5; }
		set
		{
			_d5 = value;
			NotifyPropertyChanged(() => D5);
		}
	}
}

PDFx – Property Dependency Framework – Part IV, Using PDFx with an existing 3rd party framework

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

Using PDFx with MVVM Light

Full Disclosure: The implementation presented in this post is experiential. While it passes the PDFx’s Unit Tests successfully, it has not undergone several months of stress tests in IK’s production environments (in contrast to the PDFx itself) because we’re using our own in house ViewModel base class and are consequently able to derive from BindableExt.

In Getting Started you’ve learned what steps you have to take in order to use the PDFx in your own project. As it was explained, every class that wants to leverage PDFx’s features needs to ultimately derive from PDFx’s Bindable or BindableExt because all the functionality is exposed through protected methods.

In certain scenarios, however, the ViewModel Base class that you’re using throughout the project might live in a 3rd party assembly and you might consequently not have the option to modify its source code to include the PDFx.

In order to still support those scenarios, I’ve extended the PDFx’s base classes to expose their functionality not only through protected methods but also through explicitly implemented interfaces. This allows you to use the PDFx in your project by implementing an intermediate man-in-the-middle ViewModel class that bridges the gap between your ViewModel base class and the PDFx. The following steps are necessary to implement such an intermediate ViewModel (You can skip the following steps and immediately head to the next section of this post if you would like to reuse my implementation):

Let’s assume every ViewModel in your project derives from ViewModelBase that is exposed by a 3rd party library.

  1. Create a new class MyViewModel and derive it from ViewModelBase.
  2. Change every reference in your project from ViewModelBase to MyViewModel.
  3. Create a nested BindableExt or Bindable instance inside of MyViewModel (See Library Versions to find out which one suits your needs best)
    1. If you use Bindable, create delegating methods within MyViewModel for every method the Bindable instance exposes through its explicitly implemented interface IBindableAccessToProtectedFunctionality. Omit the “Tunnelled” prefixes.
    2. If you use BindableExt, create delegating methods within MyViewModel for every method the BindableExt instance exposes through its explicitly implemented interface IBindableExtAccessToProtectedFunctionality. Omit the “Tunnelled” prefixes.
  4. Intercept every method call to ViewModelBase which ultimately results in raising the PropertyChange event and forward it instead to the Bindable instance’s TunnelledNotifyPropertyChanged method.
  5. Forward every PropertyChanged event that the Bindable instance raises to ViewModelBase’s PropertyChanged event.
  6. Implement the IDependencyFrameworkNotifyPropertyChangedInTransaction interface in MyViewModel
    1. Forward the interface’s FirePropertyChanged method to the Bindable Instance’s, which also implements the IDependencyFrameworkNotifyPropertyChangedInTransaction interface.
    2. Forward every PropertyChangedInTransaction event that is raised by the Bindable Instance to the PropertyChangedInTransaction event MyViewModel now exposes.

I’ve implemented such an intermediate ViewModel class for MVVMLight. You can find the full example here. In this scenario I’ve chosen to use PDFx’s BindableExt version (See Library Versions for more information).

How to use PDFx with a framework different from MVVM Light

In case you don’t use MVVM Light, you can still use the intermediate class i’ve implemented for MVVM Light as a starting point and follow a few simple steps to make it work with your framework:

  1. Get the intermediate class’s source code from here.
  2. Change the intermediate class’s base class from MVVMLight’s ViewModelBase to the ViewModel base class that comes with your framework.
  3. Change the intermediate class’s MVVM Light Specific region
    1. Override whatever method your base class uses to ultimately raise the PropertyChanged event and forward it to the PDFx’s TunnelledNotifyPropertyChanged method.
    2. Change the FirePropertyChanged method’s implementation to call your base class’s method which raises the PropertyChanged event. This should be the very same method you overwrote in the previous step.

If you want to make sure that you followed the steps correctly and that the PDFx is ready to use, I recommend running the MVVMLightExtension’s Unit Tests against your new intermediate ViewModel.

PDFx – Property Dependency Framework – Part III, Getting started

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

Using PDFx in your Project

Adding a reference to the PDFx

Before using the PDFx, you have to decide whether you would like to go with the platform independent Portable Class Library or one of the feature richer platform specific libraries. Please check out Library Versions to learn more about the different versions.

If you decide to go forward with the Portable Class library, all you need to do is add a project reference to PropertyDependencyFramework.dll.

If you decide to go forward with a platform specific library (recommended), you need to add a project reference to PropertyDependencyFramework.dll and a platform specific binary.

Platform .NET 4.5 Portable Class Library
Path bin\Release\PCL\PropertyDependencyFramework.dll
WinRT WP8
bin\Release\WindowsStore\PropertyDependencyFramework.dll &
bin\Release\WindowsStore\PropertyDependencyFramework_WindowsStore.dll
bin\Release\WP8\PropertyDependencyFramework.dll &
bin\Release\WP8\PropertyDependencyFramework_WP8.dll
WPF SL5
bin\Release\WPF\PropertyDependencyFramework.dll & bin\Release\WPF\PropertyDependencyFramework_WPF.dll bin\Release\SL5\PropertyDependencyFramework.dll &
bin\Release\SL5\PropertyDependencyFramework_Silverlight.dll

Deriving from Bindable

The PDFx’s features are all exposed through protected methods which live in the PCL’s Bindable-class as well as in the platform specific BindableExt-classes.
Every class, in which you would like to use the PDF’x functionality consequently needs to eventually derive from Bindable or BindableExt which both live in the PropertyDependencyFramework-Namespace.

In case you’re already using a development framework (such as MVVMLight) and cannot or don’t want to change your ViewModel’s base class, please refer to Using PDFx with an existing 3rd party framework to learn how you can merge the PDFx into those scenarios.

PDFx – Property Dependency Framework – Part II, Library Versions

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

Library Versions

The core of the framework lives in the PropertyDependencyFramework-assembly which is a Portable Class Library. Some optional PDFx features require platform specific functionality that does not come with the .NET Portable Subset. Thus, there exist platform specific libraries for WPF, Silverlight 5, WP8, Windows Store which extend the basic PropertyDependencyFramework-assembly.

If there exists a specific library for your target platform, I strongly recommend using it. If not, you can always fall back on the PCL.

Feature .NET 4.5 Portable Class Library WinRT WP8 WPF SL5
Simple Property Dependencies x x x x x
Property Dependencies to external objects x x x x x
Property Dependencies to ObservableCollections x x x x x
Callbacks x x x x x
Property Dependencies to hot swappable external objects   x x x x
Property Dependencies to hot swappable ObservableCollections   x x x x
Deferred Callbacks   x x x x
Sanity Checks       x x

PDFx – Property Dependency Framework – Part I, Introduction

The PDFx is a lightweight open source .NET library that allows developers to describe dependencies between Properties in declarative C# code. Once relationships are registered, the framework monitors property changes and ensures that the INotifyPropertyChanged.PropertyChanged event is fired for all directly and indirectly dependent properties in a very efficient way. The library is available for WPF, Silverlight, WinRT (Windows Store) and Windows Phone.

I’ve developed the PDFx as an InterKnowlogy RECESS project and published the source code and examples on codeplex.

In a series of blog posts I am going to cover the library’s most important features:

Introduction

The Property Dependency Framework (PDFx) is a lightweight library that allows you to capture the inherent relationship among the properties of your classes in a declarative manner. It is common in applications to have properties whose values depend upon the values of other properties. These properties need to be reevaluated when a change occurs in the properties on which they depend. For example, if “A” depends on “B” and “C”, we need to reevaluate the value of A whenever either B or C changes. Furthermore, B and C may not even be direct properties of the same class as that in which A exists. Instead, they may be properties of another class, or even properties of the items within a collection.

In large applications, complex chains of such dependencies can exist. Although C# gives us the INotifyPropertyChanged construct to send out a change notification (typically to UI elements), no framework to our knowledge has allowed the network of dependencies to be specified in a straightforward manner, with the proper change notifications issued automatically. The PDFx framework allows the dependencies of properties to be specified declaratively, building from them an internal network of dependencies for you. Changes to any property in the network are then propagated automatically and efficiently.

The PDFx framework establishes a simple pattern for capturing the relationships of data in applications, and removes tremendous amounts of “plumbing”. It also helps clarify and enhance the role of the View Model within MVVM, reducing the scattering of business logic throughout value converters. Once you’ve made use of PDFx, you will likely wonder how the gap it fills has gone unaddressed for so long.

Example

Since pictures tell better stories than words, I would like to demonstrate the benefits of this workhorse with a small example:

PDFX.png

The depicted algebra hierarchy represents a C# class. Green circles stand for Input Properties while purple circles indicate calculated properties. The arrows show the underlying math operations as well as the property dependencies.
As the developer of such a scenario, you’re responsible to ensure that all directly and indirectly dependent properties get reevaluated when an input property changes. Furthermore, for efficiency reasons, you also want to ensure that all unrelated properties do not get reevaluated.

If, for example, Property D1 changes, it is necessary to reevaluate C1, B1 and A1.
However, a change of D3 requires a reevaluation of only C2, B1, B2 and A1.

Using the PDFx, you don’t have to manually hardcode those relationships anymore but can rather rely on the library taking care of this job for you.
All you have to do is register the relationships in human readable code within the implementation of a property:

//....
public int A1
{
	get
	{
		Property(() => A1)
			.Depends(p => p.On(() => B1)
			               .AndOn(() => B2));
		
		return B1 + B2;
	}
}

public int B1
{
	get
	{
		Property(() => B1)
			.Depends(p => p.On(() => C1)
			               .AndOn(() => C2));
		
		return 2*C1 - C2;
	}
}

public int B2
{
	get
	{
		Property(() => B2)
			.Depends(p => p.On(() => C2)
			               .AndOn(() => C3));
		
		return -C2 + C3;
	}
}

public int C1
{
	get
	{
		Property(() => C1)
			.Depends(p => p.On(() => D1)
			               .AndOn(() => D2));

		return D1 + D2;
	}
}

public int C2
{
	get
	{
		Property(() => C2)
			.Depends(p => p.On(() => D3));

		return 3*D3;
	}
}

public int C3
{
	get
	{
		Property(() => C3)
			.Depends(p => p.On(() => D4)
			               .AndOn(() => D5));
		
		return D4 + D5;
	}
}
//....

Advanced Features

  • Dependencies on properties of external objects
  • Dependencies on ObservableCollections
  • Property Value Caching
  • (Deferred) Callbacks for Property Changes

Main Benefits

  • The dependency registration resides within the Property Getter implementation. This way you’re likely to notice immediately that an update of the registration is necessary when you change a property’s implementation.
  • The PDFx fires the PropertyChanged event only for Properties that are directly or indirectly dependent on the changed source property, thereby guaranteeing a high level of efficiency.
  • Properties whose data relies completely on the value of other properties do not need to encapsulate backing fields. They can be implemented solely in the Property Getter, thereby ensuring full integrity.

Session 10 of the WinRT Development Class – InterKnowlogy’s WinRT MVVM Framework Part I/II

Thank you all for attending Session 10 of our WinRT Development Course. We are getting close to the end!
In this session you were among the first ones who got their hands on IK’s brand new MVVM RT Framework which makes using the MVVM architecture pattern in WinRT a piece of cake. MVVM boilerplate plumbing now is a relic of the past!

Thank you Xen Rabara, for an awesome presentation about transient app states and about how they can easily be persisted with the framework. I am sure the community can’t wait to hear more from you :)

Session Resources:

Overview of sessions

The links below lead you to Meetup Events where you can RSVP. We look forward to seeing you at our next session!

1. Introductory Lecture (Nov 27th by Danny & Kevin)
2. Introduction to XAML and WinRT’s powerful Control Framework; (Dec 4th by Danny & Kevin Click here for the video recording)
3. Page-Navigation Model and Application Lifecycle (Jan 8th by Danny Click here for the video recording)
4. Fundamentals (Async/Await, WinRT API, Security) (Jan 15th by Kevin Click here for the video recording)
5. Settings and Search Contract (Jan 28th by Danny Click here for the video recording)
6. Share Contract (Feb 4th by Kevin Click here for the video recording)
7. Live Tiles and Background Tasks (March 18th by Kevin Click here for the video recording)
8. Orientation Handling and Proximity using Near Field Communication (NFC) (March 25th by Danny Click here for the video recording)
9. Introduction to ModelViewViewModel (MVVM) (April 8th by Danny Click here for the video recording)
10. InterKnowlogy’s WinRT MVVM Framework Session Part I/II(April 22nd by Kevin Click here for the video recording)
11. InterKnowlogy’s WinRT MVVM Framework Session Part II/II(May 6th by Danny)
12. Presentation of Hackathon Results + Certificate/Prize Giveaway(May 22nd by Danny and Kevin)

Session 7 of the WinRT Development Class – Live Tiles and Background Tasks

Thank you all for attending Session 7 of our WinRT Development Course. Live Tiles and Background Tasks should now be part of your daily vocabulary :)

Session Resources:

Overview of sessions

The links below lead you to Meetup Events where you can RSVP. We look forward to seeing you at our next session!

1. Introductory Lecture (Nov 27th by Danny & Kevin)
2. Introduction to XAML and WinRT’s powerful Control Framework; (Dec 4th by Danny & Kevin Click here for the video recording)
3. Page-Navigation Model and Application Lifecycle (Jan 8th by Danny Click here for the video recording)
4. Fundamentals (Async/Await, WinRT API, Security) (Jan 15th by Kevin Click here for the video recording)
5. Settings and Search Contract (Jan 28th by Danny Click here for the video recording)
6. Share Contract (Feb 4th by Kevin Click here for the video recording)
7. Live Tiles and Background Tasks (March 18th by Kevin Click here for the video recording)
8. Orientation Handling and Proximity using Near Field Communication (NFC) (March 25th by Danny)
9. Introduction to ModelViewViewModel (MVVM) (April 8th by Danny)
10. InterKnowlogy’s WinRT MVVM Framework Session Part I/II(April 22nd by Kevin)
11. InterKnowlogy’s WinRT MVVM Framework Session Part II/II(May 6th by Danny)
12. Presentation of Hackathon Results + Certificate/Prize Giveaway(May 22nd by Danny and Kevin)

Impressions


WinRT Development Class – Spring Break Update

Yesterday, Microsoft’s early Easter Bunny brought some awesome goodies for all the eager ones of you who are spending nights, days, and of course weekends developing outstanding apps for our WinRT Development Class’s Hackathon (no pressure!)!

So far, we’ve got an XBOX 360, a wireless Wedge Mobile Keyboard, a wireless Wedge Touch mouse, a top notch Microsoft Azure backpack, tons of t-shirts (try to read the word without cheating and looking at an ASCII table!) and 10 solar chargers – in case you get stranded on a lonely island (which happens to have a cellphone tower) and need to call for rescue.

Thank you Microsoft!!

UPDATE! Nokia just mailed a Lumia 800! Another amazing prize for the Hackathon! Thank you!

Overview of sessions

The links below lead you to Meetup Events where you can RSVP. We look forward to seeing you at our next session!

1. Introductory Lecture (Nov 27th by Danny & Kevin)
2. Introduction to XAML and WinRT’s powerful Control Framework; (Dec 4th by Danny & Kevin Click here for the video recording)
3. Page-Navigation Model and Application Lifecycle (Jan 8th by Danny Click here for the video recording)
4. Fundamentals (Async/Await, WinRT API, Security) (Jan 15th by Kevin Click here for the video recording)
5. Settings and Search Contract (Jan 28th by Danny Click here for the video recording)
6. Share Contract (Feb 4th by Kevin Click here for the video recording)
7. Live Tiles and Background Tasks (March 18th by Kevin)
8. Orientation Handling and Proximity using Near Field Communication (NFC) (March 25th by Danny)
9. Introduction to ModelViewViewModel (MVVM) (April 8th by Danny)
10. InterKnowlogy’s WinRT MVVM Framework Session Part I/II(April 22nd by Kevin)
11. InterKnowlogy’s WinRT MVVM Framework Session Part II/II(May 6th by Danny)
12. Presentation of Hackathon Results + Certificate/Prize Giveaway(May 22nd by Danny and Kevin)

Session 6 of the WinRT Development Class – Share Contract

Thank you all for attending Session 6 of our WinRT Development Course. I hope that every attendee will never have to suffer through the DLL Version hell and COM conflicts again :)

Session Resources:

Overview of sessions

The links below lead you to Meetup Events where you can RSVP. We look forward to seeing you at our next session!

1. Introductory Lecture (Nov 27th by Danny & Kevin)
2. Introduction to XAML and WinRT’s powerful Control Framework; (Dec 4th by Danny & Kevin Click here for the video recording)
3. Page-Navigation Model and Application Lifecycle (Jan 8th by Danny Click here for the video recording)
4. Fundamentals (Async/Await, WinRT API, Security) (Jan 15th by Kevin Click here for the video recording)
5. Settings and Search Contract (Jan 28th by Danny Click here for the video recording)
6. Share Contract (Feb 4th by Kevin Click here for the video recording)
7. Live Tiles and Background Tasks (March 18th by Kevin)
8. Orientation Handling and Proximity using Near Field Communication (NFC) (March 25th by Danny)
9. Introduction to ModelViewViewModel (MVVM) (April 8th by Danny)
10. InterKnowlogy’s WinRT MVVM Framework Session Part I/II(April 22nd by Kevin)
11. InterKnowlogy’s WinRT MVVM Framework Session Part II/II(May 6th by Danny)
12. Presentation of Hackathon Results + Certificate/Prize Giveaway(May 22nd by Danny and Kevin)