Embedded Player

Episode Transcription

Hello everyone and welcome to THE .NET Core podcast - the only podcast which is devoted to:

  • .NET Core
  • ASP.NET Core
  • EF Core
  • SignalR

and not forgetting The .NET Core community, itself

I am your host, Jamie "GaProgMan" Taylor, and this is episode 3: CoreWF with Dustin Metzgar. In this episode I interview Dustin about CoreWF, the Windows Workflow Foundation, and a little about the challenges of converting a .NET Framework application over to .NET Standard. Some of you may know Dustin from his work at Microsoft (he has worked on both .NET Framework and .NET Core teams during his tenure there), or from his book ".NET Core in Action".

Dustin is much better at introducing himself than I am, so I'll let him do that.

So lets site back, open up a terminal, type in dotnet new podcast and let the show begin.

Dustin's Introduction

My name is Dustin Metzgar. I used to work for Microsoft, I was on the .NET Framework team kind of in an out for about almost tenm years. When I started, they where just getting ready to ship .NET 4. And before Microsoft I had worked for a bunch of different companies that actually had been using .NET Framework.

I was using Workflow in one of those companies, and I was really interested. I actually went for an interview with Microsoft, and got accepted into the Workflow team. And I was kind of working on performance and actually setup for quite a while, and then moved around and did some Azure services, and actually came back to Workflow and ended up running the Workflow team - at least what was left of it.

I had a team of about ten people and we were supporting Workflow in the .NET Framework also system.transactions, which includes the TransactionScope which was introduced in .NET Framework 2.0. That was ported into .NET Core, and then my team supported that as well. We had made an attempt to port the Workflow Foundation over to .NET Core, but ran into some road blocks.

But while the whole .NET Core thing was going on, before 1.0 came out, I was approached by Manning Press - actually Manning Publications, sorry. They wanted to see if I was interested in writing a book on .NET Core and I thought, "wow, that'd be great. I'll spend a few months, and write a book, and check one of those things off of my bucket list."

Two years later, it's finally in print.

The name of the book is ".NET Core in Action". It's actually a lot thinner than I imagined it was when I was writing it, because it certainly felt a lot bigger. But I'm actually glad with the size, I think it's more approachable.

The book is actually part of a set of 4 books. So:

  • Entity Framework in Action
  • ASP NET Core in Action
  • Xamarin in Action

all fit together with my book. My book is kind of like the lower level, foundational part of "What is .NET Core?", "What is .NET Standard?". And then "EF", "ASP.NET", and "Xamarin" are all branching out from there. Although, Xamarin was a bit earlier, and I think that book was already being built before mine was being written.

Even after Microsoft I'm still doing some... I basically took the code that we had done for the Workflow Foundation and made my own repo, and started trying to convert that over to .NET Standard; and it's presented some really interesting challenges as far as enlightening me to "how would somebody covert something that's in the .NET Framework over into .NET Standard, and what kind of things would you run into?" And that's something that we can talk about later.

What Is Workflow Foundation?

Is there a brief overview that you can give, on what Workflow Foundation is?

I usually explain it to people as, let's say you have a console application where it writes something to the console, waits for your input, and then responds to the input that you give.

The classic example is: that input, there is no guarantee of when that input is gonna come, because it's come from some external source - which is the human that is typing it in.

So they could start that program and not type anything in ever, or wait a whole year, or whatever. But basically they're locking up a thread at least, or an entire process to wait for some input.

The thing with a Workflow is that your saying: "I want to wait for this input, but I can unload that object, that whole thing, that whole process; wait until the input is available; and wake it back up and then run it.

And that's, really, the core idea.

Wrapping Up

That was my interview with Dustin Metzgar. Be sure to check out the show notes for a bunch of links to some of the stuff that we covered, and a collection of text snippets from the interview. The show notes, as always, can be found at dotnetcore.show.

And don't forget to spread the word, leave me a rating or review on your podcatcher of choice, and to come back next time for more .NET Core goodness.

I will see you again real soon. See you later folks.