Visual Studio

Visual Studio 2010 Ultimate Event Content Download

Rick G. Garibay — Sun, 14 Mar 2010 01:45:01 GMT

Thanks to all who came out to the event in Phoenix, Salt Lake City & Las Vegas. We had a great turnout at all events with great questions and discussions.

Remember that the conversation continues on twitter.

If you attended the event and have a question or comment for any of the presenters, use the following hashtags:

Phoenix: #vs2010phx
Salt Lake City: #vs2010slc
Las Vegas: #vs2010vegas

Below are the presentations from all four sessions in each city:

Phoenix	A Lap Around Visual Studio 2010	Rick G. Garibay
Phoenix	Agile Management with TFS	Brendon Birdoes	*
Phoenix	No More "No Repro"	Brendon Birdoes	*
Phoenix	Architecture for Everyone	Rick G. Garibay
Salt Lake City	A Lap Around Visual Studio 2010	Rick G. Garibay
Salt Lake City	Agile Management with TFS	Jeff Leite	*
Salt Lake City	No More "No Repro"	Jeff Leite	*
Salt Lake City	Architecture for Everyone	Rick G. Garibay
Las Vegas	A Lap Around Visual Studio 2010	Rick G. Garibay
Las Vegas	Agile Management with TFS	Mickey Williams	*
Las Vegas	No More "No Repro"	Mickey Williams	*
Las Vegas	Architecture for Everyone	Rick G. Garibay

* Note that content for all venues is very similar but may vary from presenter to presenter. ~~All content for both venues will be available soon so please check back shortly.~~

Take Me with You! Ensuring Team Build Brings Dependencies Along for the Ride

Rick G. Garibay — Fri, 28 Aug 2009 03:05:14 GMT

As part of an automated build at a client, we currently have over 150 unit tests that run as part of each automated build. Some of the tests are also integration tests which serve to automatically smoke test the freshly compiled application code.

One of our apps makes use of an XML file that allows the ability to dynamically change behavior of a component without requiring an app domain recycle. A static method uses a FileWatcher to detect a change and applies the configuration changes at runtime accordingly. But I digress…

When Team Build executes your unit tests, it creates a special directory on the build agent called TestResults.The TestResults folder includes a .trx file that captures the build results in XML along with a folder for each build/run which isolates all required test assemblies and other dependant assemblies for execution. The App.config file will automatically be copied over and renamed to AssemblyName.dll.config. This is fine and dandy, but what about other dependencies like the XML file?

The answer is different depending on whether you are running your tests locally from Visual Studio or if Team Build is running your tests as part of an automated build, but you must be familiar with both techniques to accomplish a consistent and repeatable means for taking the XML file along for the ride under both scenarios which you will undoubtedly need to understand because chances are you are (or at least should be) running all unit tests locally before checking into source control, right? Right?

Local Dependencies

When running and debugging unit tests using Visual Studio and a just-in-time test runners like TestDriven.NET that have an external dependency such as an XML file, you must ensure the dependency is in the binary root relative to the executing assembly. This is also true when using other unit testing frameworks like NUnit, which I talk about here.

Right click the resource in the test project, click properties and set “Copy to Output Directory” to “Copy Always”:

This will ensure that the dependency is copied to the bin directory just as other dependencies like DLLs and App.Config/Web.Config are automatically.

At this point, the XML file can be referenced in the root of the bin which is relative to the executing assembly.

Team Build Dependencies

As I mentioned earlier, when Team Build executes unit tests, it moves all required assemblies and assembly dependencies to a TestResults folder. While this includes App.config and Web.config files, other dependencies are not copied regardless of whether you specify “Copy to Output Directory” to “Copy Always” as shown above. This makes sense, because when Team Build runs, the unit test project is no longer located with the rest of the source- instead it is copied to the TestResults folder and prepped for execution.

There are two ways to address this.

The first option is to mark each test method with a DeploymentItem attribute. This is documented here, so I won’t go into much into it. The basic usage is to mark you test method with the DeploymentItem attribute, providing a parameter with the path and filename of the dependency:

   1:  [TestMethod]

   2:          [DeploymentItem("../../MyExternalDependency.xml")]

   3:          public void FooShouldReturnBar()

   4:          {

5:

   6:             //...

7:

   8:          }

When the assembly that includes the test class loads, the attribute is reflected and the dependent file is copied to the TestResults folder. You can also add the attribute at the test class level and it will have the same effect.

The draw back of this approach is that it requires that you apply this attribute to the test class and it is really quite noisy because it is only used when running tests with Team Build or the Test List Editor.

To keep things cleaner, I prefer to make these dependencies configuration driven. So, similarly to setting the “Copy to Output Directory” to “Copy Always” for just-in-time testing, you can determine dependencies that should be copied to the TestResults folder using a global configuration setting that will apply to all tests: Test Run Configuration.

Go to Test, “Edit Test Run Configuration” and click on the configuration file as shown below:

Now, click on the Deployment option on the left, ensure “Enable Deployment” is checked, and either click “Add File” to add a specific file, or “Add Directory” to include the entire contents of a directory:

The localtestrun.testrunconfig file will be configured with the dependencies specified and this file will be consulted just prior to kicking off a test run to ensure that all dependencies are copied to the TestResults folder.

That’s really all there is to it. Thanks to Brendon Birdoes for turning me on to the DeploymentItem attribute which I was not familiar with.

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.

Free Public Class: A Day in the Life of Scrum with VSTS 2008 and TFS- 6/2 in Phoenix

Rick G. Garibay — Sun, 31 May 2009 20:49:56 GMT

I will be delivering my last free public class, "A Day in the Life of Scrum with Visual Studio Team System 2008 and Team Foundation Server" to Microsoft Phoenix next Tuesday, June 2nd.

There are still a few seats available, so feel free to register (please see invitation below with Invitation Key 4DEAA2). If you would be interested in a private class for your team or organization, please feel free to contact me for scheduling.

Please join Microsoft and Neudesic for a day in the life of Scrum with Visual Studio Team System 2008 and Team Foundation Server! Agile methods are a set of development processes intended to create software in a lighter, faster, more people-centric way. Many development teams have adopted "agile" methodologies to manage change and to improve software quality. These methodologies promote continuous integration as a practice to build and test software products incrementally as new features are included, bugs are fixed, and code is refactored.

If you missed the first series of Agile & Scrum Essentials last fall; here’s your chance to attend the follow-on event where we’ll briefly revisit the basics of Agile and Scrum and provide a walkthrough of how to configure Visual Studio Team System 2008 and Team Foundation Server for Scrum. Participants will be familiarized with how key artifacts are managed within this popular process template for enacting Scrum in organizations.

Join us for this interactive event as we explore a “day in the life of a Sprint,” that will give you a practical perspective of how Scrum teams leverage Visual Studio Team System for end to end management of the planning, execution and control of Scrum projects. The day will end with an overview of what’s coming in Visual Studio Team System 2010!

Register

Welcome: 8:30 PM

Seminar: 9:00 AM-4:30 PM

Phoenix, AZ

June 2, 2009

Click here to register or call 1.877.MSEVENT (1.877.673.8368) with invitation code: 4DEAA2.

.NET Framework 4.0 Beta 1

Rick G. Garibay — Mon, 18 May 2009 21:00:00 GMT

I am thrilled to share that today, Monday, May 18th, the .NET Framework 4 Beta 1 will be available to MSDN Subscribers through MSDN Subscriber Downloads and to the general public on Wednesday, May 20th through Microsoft Downloads.

I have been fortunate to have my hands on a limited April CTP for some time now which is very close to what is included in Beta 1, so stay tuned for more information about VS 2010 and the WCF and WF enhancements in .NET 4.0 which are key areas that I will continue to focus on and share with you here.

Until then, here are some helpful links to get you started with NET FX 4.0:

Get the Bits

Download the .NET Framework 4 beta here from MSDN Downloads:http://msdn.microsoft.com/en-us/subsc ions/downloads/default.aspx?pv=18:370
On Wed, May 20th, you can obtain the Beta 1 bits here: http://go.microsoft.com/fwlink/?LinkId=151799

Learn What’s New

A First Look at VS 2010: http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx
New .NET Framework 4 features: http://go.microsoft.com/?linkid=9666478
Scott Hanselman's .NET 4 overview (PDC 2008) : http://channel9.msdn.com/pdc2008/TL49

Get Support from the Community

Beta 1 Forum is available here: http://social.msdn.microsoft.com/Forums/en-US/category/VSPreRelease,netdevelopmentprerelease,visualstudioprerelease,vstsprerelease

Stay tuned for posts in the next couple of weeks that will address the significance of this major release, particularly around VS 2010 enhancements and Connected Systems framework technologies. Until then, if you haven’t already, please take the time to upgrade to .NET Framework 3.5 which will make sure your upgrade path to .NET 4.0 is as seamless as possible.

Phoenix Visual Studio Team System Big Event was BIG!

Rick G. Garibay — Tue, 12 May 2009 00:29:16 GMT

Thanks to all who came out for the Visual Studio Team System Big Event on Thursday, May 7th! We had a great time with the Microsoft Developer Evangelist team, Microsoft Technical Specialists, MVPs and influencers who at the end of the full day of action packed training left no doubt that Visual Studio Team System is BIG!

Dan Weinman, Senior Consultant at Neudesic kicked off with the keynote on "Development Best Practices & How Microsoft Helps" and set the stage for what the day full of training had in store. Dan talked about the various roles that VSTS supports and how each role comes together to enact process under a single tool that maximizes transparency and communication on Agile teams.

Next, Brendon Birdoes, Principal Consultant at Neudesic delivered a great talk on Test-Driven-Development with Visual Studio. Brendon covered unit testing, including test first development and showed off the refactoring capabilities right within the IDE along with code coverage. Brendon talked about how important code coverage and quality assertions are to ensuring that your unit tests are as useful as possible in maintaining high degrees of quality within your software projects.

Following the excellent session on TDD, Visual Studio Team System MVP Dave McKinstry delivered a session entitled ""It Works on My Machine!" Closing the Loop Between Development & Testing" which discussed the close integration between testing tools in Visual Studio Team System and the code itself which minimizes the cost and complexity in task switching.

We were then treated by another excellent talk by Rob Bagby, Developer Evangelist on "Treating Databases as First-Class Citizens in Development". In this session, Rob made clear that database work can no longer hide from unit testing and how the Database Project in Visual Studio Team System makes synchronizing DDL and DML objects seamless and eminently testable.

I was lucky enough to show off the new Visual Studio Team System 2010 Team Architect bits which include fully compliant UML 2.1 diagram support as well as assembly, namespace, class and method visualization using the VSTS 2010 Architecture Explorer. I talked about VSTS 2010 Team Architect being yet another clear signal of Microsoft's commitment to modeling which is, and will continue to manifest itself in technologies like Windows Workflow, BizTalk Server, Entity Framework, and Quadrant to name just a few. As a Connected Systems guy, VS2010 Team Architect is really going to go a long way in helping me and my teams visualize the problem domain and partition our big balls of mud into the right architecture.

Speaking of which, I think my favorite new modeling feature in Team Architect is the Layer Diagram which lets you define your layers and then validate them at build time! What this means is that I can use a layer diagram to define separation of concerns and single responsibility principle and then make sure that team members are honoring the layer rules. It is just awesome to be able to map namespaces to a layer diagram, wire it up to the automated build and keep violations from every being delivered.

The day winded up with a great talk by Steve Lange, Technical Specialist on how to get the most out of TFS. The session was aptly called "Bang for Your Buck" Getting the Most out of Team Foundation Server, and Steve gave away some great tips on things you can do with your investment in TFS that you may not have even known about.

I want to thank Steve and Rob for inviting us to speak at this event. The room was full of great folks with lots of passion and great questions which is exactly what we like to see at these events. If you have any follow up questions that I wasn't able to get answered at the event, please don't hesitate to contact me.

Fix: Can't Set Breakpoints in Visual Studio 2008

Rick G. Garibay — Tue, 28 Apr 2009 20:03:29 GMT

I recently uninstalled a certain productivity enhancement tool for VS 2008 which shall remain nameless because they are a good group of guys and have been very nice to me.

I uninstalled the tool, namely because I felt I was becoming a bit too dependant on it. Certainly, VS features like intellisense and basic refactoring support are not things I would willingly live without, but I feel that the features in VS are probably adequate for my needs and my IDE was starting to feel a bit clunky.

So, I uninstalled this tool, and immediately intellisense was missing. Anoying. I went into Tools->Options and re-enabled Intellisense. Life was good, or so it seemed.

For the last 5 weeks, the bane of my existence has been the fact that I couldn't set breakpoints in my code. I could debug just fine if I right clicked + Breakpoints + Insert Breakpoint, or use F9, but when I tried to set the breakpoint on the left pane, as shown here, it just wouldn't work at all:

I was giving a class on TDD to one of my biggest customers today and in desperation, having right clicked + Breakpoints + Insert Breakpoint one too many times, I offered to buy lunch to the developer who could help me fix this. Now one developer offered the F9 option as workaround, which is better than a 3 step process, and this would have helped me out. Then, about 15 minutes later, another developer said they had the fix, and sure enough, he did!

The problem was that the "Indicator Margin" had been disabled. How did this happen? Why would this happen and what the hell is an Indicator Margin? Well, I don't have proof, but I am guessing that it is that "productivity" tool that did it when I uninstalled it.

The solution was simply to go into Tools->Options->Text Editor and enable Indicator margin as shown below:

I am forever indebted to this customer and am sharing this tip here in case this is driving you as nuts as it has me over the last month!

Phoenix Visual Studio Team System Big Event is Coming to Phoenix on 5/7!

Rick G. Garibay — Mon, 13 Apr 2009 18:24:58 GMT

My friends Steve Lange, Rob Bagby and Microsoft are hosting a FREE event which will help you discover how people, process and technology are key to helping your organization succeed in today’s environment.

This all day seminar includes several sessions within Architecture, Development & Testing and Application Lifecycle Management tracks.

Dan Weinmann and Brendon Birdoes of Neudesic and I will be delivering content on each of the tracks along with members of the Microsoft Technical Specialist teamand other area VSTS MVPs and ALM practitioners.

Here is a list of available sessions:

Test Driven Development: Improving .NET Application Performance & Scalability
- This session will demonstrate how to leverage Test Driven Development in Team System. We’ll highlight both writing unit tests up front as well as creating test stubs for existing code.
"It Works on My Machine!" Closing the Loop Between Development & Testing
- In this session, we will examine the traditional barriers between the developer and tester; and how Team System can help remove those walls.
Treating Databases as First-Class Citizens in Development
- Team System Database Edition elevates database development to the same level as code development. See how Database Edition enables database change management, automation, comparison, and deployment.
Architecture without Big Design Up Front
- Microsoft Visual Studio Team System 2010 Architecture Edition, introduces new UML designers, use cases, activity diagrams, sequence diagrams that can visualize existing code, layering to enforce dependency rules, and physical designers to visualize, analyze, and refactor your software. See how VSTS extends UML logical views into physical views of your code. Learn how to create relationships from these views to work items and project metrics, how to extend these designers, and how to programmatically transform models into patterns for other domains and disciplines.
Development Best Practices & How Microsoft Helps
- Sometimes development teams get too bogged down with the details. Take a deep breath, step back, and re-acquaint yourself with a review of current development best practice trends, including continuous integration, automation, and requirements analysis; and see how Microsoft tools map to those practices.
"Bang for Your Buck" Getting the Most out of Team Foundation Server
- Today’s IT budgets are forcing teams to do as much as they can with as little as possible. Why not leverage Team Foundation Server to its full potential? In this session we’ll highlight some capabilities of TFS that you may or may not already know about to help you maximize productivity.

This event will not only provide you with best practices around development and testing, but will demonstrate key capabilities of both Visual Studio Team System 2008 and the upcoming 2010 release that you won't want to miss. It’s a day that promises to have something for everyone!

Click here to register with invitation code: 90BC47

If you have any problems registering, please drop me a note.

Free Public Class: A Day in the Life of Scrum with VSTS 2008 and Team Foundation Server - 4/2 in Bellevue, WA

Rick G. Garibay — Sat, 28 Mar 2009 04:07:46 GMT

I will be delivering the second free public class, "A Day in the Life of Scrum with Visual Studio Team System 2008 and Team Foundation Server" to Microsoft Bellevue next Thursday, April 2nd.

Please see invitation below and be sure to register ASAP as seating is limited. If you are not in Bellevue, but would be interested in a private class for your team or organization, please feel free to contact me. Also, stay tuned right here for additional free public classes coming to your city soon!

Register

Welcome: 8:30 PM

Seminar: 9:00 AM-4:30 PM

Bellevue, WA

April 2, 2009

Click here to register or call 1.877.MSEVENT (1.877.673.8368) with invitation code: 46F263.

Visual Studio 2008 Guided Tour

Rick G. Garibay — Tue, 24 Mar 2009 16:07:25 GMT

J. Michael Palermo pointed me to this menu of VS resources: http://msdn.microsoft.com/en-us/library/bb514232.aspx

Great one-stop reference, thanks Michael.