Download the free ebook from this MS Press post. Happy Win8 Development folks :)

ARTICLE:

https://www.lifehacker.com.au/2012/06/the-10-most-useful-windows-8-keyboard-shortcuts/

VIDEO (@Channel9):

https://msdn.microsoft.com/en-us/magazine/ff796231.aspx

tc,

Read here: https://www.intertech.com/Blog/post/Windows-Azure-Table-Storage-vs-Windows-SQL-Azure.aspx

tc,

  "Cannot open you default e-mail folders. An unexpected error has occured. 

 MAPI was unable to load the information service msncon.dll. Be sure the service is correctly installed and configured."

Steps:

·         Close Outlook2010

·         Goto Control Panel > Add or Remove Programs

·         Uninstall your old Outlook Connector for Hotmail/Live mail > Restart

·         Get the new connector (version 14.0.4514.1004) from the links below:

·         Open Outlook2010 again, no restart required.

32 bit: https://download.microsoft.com/download/D/F/8/DF8DC3A7-CF01-4F22-B965-DD8CD86411ED/OutlookConnector.exe
64 bit: https://download.microsoft.com/download/8/F/2/8F2D0D4D-719B-4BD3-90BC-56B7AF48C419/OutlookConnector.exe

I noticed that some posts out there have download links to Version 12 of the connector, which is not compatible with Outlook2010. Use the links above and it will work like a charm J

Enjoy Office2010! . . .Need more help? See here

In this scenario we have an existing WF workflow instance that we will change using the WorkflowChanges class. Our objective would to be to retain these changes (using XOML) and use this new WF activity structure to create new WorkflowInstance(s).

So, let’s look at the code. For easy understanding we will break this up into 5 simple steps.

1.      Create a XOML only workflow as a starting point. This would have an associated assembly containing the functionality that we will load later.

2.      Host the WF runtime in a console app and create a workflow instance.

3.      Make changes to the workflow instance

4.      Store the new (modified) workflow template

5.      and finally, create new instances from this new template

Step1: Create a XOML only workflow

a) Create a Class Library project and create your own type that derives from SequenceActivity and add the required code beside elements and compile it. Refer to WorkflowProject1 in the attached code.

Note: make sure that the code handlers are public otherwise you won’t be able to bind to it from your markup (XOML workflow).

namespace WorkflowProject1

{

    public partial class Activity1 : System.Workflow.Activities.SequenceActivity{

    public void codeActivity1_ExecuteCode(object sender, EventArgs e)

    {

        Console.WriteLine("Executing Code Activity1");

    }

    public void codeActivity2_ExecuteCode(object sender, EventArgs e)

    {

        Console.WriteLine("Executing Code Activity2");

    }

}

}

b) Create a XOML only workflow (TextFile1.xoml) as shown below. Note that the type created above is the root activity in this case and refers to the assembly created above. Also note that we have only two CodeActivities in this template.

<ns0:Activity1 x:Name="Activity12" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/workflow" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" xmlns:ns0="clr-namespace:WorkflowProject1;Assembly=WorkflowProject1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">

  <CodeActivity x:Name="codeActivity1" ExecuteCode="{ActivityBind Name=Activity12, Path=codeActivity1_ExecuteCode}" />

  <CodeActivity x:Name="codeActivity2" ExecuteCode="{ActivityBind Name=Activity12, Path=codeActivity2_ExecuteCode}" />

</ns0:Activity1>

Step2: Host the WF runtime in a console app and create a workflow instance

Create a Console app (ConsoleHostApplication1) and add the WorkflowProject1 assembly as a reference.

Before we can create an instance of the above XOML workflow, we need to tell the WorkflowRuntime where to find the associated functionality (for the activities being used). For this we need to add a TypeProvider runtime service. Add the following to the Program.cs (you would need some more WF hosting code that you would find in the attached code sample)

Note: We do not need the TypeProvider if the assembly is deployed to GAC.

WorkflowRuntime workflowRuntime = new WorkflowRuntime();

// Add the Assembly that contains the codebehind

// to a TypeProvider and register the TypeProvider with

// the WorkflowRuntime.

TypeProvider t = new TypeProvider(workflowRuntime);

t.AddAssembly(typeof(WorkflowProject1.Activity1).Assembly);

workflowRuntime.AddService(t);

//run XOML workflow

XmlTextReader reader = new XmlTextReader(@"TextFile1.xoml");

WorkflowInstance instance = workflowRuntime.CreateWorkflow(reader);

instance.Start();

Related reading for Step 2:

Loading Workflow Models in WF

Using Workflow Markup

Using Rules with Workflow Markup

Using Custom Activities with Workflow Markup

Step3: Make changes to the workflow instance

We do this with the help of the WorkflowChanges class in Framework. This lets us create a transient workflow and make changes to it. Read more about it in the “Related reading” section for this step.

In our case we add another CodeActivity to the existing activity tree.

** You may want to provide a designer for editing the XOML. Please find related resources/sample code at the end of this post.

 //Suspend before changing

 instance.Suspend("Changing");

 //making changes

 WorkflowChanges changes = new WorkflowChanges(instance.GetWorkflowDefinition());

 changes.TransientWorkflow.Activities.Add(new CodeActivity("codeActivity3"));

 ActivityBind bind = new ActivityBind("Activity12", "codeActivity2_ExecuteCode");

 changes.TransientWorkflow.Activities["codeActivity3"].SetBinding(CodeActivity.ExecuteCodeEvent, bind);

 instance.ApplyWorkflowChanges(changes);

Related reading for Step 3:

Workflow Changes Overview

Workflow Changes to Rule Conditions

Using Workflow Changes in Workflows

How to: Apply Workflow Changes to Workflows

Dynamic Update from Host - Sample

Changing Rules - Sample

Step4: Store the modified template for future use

Note that we had suspended the workflow instance in step3. We take the structure of this paused (and now modified) workflow instance and store it in memory. Later we show it on the Console as output. You can just as well add some simple code to store this in a database table and even associate some version numbers to these templates. The key to this step is the WorkflowMarkupSerializer. Read more about it in the “Related reading” section for this step

//get the new workflow template/blueprint, optionally save it to a database with new version number for the template

WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();

StringBuilder sb = new StringBuilder();

XmlWriter xwriter = XmlTextWriter.Create(sb);

serializer.Serialize(xwriter, instance.GetWorkflowDefinition());

Console.ForegroundColor = ConsoleColor.Cyan;

Console.WriteLine(sb.ToString() + "\n"); //show modified workflow template, notice the additional Code activity in the console output

Console.ForegroundColor = ConsoleColor.White;

Read about the Visual Studio 2008 Evolution

.Net Framework 3.5 - Red and Green Bits - the additive changes, 3.5 should not break your application unless your code is based on some bug that has now been fixed. CLR v.2.0 stays the same though, see here.

Jason Zander wrote a blog on Framework compatibility in the VS 2005 context (in case you are interested)

Windows Communication Foundation (WCF) is Microsoft’s unified programming model for building service-oriented applications. It enables developers to build secure, reliable, transacted solutions that integrate across platforms and interoperate with existing investments. So you can expose a service over multiple channels, each of which can be configured to take advantage of select protocols like WS-Security, WS-Trust or WS-SecureConversation for secure message exchanges; WS-ReliableMessaging for reliable transfer of messages etc. You can also choose what transport protocol you want to use for communication (eg: HTTP, TCP, MSMQ, Named Pipes, custom) and the encoding format (XML, Binary, MTOM).

WCF is able to support interoperability as it’s native messaging protocol is SOAP (an open standard) thus providing the opportunity for WCF services to interact with different technologies running on Microsoft and non-Microsoft platforms. It also works with its predecessors like COM+ and Enterprise Services which reduces the amount of infrastructure code that you have to write as a developer in order to achieve heterogeneous interoperability. Here is a performance article you can go through.

Some resources to get started:

WCF Community Website

Windows Communication on MSDN

Understanding Windows Communication Foundation Virtual Lab

Books

Learning WCF: A Hands-on Guide

Inside Windows® Communication Foundation

Programming WCF Services by Juval Lowy (Author)

These training kits provide a way for developers to grasp the breadth of the entire release, as well as dive deep into a specific technology. The .NET 3.5 Enhancements Training Kit covers the technologies in the .NET 3.5 SP1 release and beyond (ASP.NET MVC and the ASP.NET Silverlight controls). Currently, the training kit contains six hands-on labs, made up of the following technologies:

1)      ADO.NET Data Services

2)      ADO.NET Entity Framework

3)      ASP.NET AJAX History

4)      ASP.NET Dynamic Data

5)      ASP.NET MVC

6)      ASP.NET Silverlight controls

You can download the training kit at https://go.microsoft.com/?linkid=8719735

Happy Learning!!