• mwinkle.blog

    WF, BPEL and the Dark Side of the Moon


    There are a few common questions I usually get when I talk about workflow:

    • That's great, but I can't use SQL Server, can I use foo ?
    • How can I use it to re-unite Pink Floyd for one last tour?
    • What about BPEL support?

    Question 1: Check out the Persistence Service sample in the SDK.

    Question 2:  Man I wish I could say yes, but that's probably a feature that might show up after Orcas if I have my way.

    Question 3: We've done some dancing around this on timelines when it has been brought up in the past, but Paul has the scoop here.  I think this is a great thing for our customers, the support for BPEL not only allows the use of additional process defintion artifacts in the enterprise, but is a great demonstration of the flexibility and extensibility of WF.

    Paul also talks about how this also impacts BPEL in BizTalk Server.

    I'm going to be filming a Channel9 video with the team behind this in the next week or so.  It's Vista Week on Channel9, once that's done I will try to get it posted quickly.

  • mwinkle.blog

    WF, WCF and CardSpace training materials posted


    We've put a fair amount of content out on the community site.  4 days worth of presentations, labs and demos to be specific.  Check it out here.  It's about 50MB worth of downloads, the page shows 11.4kb in errror, that's just the size of the license page.

    The content breaks down like this:

    • Demos
    • Labs
    • Presentations
      • Day 1
        • Overview on the technologies
      • Day 2 - WCF
        • Contracts
        • Bindings and Behaviors
        • Security, Reliability and Consistency
      • Day 3 - WF
        • Custom Activities
        • Hosting
        • Workflow and Communication
        • State Machine Workflows
      • Day 4 - Identity and CardSpace
        • Identity Metasystem
        • CardSpace

    Download the content and let us know what you think!

  • mwinkle.blog

    Mechanical Turk Activities


    Mark Blomsma has put together some activities and an article which shows how to interact with Amazon's Mechanical Turk with WF activities.

    I've linked to the sample on here.

    Cool, cool, cool

  • mwinkle.blog

    DinnerNow, the other thing shipping


    One of the things my team has been working on for the last few months has finally been released.  It started with a discussion in James' office and has come pretty far from there.  You may have seen it at some of the launch events, but unlike a lot of traditional demos, we're releasing all of the code with a great installer that David Aiken wrote in order to make sure all of the moving pieces and parts get put in the right place.

    What is it?

    DinnerNow demo
    DinnerNow demo

    Check out the video on soapbox

    Pieces and Parts, what do you mean by that?

    The only thing we couldn't get into v1 of this thing is the ability for it to flush toilets remotely.  Never fear though, we are working hard to get this into a future release :-)  Here's a list of the technologies that we have in this thing:

    • Vista and Longhorn Server platform API's (things like the transactional file system)
    • IIS 7 modules
    • ASP.NET Ajax extensions
    • Linq
    • Windows Communication Foundation
      • Queued Services using MSMQ
      • "Normal" WS-* web services
      • POX and RSS over WCF
    • Windows Workflow Foundation (bunch of details on this to follow)
      • State Machine and Sequential
      • Correlation
      • Use of the ReplicatorActivity to execute in parallel
      • Designer Rehosting
      • Communication between parent and child workflows
    • Windows Presentation Foundation (even us server guys figured out a way to make it look pretty)
    • Windows Powershell (David's life wouldnt' be complete if it wasn't in there)
      • Powershell commandlets that query the workflow tracking store!
    • Windows CardSpace
    • .NET Compact Framework (because we don't want our mobile folks to feel left out)
    • Incredibly cool installation experience (we worked really hard to make sure all of the above pieces are configured properly)

    Where can I get it?

    Check out the website and you can get the code from codeplex.  If you find something you don't like, file a work item in codeplex, it leads right into our TFS system.

    What now?

    Go, get the code and install it on a Vista or Longhorn Server machine.  Let us know what you think!  We're going to be pushing out some additional information in the upcoming weeks, let us know what you think!

  • mwinkle.blog

    Tracking Objects and Querying For Them


    A sample that I like to give during WF talks is that the tracking service can be used to track things at an event level ("Workflow started") as well as things at a very granular level ("What is the Purchase Order amount?"). 

    I wanted to put together a sample showing these, and you can find the file on netfx3.com

    In order to track things, we first need to specify the tracking profile.  This tells the workflow runtime which events and pieces of data we are interested in collecting while the workflow executes.  I think that the xml representation of the tracking profile is pretty readable, but there is a tool that ships in the Windows SDK designed to make this even easier.  The tool can be found after extracting the workflow samples to a directory under \Technologies\Applications\TrackingProfileDesigner.  This tool will let you open up a workflow by pointing at its containing assembly and then design a tracking profile.  It will deploy the tracking profile to the database for you, but I borrowed some code from another sample that shows the same functionality.  The tool allows you to specify workflow level events as well as activity level events, and allows you to designate what information you would want to extract and specify the annotation as well.

    The output of the designer is an xml file, which we will edit further by hand.  The important parts to look at are the tracking points, that is, where and when do we extract what data.


                      <Type>TrackingObjectsSample.CreditCheck, TrackingObjectsSample, Version=, Culture=neutral, PublicKeyToken=null</Type>
                  <Annotation>data extracted from activity</Annotation>

    Here we specify the tracking location, in this case the CreditCheck activity, as well as the events we wish to listen for, and finally what data we want to extract.  I like to point out in the extracts section that we can take advantage of dot-notation in order to traverse an object hierarchy to get to specific pieces of data we wish to extract.  If we don't get down to the simple types, the workflow runtime will attempt to serialize the object and store it as a binary blob (so make sure you mark the types you want tracked as serializable).  This is what is being done with IncomingOrder above.  This will allow us to bring back IncomingOrder, but we won't be able to query against that blog, hence why we might extract OrderTotal in order to generate a report of high value orders.

    When we track the information it will get stored to SQL (assuming we are using the SqlTrackingService).  There are a number of views we could use to build queries on top of.  The one I want to point out is the vw_TrackingDataItem view which contains all of the tracking data items (so it is well named :-) ) The FieldTypeId references back to vw_Type where you will see the different type of objects and their respective assemblies which are being tracked.  This lets the consume know what type of object they may need to instantiate if they wish to consume the object.  But what about querying on that object in plain old SQL?  Well, there is a column in the view designed for that.  The Data_Str column will show a string representation of the tracked item, so in the case of numbers and strings and other basic types, we will be able to query.  In the case of complex types, the name of the type will appear.  This is basicly the ToString of the object being tracked.  The Data_Blob column contains the binary represenation of the objects in order to restore them into objects inside of .NET code.

    So, back to the task at hand, the sample.  A simple workflow has been created that takes an Order object.  The workflow doesn't do much, although the last code activity modifies a value of the Order object.  We do this to show that the changed values can be tracked over time.  The workflow runtime uses the SqlTrackingService, and before this all starts the tracking profile is inserted into the database using the InsertTrackingProfile method that is used in the SDK (I grabbed it from the UserTrackPoints sample: \Technologies\Tracking\UserTrackPoints).  The workflow then executes.  Clicking on the "Get Tracking Info" button will then use the SqlTrackingQuery to get a SqlTrackingWorkflowInstance, an object representation of all of the available tracking information.  We then iterate over the various event sources in the SqlTrackingWorkflowInstance such as the workflow events and the activity events and place them into a TreeView.  This could easily be extend to include user track points as well.  The following bits of code which do this are below:


    SqlTrackingQuery query = new SqlTrackingQuery(connectionString);
    SqlTrackingWorkflowInstance sqlTrackingWorkflowInstance;
    if (query.TryGetWorkflow(new Guid(WorkflowInstanceIdLabel.Text),
                out sqlTrackingWorkflowInstance))
         TreeNode tn1 = treeView1.Nodes.Add(string.Format("Activity Events ({0})", 
         foreach (ActivityTrackingRecord activityTrackingRecord in sqlTrackingWorkflowInstance.ActivityEvents)
            // do something here

    It is useful to place a breakpoint in the foreach loop in order to inspect the different aspects of the ActivityTrackingRecord and the other tracking objects that live inside of SqlTrackingWorkflowInstance.  By looking at the TrackingDataItem 's that are placed in ActivityTrackingRecord.Body we can find the field name as well as its value, which could be an object.  By browsing around in the break mode, the debugger will take care and allow you to move through the serialized object which will be present inside the TrackingDataItem.Data.

    Link to sample code

  • mwinkle.blog

    WF and BizTalk Server 2006 R2


    One of the cool things coming in BizTalk R2 is a tracking service for WF that talks to BAM.  Jesus Rodriguez has put together a walkthrough of using the BizTalk Server R2 BAM interceptor for WF.

  • mwinkle.blog

    Upcoming Ohio and Michigan Tour


    Next week I will be in Ohio and Michigan meeting with customers and speaking about Windows Workflow Foundation at the Cleveland and Ann Arbor .NET User Group meetings.  If you're in the neighborhood, you should stop on by!

    I'll be posting slides from the talks and will try to summarize questions that I get here as well. 

  • mwinkle.blog

    Hosting WF inside a Windows Service


    Dennis has put together a nice sample showing how to host a workflow inside of a Windows Service, a common request for people looking to host long running processes.  Check out his posting here.  This sample is also available on the community site here.

    We're working on some other samples around hosting, so stay tuned for details on those!

  • mwinkle.blog

    Matt and Paul talk WF


    A few weeks back Paul Andrew and I sat down with Ron Jacobs to record this Arcast about WF. 


    The funny thing is that a few weeks before that, Paul Andrew and I sat down with Ron Jacobs to record that same Arcast, except there was a problem with the microphone and Ron's voice didn't get recorded, so it was as if Paul and I were extemporaneously responding to the voices in our heads about WF.

    There are more questions to go through, so we will be doing at least a part 2.  Any feedback or other questions you want to see answered? Let me know! 

  • mwinkle.blog

    WF inside of SharePoint


    I'm a little late to notice this, but Eilene Hao, a PM on the SharePoint Workflow team, has put together a massive 7 part series on writing workflows in SharePoint. I haven't focused a lot on workflows inside of Office, looks like I need to spin up a VPC and dive through some articles!


  • mwinkle.blog

    Where Are the Tools?


    I get a number of queries about when WF will ship, or (more frequently) when the tools will be ready.  The answers are "done" and "done."  I've had two internal requests in the last week along these lines, so I wanted to try to state this as clearly as possible.  The tools for WF are released and supported.  The tools for WCF and WPF are in CTP and will continue to be updated in a CTP like fashion.

    You can get the bits from the list of links here.

    It is important to point out that the "Visual Studio 2005 Extensions for .NET Framework 3.0 (Windows Workflow Foundation)" is shipping and supported, while similarly named "Visual Studio 2005 Extensions for .NET Framework 3.0 (WCF and WPF), November CTP" are being published as a CTP, so things can and will change with the WCF and WPF tools.  Let me say that one last time in case you got caught up in the names: 

    The tools for WF are released.  You can use them today. 


  • mwinkle.blog

    Solution Showcase Launched


    Head on over to http://showcase.netfx3.com and check out the solution showcase.  You can dive down and search through the tag cloud to find solutions that are interesting to you. 

    If you'd like to have your solution featured here, go to this form and submit the information.  We'd love to find out more about how you're using the .NET Framework 3.0 technologies, and let you get the word out about your solution.

  • mwinkle.blog

    Back From Barcelona


    I arrived into SEA yesterday around 3, so I'm feeling a little bit of the 'lag from my week in Barcelona.  A few things to point out:

    • Tim has a fantastic "Vista on the M400" post.  The little dude's getting an upgrade while this gets typed, results in a future post
    • Kudos to who-ever put together this diagram.  I think it could be made a bit better by having links to the section of MSDN which further explains how to dev, say, win32 or hybrid applications, but it's a nice way to represent and download the bits you're interested in. 
    • The long awaited WF perf whitepaper is available, as Paul points out.  As Paul mentions, the 10K empty workflows per second is not a number one should run out a room assuming can be obtained, but there are a few things that I really liked seeing:
      • What happens when we scale out?
      • Should I implement a while loop in my code to loop 1000 times, or should I use the While activity?  This is one of my favorite examples when people ask "How should I think about moving to a WF driven design?"  I like this paper as it explains things in terms of trade-offs.
      • Finally, beneath figure 13, the discussion of the overhead involved with using the tracking service is discussed.  This is important, and it shows the difference between batching and not batching the "transactions" of the tracking service.  Transaction is mentioned in quotes as these have little to do with System.Transactions, rather when tracking data is written to the database.  The number to notice here is not just workflows per second, but also the increased load on the SQL Server.  Again, these are just some things to think about when you start discussing "perf" with workflow.  The papers about 50 pages long, so there's a bunch of stuff to see there.  Check it out!
    • Thanks to everyone who dropped in on my sessions in Barcelona.  I'll be posting some followup information when I get a little time to recover (or at 3:30 tomorrow morning when I am wide awake and thinking it is lunch time in Barcelona :-) )
    • There's also this page, which is a nice gateway into downloading all sorts of the things we talked about at TechEd.
  • mwinkle.blog

    Did you hear the news, .NET 3.0 is live


    Things got signed off last week, and early yesterday (depending on the timezone), the RTM build was published on MSDN.  James put the details up on the community site, and there's been a ton of people headed to check it out (look at all the trackbacks on James' post).  Thank you to all of the bloggers who have picked up the story and are passing it along.

    So, now what?  Well, there's still plenty of work for me to do, including looking forward to vNext (the great part of evangelism!)  In the short term, I'll be presenting today on Reliabilty, Scalability and Maintainability of workflows hosted in IIS here in Barcelona. I won't be talking about the IIS scenario nearly as much as the other three parts, as well as discussing some performance information.  After the talk, a number of us are headed to a soccer game, which I'm looking forward to.    Tomorrow, Paul Andrew and I are conducting a drop-in clininc for WF, so, if you got questions, stop on by.

    So, what's next for you?  Get the bits, get some training, and start writing workflows!


    [updated] realized I had a problem spelling "hear" in the title :-)

  • mwinkle.blog

    Off to Barcelona!

    I'm in the office this morning, wrapping some things up and then it's wheels up to Barcelona for a week.  Paul, Clemens, Shy and I will all be there hanging out somewhere between our talks and the Connected Systems booths, so stop on by and say hi!
  • mwinkle.blog

    Free WF Training Materials


    Paul has the scoop, check this out. 


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

  • mwinkle.blog

    SOA Conference Questions


    I headed over to building 33 yesterday for the Microsoft SOA and Business Process Conference to host a Q&A session with some other people from the Connected Systems division (Clemens, Shy, Lee and Joe).  We had a pretty decent audience, and I wanted to repost the questions that I got here and answer them.

    Will Speech Server (or SharePoint, or other hosts) let me run activity x?

    The other big host to talk about right now is Office, in SharePoint.  The answer, in true consultant fashion is that it depends.  It will really be left up to the implementation of the host as to what behavior they will allow.  For instance, the SharePoint host will not allow the addition of additional services.  This has been done for performance, stability and security reasons.  SharePoint is also very particular about the activities it will allow to be executed, using the concept of a white-list in order to mark activities as able to be run.  You can imagine that allowing a code activity could be a very bad thing in SharePoint, and thus, it is not allowed. 

    These are all hosts for WF, their behavior is chosen to optimize for the scenario to be used in.  Similarly, you may have the same constraints, which you can enforce in your host, or maybe you have none of them, in which case, you don't need to implement any of them.

    Is the WF Rules Engine a Rete Engine?  (with follow on: If not, why not?)

    No, the WF Rules Engine is not based on a  Rete algorithm.  Check out Don's blog posting here.  There are a few relevent paragraphs I will repost here.

    There are plenty of resources out there that describe what the Rete algorithm does and why it is so often used in Rules engines. At the end of the day, Rete is an optimization. You don't need a Rete engine to implement a forward-chaining rules engine; however, the Rete optimization may improve the runtime performance of a Rule Set. That's what optimizations do. In particular, Rete reduces the number of predicate evaluations by remembering the most recent value and re-using it on subsequent re-evaluations.


    I certainly concede that there are many examples of Rule Sets that contain a lot of common predicates. In those cases, a Rete-based Rules engine like BRE will crush a non-Rete engine like WF Rules. However, in cases where there are few common predicates, the reverse has also been demonstrated: WF Rules and its non-Rete execution mechanism will crush Rete-based BRE.

    My point is simply that Rete is an optimization strategy that is not necessarily appropriate for all Rules-based solutions. For WF Rules, we placed much more importance on how much you can express in your Rules, how easy it is to express it, and how well it integrates into Windows Workflow Foundation and the .NET framework.

    If you're interested in more things about rules, Kavita emailed me the other day to let me know the team has started blogging here.

  • mwinkle.blog

    Sweet Actvity Designer


    Mark Schmidt recently posted a great sample to the community site showing how you can implement your own activity designer to include animations on the designer.  If that doesn't sound useful to you, it's still a valuable sample to see how you can control the various design aspects of an activity using the designer attribute.

    Check it out here.

  • mwinkle.blog

    Sudoku Validator, part I - Rules and Collections


    When I go out and I talk to partners and customers about WF there is a lot of interest in leveraging the rules capabilities.  Whether they are looking to have declarative rules inside their workflows, or by executing complex policy against a set of custom objects in any .NET code, there's a lot about rules to like. 

    I'm working on a sample which uses Rules to validate a Sudoku board, namely from Sudoku sample on the community site.

    Now, there are plenty of complicated ways to determine if a Sudoku configuration is valid (and plenty of other ways to solve the Sudoku [including Don Knuth's Dancing Links approach to solve the Exact Cover problem for Sudoku]).  But I'm going to focus on a relatively simple, validate rows, validate columns and validate boxes approach. 

    I'm going to need to operate my rules across a collection, namely a 2-dimensional array of integers.  So, how do we operate across a collection?

    Searching in the SDK, which is full of fantastic information, leads us to the "Using Rule Conditions in Workflows" section.  In there you'll find the "Collection Processing" section that outlines how you can process over collections.  It goes a little something like this (in descending priority):

    • Rule 1: Create an initialization rule, with a higher priority than any of the rules that follow.  This is where you can get the enumerator for the collection.
    • Rule 2: Get the current object (this is where we check to make sure we should keep on enumerating by having enumerator.MoveNext() as our condition.  To re-evaluate this rule, we either need to modify enumerator, or we need to explicitly call Update("this/enumerator") in order to cause this rule to re-execute.
    • Rule 3: Execute rules against this instance of the item
    • Rule 4: Lowest priority, we need to make sure this gets evaluated every time, so something like this.currentInstance == this.currentInstance is a good bet.  Because we update currentInstance, this rule will eventually re-fire, but due to its lower priority will execute after the actions on the current instance.  The condition of this rule is that we update the enumerator (the fact that rule 2 depends upon, causing us to loop back up to rule 2 and begin executing on our next instance.

    Now, I have an array.  Sure, I can get the enumerator from this, but I'd like to use an integer which I update to navigate through this array.  This is important to me because I need to know where I am at in the process (the 1st element or the 5th element) in order to convey some relevant information out to the user.

    For an array, we've got a little simpler pattern that incorporates some shortcuts, we could certainly do the approach above, and if we're sure of our incoming variables (namely the integer we use to keep track of our current position), we can do it in one rule.  The rule looks like this:

    if (i < ItemCount)


    total = total + items[i]

    i = i + 1  <== this is what causes the rule to then re-evaluate itself due to chaining

    We have an initial rule, with a priority of 2 set to initialize i to 0.  But wait, you may say, why does my class need to have this iterator.  The short story, it doesn't, but you have to have it somewhere, so what I have done is create a rule helper class that contains an instance of the class I am interested in executing the ruleset on, along with whatever "support" variables I need.  So, we use the rules engine chaining capabilities in our second rule, with priority 1, to force the re-execution of the rule as many times as we need.  And thus, we iterate over our simple array, the collection we all start from!

    Ok, you may say, but I want a sample of this working when I truly have a collection of custom objects.  Let's do that as well.  There's one tricky thing to note here:  The Intell-sense like interface sometimes makes it hard to consistently case stuff.  I spent a while chasing down why my ruleset was only executing twice when I had 30 objects in the list.  Consistently casing things made that work right.  The problem that I had was that the final rule, was cased to the member variables, all lower case.  The rule where I set the current item to the next one in the stack was cased to the property.  When I changed this, because the symbol names didn't match up (the facts, if you will) the engine did not know to re-execute my final rule, which in turn did not call update to cause everything to re-evaluate.  I also had some odd behavior with a typed IEnumerator (from System.Collection.Generics), but it appears now that things are working fine after discovering and correcting the cAsInG issues.  So, like I said, pay attention to your casing, especially if you follow a variableName / VariableName naming scheme for C# private variables and properties.

    Also, check out Moustafa's post on how you can use rule tracing to see what rules executed, this is what clued me in to what was and wasn't happening.

    In the meantime, you can check out the sample that I have posted to the community site here.

    Steps to get the application to work:

    • Download and extract the RulesWithCollectionSample
    • Open the RulesWithCollectionSample solution and build it
    • Download and extract the External RuleSet Toolkit, and create a rules database.
    • Import the rules from the .rules file in the RulesWithCollectionSample folder (you will need to point it to the assemblies of the RulesWithCollectionSample solution that you just built)
    • Save this to the rules database
    • Make sure the app.config file points to the right rules database.
    • Hit F5 to run, and you will be able to add numbers in one of two ways (via an array or a collection of objects)

    I look forward to your feedback!

  • mwinkle.blog

    RC Madness


    Moustafa has the scoop, right before a three day weekend here in the US, here's the RC of the .NET Framework 3.0 made available.


    And from what I hear, there is a Go-Live license for this as well!

  • mwinkle.blog

    Office Activity, or Wrapping Existing Code Quickly


    One of the nice things about the WF activity model is that you can pretty rapidly take existing code and expose that functionality out as a WF activity.  I was reading on Doug's blog, and noticed that he's got a series going where he will create an Open XML document (the XML based representation of the next version of Office documents).  He's got two parts so far, a Word document and an Excel spreadsheet creator.  I've taken those and wrapped those into WF activities that are available on the community site (Word document activity, Excel spreadsheet activity).  Make sure to check out the implementation notes on Doug's site, if you want to do some large scale number crunching in Excel, this would be a good start, but you would want to change so that it doesn't write out a single cell at a time.  Formatting and formulas are also not included in this sample, but you could easily extend to support these by diving through some other Open XML posts.

    The Excel activity takes in a dictionary with cell references and then its values (see code below).

             Dictionary<string,object> cellContents = new Dictionary<string, object>();
             cellContents.Add("A1", "hello World");
             cellContents.Add("B2", 34);
             cellContents.Add("C5", 232);

    There is one trick to remember and that's to add the reference to WindowsBase (on my machine, located at: C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\WindowsBase.dll) if you're looking around for System.IO.Packaging.

    When he gets a Powerpoint post up there, I will wrap that up in an activity as well.  If anyone extends these to support some more advanced scenario, or have a really nice design experience (think grid control), please let me know, and we'll get your version hosted on http://wf.netfx3.com!

    Let me know what you think!

  • mwinkle.blog

    In this corner... (and $100)


    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

    24 Workflow Screencasts Posted to wf.netfx3.com


    The other day, someone directed me to Mike Taulty's blog (http://mtaulty.com/blog/ ) where he has some fantastic posts about using Windows Workflow Foundation (check out his post on long running activities).  Mike also has put together a ton (24 as of today) screencasts on using WF. 

    These have been added to a new screencasts directory in the file area.  Dive in and check them out.  If you've got screencasts that you're doing, feel free to upload those as well.  Once they get approved, they will be added into this directory.

  • mwinkle.blog

    Tracing Rules Execution


    So, we've got some examples of using the WF Rules Engine outside the confines of a workflow (see here, and here).  One feature you get inside of a workflow is that the rules engine will utilize the tracking service, if one has been provided, to log out information regarding rule execution.  Moustafa shows how you can use System.Diagnostics tracing in order to have the same effect when using the rules outside a workflow. 

    Take a look at this sample, especially if you are interested in incorporating the WF Rules Engine in a non-workflow application.  This would be something nice to attach a config flag or other setting to in order to enable rule tracing, which may be helpful if you are trying to debug a complex rules scenario.

    I'm working on putting some other rules samples together, if there are specific scenarios you are interested in, drop me a line and I'll see what we can do!

  • mwinkle.blog

    WF & Sudoku


    I would be remiss if I did not point out this, a sample showing a nice WPF interface, WCF peer-to-peer communication, and WF to handle the logic of game generation.

    I'm going to take a look at it and see if we could use rules as the validation mechanism, that way there is a "server" and a "client" workflow component to the application.

Page 5 of 6 (148 items) «23456