I think (yes – only think) I was able to overcome this issue. All you have to do is follow couple of simple steps – ever since I have done this all my issues are gone.

1. Before you install the drivers, go to power options and click on “Change plan settings” on any power plan
2. Click on “Change advanced power settings”
3. For each power option (in the dropdown list) disable the “Link State Power Management” options (on battery and plugged in) under PCI Express – make sure you change this for all power options in the dropdown list (balanced, high performance, power saver and any others that are available)
   
   
4. Install the latest NVIDIA Drivers
5. After installing the drivers and before rebooting, for each power option disable the “NVIDIA Display Power Saving technology” under Display for both “On battery” and “Plugged in” options – make sure you change this for all power options in the dropdown list
(balanced, high performance, power saver and any others that are available)


6. Reboot and enjoy

Just a quick note – I was able to test these steps and the result was success both on my and couple of other systems.  Follow them at your own risk but before you do, make sure you have a good working image backup of your system just in case you want to undo the changes.

Fist lets start with the official introduction by “Microsoft Research” (https://research.microsoft.com/en-us/projects/contracts/).

Code Contracts provide a language-agnostic way to express coding assumptions in .NET programs. The contracts take the form of preconditions, post conditions, and object invariants. Contracts act as checked documentation of your external and internal APIs. The contracts are used to improve testing via runtime checking, enable static contract verification, and documentation generation.

Code Contracts bring the advantages of design-by-contract programming to all .NET programming languages.

I will try introduce the Code Contracts with a few examples (the language I have chosen is C# but remember Code Contracts is language-agnostic). We will try to enforce some validation of parameters before the execution of the logic as well as validation of the results after the execution of the code block. We will have write a console application where we utilize a manager class (PowerfulManager) that will act like a business tier object. In this manager class, we will see how to enforce some “contracts”. (To keep things simple, we will not example the console application but as you can easily guess, it will be an application that will create an instance of PowerfulManager and call the related functions.)

The PowerfulManager class will have a public property called UserId. We will first try to enforce that during the initialization of the class, a user id has to be provided which will be of type string. Our first rule will be to make sure that the provided user id parameter is not null or is not empty. Our class code would look something like below:

   1: public PowerfulManager(string userId)

   2:     : this()

   3: {

   4:     if (string.IsNullOrEmpty(userId))

   5:     {

   6:         throw new ArgumentException("userId");

   7:     }

   8:  

   9:     this.UserId = userId;

  10: }

With Code Contracts, the code above will be transformed into something like below:

   1: public PowerfulManager(string userId)

   2:     : this()

   3: {

   4:     Contract.Requires<ArgumentException>(!String.IsNullOrEmpty(userId), "userId");

   5:     this.UserId = userId;

   6: }

As you can see from the example above, we introduced the rule of userId parameter not being null or empty using the Contract.Requires static function.

Let’s now try to create a function that will take 2 integer parameters and return an integer result. The rules should be something like as follows:

• minValue  hould be greater or equal to 0
• maxValue should be greater or equal to 0
• minValue should be smaller than maxValue
• The result should be smaller than maxValue

The original implementation would be something like this:

   1: public int DoSomething(int minValue, int maxValue)

   2: {

   3:     if (minValue >= 0)

   4:     {

   5:         throw new ArgumentException("minValue");

   6:     }

   7:  

   8:     if (maxValue >= 0)

   9:     {

  10:         throw new ArgumentException("minValue");

  11:     }

  12:     

  13:     if (!(minValue < maxValue))

  14:     {

  15:         throw new ArgumentException("minValue, maxValue");

  16:     }

  17:  

  18:     var result = maxValue - minValue;

  19:  

  20:     if (!(result <= maxValue))

  21:     {

  22:         throw new Exception("Something went wrong");

  23:     }

  24:  

  25:     return result;

  26: }

Now let’s see how this will can written using the Code Contracts.

   1: public int DoSomething(int minValue, int maxValue)

   2: {

   3:     Contract.Requires<ArgumentException>(minValue >= 0);

   4:     Contract.Requires<ArgumentException>(maxValue >= 0);

   5:     Contract.Requires<ArgumentException>(minValue < maxValue);

   6:  

   7:     Contract.Ensures(Contract.Result<int>() <= maxValue);

   8:  

   9:     return maxValue - minValue;

  10: }

I believe this is much neater, much more readable. Here we also see the “Contract.Ensures” method (line 7). This call allows us to define what should happen when we are returning from the function.  As you can see in the code, we retrieve the value that we are returning using the Contract.Result method and check it against the maxValue.

Let’s now add one more function with the following logic and rules:

• Let the function take two integer parameters and always return –1 after a successful run
• Let’s set the class’s UserId property to “NewUserId”
• As a rule, if we have to throw a BusinessException exception, we have to make sure we undo the UserId property to its old value
• As a rule, when this function completes it’s execution, the UserId should never be null or empty

To simulate different possible scenarios, we will calculate maxValue modulus 4 and perform the following actions according to the value we get:

• If value is 0, work as normal
• If value is 1, throw a new Business Exception exception
• If value is 2, first undo the change to the UserId property, then throw a new BusinessException exception
• If value is 3, set the UserId property’s value to String.Empty

Now this is what the code will look like:

   1: public int DoSomethingElse(int minValue, int maxValue)

   2: {

   3:     Contract.EnsuresOnThrow<Exceptions.BusinessException>(Contract.OldValue<string>(this.UserId) == this.UserId, "UserId value is instable");

   4:     Contract.Ensures(!String.IsNullOrEmpty(this.UserId));

   5:  

   6:     var evaluationResult = maxValue % 4;

   7:  

   8:     var oldUserIdValue = this.UserId;

   9:  

  10:     this.UserId = "NewUserId";

  11:  

  12:     if (evaluationResult == 1)

  13:     {

  14:         throw new BusinessLogicLayer.Exceptions.BusinessException("Exception occured, I should undo the userId");

  15:     }

  16:  

  17:     if (evaluationResult == 2)

  18:     {

  19:         this.UserId = oldUserIdValue;

  20:         throw new BusinessLogicLayer.Exceptions.BusinessException("Exception occured, I should undo the userId");

  21:     }

  22:  

  23:     if (evaluationResult == 3)

  24:     {

  25:         this.UserId = String.Empty;

  26:     }

  27:  

  28:     return -1;

  29: }

At like 3, we define a rule saying that if BusinessException is thrown, old value of UserId property should be the same as the current value of UserId (in other words, any changes done to the UserId property should be undone). At Line 4, we define a rule where we say that, no matter what, when the function completes, UserId property should not be null or empty.

I find “Code Contract” fascinating, fun to use and great to experiment with. The examples I have provided above are just simple examples of what you can do with them. If you read the documentation (the documentation is over explanatory), you will see that there are a great number of more functionality provided such as Contract.ForAll, Interface Contracts and Object Invariants.

Object Invariants is a great feature where you can define what conditions that should hold true on each instance of a class whenever that object is visible to a client. Literally, you can enforce the object to be in a “valid” or “good” state. Depending on the feedback, I may try to provide some examples around Object Invariants.

One way to achieve this goal is to create an event queue, modify the controller to enqueue a message that indicates a recycle is requested and make your web roles listen to this queue. Your controller can also enqueue 3 messages if you have 3 Web Roles to recycle. Below is the basic design for such an approach.

While you can use a queue as to mediate your messaging needs, you can also use WCF services to do interrole communication. In this approach, your roles would expose an internal endpoint, bind a WCF service that would listen on this endpoint. Your controller would use the RoleEnvironment to identify each role instance and invoke the service endpoints to notify each instance that a recycle is required. The design for this approach is below.

In this post I will try to provide a simple example of interrole communication using WCF – in other words, I will try to realize the design above. The code examples will not have much error handling, instead I will try to concentrate on the basics. Our Tier 1 Role Instances will expose a WCF Service that will use TCP transportation. The service interface will be a simple one that will include a one-way function called RecycleYourself. Upon retrieval of this message, our Tier 1 Role instances will recycle themselves.

We will start with adding input endpoints for our Tier 1 Role instances. This is pretty easy to do using Visual Studio. We will start with right clicking on the Worker Role definition and selecting properties.

In the endpoints section of the Tier 1 Worker Role properties screen, we will click on the “Add Endpoint” button to add a new internal endpoint. Let’s name it “NotificationServiceEndPoint”, select “Internal” as the type (we are selecting the “Internal Endpoint Type” since we will not be exposing this endpoint to external world) and select Protocol to be TCP.

Next step is to create an interface for the service that will accept the recycle notification. This interface will expose a one-way endpoint. You can modify the contracts to suit your needs. I would suggest creating a class library project and putting the contracts in this project since we will be referencing it both for hosting and consumption purposes. The project that you create for your service and contracts should reference System.Servicemodel and System.Runtime.Serialization assemblies.

The code for the datacontract is provided below. This will be our message that is passed as a parameter to the host.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization;

namespace InterroleCommunicationContracts

{

    [DataContract(Namespace = "urn:InterroleCommunicationTest:2010:06:24")]

    public class NotificationMessage

    {

        [DataMember]

        public string RoleName { get; set; }

        [DataMember]

        public string Tag { get; set; }

    }

}

The service contract is a very simple one. The only function will be a void one called RecycleYourself with a parameter of type NotificationMessage.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

namespace InterroleCommunicationContracts

{

    [ServiceContract(Namespace="urn:InterroleCommunicationTest:2010:06:24")]

    public interface INotifiyService

    {

        [OperationContract]

        void RecycleYourself(NotificationMessage message);

    }

}

Next step is to host a WCF Service in our Tier 1 Worker Roles. This service host will expose an event that will be raised whenever our service receives a notification message. We will later handle that event in our Worker Role and take appropriate actions. The hosting code is provided below.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using InterroleCommunicationContracts;

using System.ServiceModel;

namespace Tier1WorkerRole

{

    public delegate void RecycleNotificationRecievedEventHandler(object sender, NotificationMessage e);

    [ServiceBehavior(

        InstanceContextMode = InstanceContextMode.Single,

        ConcurrencyMode = ConcurrencyMode.Multiple,

        IncludeExceptionDetailInFaults = true,

        AddressFilterMode = AddressFilterMode.Any)]

    public class NotificationServiceHost : INotifiyService

    {

        public event RecycleNotificationRecievedEventHandler RecycleNotificationRecieved;

        public void RecycleYourself(NotificationMessage sender)

        {

            this.OnRecycleNotificationRecieved(sender);

        }

        protected virtual void OnRecycleNotificationRecieved(NotificationMessage e)

        {

            RecycleNotificationRecievedEventHandler handler = RecycleNotificationRecieved;

            if (handler != null)

            {

                // Invokes the delegates.

                handler(this, e);

            }

        }

    }

}

As you can see in the code snippet above, our service host exposes an event called RecycleNotificationRecieved. Whenever we receive a RecycleYourself call, we raise this event. There are also some attributes in our service host where one of them is very important for our case. As we will need only one instance of this service, we have decorated it as InstanceContextMode.Single. The reason why we will need only one instance (a singleton pattern) is because we will be hosting this service as a singleton so that we can hook into it’s event.

In order to host this service in our Tier 1 worker role, we will first reference to the project where we have created our interfaces. We will later need to get the endpoint that we created above, create an instance of our host and instantiate a service host around this instance. We will also hook into the event and handle it in our worker role. We will create and run the service in our Run() method. Below is the full listing of our Tier 1 worker role.

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Net;

using System.Threading;

using Microsoft.WindowsAzure;

using Microsoft.WindowsAzure.Diagnostics;

using Microsoft.WindowsAzure.ServiceRuntime;

using Microsoft.WindowsAzure.StorageClient;

using InterroleCommunicationContracts;

using System.ServiceModel;

namespace Tier1WorkerRole

{

    public class WorkerRole : RoleEntryPoint

    {

        public ServiceHost ServiceHost { get; private set; }

        private void StartServiceHost()

        {

            Trace.WriteLine("Starting Service Host", "Information");

            NotificationServiceHost serviceHostBase = new NotificationServiceHost();

            serviceHostBase.RecycleNotificationRecieved += new RecycleNotificationRecievedEventHandler(ServiceHost_RecycleNotificationRecieved);

            ServiceHost = new ServiceHost(serviceHostBase);

            this.ServiceHost.Faulted += (sender, e) =>

            {

                Trace.TraceError("Service Host fault occured");

                this.ServiceHost.Abort();

                Thread.Sleep(500);

                this.StartServiceHost();

            };

            NetTcpBinding binding = new NetTcpBinding(SecurityMode.None);

            RoleInstanceEndpoint notificationServiceHostEndPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["NotificationServiceEndPoint"];

            this.ServiceHost.AddServiceEndpoint(

                typeof(INotifiyService),

                binding,

                String.Format("net.tcp://{0}/NotifyService", notificationServiceHostEndPoint.IPEndpoint)

                );

            try

            {

                this.ServiceHost.Open();

                Trace.TraceInformation("Service Host Opened");

            }

            catch (TimeoutException timeoutException)

            {

                Trace.TraceError("Service Host open failure, Time Out: " + timeoutException.Message);

            }

            catch (CommunicationException communicationException)

            {

                Trace.TraceError("Service Host open failure, Communication Error: " + communicationException.Message);

            }

            Trace.WriteLine("Service Host Started", "Information");

        }

        void ServiceHost_RecycleNotificationRecieved(object sender, NotificationMessage e)

        {

            Trace.WriteLine("RecycleNotification Recieved From : " + e.RoleName, "Warning");

            // TODO: Recycle My Instance

            // RoleEnvironment.RequestRecycle();

        }

        public override void Run()

        {

            // This is a sample worker implementation. Replace with your logic.

            Trace.WriteLine("Tier1WorkerRole entry point called", "Information");

            this.StartServiceHost();

            while (true)

            {

                Thread.Sleep(10000);

                Trace.WriteLine("Working", "Information");

            }

        }

        public override bool OnStart()

        {

            // Set the maximum number of concurrent connections 

            ServicePointManager.DefaultConnectionLimit = 12;

            DiagnosticMonitor.Start("DiagnosticsConnectionString");

            // For information on handling configuration changes

            // see the MSDN topic at https://go.microsoft.com/fwlink/?LinkId=166357.

            RoleEnvironment.Changing += RoleEnvironmentChanging;

            return base.OnStart();

        }

        private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)

        {

            // If a configuration setting is changing

            if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))

            {

                // Set e.Cancel to true to restart this role instance

                e.Cancel = true;

            }

        }

    }

}

As our Tier 1 instance is ready to host our service, now is the time modify our controller. We will call our controller worker role, Tier 2 worker role. In this worker role, we will create a proxy for our service, find out all instances of Tier 1 Role, get their service endpoints and invoke the appropriate endpoints. The code for this process is below.

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Net;

using System.Threading;

using Microsoft.WindowsAzure;

using Microsoft.WindowsAzure.Diagnostics;

using Microsoft.WindowsAzure.ServiceRuntime;

using Microsoft.WindowsAzure.StorageClient;

using System.ServiceModel;

namespace Tier2WorkerRole

{

    public class WorkerRole : RoleEntryPoint

    {

        public override void Run()

        {

            // This is a sample worker implementation. Replace with your logic.

            Trace.WriteLine("Tier2WorkerRole entry point called", "Information");

            while (true)

            {

                NotifyRolesForRecycle();

                Thread.Sleep(10000);

                Trace.WriteLine("Working", "Information");

            }

        }

        public override bool OnStart()

        {

            // Set the maximum number of concurrent connections 

            ServicePointManager.DefaultConnectionLimit = 12;

            DiagnosticMonitor.Start("DiagnosticsConnectionString");

            // For information on handling configuration changes

            // see the MSDN topic at https://go.microsoft.com/fwlink/?LinkId=166357.

            RoleEnvironment.Changing += RoleEnvironmentChanging;

            return base.OnStart();

        }

        private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)

        {

            // If a configuration setting is changing

            if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))

            {

                // Set e.Cancel to true to restart this role instance

                e.Cancel = true;

            }

        }

        public void NotifyRolesForRecycle()

        {

            var role = RoleEnvironment.Roles["Tier1WorkerRole"];

            Trace.WriteLine("Number of Instances found: " + role.Instances.Count, "Information");

            foreach (var instance in role.Instances)

            {

                RoleInstanceEndpoint notificationServiceHostEndPoint = instance.InstanceEndpoints["NotificationServiceEndPoint"];

                NetTcpBinding binding = new NetTcpBinding(SecurityMode.None, false);

                EndpointAddress myEndpoint = new EndpointAddress(

                    String.Format("net.tcp://{0}/NotifyService", notificationServiceHostEndPoint.IPEndpoint)

                    );

                try

                {

                    ChannelFactory<InterroleCommunicationContracts.INotifiyService> myChanFac = new ChannelFactory<InterroleCommunicationContracts.INotifiyService>(binding, myEndpoint);

                    InterroleCommunicationContracts.INotifiyService myClient = myChanFac.CreateChannel();

                    myClient.RecycleYourself(new InterroleCommunicationContracts.NotificationMessage() { RoleName = "Tier2", Tag = "none" });

                }

                catch (Exception e)

                {

                    Trace.WriteLine("An error occured trying to notify the instances: " + e.Message, "Warning");

                }

            }

        }

    }

}

As you can see above, the NotiyRolesForRecycle is the function where we do most of the work. In this function we get the Role for Tier 1 Worker Role using the RoleEnvironment.Roles dictionary. Once we get the Role object, we iterate through its instances. For each instance we get the endpoint using InstanceEndPoints dictionary of RoleInstance object. After creating a basic TCP binding and an endpoint to use with our channel factory, we create a client and invoke the RecycleYourself function.

Allow me to underline that the example I have provided above lacks error handling, tracing and any other decorations to make it robust. Again, for example purposes I tried to keep the interfaces simple. You can enhance this example to use more complex data contracts, add more functionality to your services. You can also use Duplex Bindings which will be very handy if you need check the status of other worker roles.

Before you go on reading, allow me to note that I believe there are many other (and even more elite ways) of achieving this. For me the easiest was to do what I am going to explain below. I also want to underline that I am a generalist and I am one those people who want to get things done as soon as possible but also as neatly as possible.

The first thing I did was to create multiple pages and integrate the Navigation Application template to my solution. So far everything was great. Next thing I did was to add regions to each navigation page with different names. I modified the bootstrapper to load my modules on-demand so that until the user would view a page they would not be loaded.

All was great except the fact that nothing was displayed in my pages – which makes sense since they were to be loaded on-demand.

I added a new class called ModuleMapper – a static one to include a static dictionary that would let me map my page URIs with my Module Type names. This way, I would be able to know which module to load when I navigated to a page. The code for ModuleMapper is below and as you can see there is nothing fancy.

   1: public static class ModuleMapper

   2: {

   3:     /// <summary>

   4:     /// Gets or sets the module maps.

   5:     /// </summary>

   6:     /// <value>The module maps.</value>

   7:     public static Dictionary<string, string> ModuleMaps { get; set; }

   8:  

   9:     static ModuleMapper()

  10:     {

  11:         ModuleMaps = new Dictionary<string, string>();

  12:     }

  13: }

I then modified my shell to get references for module manager, module catalog and unity container.

   1: public NavShell(IModuleManager moduleManager, IModuleCatalog moduleCatalog, IUnityContainer container)

   2: {

   3:     InitializeComponent();

   4:     this.ModuleManager = moduleManager;

   5:     this.ModuleCatalog = moduleCatalog;

   6:     this.Container = container;

   7: }

Next thing I did was to add a function to my shell’s code behind that would let me load the module that corresponds to the page I am navigating to.

   1: private void LoadModule(string uri)

   2: {

   3:     // if link requires a module then load it

   4:     if (ModuleMapper.ModuleMaps.ContainsKey(uri))

   5:     {

   6:         var module = ModuleCatalog.Modules.SingleOrDefault(x => x.ModuleName == ModuleMapper.ModuleMaps[uri]);

   7:         

   8:         if (module == null)

   9:         {

  10:             throw new InvalidOperationException("Requested module is not loaded");

  11:         }

  12:  

  13:         if (module.State == ModuleState.NotStarted)

  14:         {

  15:             ModuleManager.LoadModule(ModuleMapper.ModuleMaps[uri]);

  16:         }

  17:     }

  18: }

Last but not least, I added an event handler for my frame’s navigated event that would let me load the relevant module as I am navigating.

   1: private void ContentFrame_Navigated(object sender, NavigationEventArgs e)

   2: {

   3:     LoadModule(e.Uri.ToString());

   4:  

   5:     foreach (UIElement child in LinksStackPanel.Children)

   6:     {

   7:         HyperlinkButton hb = child as HyperlinkButton;

   8:         if (hb != null && hb.NavigateUri != null)

   9:         {

  10:             if (hb.NavigateUri.ToString().Equals(e.Uri.ToString()))

  11:             {

  12:                 VisualStateManager.GoToState(hb, "ActiveLink", true);

  13:             }

  14:             else

  15:             {

  16:                 VisualStateManager.GoToState(hb, "InactiveLink", true);

  17:             }

  18:         }

  19:     }

  20: }

What was left for me to do was to start using my ModuleMapper. The hook point I chose was in my bootstrapper. Inside my bootstrapper I had a function called GetModuleCatalog that looked perfect to inject my ModuleMapper code into.

   1: protected override IModuleCatalog GetModuleCatalog()

   2: {

   3:     ModuleCatalog catalog = new ModuleCatalog();

   4:     catalog.AddModule(typeof(Modules.Module1), InitializationMode.OnDemand);

   5:     catalog.AddModule(typeof(Modules.Module2), InitializationMode.OnDemand);

   6:  

   7:     ModuleMapper.ModuleMaps.Add("/ModuleViewPage1",typeof(Modules.Modile1).Name);

   8:     ModuleMapper.ModuleMaps.Add("/ModuleViewPage2", typeof(Modules.Module2).Name);

   9:     

  10:     return catalog;

  11: }

Once I did all this, I was excited to click on the “Run” to see what happens. And guess what – all worked fine. At least for a while. I navigated to the first page and the module loaded fine. I navigated to the second page and the module loaded fine. I navigated back to the first page and my application crashed.

The exception I got when my application crashed was: “Unhandled Error in Silverlight Application Code:4004, System.InvalidOperationException: Element is already the child of another element”.

After some debugging and doing a small research I realized that the problem was related with the Navigation Framework. Each time navigation framework displays a page, it creates a new instance of the class associated with the page. This makes absolute sense – makes absolute sense if you are destruct your modules and load them again when necessary.

Here is what is causing this problem. On your first call to the page, RegionManager makes sure that your view is instantiated and associated with that view. On subsequent calls, the region used previously is destroyed and your region manager wants to associate the old view to a new region created when your page class is instantiated. This causes the problem above since your view was already set as a child of another element.

The solution that I came up with was to implement my own version of ContentLoader for Navigation Framework where each content would behave as a Singleton. So here is what I did (some of the code is based on other blog posts Content Loaders).

First I created my Async Result class that would implement IAsyncResult interface and would act as my result object.

   1: public class SingletonContentLoaderAsyncResult : IAsyncResult

   2: {

   3:     public object Result { get; set; }

   4:  

   5:     public SingletonContentLoaderAsyncResult(object asyncState)

   6:     {

   7:         this.AsyncState = asyncState;

   8:         this.AsyncWaitHandle = new ManualResetEvent(true);

   9:     }

  10:     #region IAsyncResult Members

  11:  

  12:     public object AsyncState

  13:     {

  14:         get;

  15:         private set;

  16:     }

  17:  

  18:     public System.Threading.WaitHandle AsyncWaitHandle

  19:     {

  20:         get;

  21:         private set;

  22:     }

  23:  

  24:     public bool CompletedSynchronously

  25:     {

  26:         get { return true; }

  27:     }

  28:  

  29:     public bool IsCompleted

  30:     {

  31:         get { return true; }

  32:     }

  33:  

  34:     #endregion

  35: }

Next I created my Singleton Content Loader class. It would make sure that it would keep references to the created page contents and serve them back on subsequent requests. If the page was not loaded before, it would create an instance and store the page in its local static list.

   1: public class SingletonContentLoader : INavigationContentLoader

   2: {

   3:     static SingletonContentLoader()

   4:     {

   5:         InstantiatedUserControls = new Dictionary<string, object>();

   6:     }

   7:  

   8:     private string GetTypeNameFromUri(Uri uri)

   9:     {

  10:         if (!uri.IsAbsoluteUri)

  11:             uri = new Uri(new Uri("dummy:///", UriKind.Absolute), uri.OriginalString);

  12:         return Uri.UnescapeDataString(uri.AbsolutePath.Substring(1));

  13:     }

  14:  

  15:     #region INavigationContentLoader Members

  16:  

  17:     public bool CanLoad(Uri targetUri, Uri currentUri)

  18:     {

  19:         string typeName = GetTypeNameFromUri(targetUri);

  20:         Type t = Type.GetType(typeName, false, true);

  21:         if (t == null)

  22:             return false;

  23:         var defaultConstructor = t.GetConstructor(new Type[0]);

  24:         if (defaultConstructor == null)

  25:             return false;

  26:         return true;

  27:     }

  28:  

  29:     public static Dictionary<string, object> InstantiatedUserControls { get; set; }

  30:  

  31:     public IAsyncResult BeginLoad(Uri targetUri, Uri currentUri, AsyncCallback userCallback, object asyncState)

  32:     {

  33:         var result = new SingletonContentLoaderAsyncResult(asyncState);

  34:         Type t = Type.GetType(GetTypeNameFromUri(targetUri), false, true);

  35:         object instance = null;

  36:         if (t != null)

  37:         {

  38:             if (InstantiatedUserControls.ContainsKey(t.Name))

  39:             {

  40:                 instance = InstantiatedUserControls[t.Name];

  41:             }

  42:             else

  43:             {

  44:                 instance = Activator.CreateInstance(t);

  45:                 InstantiatedUserControls[t.Name] = instance;

  46:             }

  47:         }

  48:         result.Result = instance;

  49:         userCallback(result);

  50:         return result;

  51:     }

  52:  

  53:     public LoadResult EndLoad(IAsyncResult asyncResult)

  54:     {

  55:         return new LoadResult(((SingletonContentLoaderAsyncResult)asyncResult).Result);

  56:     }

  57:  

  58:     public void CancelLoad(IAsyncResult asyncResult)

  59:     {

  60:         return;

  61:     }

  62:  

  63:     #endregion

  64: }

Last thing to do was to add this content loader to my frame and modify my UriMapper to map each URI to a full class name which is to be loaded. Below is the example code from my navShell.xaml.

   1: <navigation:Frame x:Name="ContentFrame" Style="{StaticResource ContentFrameStyle}" Navigating="ContentFrame_Navigating"

   2:                   Source="/Home" Navigated="ContentFrame_Navigated" NavigationFailed="ContentFrame_NavigationFailed">

   3:     <navigation:Frame.ContentLoader>

   4:         <local:SingletonContentLoader />

   5:     </navigation:Frame.ContentLoader>

   6:     <navigation:Frame.UriMapper>

   7:         <uriMapper:UriMapper>

   8:             <uriMapper:UriMapping Uri="" MappedUri="AdministrationTools.UI.Views.Home"/>

   9:             <uriMapper:UriMapping Uri="/{pageName}" MappedUri="AdministrationTools.UI.Views.{pageName}"/>

  10:         </uriMapper:UriMapper>

  11:     </navigation:Frame.UriMapper>

  12: </navigation:Frame>

All this code put together does the magic – with the code above you have your own content loader that instantiates the objects once and serves them back on subsequent calls.

ps: I just finished writing this post on a Friday evening and I am planning to head back home now – so no grammar or typo checking.

When I was near the completion two modules I realized that my views did not look great when they were hosted in the main UI application. They never stretched (especially my DataGrids) to full size even though at design time all was fine. So without doing any proper research I tried to simulate the whole problem in a simple Silverlight application (with no Prism involved) and guess what – all was working great, my datagrids stretched to fill the pages and it was a full WYSIWYG experience. There was only one other thing left to blame and it was Prism’s Regions – which I was write to put blame on.

John Papa in his blog explains the problem in details and provides a solution (Fill My Prism Region, Please : JohnPapa.net). If you scroll down the comments you will see that there is a great alternative for the coding solution (provided by NVenhola) – I have applied it and it works like a charm. All you have to do is modify the ItemsControl you are using to add a template to use a Grid. Below is the code change I made (add ItemsControl.ItemsPanel and ItemsPanelTemplate, and put a Grid in it).

   1: <ItemsControl Name="CounterDataViewerRegion" 

   2:               Regions:RegionManager.RegionName="CounterDataViewerRegion">

   3:     <ItemsControl.ItemsPanel>

   4:         <ItemsPanelTemplate>

   5:             <Grid/>

   6:         </ItemsPanelTemplate>

   7:     </ItemsControl.ItemsPanel>

   8: </ItemsControl>

Think of a web application where you have to provide blog like functionality to your end users. Assume that this application also enables its users to do threaded discussions. Let’s assume that this application will also serve different groups of users where the membership of a user would determine whether or not a user can create a comment on a post. To make thing a little bit more simpler, think that you need to provide the functionality for users creating their own groups and manage those groups.

Now let’s take the requirements couple of steps further. Assume that you want to provide a fancier user interface compared to SharePoint’s native UI – one that is developed in Silverlight with nice transitions. Your users started to demand a Windows Desktop application that would allow them to use the system both offline and online. As the Web and Windows applications make their grounds, you decided to provide your users a native Windows Phone 7 application experience.

One approach is do custom development – unleash the power of the Microsoft .NET platform and utilize Microsoft SQL Server as much as you can. You will have to tackle with database structures, manage authentication and authorization, and address other common tasks but again that is the nature of custom development.

There is an alternative solution. Why not utilize a product that would address most of the requirements (and even more) that we have talked above – why not utilize SharePoint to handle both the business logic and the data related activities and concentrate on user interface. SharePoint’s native user interface can be used for administration purposes. As different user interface clients will utilize the functionality provided by SharePoint, a WCF layer will be a perfect wrapper. In this WCF layer, some additional logic can be implemented to address any functionality that SharePoint does support out of the box.

By utilizing SharePoint as a backend server, we have reduced the amount of coding we have to do by at least %60. We no longer have to worry about authorization, no longer have to design database tables to support blog like functionality. Suddenly, we have a search system that indexes all the data, we have picture libraries, agendas that we can expose as services. Again, we have the administration system ready to use where we can even separate the administrators from normal users.

With this architecture in place, I have suddenly created a framework that lets me utilize SharePoint as a backend server. I can now access SharePoint through my WCF Services and make it create me a blog. Again I can ask SharePoint to list all the profiles. I can let my users manage their profile securities. For all this functionality, I have to write only a small bit of code just to utilize the SharePoint.

The problem at this stage is how to make this work. The whole set up is the same as setting up a normal SharePoint. After installing the SharePoint you will create a services machine to host your WCF Services. Now you have to choose how to communicate with SharePoint.

To communicate with SharePoint you have couple of methods that you can choose from. Below is the list of possible ways:

• SharePoint Front-End Protocols: SharePoint Front-End protocols are a layer of web services that you can make your software talk with. It is very straight forward and you can even utilize the web services from your clients. I find the main drawback to be the performance. More information can be found here: SharePoint Front-End Protocols
• SharePoint .NET API: To use the SharePoint API, you have to make your services layer a part of the SharePoint farm. After you do that, you can start using the SharePoint API inside your WCF service code. You will open the site, open the web, find the list and get the data as you would do if you were to implement a SharePoint web part. I find this to be faster (in terms of performance) compared to SharePoint Web Services. I mostly use this approach for adding, updating and deleting data.
• SharePoint Foundation RPC Protocol: This protocol can be used in Win32-based applications or in ASPX applications to make HTTP POST requests to the server. Methods in this protocol that do not modify the contents of the database can also be used in URL protocol to make HTTP GET requests. I prefer this when doing data retrieval on lists. More information can be found here: https://msdn.microsoft.com/en-us/library/ms478653.aspx
• SharePoint Back-End protocols: This protocol set is a huge set of protocols which helps you manage SharePoint Back-End functionality such as listing the profiles, adding new Sites etc. Most work using SQL Service Stored Procedures which is very fast since you are removing layers that reside between your application and your database storage. For more use the following link: SharePoint Back-End Protocols

The list above can be enhanced more with SharePoint 2010. With SharePoint 2010 we get some other methods listed as follows:

• Microsoft SharePoint Foundation 2010 – Managed Client Object Model: The new client-side object model provides remote access to the functionality of the SharePoint Foundation server-side object model. In previous releases of SharePoint Foundation, SOAP Web services provided access to only a fraction of the server-side object model, but in SharePoint Foundation 2010, the client object model fills many of the gaps. For more information: Managed Client Object Model
• Microsoft SharePoint Foundation 2010 – REST Interfaces: The new SharePoint Foundation REST interface exposes lists and libraries as a relational data service, and serves as a standards-based interface for interoperability with other platforms. More details can be found at the following URL: REST Interface

In my case I was using SharePoint 2007 and I have fully utilized the last 3 methods of access for SharePoint 2007. My WCF services host is a part of SharePoint farm. This lets me to access the SharePoint .NET API and perform the Create, Update and Delete operations against my data that resides on SharePoint. I use RPC to list all my data. This covers my CRUD against any data object. For some heavy load operations, such as listing all the profiles in SharePoint, I use SharePoint Back-End protocols. I use SharePoint Sites structure to structure the data and in each site I have blogs and threaded discussion lists that I let my users work on. Exposing all this functionality by encapsulating them in a WCF layer lets any UI technology utilize my solution.

I am planning to provide more details of each protocol in following posts under this title – of course as long as the time permits.

Before diving into screenshots, allow me to explain a bit more about why usage of TFS Integration Platform was necessary. For the current project I work for, we have installed a TFS 2008 server to host the code base and work items. We have 3 development teams and 1 management team, all in different geographies accessing the same TFS Server. Again, all teams have different branches that they work on. When a feature implementation is complete, merging is done to an integration branch allowing feature to be promoted for testing. After the release of TFS 2010, I wanted to upgrade the TFS 2008 server to TFS 2010. Due to the nature of geographically distributed teams, I wanted to make sure that the development continues without any downtimes and I will be able to switch the teams one by one to the new TFS Server. This is where TFS Integration Platform comes in handy – one of the many valuable features is that it allows you run two different TFS servers in sync.

There are two approaches you can take in using TFS Integration Platform for tackling this problem. One of them is to create your own configuration files and run the Integration Platform’s Services to perform the synchronization. The other option is more like a NEXT NEXT FINISH approach, allowing you to visually create the configuration files and execute the synchronization. In this post I will try to introduce you to TFS Migration Shell which allows you to define a TFS to TFS Connection Configuration. To keep the post short, we will only synchronize the source code.

The first step is to download the TFS Integration installer from https://tfsintegration.codeplex.com/ and install it to an environment that is going to be responsible for performing the SYNC between two different TFS Servers. During installation, you will be asked for a storage SQL Server and you can use any SQL Server Instance that is suitable for you. Again you will also be asked for credentials which has to have permission to access both TFS Systems (and projects that you are going to sync) and SQL server.

The next step is to browse the installation directory (in my case it is \Program Files\Microsoft Team Foundation Server Integration Platform\TFS to TFS Connector) and run the TFSMigrationShell.exe. You will see something similar to the following screenshot.

We will proceed with New Configuration option that will allow us to create a new configuration to sync our two TFS servers. As soon as we click on the New Configuration, we will be asked to choose a template. Using the file open dialog, browse to \Program Files\Microsoft Team Foundation Server Integration Platform\TFS to TFS Connector\Configurations directory which contains couple of templates. The first template is the VC_TFStoTFS_Template.xml which is designed for TFS to TFS version control synchronization. The second template is WIT_TFSToTFS_Template.xml which is designed for Work Item synchronization. The third template is WIT_TFSToTFS_FieldMap_Template.xml which is again designed for Work Item synchronization but with field mapping. As we are planning to do a TFS to TFS synchronization and we are planning only to synchronize the source code we are going to choose “VC_TFSToTFS_Template.xml”.

Once we select the template a new screen will show up where we will configure the template to fit our case. The first few values we have to provide are straight forward. The configuration asks us to provide a Configuration Name which is going to be the name that we will be able to locate the sync job.

The next value we have to provide is the Workflow Type. This is where we will be able to select what kind of a synchronization is going to take place. We can select one of the following:

• One-Way Migration: If the configuration is set to be one-way, the synchronization will only from Source to Destination. It is more like a pull subscription where the destination server is only a consumer. One can use this model where the source server gets updated and the destination server stays idle.
• Two-Way Sync: This option allows the changes to be propagated to both servers. This will be our option as we want to move the teams one by one to the new server.
• Custom: This is the option where you can define the frequency, direction and synchronization context. The frequency can be Continuous Automatic, Continuous Manual and One Time. The direction can be unidirectional and bidirectional. You can also disable the sync context or you can select unidirectional or bidirectional context synchronization.

Once we select the workflow type and put in a name, we will have to specify the Source System. This is again very simple. Remember our example was to move the code base and the users from TFS 2008 to TFS 2010. So we will be selecting TFS 2008 Migration VC Provider.

Once you select the TFS 2008 Migration VC Provider, you will be prompted for connecting to TFS. If you have not defined any servers before, click on the Servers button and add the TFS server. Once you add the server you will be back at the Connect to Team Foundation Server screen.Select the Server from the dropdown and select the team project you want to source from. For our case, we will be sourcing from server “tfs” and will use the Test-Playground team project.

The Right Source: Target System part is similar to Left Source. All we are going to do is click on the configure button and select “TFS 2010 Migration VC Provider”. Once we do that, we will be prompted for the TFS 2010 Server, Team Project Collection and the Team Project.

As you can see from the screenshot above, we are mostly done. We can add / delete Sync Paths in the Source Control. If you wish to sync only one branch or one directory, you can modify the existing Path to make sure that you ignore the rest.

Since your configuration is now ready, you can choose the export it. With or without exporting, clicking Save and Close will take you to the Execution screen where you can pause, resume, stop and start the synchronization. Depending on your source code you will also encounter conflicts which you will also be able to solve on this screen. Again you can write / define rules in the Conflicts tab page to automatically resolve any conflicts.

Since the process takes place in the background services, you can exit the application and come back at a later time – you will be able to choose your configuration once you select the Open Configuration option at the start of the application - once you start the application you are prompted either to start a new configuration or to open a existing configuration. Alternatively you can choose to open a configuration by using the File Menu and clicking on the Open.

There is much more you can do with the Migration Shell but I guess you now know your way