• mwinkle.blog

    wf.netfx3.com new rss feeds

    • 5 Comments

    One thing that isn't so nice about the new http://wf.netfx3.com site is that all of the file listings do not roll up into one single nice syndication feed.  I want the ability to aggregate all of the files into nice rss feeds so I can stay on top of samples, activities, etc. In order to enable this I had to create new blogs that aggregate the individual folder feeds, and then another one to aggregate those blogs.

    So, here we go:

    And, the rss feed that rules them all

    All Content From wf.netfx3.com

    Enjoy!   

  • mwinkle.blog

    Pageflow Sample Update

    • 2 Comments

    Updated to version 1.1

    Changes

    • Corrected the install to display the EULA at a more opportune time (thanks to this comment)
    • Updated to fix the exception being thrown at the completion of a workflow
      • NavigationManager.cs
      • AspUserInput.cs
      • WebHostingModule.cs

    To install this, download the bits (same location), uninstall the existing version and install this version.

    Other Setup Notes

    I got a few pieces of feedback on the setup to get things working, here are some hints to get up and running:

    • If you extract the samples.zip file in the install directory (Program Files\Windows Workflow Foundation Samples\...) they may be marked as read-only.  Mark the whole directory as non-read-only (so you can write) and then you will be able to compile successfully.
    • To run the sample, you need to set up a persistence database, this will be used to store the state of the workflow while we are not interacting with it
      • Then go into the App.config or web.config and find the ConnectionString settings and update it to point to the correct database.  On most default VS installs, you can point at localhost\sqlexpress, but it can certainly be any sql install.

    Other Notes

    For the folks using WCSF, Glenn has a good summary that fills in some of the story on the WCSF side, and sneaks an Eminem reference into the title :-)

  • mwinkle.blog

    VS 2008 RTM's!

    • 0 Comments

    As widely reported on blogs far and wide, Visual Studio 2008 has been released to manufacturing (or shipped, available, ready to get, etc).  MSDN subscribers can do their part to degrade the global bandwidth supply and get in the download queue via the subscription center, trial editions are available here.  One can also simply get the updated version of the .NET Framework, .NET 3.5 here, and I'd strongly recommend the web setup to only get the bits you need on the machine, and not ones you may already have.

    While you're waiting for those bits to get downloaded, you might find yourself with some free time watching the status bar slowly move in the direction of completion.  Maybe I can interest you in some quality work that has been done by my former team (more on that in the next day or two). 

    First, I would grab the VS 2008 Training Kit, which consists of a metric boatload of labs, content, presentations and sample code to get you excited.  This is something my colleague, David Aiken, has been hard at work putting together.  In David's words:

    The Visual Studio 2008 and .NET Framework 3.5 Training Kit includes presentations, hands-on labs, and demos. This content is designed to help you learn how to utilize the Visual Studio 2008 features and a variety of framework technologies including: LINQ, C# 3.0, Visual Basic 9, WCF, WF, WPF, ASP.NET AJAX, VSTO, CardSpace, SilverLight, Mobile and Application Lifecycle Management.

    This content was developed over the last few months. As part of the development process, we presented many of the topics to real people we invited to Redmond. In September we recorded these sessions and are making these available on Channel 9. There will be several videos posted each Monday for the next few weeks. Today I posted:

     

     

    The Channel9 videos are especially good, these are all various Microsoft folks from the product teams presenting about their individual area of expertise.  I especially recommend the What's new in VB9 and intro to LINQ talk.  There are some pretty cool things in VB9, and I think the XML support is something really cool.  For those of you from the WF world, inside the training kit is a presentation on the WF-WCF integration, as well as a set of labs and demos that walk through simple to complex use cases.

    That should be enough to get you through a few hours of downloading :-)

    Congrats to all the product teams involved in shipping, it's always incredible to me to see how we actually ship software out of this place (and to get to take part in bits and pieces of it).

  • mwinkle.blog

    Pageflow Questions: Why not a state machine?

    • 1 Comments

    Here's a comment from my initial post introducing the pageflow sample from wleong:

    NavigatorWorkflow looks like a state machine to me.  Why create a new workflow type?

    Tuesday, June 12, 2007 3:44 AM by wleong

    This is a good question.  There a couple of reasons why we create our own workflow type:

    • To more accurately model a process
    • Enable different execution semantics
    • Make development faster by focusing on the model, not the implementation details.

    For a little more background on the problem, see my previous post on "Different Execution Patterns for WF (or, Going beyond Sequential and State Machine)" that talks in a little more depth about the trouble one can encounter by only think about the two out of the box models.

    For this problem, in particular, all of the reasons are relevant.

    Accurately modeling a process

    It is very natural to think of UI navigation as a series of places we can be, and a set of transitions from any one of those places to another.  That's what the navigator workflow models.  There is a subtle difference from a state machine that plays to point 3 here.  This model allows me to not worry about putting an IEventActivity at the top of a state, then making some decision and then setting a new state.  We abstract away from defining the events, that's taken care of for us.  This lets us model the process naturally.  In a state machine, one could argue that modeling pageflow with transitions has me place one event and then have an IfElse activity that lets me decide which state to transition to.  This adds mental overhead to the model, moving me much closer to the implementation details (again, point 3).

    Enable Different Execution Semantics

    This was the primary reason I wrote the original article, my customer was doing some very unnatural acts in order to model their process in a sequential workflow.  In the case of UI navigation, we have the ability to be in multiple interactions at the same time.  The WF state machine has the (very natural) restriction that we can only be in one state at a given time (although there are certainly other state machine models that do not have that restriction). The pageflow sample allows you to be in multiple interactions at the same time, so think about filling out a mortgage application, I can be in the midst of many minor sub processes that all roll up into the larger application process, and I can jump from filling out my salary history to the details of the property I am buying by simply clicking on a tab at the top of the page.

    Make development faster by focusing on the model, not the implementation details.

    If we decide to use a state machine, we are coupling our model to the implementation and execution details of the state machine, which will cause us to do things that we don't need to do for this application.  The WF state machine is generic, any state can receive n different events and react to each on differently.  In pageflow, we know there is only one event, "GoForward" and then we have a set of rules to operate on that to determine where we transition to.  By spending the time to create our own root activity, we remove the burden of the implementation details from the workflow developer, allowing them to focus on the details of their process, not the configuration of a given activity.

  • mwinkle.blog

    In this corner... (and $100)

    • 5 Comments

    The great thing about this position is that I get to pay attention to all of the conversations folks are having about WF.

    The bad thing about this position is that I get to pay attention to all of the conversations folks are having about WF.  I'm still learning how to listen to everything and anything that's going on in the world of WF, so forgive me for being a little slow to respond.

    Brian Noyes started off with this post last Wednesday about the complexities inherent in WF, which was followed by Scott listing some of the common gotcha's in WF development.  Tomas also has two posts (part 1 and part 2) on the subject.  Jon weighed in somewhere in the middle there discussing some of the points raised.  Some interesting comments are being posted to Jon's and Brian's posts.

    For me, this is really rewarding to see the community having these conversations about the technology.  Please keep having them, and if you have feedback, post it into our connect site.  These things get routed directly to the team.  Things are pretty much ready to go on v1, but that means we're working on planning what vNext and beyond are looking like, and we need to hear these things!

    That being said, there is complexity in our model, and a lot of that comes from being extensible enough to manage the logic of your Windows Forms app using the same engine that runs the document life cycle workflows in MOSS. I think this is the benefit of providing this "foundational" api to enable workflow in any application, but it does come at the cost of a learning curve and complexity, and there are valid arguments whether certain pieces of complexity are neccessary.  So, what do we do about it?  Let's have a real informal $100 exercise.  Basics of the exercise here:

    You have $100 engineering dollars to spend.  No matter how many millions we'd actually wind up spending, we use $100 as an easy number for people to keep in their heads.

    There are well over $100 dollars worth of features you want.

    The challenge is in determining how to spread the $100 in a way that produces with the most aggregate value.

    What would you like to see added, improved, "fixed" in WF? Some thoughts, but don't feel limited to these: [Standard disclaimer: These are just my ideas, and nothing here means it will become part of the product.]

    • Providing out of the box hosting for certain scenarios (eg: Windows service, WCF, ASP.NET)
    • Management tools (what would these look like?)
    • WF for client workflow scenarios (like Apple's Automator?)
    • Application Scenarios (eg: page flow)
    • Activity libraries (what kind of activities?)
    • Tooling (better spawned context awareness [what would that look like?]?, different project templates, etc)
    • Guidance

    Post away!

  • mwinkle.blog

    Would you like to refactor workflows?

    • 9 Comments

    One of the things I am working on now is the next release of the workflow designer.  One thing I have heard a number of requests for over the years is the ability to refactor workflows.  I'd love to get some feedback if this would be valuable (I'm pretty convinced it is), and if it is valuable, what kind of things would you like to be able to do?  One I have heard before is the selection of some subset of activities in a workflow and select "refactor to new activity" which would pull that out to a new custom activity.

    What other things make sense?  Please reply in comments, a blog post that pingbacks, or send me email at mwinkle_AtSign_Microsoft_dot_com.

     

    <Usual disclaimers apply, this is not something we have made any decisions about, I am just trying to gather some data>

  • mwinkle.blog

    Improving ModelItem with Dynamic

    • 0 Comments

    Hi all, I’m back, and apologize for the delay, things have been crazy here and I’ve taken a little time off following shipping VS2010, so I’m getting back into it.  I’d like to talk about one of my favorite late additions to the WF4 designer programming model.  We added this change sometime in the RC/RTM timeframe in response to some feedback that we had gotten about the verbose-ness of programming against ModelItem.

    If you recall from this post, ModelItem exists to serve as a INotifyPropertyChanged (INPC) aware proxy to the underlying instance being edited within the designer. In exchange for this fairly flexible proxy layer, you get in return a pretty verbose way in which one has to interact to actually get to the data.  Often times there are fairly long incantations of myModelItem.Properties[“foo”].Value.Properties[“bar”].Value.GetCurrentValue() in order to actually return the data (or be able to set the value).  From the beginning, we had decided we wanted to optimize for the WPF XAML consumer of the model item, and so we chose to implement ICustomTypeDescriptor so that WPF binding would be pretty simple (the above would result in a binding syntax of ModelItem.foo.bar). 

    One quick note, looking at the definition of ModelItem itself will show that only the INPC interface is implemented.  However, ModelItem is an abstract type, and the implementation subclass ModelItemImpl contains the definition and implementation of the following interfaces ModelItem, IModelTreeItem, ICustomTypeDescriptor, IDynamicMetaObjectProvider

    As we worked with some of our customers, it became clear that they were frequently using ModelItem in code as well, and so the programming model was becoming more of a problem (we had somewhat hoped that the majority of customers would be using XAML).  We initially went with the idea that we would create a series of Design time peers to all of the common types in WF (making a SequenceDesign, ParallelDesign, etc) which provided an identical programming surface to its peer, but under the covers in the property getters and setters would redirect to an underlying ModelItem.  This has the advantage that we could create the appearance of a strongly typed API surface, but has the downside that it introduces an extra type for every activity we ship, and it requires customers to create two types as well, and not just for activities, you would want one for customer too.  The other approach we kicked around was using the Dynamic capabilities introduced in .NET 4.

    It’s important to note that these are ultimately complimentary approaches, that is, it’s possible in a future framework release (or in a codeplex project if anyone is looking to for a little fun on the side) you could release the strongly typed design time peers. From a timing perspective, it was not likely that we could introduce 30+ new types in the RC/RTM release, and we had questions about the long term sustainability of requiring an additional type for activities.  So, we went ahead with the plan for dynamic support.   In order to do this, we had to add an implementation of IDynamicMetaObjectProvider.  Bill Wagner has a good article here on the basics of doing this.  This requires us to implement one method, GetMetaObject.  In our case, we have an internal, nested ModelItemMetaObject type which inherits from System.Dynamic.DynamicMetaObject. 

    In our case, there are basically two important methods that we care about, BindGetMember and BindSetMember.  These wire up to two methods on ModelItemImpl to get and set based on the property name.  The net result of this is that the following code

    root.Properties["Residence"].
            Value.
            Properties["StreetAddress"].
            Value.GetCurrentValue()

    Can now be written as

    dynamic mi = root;
    Console.WriteLine(root.Residence.StreetAddress)

    Now, with anything there are some tradeoffs, the biggest one is that this is dynamic, I don’t get compile time checking, and I could have a type that will result in an exception being thrown (that said, that problem exists in the verbose form as well).  This does let me write much more succinct code when programming the model item tree though for both gets and sets.  As an added bonus, we found there is actually a decent perf improvement from the WPF XAML data binding that now leverages the IDynamicMetaObjectProvider (mentioned in ScottGu’s post here) in the way that the runtime will only compute the way to resolve the property once (as opposed to every time when it goes through the ICustomTypeDescriptor code path).

     

    Enjoy!

  • mwinkle.blog

    Orcas Beta 1 Samples (WF, WCF)

    • 1 Comments

    Beta 1 samples have been posted.  In this release there are separate installs for WF and WCF (and the workflow services are in the WCF one, go figure!)

     

    From Laurence's blog:

    This is the only version of the new samples that works at this time. The version that comes with the VS Orcas Beta1 offline Help does not work.

    New samples in this release:

    WF Samples\Technologies\Rules And Conditions\Order Processing Policy

                WCF Technology Samples\Basic\Ajax

                WCF Technology Samples\Basic\Syndication

    WCF Technology Samples\Basic\WorkflowServices

    You can download the zip files through any of the samples.

    To setup and run the Orcas Beta1 samples:

    1. Setup:

    a. Check out the Setup Instructions for the Ajax, Syndication, and Workflow Services samples.

    i. Use the Setup scripts under the “OrcasSetup” dir in the downloaded WCF zip file. In contrast, the “Setup” dir includes the scripts necessary for the samples already released with WCF 3.0

    b. On Win2K3, if you see a plain text page when connecting to http://localhost/NetFx35Samples/service.svc, you need to run:

    “%SystemDrive%\Windows\Microsoft.NET\Framework\v2.0.50727\aspnet_regiis.exe” -i –enable

    "%WINDIR%\Microsoft.Net\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe" -i

    c. The WCF Samples setup script Setupvroot.bat will not run unless MSMQ is installed or the NetMsmqActivator service is disabled

    2. Ajax samples:

    a. For the Simple and Post Ajax service samples, you will need to completely refresh your session to be able to reload ClientPage.htm from one service to another as there is an issue with IE. Or simply rename ClientPage.htm in one of the samples

    3.  Workflow Services:

    a. WorkflowServiceUtility is a reference necessary to the CalculatorClient and DuplexWorkflowServices samples

    b. CalculatorClient is the client for both DurableService and StateMachineWorkflowService. Click on “C” to stop the session (it becomes red) before switching services

    c. The Conversations client is the window that has “Press enter to submit order”

    d. In DuplexWorkflowServices, only the ServiceHost and ClientHost projects need to be started

    Technorati Tags: , , ,
  • mwinkle.blog

    Endpoint.tv Talks Tracking

    • 1 Comments

    I heard that the folks that bring you endpoint.tv are doing a two part series on Workflow Tracking in 3.0/3.5.  This is one of my favorite feature areas in 3.0/3.5, and one that I think is not talked about too often.  The team built a lot of functionality in there besides the very basic "emit tracking info" one might expect with the feature description.

    Check it out, and if you want some other background, check out these blog posts I made a few years back!

  • mwinkle.blog

    Workflow @ TechEd 2006

    • 4 Comments

    The scene: Boston, June 20006

    The story: Workflow is going to be out in full force, we've got a ton of great sessions lined up, and we've tried to create a bunch of good chalk-talks for people to attend when they just can't get enough workflow!  Ok, to be specifice, we've got 15 workflow sessions, and another 8 chalk-talks on top of that.  You can't find the chalk-talks from the main site yet, so I'm going to list them below.  When you get to Boston come find us in the Connected Systems (CON) in the developer Technical Learning Center (TLC), which I believe is going to be color designated the blue TLC.  We'll have something that lets you know when you can attend these great sessions. And remember, these aren't recorded, so it's a one time show, you may never be able to catch these presentations again!

    CON-TLC206 Monitoring Running Workflows Using the Tracking Service
    Presenters: Moustafa Ahmed & Joel West 

    In Windows Workflow Foundation, the tracking service keeps log information about workflow events and activity execution statuses. The workflow runtime automatically identifies events related to executing workflow instances and outputs them to a tracking service. This chalk talk will cover the capabilities of the out of box SQL-based tracking service as well as how and why you would build a custom tracking service.

    CON-TLC208 Hosting a web application business logic in WF
    Presenter: Matthew Winkler 

    In this chalk talk we’ll look at ways to leverage WF to handle the business logic in your web application.  First, we’ll look at hosting options (in process, exposed via WCF) and then move into a few different patterns for workflow.  These will include using WF to manage short lived business logic (from postback to render), participating in long running business process managed by WF, and using the Rules Engine to drive validation and other rules based scenarios.  We’ll also discuss security considerations in these approaches as well as listen to how you’re planning on using WF in your web applications.

    CON-TLC209 Rehosting of the Workflow Designer
    Presenter: Devinder Singh 

    Windows Workflow Foundation comes with a workflow designer which you normally use in Visual Studio 2005. The workflow designer component is allowed to be rehosted in your application. This talk will describe how you can add the workflow designer into your application so that your application can create and edit sequential and state machine workflow models. We will cover workflow designer feature integration of activity property binding, the rules editor and using code handlers with your designed workflow models.

    CON-TLC302 UI Page Flow by hosting WF in ASP.NET
    Presenter: Israel Hilerio 

    In a web application the transitions between multiple web pages is often written in code. The business logic deciding which page to send the user to next gets hidden in with the procedural code in the page. User interface page flow is a concept to allow the declarative modeling of page transitions and this can be implemented using Windows Workflow Foundation. This talk will describe the concept in more detail and give you a sneak peak at the advances that Microsoft is planning in this area.

    CON-TLC303 The Windows Workflow Foundation Scheduler Service and Transactions
    Presenter: Israel Hilerio 

    The WorkflowSchedulerService defines how CPU threads can be used by the workflow runtime. Standard ACID transactions are supported in Windows Workflow Foundation through the TransactionScope composite activity. Long running processes that require some compensatory action when an exception occurs are also supported through the CompensatableTransactionScope. This talk will discuss these interesting areas of Windows Workflow Foundation.

    CON-TLC304 Understanding Windows Workflow Exceptions, Transactions and Compensation
    Presenter: Gerald Walsh 

     

    Windows Workflow Foundation provides a rich set of features to support powerful fault handling, robust Atomic and long-running transactions, and flexible compensation support for failed transactions. This session will examine how to manage exceptions within a workflow, how to use the System.Transactions namespace, how to implement both atomic and long-running transactions, and how to utilize compensation and the compensate activity to recover from faults occurring during a transaction’s execution. Demonstrations will be provided to highlight the features and techniques developers need to know to build resilient and reliable workflow applications.

    CON-TLC305 Inside the WF runtime
    Presenter: Bob Schmidt 

    The WorkflowRuntime is the engine that manages executing workflow instances in Windows Workflow Foundation. It handles events for workflow instances, interacts with services that the host application adds and manages workflow persistence. This talk will drill down into the workflow runtime and give you some insight as to how it works. This will be an advanced talk and you should have some prior exposure to Windows Workflow Foundation prior to attending.

    CON-TLC306 Windows Workflow Foundation - Rules Engine Extensibility
    Presenter: Jurgen Willis 

    The breakout session “Windows Workflow Foundation: Building Rules-Based Workflows” gave an introduction to the rules engine capabilities provided in Windows Workflow Foundation (WF).  In this chalk talk, learn more about the WF Rules extensibility mechanisms, which support more advanced scenarios.  See an example of how to externalize rules so that they can be maintained separately from the workflow assembly.  In addition, learn how to author and execute rules outside of a workflow.  Also, see how you can create custom expression and action types that can be used directly in your rules.

  • mwinkle.blog

    Pageflow questions: "What about WCSF / Acropolis / Codename 'foo'"?

    • 1 Comments

    So, I got a little bit of feedback from my initial post.  First, thanks, it's great to see all of the interest in the technology.  I want to use this as the place to answer common questions that arise about the sample. 

    Here's one that I got internally as well as externally(here, here )

    What about WCSF and Acropolis?  Does this change how we think about the problem today? 

    The short answers are "they are still here", "no".

    WCSF 

    There are a lot of people who are using the Web Client Software Factory.  It is definitely something you should check out, it is a great toolkit to build composite web applications.  Part of what it does, among many other things, is the Pageflow Application Block designed to model navigation.   This is what most people are wondering about when they first hear about the pageflow sample we released.  Don't they do the same thing?  From a functional level, yes, they both provide a nice abstraction to model flow through an application.  This is a sample usage of WF to solve a similar problem in a little bit of a different way.  The model inside the WCSF is extensible, allowing a different provider of pageflow information, so it is probably even possible to put this pageflow sample inside of the WCSF, I have yet to give that a try.

    At a deeper level, there are some differences that stem from the implementation of the Pageflow Application Block as a state machine, which I will get into in my next post.

    Acropolis

    Acropolis, announced at TechEd last week, is still early on in its lifecycle, as part of the ".NET Client Futures".  I haven't spent a lot of time looking at it yet, but it is something else which will have a way to model the flow within an application, in this case between WPF forms. 

    Conclusion

    From a support perspective, it's important to note that this sample is unsupported (save for myself and a few others) as opposed to Acropolis and WCSF which have teams working on them.

    It is important to note that both WCSF and Acropolis aim to solve a much larger problem than simple UI navigation.  In that sense, in no way does the pageflow sample released represent a wholesale replacement of either of them.  The sample that we released aims to illustrate a way to use WF to solve the problem of UI navigation.  The important thing to take away from this is that it can be incredibly valuable to model the flow through one's application using a technology which allows separation from the UI.  This makes our UI more loosely coupled with the rest of our application, and increases the agility to react to changes in process / data required / need to track infomation. 

    Also, even if you don't want to use this for pageflow, tune in, because there are some pretty valuable things that any WF developer can learn by taking a look at this sample.  I will continue to discuss those as well.

  • mwinkle.blog

    Displaying Validation Errors in a Rehosted WF4 Designer

    • 1 Comments

    Here’s a quick one

    “I’d like to find out if the workflow in the designer is valid… is there someway to retrieve the validation errors?”

    Yes, the short answer is that you need to provide an implementation IValidationErrorService.  There is one important method to implement on this interface, ShowValidationErrors which will pass you a list of ValidationErrorInfo objects.

    The next thing that needs to happen is that you need to publish an instance of that new type to the editing context.

    Let’s look at a really simple implementation that will write out the validation errors to the debug log.

    using System.Activities.Presentation.Validation;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    
    namespace VariableFinderShell
    {
        class DebugValidationErrorService : IValidationErrorService
        {
            public void ShowValidationErrors(IList<ValidationErrorInfo> errors)
            {
                errors.ToList().ForEach(vei => Debug.WriteLine(string.Format("Error: {0} ", vei.Message)));
            }
        }
    }

    The final bit is to publish this to the editing context:

    wd.Context.Services.Publish<IValidationErrorService>(new DebugValidationErrorService());

    Now, when editing the workflow in the rehosted app, let’s introduce some errors and then look at the output window.  Note, most of the errors below come from incorrect expressions introduced in the expression editor (putting integers in the wrong place, wrong variable name, etc).

     

    image

  • mwinkle.blog

    Proving a Point with LINQ (or, the Longest Type Names in the .NET Framework)

    • 1 Comments

    I will often take a few moments during a presentation to get a chuckle by bringing up the SharedConnectionWorkflowCommitWorkBatchService.  Due to the sheer length of the type name, it's sure to bring a smile or two in one of my otherwise snore-inducing presentation.

    The other day, while reviewing a deck for a colleague I brought up that he should mention this type, and that it usually gets a laugh from a developer audience.  He then asked, "Is that really the longest type name in the framework?"  My response, "Well, I'm not really sure, I bet you could do some LINQ magic in order to figure it out." 

    Well, sitting on the bus this morning with some traffic time to spare (and needing to work on my LINQ skills a bit), put together some code.  My goal was to go through all of the types, calculate their length and figure out which one was the longest named type.  You can replicate this, create a new console application, right click to add references, and select all the references you want to add into this comparison.  I added all of the system.* assemblies, PresentationFramework, PresentationCore and WindowBase.  You could do even more by selecting everything in the reference dialog.

    The thing that appeals to me about LINQ is really that i can just write a query, I don't have to worry about looping through a number of times.  I also like the fact I can develop by refining, that is, I can get a collection back, tweak the query to shape it, take that new collection and query against that.

    Let's first look at what I started with:

    var orderedTypeListing =
           (from assembly in AppDomain.CurrentDomain.GetAssemblies()
            select assembly.GetExportedTypes());

    This ends up returning an object of type IEnumerable<List<Type>>, which doesn't quite get me to what I want.

    I use the Aggregate extension method to operate on this and create an entire list of all the types contained (think of this as flattening the tree by one level, or only returning the leaf nodes in the tree).  With the Aggregate method, I need to provide the operation to do the accumulation.

    var orderedTypeListing =
       (from assembly in AppDomain.CurrentDomain.GetAssemblies()
         select assembly.GetExportedTypes()).Aggregate(
               (x, y) =>
               { return x.Union(y).ToArray(); }
            )

    The only weirdness here is that I have to use ToArray(); since Aggregate returns T[], rather than IEnumerable<T>.

    Now I add a little bit of code to do some ordering.  I like the ordering syntax since I just provide a way to get the value I want to sort by.  Remember to use OrderByDescending in order to get the right ordering.

    Our query near looks like this:

    var orderedTypeListing =
       (from assembly in AppDomain.CurrentDomain.GetAssemblies()
         select assembly.GetExportedTypes()).Aggregate(
               (x, y) =>
               { return x.Union(y).ToArray(); }
            ).OrderByDescending(
                (x) =>
                { return x.Name.Length; }
            );

    So this returns a list, ordered by the length of the name.

    I could just grab the first one off the list, and I'd be done, but I'd like to see the 100 longest names, just in case I'm wrong about our friend SharedConnectionWorkflowCommitWorkBatchService.   To do this, I'll say I want to take 100 off the top of the list and print those out. 

    int count = 1;
    orderedTypeListing.Take(100).ToList().ForEach
    (
        x => 
        Console.WriteLine("{0}: {1}, {3} ({2})", 
        count++, 
        x.Name.Length, 
        x.Assembly.FullName.Split(",".ToCharArray())[1], 
        x.Name)
        );

    This will pretty print the top 100 longest names (these are at the bottom of the post).

    Next, i thought, I'd really like to see a histogram of the sizes.  To do that, I need to group by data.  The Group() extension method, just like the order method, allows me to pass in the value by which I want to group (and that can be computed, say a hash).  It also returns an IGrouping that lets me see the key (in my case, the size of the key) and the IEnumerable itself.

    var groupedTypeListing = orderedTypeListing.GroupBy(
        t => 
        { return t.Name.Length; }
        );
    groupedTypeListing.ToList().ForEach(
        x => 
            Console.WriteLine("{0} : {1}", x.Key, x.Count())
            );

    Finally, I thought I'd see just how many types were included in each version of the framework, and prove that I can group by anything, including manipulating the string on the assembly's full name.

    var groupedVersionListing = orderedTypeListing.GroupBy(
        t => 
        { return t.Assembly.FullName.Split(",".ToCharArray())[1]; }
        );
    groupedVersionListing.ToList().ForEach(
        x => 
            Console.WriteLine("{0} : {1}", x.Key, x.Count()
            )
    );

    This has now let me retrieve a lot of interesting data (interesting at least to me :-) ) that I was able to write with a pretty simple query syntax and do some somewhat sophisticated things (grouping, etc).

    It turns out that our friend SharedConnectionWorkflowCommitWorkBatchService is only number 16 on my list.  The real honor goes to:

     

    AttachedPropertyBrowsableWhenAttributePresentAttribute, with 53 characters.

     

     

    Histogram of Type Name Sizes

    image

     

    Top 100 Longest Type Names

    Rank Length Name Version
    1 54  AttachedPropertyBrowsableWhenAttributePresentAttribute   v3.0
    2 53  ListViewVirtualItemsSelectionRangeChangedEventHandler   v2.0
    3 52  ServiceModelEnhancedConfigurationElementCollection`1   v3.0
    4 50  DataGridViewCellContextMenuStripNeededEventHandler   v2.0
    5 50  ListViewVirtualItemsSelectionRangeChangedEventArgs   v2.0
    6 49  DataGridViewRowContextMenuStripNeededEventHandler   v2.0
    7 49  WorkflowServiceAttributesDynamicPropertyValidator   v3.5
    8 48  DataGridViewColumnDividerDoubleClickEventHandler   v2.0
    9 47  DataGridViewCellContextMenuStripNeededEventArgs   v2.0
    10 47  DataGridViewCellStyleContentChangedEventHandler   v2.0
    11 47  ReadOnlyActiveDirectorySchemaPropertyCollection   v2.0
    12 47  ExtendedWorkflowRuntimeServiceElementCollection   v3.5
    13 46  IDataGridColumnStyleEditingNotificationService   v2.0
    14 46  DataGridViewRowContextMenuStripNeededEventArgs   v2.0
    15 46  UpdateProgressAssociatedUpdatePanelIDConverter   v3.5
    16
    46
     SharedConnectionWorkflowCommitWorkBatchService 
     v3.0
    17 46  DispatcherUnhandledExceptionFilterEventHandler   v3.0
    18 45  DataGridViewColumnDividerDoubleClickEventArgs   v2.0
    19 45  DataGridViewCellToolTipTextNeededEventHandler   v2.0
    20 45  DataGridViewEditingControlShowingEventHandler   v2.0
    21 45  DataGridViewRowDividerDoubleClickEventHandler   v2.0
    22 45  NamedServiceModelExtensionCollectionElement`1   v3.0
    23 45  StandardBindingOptionalReliableSessionElement   v3.0
    24 45  X509CertificateTrustedIssuerElementCollection   v3.0
    25 45  X509ScopedServiceCertificateElementCollection   v3.0
    26 45  InitiatorServiceModelSecurityTokenRequirement   v3.0
    27 45  RecipientServiceModelSecurityTokenRequirement   v3.0
    28 45  DataContractSerializerMessageContractImporter   v3.0
    29 45  ClientWindowsAuthenticationMembershipProvider   v3.5
    30 45  IClientFormsAuthenticationCredentialsProvider   v3.5
    31 45  AttachedPropertyBrowsableForChildrenAttribute   v3.0
    32 44  DataGridViewCellStyleContentChangedEventArgs   v2.0
    33 44  DataGridViewColumnDesignTimeVisibleAttribute   v2.0
    34 44  CodeParameterDeclarationExpressionCollection   v2.0
    35 44  ReadOnlyActiveDirectorySchemaClassCollection   v2.0
    36 44  ServiceModelConfigurationElementCollection`1   v3.0
    37 44  UseManagedPresentationBindingElementImporter   v3.0
    38 44  WS2007FederationHttpBindingCollectionElement   v3.0
    39 43  KeyContainerPermissionAccessEntryCollection   v2.0
    40 43  KeyContainerPermissionAccessEntryEnumerator   v2.0
    41 43  DataGridViewAutoSizeColumnsModeEventHandler   v2.0
    42 43  DataGridViewCellErrorTextNeededEventHandler   v2.0
    43 43  DataGridViewRowHeightInfoNeededEventHandler   v2.0
    44 43  DataGridViewRowHeightInfoPushedEventHandler   v2.0
    45 43  PerformanceCounterPermissionEntryCollection   v2.0
    46 43  TypeUniqueIdentifierSchemaImporterExtension   v2.0
    47 43  IRemoteArgumentDictionaryEnumeratorContract   v2.0
    48 43  ForeignKeyReferenceAlreadyHasValueException   v3.5
    49 43  SecurityPackageContextConnectionInformation   v2.0
    50 43  PrintSystemObjectPropertiesChangedEventArgs   v3.0
    51 43  IssuedTokenClientBehaviorsElementCollection   v3.0
    52 43  IssuedTokenParametersEndpointAddressElement   v3.0
    53 43  X509ServiceCertificateAuthenticationElement   v3.0
    54 43  TransportConfigurationTypeElementCollection   v3.0
    55 43  ClientFormsAuthenticationMembershipProvider   v3.5
    56 43  ServiceDescriptionFormatExtensionCollection   v2.0
    57 43  DispatcherUnhandledExceptionFilterEventArgs   v3.0
    58 42  DataGridViewCellToolTipTextNeededEventArgs   v2.0
    59 42  DataGridViewEditingControlShowingEventArgs   v2.0
    60 42  DataGridViewAutoSizeColumnModeEventHandler   v2.0
    61 42  DataGridViewColumnStateChangedEventHandler   v2.0
    62 42  DataGridViewRowErrorTextNeededEventHandler   v2.0
    63 42  DataGridViewRowDividerDoubleClickEventArgs   v2.0
    64 42  ToolStripItemDesignerAvailabilityAttribute   v2.0
    65 42  EdmRelationshipNavigationPropertyAttribute   v3.5
    66 42  BehaviorServiceAdornerCollectionEnumerator   v2.0
    67 42  DirectoryServicesPermissionEntryCollection   v2.0
    68 42  ForestTrustRelationshipCollisionCollection   v2.0
    69 42  X509ClientCertificateAuthenticationElement   v3.0
    70 42  ServiceControllerPermissionEntryCollection   v2.0
    71 42  DatabaseNotEnabledForNotificationException   v2.0
    72 42  DesignTimeResourceProviderFactoryAttribute   v2.0
    73 41  CryptographicUnexpectedOperationException   v2.0
    74 41  DataGridPreferredColumnWidthTypeConverter   v2.0
    75 41  IDesignTimeResourceProviderFactoryService   v2.0
    76 41  SiteMapDesignerHierarchicalDataSourceView   v2.0
    77 41  WindowsUserNameSecurityTokenAuthenticator   v3.0
    78 41  PrintSystemObjectPropertyChangedEventArgs   v3.0
    79 41  ConnectionOrientedTransportBindingElement   v3.0
    80 41  SecurityContextSecurityTokenAuthenticator   v3.0
    81 41  SecureConversationSecurityTokenParameters   v3.0
    82 41  X509CertificateInitiatorServiceCredential   v3.0
    83 41  X509CertificateRecipientServiceCredential   v3.0
    84 41  RecordDescriptionToTypeReferenceConverter   v3.0
    85 41  BlobMessageEncodingBindingElementImporter   v3.0
    86 41  DistributedTransactionPermissionAttribute   v2.0
    87 41  CompositeActivityDesignerLayoutSerializer   v3.0
    88 41  SqlPersistenceWorkflowInstanceDescription   v3.0
    89 41  AttachedPropertyBrowsableForTypeAttribute   v3.0
    90 40  DataGridViewAutoSizeColumnsModeEventArgs   v2.0
    91 40  DataGridViewCellErrorTextNeededEventArgs   v2.0
    92 40  DataGridViewCellStateChangedEventHandler   v2.0
    93 40  DataGridViewRowHeightInfoNeededEventArgs   v2.0
    94 40  DataGridViewRowHeightInfoPushedEventArgs   v2.0
    95 40  ListViewItemSelectionChangedEventHandler   v2.0
    96 40  DesignerSerializationVisibilityAttribute   v2.0
    97 40  TypeSmallDateTimeSchemaImporterExtension   v2.0
    98 40  SchemaImporterExtensionElementCollection   v2.0
    99 40  ProtectedConfigurationProviderCollection   v2.0
    100 40  DirectoryAttributeModificationCollection   v2.0
  • mwinkle.blog

    Where is System.Activities.Design in WF4 Beta2 and Beyond?

    • 0 Comments

    I got an email over the weekend asking about this, and I realized that it’s somewhat buried in this post here.  Anyway, in Beta1, you often saw System.Activities.Design.  For beta2 (and RTM), one important change

    System.Activities.Design  => System.Activities.Presentation

    The primary reason for this change is that the *.Design suffix is generally reserved for VS design extensibility.  As our designer ships in the framework, *.Design was not the correct suffix.  *.Presentation is where we landed. 

    Hoping that putting this in the title lands this high up in search queries so that this post might be useful for a few people.

  • mwinkle.blog

    Free WF Training Materials

    • 1 Comments

    Paul has the scoop, check this out. 

     

    Disclaimer: My voice may be the one that appears in parts of the WF training.

  • mwinkle.blog

    WCF Perf Talk @ PDC (or, the Doctor Teaches Fishing)

    • 1 Comments

    I'm probably not going to have too much time to attend talks at PDC, but one talk that would be high on my list is the one that Dr. Allen blogs about here, where he talks about the Zen of WCF Performance and Scale. 

    I like "Zen" style talks, especially for topics like performance and scale.  Sure, I could go and listen for 75 minutes for tips and tricks that may be applicable to my scenario, but this is giving you a fish.  Having a 75 minute conversation about how to think about perf and scale, how to think about achieving that in a distributed messaging system teaches you how to fish.  This is going to equip you with a lot more knowledge about how to plan for and solve performance and scale issues down the road.

    This is one lunch session, I wouldn't want to miss.  As a plus, he's taking questions and suggestions on his blog, so fire away!

  • mwinkle.blog

    Providing Callbacks for the Host (WF4 EditingContext Intro Part 4)

    • 0 Comments

    This part 4 of my 6  part series on the EditingContext.

     

    In addition to having a host provide an instance of a type to be used within the designer, it can also be used to pass an instance that will route callbacks to the host.  I covered this briefly in a previous post (Displaying Validation Errors in a Rehosted WF4 Designer).  In that case, we provide an implementation of IValidationErrorService, which the designer infrastructure will call, if available, towards the end of a completion of a validation episode.  In the sample application in that post, we use that instance to route, and display the validation errors in the system.

    Rather than duplicate the code, I will simply encourage you to check out that post and think about the way you could publish a service that your activity designers know about, and use it as a mechanism for calling methods within the hosting application. 

  • mwinkle.blog

    How I Spent My Winter Vacation

    • 1 Comments

    I haven't posted since prior to PDC, and since then it's been a whirl wind.  You see, in the middle of September, my wife and I had a healthy baby boy, so I've been a little busy since then with things like diapers, visiting family, etc.  Given the huge time crunch of PDC, I decided to cash in on Microsoft's awesome parental leave benefit and I have been away from work for a little over a month. 

    I started working for my dad's company during the summer when I was still in high school, in college I worked summers to pay tuition, and following graduation went right to work two weeks later.  I've never taken this much time away from work, brendan with grinand I sorely regret not having done it sooner.  When my daughter was born, I was unable to take much more than a week or so off, and I miss having been able to spend this kind of time with her. My boss and grand-boss were very supportive, including a few gentle slaps on the wrist when I did log in to check on a few emails.

    This gave me a great opportunity to really unplug after a crazy year, and an even crazier PDC.  Most importantly though, it let me really spend a lot of quality time with my new son while he's at a pretty fun age (as you can see from the grin)

    I stayed pretty true to my commitment to avoid work stuff, but I did keep up on tech news (including fun rumors) and started to lurk through some ASP.NET MVC stuff earlier in the break.  I've begun to become much more addicted to google reader, friendfeed and twitter than is probably healthy

    I also got to do a fair amount of reflection on work, what we're doing, what I'm doing, and how excited I am about the work that my team is doing.

    I'll be getting back to my more regular series of postings, first on some WF things, and then I'll start doing more posts on Oslo and more specifically, Quadrant.

  • mwinkle.blog

    More Workflow Service Questions

    • 1 Comments

    In response to this post, Anderson raised the following question.

    Definitely too hard and not service-oriented.  I like the idea of sending it via the headers or some other such implementation, but that would also require implementation on the other side in the form of an agreed-upon place and format of the context information or a custom binding implementation that you either distribute or have the other side of the fence reimplement.

    The first time I did this I spent days working on it saying to myself "surely you don't have to do this... surely you don't have to tell the target service which *activity* you want it to talk to next".  But you do.  It makes me sad inside.

    matt:  Our general goal is not to introduce more misery into the world.  At this point in time, doing duplex requires the explicit management of the context token.  We're working to make it better, so hopefully around PDC time, you will no longer be sad inside. 

    One thing I've not seen implemented yet in a demo.  I really like the feature of State Machine super states and substates.  The ability to take a group of 3 states and put them in another state called "Cancellable" or some other such interrupty business function is really kickass.

    Let's say you are in state "Processing" which has an event-driven that listens for the service method "FinishedProcessing".  "Processing" is also in a superstate called "Cancellable" with an event-driven that listens for "CancelProcess".  How could you implement this when you have to tell the other service about the context identifier of the target receive activity?  Do you have to send both contexts?  I fear your answer will be yes.

    matt:  In that case, provided you are not listening for the same operation in two places, you can get away with grabbing the context token from either FinishedProcessing or CancelProcess and send that along.  The context token will be the same fore either of them, it will only consist of the Workflow Instance Id.  The Instance Id + the OperationName is the combination used to enqueue an inbound message, unless you've gotten clever as in the Conversations sample and told the Receive activities to create queues based on an additional conversation id. 

     

    Also, it sounds like Anderson is delivering a talk tomorrow night in Dallas about WCF /WF integration.  If you're in the area, head on over and check it out.

  • mwinkle.blog

    10-4 Good Buddy, First Look at WF 4

    • 1 Comments

    Our WF evangelist, Ron Jacobs, just posted a 10-4 screencast that walks through WF4 as it's looking in VS 2010.  This is a good first look at our bits since PDC (we've changed things a little bit).  I really like that he takes it from a unit testing perspective.  There are certainly things that have been added (like WorkflowInvoker.Invoke) which will make testing activities a lot easier than the 3.0 days.

    Check it out, let me know if you've got feedback. 

    Get Microsoft Silverlight

  • mwinkle.blog

    workflowRuntime.CreateWorkflow(typeof(mwinkle));

    • 0 Comments

    So here I am...

    Two weeks following my NEO (new employee orientation) here in Redmond, I've finally caught my breath enough to put an entry up on this blog.

    First, a little bit about me, before I dive right into all things workflow.  I'm from St. Louis, where I grew up, and spent the last five years working for two different Microsoft partners.  Then, in January, I decided to accept a position here at Microsoft as the technical evangelist for Windows Workflow.  My wife, daughter, and pug then headed out here.

    I'm out here now as the Technical Evangelist for Windows Workflow. I'm working in James Conard's Longhorn Server Evangilism team, with some other evangelists are doing some cool things.

    I'm focused on talking about Windows Workflow, so let me start by talking about why I am so excited about it.  Almost every application, from an embedded video controller, to an enterprise content management system, manages a lot of the same things.  We manage where we're at, where we're going.  We (should) track where  we've been, what we're doing right now, how long things are taking, and we should make that information easy to see.  We usually need to act over a period of time that's longer than a quick void main(), and we should be able to gracefully recover in the case where something goes wrong.  If we don't like the way a current app is handling these things, we should be able to swap that out with an implementation
    that fits our situation a litle better.

    Now, a well-designed, well-planned, well-coded and well-tested solution will handle a lot of these scenarios. Windows Workflow Foundation gives a toolkit to developers that does a lot of this for us, giving us a very well designed base to build our apps on top of.  A lot of that infrastructure that we write again and again on applications, or bake into frameworks we push out to our organization's developers to use, exists in Workflow already.  We can easily extend it to map to our specific objects by writing our own activities.  We can incorporate those activities (graphically) into our program flow or composite those basic activities into more  complicated ones.   If the out of the box host doesn't meet our needs, we can write a new tracking service, a new persistance provider.

    These are common problems faced in many problem domains, and this is an incredibly versatile swiss-army knife that many developers will be able to use. I'm excited becuase I think it's a well designed product, and I think it's something that almost every developer can use, and I can't wait to hear about how everyone's using it!  Until next time, check things out at http://www.windowsworkflow.net/

  • mwinkle.blog

    We're Hiring

    • 2 Comments

    My team is looking for people interested in building the next generation of the WF designer.  We've posted an opening here, please let me know if you're interested. 

    I can't really say too much about what we're building, but it's a great team that's committed to creating a great experience for building, editing, and viewing workflows.  Everyone on the team believes in the power of a declarative model of process, and believes that tools are the way that model is consumable by humans.  Everyone also believes that we're making it easier to write code and solve problems with software, which makes our mission exciting.

    From the job posting:

    Windows Workflow Foundation (WF) is the workflow engine that powers SharePoint, Speech Server, the next major release of BizTalk, and countless customer and partner solutions as part of the .NET Framework. Our team builds the tooling that allows people to rapidly model, execute and debug the execution logic of their applications in a rich, graphical programming environment. The tools we build range from flowchart and process designers, to the visualization and management of complex rule sets. If you’re passionate about enabling the rapid modeling of process, or creating a great user experience building on the power of WPF, check us out. The tools we build will ship inside the next release of Visual Studio and the .NET Framework, and support the “Oslo” effort currently ongoing in Microsoft’s Connected Systems Division.

    The Program Manager role so far has been a great experience for me (coming up on 4 months now).  If you've got questions, drop me a line at mwinkle [at] [large redmond based software firm].com. 

  • mwinkle.blog

    MSDN Workflow Webcast Info

    • 2 Comments

    I did my first MSDN webcast this morning (you can find details about it here).  As promised I wanted to put in links to all of the demos that I did during the webcast.  If you have any questions, please let me know.  SDK samples are available in the \Program Files\Microsoft SDKs\Windows Workflow Foundation\Samples.zip.  I usually just expand the zip file so that I have a samples subdirectory in that folder.

    • Long Running Processes (expense reporting sample)
    • Using Comples Rules (rules driven ui sample)
    • Ad Hoc Workflow (SDK:  Samples\Applications\SpeechApplication)
    • Customizing Workflows Inflight (not shown in the webcast, SDK: Samples\Technologies\DynamicUpdate\FromHost)
    • Surfacing Process Information (SDK: Samples\Applications\WorkflowMonitor)
    • Allowing Users to Customize the Workflow (custom designer sample, this will be posted shortly)

    Special thanks to Vittorio Bertocci and Iwona Bialynicka-Birula for their work on the custom designer sample application.

  • mwinkle.blog

    Regarding Re-use of Context-aware Proxies

    • 1 Comments

    Yesterday, following my "What's the context for this conversation" presentation, I was approached with the following question:

    I am sharing a singleton client that I want to use to interact with multiple workflow instances, how do I change the context for each of them.

    Completely unbeknownst to me, Wenlong, one of the product team's more prolific bloggers, addressed this very topic in his post here, conveniently posted yesterday :-)

  • mwinkle.blog

    TechEd 2008

    • 1 Comments

    TechEd Developer kicks off next week in Orlando, the first time the US group has tried the European model of separate dev and IT pro weeks.  I've grown to like the model in Europe a little better, because I think both attendees and speakers benefit from the greater focus within their specialized areas.  The people who it hurts are obviously those who fall squarely into both camps, but at the US events, I have not run into many of those.

    The conference agenda is getting busy for folks who like to stay on top of Microsoft technologies (or who like to speak at these events), with MIX in the spring, PDC in the fall, and TechEd in the summer, and that's just the US centric Microsoft "general" conferences.  I'm intentionally excluding the Office Developer Conference, international conferences, and those that are not directly put on by Microsoft, such as VS Live.

    Why am I going next week?  In short, it's to give a session talking about advanced WF+WCF integration, but more importantly to escape the Redmond bubble and find out what's actually happening to real customers in the real world.  Those interactions become more and more valuable as we work to build tools to help those customers build applications.  A few of the sessions I'd be interested in as an attendee:

     

    SOA209 The Road to “Oslo”: The Microsoft Services and Modeling Platform

    Thursday, June 5 1:00 PM - 2:15 PM, S220 A 

    Speaker(s): David Chappell

    Microsoft’s “Oslo” project aims at creating a unified platform for model-based, service-oriented applications. This new approach will affect the next versions of several products and technologies, including the Microsoft .NET Framework, Microsoft Visual Studio, Microsoft BizTalk Server, Microsoft System Center, and more. Although many details of “Oslo” won’t be public until later in 2008, this session provides an overview of what Microsoft has revealed so far. Along with a description of the problems it addresses, the session includes a look at several new “Oslo” technologies, including a general-purpose modeling language, role-specific modeling tools, a shared model repository, and a distributed service bus.

    Why? This is the first time we'll be saying more about what's going on in Oslo.  David's a fantastic speaker and the approach he will take with this presentation will take a lot of what we've said so far and tie it together.

     

    SOA302 Framework and Microsoft BizTalk Best Practices with an Eye Toward "Oslo"

    Wednesday, June 4 4:30 PM - 5:45 PM, S210 B 

    Speaker(s): Jon Flanders

    Microsoft has announced "Oslo", the code-name for a wave of technology affecting the Microsoft .NET Framework, Microsoft BizTalk Server, and the idea of building service-oriented systems using Microsoft technologies. In this session we discuss what we know so far about these technologies, and how to think about what you are currently doing with Windows Communication Framework/Windows Workflow Foundation and BizTalk Server to best prepare for the future.

    Why? David's talk is more about the ideas, Jon's talk is more about the tech.  If you code WF, WCF, or BizTalk solutions today, this will be a great talk to understand how to make your apps ready to take advantage of the new features coming in Oslo

    SOA305 Getting Workflows Running and Talking in Your Applications

    Friday, June 6 1:00 PM - 2:15 PM, S320 E 

    Speaker(s): Brian Noyes

    Once you understand the basics of Windows Workflow Foundation (WF) and can put together a workflow using the built-in activities, you will need to know how to get that workflow running in a variety of hosting environments and communicate between the workflow and the host application or the outside world. This session gives you a solid foundation to get started with these techniques. Gain a better understanding of how workflows exist in a hosting process and how to control the hosting services. Learn about the various forms of communication that can exist between a running workflow and the hosting application as well as with outside Web and WCF Services. Also, learn about the persistence and tracking features of WF.

    Why? Brian's talk will focus on how to get workflows communicating, something that's neccessary in any WF app.  I'll follow on this talk with an advanced look at WC+WCF integration in .NET 3.5

    SOA403 Building Federated Solutions on the Internet Service Bus

    Thursday, June 5 10:15 AM - 11:30 AM, S220 C (DEV) 

    Speaker(s): Clemens Vasters

    Using the code-name "BizTalk Services," Microsoft is building a set of "cloud" technologies that are developed and operated by Microsoft as a logical extension to the .NET Framework and the Microsoft SOA technologies. They aim to enable corporate software developers and ISVs building solutions that require broad, cross-organizational identity management, the ability to safely and securely traverse NATs and Firewalls to enable bi-directional communication, Internet-scale publish/subscribe services, broad interoperability, and services orchestration. In short, these technologies are expanding the reach of the ESB pattern to the Internet—that’s why we call it "Internet Service Bus." In this session, Clemens takes you along on a "lots of code" tour through an exemplary solution built using these technologies.

    Why? Get on the bus, baby!  This team is doing some very cool stuff in the cloud, and the infrastructure that is being provided is something that enables you to focus on the cool stuff your app does, not the bizarre intricacies of network traversal or identity management implementation details.

    TLA304 The Nine Essential Power Tools for Every Developer: Extending Microsoft Visual Studio to Enhance the Microsoft Office Development Experience

    Wednesday, June 4 8:30 AM - 9:45 AM, S320 E 

    Speaker(s): John Durant

    Check out the first release of Visual Studio Power Tools, a set of free tools that enhance the design-time or runtime capabilities of Office development in Visual Studio 2008 Professional.This session includes demos of all the tools, such as the Office Interop API Extensions library which brings optional and named parameters to Microsoft Visual C#, the Ribbon IDs Tool Window, and the SharePoint Workflow Package Generator. Come check them out and find out how you can start using them today

    Why?  John is a great speaker, he once appeared at a talk I set up wearing Heelys and wheeled around the audience blasting through technical details.  At 8:30 am, this talk is a great way to start your Wednesday.

    TLA317 Busy .NET Developer's Guide to Microsoft F#

    Speaker(s): Luke Hoban, Ted Neward

    F#, Microsoft's new functional language for the Microsoft .NET platform, makes it easy—as in, half the total lines of code easy—to create business objects for .NET applications that can be used from any other .NET language, like Microsoft Visual C#, Visual Basic, or Visual C++/CLI. In this presentation, we look at how to do this in F#, the advantages of doing so, and how doing this simplifies your life as a .NET developer.

    Why? Luke gave this talk in Israel where it was well received.  The addition of functional programming into the VS family of languages is a huge win for developers.  This talk will help you think about programs from a functional perspective, and show you how to do it.

Page 3 of 6 (148 items) 12345»