WCF

Desert Code Camp 2010.1 – The Goods

Rick G. Garibay — Thu, 20 May 2010 02:16:02 GMT

This was a great event as usual, and I really have to hand it to @jguadango, @coneybeer, Devry University and all the volunteers for putting this together. The logistics, facilities, scheduling and planning for 55+ sessions is not easy.

I’ve presented at every Desert Code Camp since the very first one, so I think this one makes 6 or 7. Code Camp is always a great day to interact with Phoenix’s community of technologists through conversation, teaching and learning and this one was no exception.

Below are the goods for each session, and as promised I’ve included videos of my WCF and AppFabric Service Bus demos.

Session

Content

Code

Demo Vids

Let the Good Guys in with Azure AppFabric Service Bus

Demo1: Unicast One-Way Messaging with NetOneWayRelay Binding

Demo 2: Multicast On-Way Messaging with NetRelayBinding

Demo 3: World Peace & Fireworks with NetTcpRelayBinding (HD)

Beyond the Whiteboard: Enforcing Conceptual Integrity with Visual Studio 2010

N/A

New Features in WCF 4 that will Instantly Make you More Productive

Demo 1: Convention over Configuration (HD)

Demo 2: Dynamic Endpoint Discovery (HD)

Demo 3: Monitoring Service Availability with WS-Discovery Announcements (HD)

If you have any comments or questions, drop me a line.

AZ.NET UG WCF 4.0 Materials

Rick G. Garibay — Sun, 14 Feb 2010 14:46:17 GMT

Below please find my presentation and demos from my talk on new productivity features in WCF 4.0 at the AZ .NET User Group.

Thanks to Scott Cate and the AZ.NET UG for hosting me- I had lots of fun!

Byte-Size WCF Episode 1: Default Endpoints in WCF 4.0

Rick G. Garibay — Sun, 24 Jan 2010 01:35:27 GMT

WCF 4.0 simplifies the configuration experience significantly by providing a new default endpoint feature. This saves time and simplifies the configuration requirements for hosting a WCF service by providing a File –> New Project –> Code –> F5 hosting experience.

In this episode you’ll learn how to get up and running quickly with default endpoints and how to gain more control over the default bindings for each scheme (HTTP, TCP, MSMQ, etc) you may want to configure using the new protocol mapping capabilities in WCF 4.0.

Is .NET a Great Disruptor of the Decade?

Rick G. Garibay — Sat, 16 Jan 2010 01:08:53 GMT

The following article was recently brought to my attention. It asks if .NET should be considered a disruptor in the last decade: http://blogs.zdnet.com/service-oriented/?p=3921

I actually gave this a bit of thought and the best answer I was able to come up with was “Yes and No”. Here’s why…

A technology can be "disruptive" when it gains wide spread attention but can fizzle out just as quickly or over an undetermined period of time. How deep into a revolution a technology can sink its teeth and still emerge a clear winner is a true long term measure that I believe earns the designation of "disruptor".

A true market leader leverages (or themselves are responsible for) a revolutionary technology and both exploits it fully while surviving several aftershocks that typically follow.

For example, I would argue that SOA was a revolutionary innovation that changed the mindset of an industry. In the process it displaced many traditional (and proprietary) approaches to distributed computing and a new market segment exploded.

I think Microsoft capitalized on this with ASP.NET Web Services (ASMX) which at the time I would certainly consider disruptive- offering 1st generation commodity SOA to the masses- but had the innovation wave stopped there, Microsoft wouldn't have a SOA story today.

Enter WCF . WCF is both an evolution over ASMX as well as a technology that has been successful in displacing many proprietary incumbents. However I think today what we have is a low-end disruption because it is evident that WCF overshot the market with performance and features. Incredibly, almost in perfect harmony with this market perception REST came into its own and disrupted our whole perspective on SOA and continues to challenge our values in the process (as all disruptive technologies do).

WCF 3.5 and the REST Starter Kit answered this call cementing the fact that .NET (WCF) is deep enough to survive and subsume other distrubtions and at the same time, WCF 4 will attempt to democratize WCF for the masses, likely gaining both mindshare and market share in the process.

So, while .NET has been disruptive, I don't know that we can claim it as disruptor just yet.

One thing is for certain. Azure has the potential to propel .NET to a more profitable market segment ushering with it new market disruption and establishing .NET in a clear lead position.

But these are just my thoughts. What do you think?

Desert Code Camp November 7th

Rick G. Garibay — Sat, 31 Oct 2009 12:11:22 GMT

I will be speaking at DCC on November 7th on the following topics:

Developing and Deploying an On-Premise .NET Application with Azure Table Storage
Developing and Deploying a WCF Application with Azure Compute Services and Azure Table Storage

There are several excellent sessions this time around, including talks from fellow colleagues at Neudesic like Michael Collins, Joel Neubeck and Andrew Wilson.

Hope to see you there!

.NET 4.0 and Visual Studio 2010 Beta 2 Announcements

Rick G. Garibay — Mon, 19 Oct 2009 23:30:00 GMT

.NET 4.0 and Visual Studio 2010 Beta 2 is now available to MSDN subscribers as of 9:30 AM PST. This release includes the new version of Connected Framework products like WCF and WF 4.0, Entity Framework 4.0 and a host of additional new features across work streams including MEF, Parallel Extensions, and significant enhancements to Visual Studio Team System and Team Build.

Having spent some time with both WCF and WF limited CTP, Beta and pre-Beta 2 bits, this release includes significant improvements, re-design and new features specifically around WCF and WF 4.0. If you are like me, you will likely welcome many of the designer enhancements in WF 4.0 and may lament a number of designer design changes within messaging activities. You’ll just need to rip off the shrink wrap on Beta 2 to find out yourself!

I plan to start doing a significant amount of writing around WF 4.0 because I think that having been re-written from the ground up, WF 4.0 addresses many, many of the pain points in the 3.0 and 3.5 version, and I believe that WF + WCF 4.0 will lower the barrier of entry for writing workflow and service/model-oriented applications. In addition, the improvements within Workflow Services and the ease with which those new to WCF can get a service up and running are both significant and necessary to increasing the reach of these fantastic technologies.

Another major area of VS 2010 I am excited about is in the new architecture and design tools in Microsoft Visual Studio Team System 2010 Architecture Edition which introduces new UML designers, use cases, activity diagrams, sequence diagrams and the ability to explore and visualize existing code, design and apply layering to enforce dependency rules, and physical designers to visualize, analyze, and refactor your software. In May of the year, I demonstrated how VS 2010 extends UML logical views into physical views of your code along with how to create relationships from these views to work items and project metrics, and how to programmatically transform models into patterns for other domains and disciplines.

Needless to say, I’m excited about VS 2010 Beta 2, and am even more excited to announce that the official launch of Visual Studio 2010 will take place on March 22nd, 2010.

Until then, you can download Beta 2 on October 21st here: http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

Some other notes of interest:

Microsoft is announcing a new, streamlined packaging lineup and licensing options for Visual Studio 2010 and MSDN. This includes an "Ultimate Offer" to help customers upgrade to the latest developer tools. For more information on the new packaging, licensing, and pricing of Visual Studio 2010, visit: http://go.microsoft.com/fwlink/?LinkID=166249
As you may have noticed, MSDN has undergone a significant redesign which includes new benefits for all MSDN subscribers: http://msdn.microsoft.com/en-us/default.aspx

March 22nd will be here before you know it, so jump on the Beta 2 bits now and get ready!

Oh, and don’t forget, PDC 2009 is right around the corner. Register now for key insights you just won’t find at any other conference: http://microsoftpdc.com/

Speaking at Ultimate Virtual Conference on October 22

Rick G. Garibay — Wed, 23 Sep 2009 04:14:09 GMT

I will be speaking at the SQL Server Worldwide User Group Ultimate Virtual Conference on October 22.

If you haven’t experienced an Ultimate Virtual Conference, it is very similar to other industry conferences. There are a number of tracks including .NET, SQL and MOSS and sessions are scheduled on specific days.

Unlike traditional conferences, however, you don’t have to leave the comfort of your home or office to attend. All sessions are streamed in HD video at the scheduled time. Speakers are available via live chat during the initial screening of their sessions and then you can watch the sessions again and again.

I will be delivering the following two sessions:

Developing and Deploying an On-Premise .NET Application with Azure Table Storage

Azure Table Storage provides a scalable data access solution for applications hosted on-premise or in the Azure cloud. Learn how to get up and running with Table Storage with a look at building entities, provisioning Table Storage locally in Development Storage and in Azure Table Storage along with techniques for maintaining a consistent development experience when developing locally or against the cloud.

Developing and Deploying a WCF Application with Azure Compute Services and Azure Table Storage.

The Azure Compute Service provides robust hosting capabilities of you .NET application in the Azure operating system. Learn about Web Roles and Worker Roles and how to configure your .NET application for deployment to Windows Azure. We will also explore techniques for consuming data via Azure Table Storage and put at all together and deploy the application live to Windows Azure.

My colleague Brendon Birdoes of Neudesic will also be presenting the following sessions:

ESB Toolkit 2.0 Overview

An Enterprise Service Bus (ESB) is an architectural pattern and a key enabler in implementing the infrastructure for a service-oriented architecture (SOA). The ESB Toolkit for BizTalk Server 2009 implements best practices and patterns for building loosely coupled service oriented solutions using BizTalk as the bus. The ESB Toolkit 2.0 is one of the best new features of Microsoft BizTalk Server 2009! Join Brendon as he explains what the ESB Toolkit is, explores the features and capabilities and discusses the benefits of using the Toolkit for your BizTalk solutions.

Implementing Messaging Solutions Using ESB Toolkit 2.0

Itinerary based routing is the key pattern in delivering solutions in the ESB Toolkit 2.0. The challenge though is how to take a traditional BizTalk scenario and implement it using the ESB Toolkit and itinerary based routing. This session will walk through a real world scenario and iteratively build the solution from a simple itinerary to a more complex itinerary including some of the more advanced capabilities of the Toolkit. This session will also take a closer look at the best new feature of the ESB Toolkit which is the Itinerary Designer that is fully integrated into Visual Studio 2008. If you are a BizTalk developer and would like to get an idea of the Toolkit development experience, this is a must see.

For a complete list of sessions and speakers, go to http://www.vconferenceonline.com/shows/fall09/uvc/

~~I have a limited amount of discount codes I can give out so feel free to contact me via email or @rickggaribay on twitter and I will set you up.~~

Please feel free to use discount code SPRGUVC09 for $25 off registration discount.

PCSUG Meeting this Thursday: Developing and Deploying a WCF Application with Azure Compute Services and Azure Table Storage

Rick G. Garibay — Tue, 08 Sep 2009 01:11:48 GMT

I will be speaking at the PCSUG this Thursday on how to design, develop and deploy a WCF application for Windows Azure. I’ll demonstrate configuration for testing locally in the development fabric as well as development storage and wrap up with deployment to Compute Service and Table Storage.

Pizza and sodas at 5:30 pm, and we’ll kick off at 6:00 pm and go until 7:30 pm.

Hope to see you there!

Slides and demo code are now available here: http://pcsug.org/Home/Events

The Modeling Vision Continues

Rick G. Garibay — Tue, 18 Aug 2009 20:43:16 GMT

Recently the Connected Systems Division at Microsoft, who is responsible for technologies including Windows Application Server, BizTalk Server, and .NET Framework technologies including Windows Communication Foundation and Windows Workflow Foundation,.NET cloud services, and the "Oslo" modeling platform was reorganized into the Data and Storage Platforms Division as the Business Platform Division (BPD) which is part of the Server and Tools Group responsible for products like Windows Server, Visual Studio and SQL Server.

This move was not a big surprise, because if you look at products like BizTalk, Dublin and Oslo, Windows Server and SQL Server are intrinsically related, delivering on the need for a comprehensive plug-and-play platform for connecting disparate systems. For example, BizTalk, Dublin and Oslo run on the Windows Server platform, and each depend on SQL Server to varying extents.

SQL Server has proven itself as a RDBMS platform and Dog-fooding SQL Server is good for business. I’ve also talked about the robustness of Windows Server, and the fact that it not only runs the .NET stack faster than Java, put runs Java faster than AIX. Needless to say, the server platform that was beat up throughout the 90's as not worthy of the enterprise has certainly come of age.

Anyone who knows me, has come to PCSUG meetings or reads this blog has probably heard me talk about the progression from imperative programming into declarative software development and how critical model-driven development will become in the not so distant future. As a believer, I strive to incorporate technologies like WCF, which is declarative, and Entity Framework which is both declarative and model-driven into my solutions. Entity Framework raises the level of abstraction beyond the logical/data layer in the database, to the conceptual layer, which is the true “stuff” of software, the model. With a model, we can have solution-oriented conversations about the problem domain without talking about tables, views, classes, bits or bytes. In addition, developer’s benefit from significant productivity gains by avoiding boiler-plate ADO.NET code which is largely commoditized into the Entity Framework.

Yesterday, Doug Purdy announced that the Olso team is joining the Data Programmability Team which is responsible for technologies like… wait for it… Entity Framework. Despite mixed messaging from Microsoft, Oslo represents the culmination of the declarative and model-driven vision within the Microsoft CSD. As of today, Oslo will deliver languages like “M” which will at a minimum allow developers to further reduce the impedance mismatch between RDMS and application development by raising the abstraction of how developers and architects develop data models that are decompiled into TSQL. I demonstrated this in June in Phoenix at Desert Code Camp, and while it is cool, it is only the beginning. “M” will allow developers to create domain specific languages that will bring the conceptual layer closer to the design and problem solving stage. Applications built on foundational frameworks such as WCF and WF will take advantage of their declarative model to easily be serialized into the Oslo Repository for centralized management. These applications are surfaced via Quadrant, which provides a model with which to interact with the applications both individually and at the solution and enterprise scope.

As Doug teases in his post, look for some key insights at PDC 09 this year as to the future of the modeling vision which appears to be very bright indeed.

Unit Testing Microsoft Sync Framework 2.0 & WCF

Rick G. Garibay — Tue, 18 Aug 2009 04:46:33 GMT

I just wrapped up some work for a client that entails exposing the Sync Framework 2.0 via WCF.

We are using Sync Framework 2.0 CTP 2 to support occasionally connected client scenarios between applications deployed out in the edge and core services hosted in the client’s cloud. I am using WCF to wrap the Sync Fx APIs to support interoperable synchronization support via SOAP 1.1. This way, any client can on-ramp with the core services and essentially become self-provisioned by initiating and initial synchronization to download required data necessary to come on line. In addition, when events happen out on the edge, the client can synchronize each event back to the cloud using an upload semantic.

There are many benefits to using the Sync Fx as opposed to rolling your own, and one benefit is the extremely simple provider model which makes basic synchronization scenarios a breeze, particularly between relational replicas such as SQL Server. Note however, that Sync Fx is fully extensible and capable of synchronizing any two memory streams.

So, the basic idea is that given a SyncProvider for the local and remote replica, any two data sources/applications can be synchronized:

In my scenario, the local client out in the edge utilizes the out of the box SqlSyncProvider. The goal was to expose the cloud over HTTP using SOAP, which required some understanding of the underlying APIs. From there, it was simply a matter of wrapping the Sync Fx APIs in a service layer, so that I would arrive at something like this:

By providing a proxy to the orchestrator, I was able to implement a proxy which is polymorphic with RelationalSyncProvider.

Immediately it should be obvious that this is not your typical integration scenario. Essentially, I am extending a framework by exposing it over WCF so that any orchestrator can leverage the WebSyncProvider.

I started the implementation by writing some tests. It was simple enough to extract an interface for the RelationalSyncProvider type because it is abstract. I used RhinoMocks to stub it, which worked great but where I ran into problems was in recording expectations on the return types because there are not a lot of test seams in the framework. With the absence of setters on main properties that I needed to assert, I needed a way to reach into the framework types and manipulate them so that I could develop the CUT (in this case the ServiceContract implementation) independent of the framework.

Publicize.exe works pretty nicely for what I was looking for.

For example, let’s say I want to stub a closed/framework type so that I can actually write my test without having to resort to integrating with the framework (which wouldn’t be a unit test at all), in this case, a couple of types in the Microsoft.Syncronization.dll assembly.

I run Publicize.exe Microsoft.Syncronization.dll and it generates a shadow assembly called Microsoft.Syncronization_Accessor.dll, which takes all types, adds _Accessor and exposes all non-public members as public as shown in Reflector on the right.

This pretty powerful.

I can now stub the return type of any closed/framework class and test as long as I am asserting *properties*, which is pretty common:

1:

   2:          [TestMethod]

   3:          public void GetChangesShouldReturnNumberOfChangesApplied()

   4:          {

   5:              MockRepository mockRepository = new MockRepository();

6:

   7:              RelationalSyncProvider provider = mockRepository.Stub<RelationalSyncProvider>();

8:

9:

  10:              using (mockRepository.Record())

  11:              {

12:

  13:                  // Set up the out parameter on RelationalSyncProvider Stub

  14:                  DbSyncContext changeDataRetriever = new DbSyncContext();

15:

  16:                  // Set up ScopeProgress property on DbySyncContext instance

  17:                  /*

  18:                   * Note that in order to test for number of changes applied, we need to reach into the

  19:                   * DbSyncScopeProgress and access the _totalChanges private member

  20:                   * so that public properties can be asserted. This is because the TotalChanges property only has a

  21:                   * getter, so the only way to influence the value is through it's backing field.

  22:                   */

23:

  24:                  DbSyncScopeProgress dbSyncScopeProgress = new DbSyncScopeProgress();

25:

  26:                  // Reference the actual object which will be accessed by the generated accessor

  27:                  PrivateObject obj = new PrivateObject(dbSyncScopeProgress);

28:

  29:                  // Generated accessor which wraps the type to be exposed using reflection.

  30:                  // Instead of writing the reflection code manually, Publicize.exe was run against the real assembly,

  31:                  // which in turn generated reflection wrappers for *all* types.

32:

  33:                  DbSyncScopeProgress_Accessor dbSyncScopeProgressAccessor = new DbSyncScopeProgress_Accessor(obj);

34:

  35:                  // Look ma, I am accessing a private field

  36:                  dbSyncScopeProgressAccessor._tablesProgress = new List<DbSyncTableProgress>();

37:

38:

  39:                  // Now we need to repeat the same process again for this type, which is at the heart of what we need to

  40:                  // gain access to.

  41:                  DbSyncTableProgress dbSyncTableProgress = new DbSyncTableProgress();

42:

  43:                  // Provides the accessor with a reference to the actual object

  44:                  obj = new PrivateObject(dbSyncTableProgress);

45:

  46:                  // Generated accessor which wraps the type to be exposed using reflection.

  47:                  // Instead of writing the reflection code manually, Publicize.exe was run against the real assembly,

  48:                  // which in turn generated reflection wrappers for *all* types.

  49:                  DbSyncTableProgress_Accessor dbSyncTableProgressAccessor = new DbSyncTableProgress_Accessor(obj);

50:

  51:                  // Set the _rowsApplied field so that the stubbed return instance of DbSyncScopeProgress can be asserted.

  52:                  dbSyncTableProgressAccessor._rowsApplied = 42;

53:

  54:                  // Add the dbSyncTableProgress to the private collection

  55:                  dbSyncScopeProgressAccessor._tablesProgress.Add(dbSyncTableProgress);

56:

57:

  58:                  // Now, set the property to our used and abused instance of DbSyncScopeProgress

  59:                  changeDataRetriever.ScopeProgress = dbSyncScopeProgress;

60:

  61:                  // Provider is implemented in COM so out params are prevelant (yuk)

  62:                  object changeDataRetrieverObj = changeDataRetriever;

63:

  64:                  // Set the expectation

  65:                  provider.GetChangeBatch(0, null, out changeDataRetrieverObj);

66:

  67:                  // Initialize params

  68:                  SyncIdFormatGroup idFormats = new SyncIdFormatGroup();

  69:                  SyncKnowledge destinationKnowledge = new SyncKnowledge();

  70:                  ForgottenKnowledge sourceForgottenKnowledge = new ForgottenKnowledge();

71:

  72:                  // Stub the return, including the object reference to DbSyncContext

  73:                  LastCall.Return(new ChangeBatch(idFormats, destinationKnowledge, sourceForgottenKnowledge))

  74:                      .OutRef(changeDataRetrieverObj).IgnoreArguments();

  75:              }

76:

  77:              IRelationalSyncManager manager = new RelationalSyncManager();

78:

  79:              // Inject the stub

  80:              manager.Provider = provider;

81:

  82:              SyncKnowledge localKnowledge = new SyncKnowledge();

  83:              DbSyncContext returnedContext = new DbSyncContext();

  84:              returnedContext.ScopeProgress = new DbSyncScopeProgress();

85:

86:

  87:              var changeBatch = manager.GetChanges(0, localKnowledge, out returnedContext);

88:

  89:              DbSyncContext context = returnedContext;

90:

  91:              Assert.IsTrue(context.ScopeProgress.TotalChangesApplied ==42);

92:

  93:          }

There is a bit of work here, but with a bit of elbow grease thanks to Visual Studio Test Tools, RhinoMocks, reflection and a little code generation the framework is testable.