Visual studio feeds

All Visual Studio blogs in one place


Enter your email address:

Delivered by FeedBurner

Increase your website traffic with



Anti-spam: How many eyes has a typical person?

Follow us on FB


Understanding the Portable Library by Chasing ICommand (1 of 3)

AddThis Social Bookmark Button
Part 1: Creating the Portable Library (this post)
Part 2: Portability in Silverlight and WPF: a Tale of Type Forwarders
Part 3: Portability in Metro: A CLR and WinRT Love Affair The portable library tools have been available for several months now. The goal for this add-in to Visual Studio 2010 was to enable you to create special portable assemblies that can run on various platforms, ranging from XBox and Windows Phone 7 to various versions of the .NET Framework and Windows 8, without having to recompile them. That’s a pretty amazing feat and allows developers to avoid some
crazy practices like linking source code. With Visual Studio 11, the tools are no longer an add-in but are a built-in part of the product. You can directly create portable class libraries and build these magic assemblies that can be reused without recompiling. For many users, this is incredibly important because it means they can not only reuse their libraries between platforms like the phone and the desktop, but also can build insurance for the future. Think about it: you can build a Silverlight application today, share your libraries with a Metro application you are developing for tomorrow, and only...(Read whole news on source site)

C#/.NET Little Wonders – The DateTimeOffset struct

AddThis Social Bookmark Button
Once again, in this series of posts I look at the parts of the .NET Framework that may seem trivial, but can help improve your code by making it easier to write and maintain. The index of all my past little wonders posts can be found here. Anyone who has done any .NET programming has most likely used the DateTime structure at one time or another in their development.  It is a handy structure for storing dates, times, or date-times relating to the local time zone (or, alternatively, UTC). That said, there are times when
you may be writing a program where you want to preserve a time in its given offset and not convert it to local time.  This is where the .NET 3.5 DateTimeOffset structure comes in handy. The Problem: DateTime parsing can convert to local time Let’s say you are consuming a file, web service, etc. from a third party whose servers are in a different time zone.  Further, they have several fields in their response data that are meant to represent dates but are actually serialized DateTime instances where they have a date and a time set to midnight. ...(Read whole news on source site)

Monetize your Metro style app with Microsoft AdCenter

AddThis Social Bookmark Button
Today, the Microsoft Advertising team announced an update to their AdCenter SDK to include support for monetizing your Metro style apps. In a blog post announcing the update, Ian notes that if you were using the previous SDK that there have been breaking changes and to use the updated SDK.  This update includes support for XAML applications and adding the ad units couldn’t be easier.  After installing their SDK (which was developed using the same distribution concepts in my post about creating a distributable custom control previous post), you will be able to use Add Reference in
Visual Studio, navigate to the Windows/Extensions area and add the SDK.  After that it is as simple as adding the control in your project:
1: 2: 3: (Read whole news on source site)

Launching "Learn the Cloud, Make a Difference" DC Effort

AddThis Social Bookmark Button
A cool program from my Cloud-focused peers is being relaunched…my colleague Brian Hitney has the details: Two years ago, Jim O’neil and I developed a quick Azure training program called “@home with Windows Azure” – a way to learn Windows Azure and have some fun contributing to a well known distributed computing effort, Folding@home.  A few months later, Peter Laudati joined the cloud team and we developed the game RockPaperAzure.   RockPaperAzure was a lot of fun and is still active, but we decided to re-launch the @home with Windows Azure project because of
all of the changes in the cloud since that effort in 2010. So, having said all that, welcome to our “Learn the Cloud.  Make a Difference” distributed computing project!  It’s been updated, as you can see on the page – a much cleaner and nicer layout, maintaining our great stats from the 2010 effort where we had a cumulative 6,200+ virtual machines having completed 188k work units!   (Of course, as happy as I am with the numbers, the Folding@home project has a over 400k active CPUs with over 8 petaFLOPS of processing power! Stanford University’s Pande Lab...(Read whole news on source site)

Eduasync 20: Changes between the VS11 Preview and the Visual Studio 11 Beta

AddThis Social Bookmark Button
A while I ago I blogged about what had changed under the hood of async between the CTP and the VS11 Preview. Well, now that the VS11 Beta is out, it's time to do it all again... Note that the code in this post is in the Eduasync codebase, under a different solution (Eduasync VS11.sln). Many of the old existing projects won't compile with VS11 beta, but I'd rather leave them as they are for posterity, showing the evolution of the feature. Stephen Toub has an excellent blog post covering some of this, so while
I'll mention things he's covered, I won't go into much detail about them. Let's start off there though... Awaiter pattern changes The awaiter pattern is now not just a pattern. The IsCompleted property and GetResult method are still "loose" but OnCompleted is now part of an interface: INotifyCompletion. Awaiters have to implement INotifyCompleted, but may also implement ICriticalNotifyCompletion and its UnsafeOnCompleted method. The OnCompleted method is easier to implement (basically it's as before) and doesn't need to flow the ExecutionContext (the infrastructure will do it for you); the UnsafeOnCompleted method must flow the...(Read whole news on source site)

How Claims encoding works in SharePoint 2010

AddThis Social Bookmark Button
I've seen it asked numerous times on forums and I've been asked over and over how to interpret the encoded claims - so here it is: a post which will show you all the secrets behind how claims are encoded in SharePoint 2010. Updates: Added Forms Authentication info. Background If you have been using previous versions of SharePoint 2007, been working with .NET or just Windows you should be familiar with that (NETBIOS) user names are formatted DOMAIN\user (or provider:username for FBA in SharePoint). When SharePoint 2010 introduced the claims based authentication model (CBA) these
formats was not sufficient for all the different options needed. Therefore a new string format was invented to handle the different claims. The format might at first glance look a bit weird... How it works? The claim encoding in SharePoint 2010 is an efficient and compact way to represent a claim type and claim value, compared to writing out all the qualified names for the claim types and values. I will illustrate how the claim are encoded in SharePoint 2010 focused on user names, but this claim encoding method could be used for basically any claim. Let's start...(Read whole news on source site)

Windows Azure and Cloud Computing Posts for 3/8/2012

AddThis Social Bookmark Button
A compendium of Windows Azure, Service Bus, EAI & EDI Access Control, Connect, SQL Azure Database, and other cloud-computing articles. Note: This post is updated daily or more frequently, depending on the availability of new articles in the following sections: Windows Azure Blob, Drive, Table, Queue and Hadoop Services SQL Azure Database, Federations and Reporting Marketplace DataMarket, Social Analytics and OData Windows Azure Access Control, Service Bus, and Workflow Windows Azure VM Role, Virtual

Why you shouldn't add methods to interfaces in APIs

AddThis Social Bookmark Button
It is an oft-repeated maxim that you shouldn't add methods to a publically-released interface in an API. Recently, I was hit hard when this wasn't followed. As part of the work on ApplicationMetrics, I've been implementing auto-reporting of MVC action methods; whenever an action was called on a controller, ApplicationMetrics would automatically report it without the developer needing to add manual ReportEvent calls. Fortunately, MVC provides easy hook when a controller is created, letting me log when it happens - the IControllerFactory interface. Now, the dll we provide to instrument an MVC webapp has to be compiled against .NET 3.5 and
MVC 1, as the lowest common denominator. This MVC 1 dll will still work when used in an MVC 2, 3 or 4 webapp because all MVC 2+ webapps have a binding redirect redirecting all references to previous versions of System.Web.Mvc to the correct version, and type forwards taking care of any moved types in the new assemblies. Or at least, it should. IControllerFactory In MVC 1 and 2, IControllerFactory was defined as follows: public interface IControllerFactory { IController CreateController(RequestContext requestContext, string controllerName); void ReleaseController(IController controller); } So, to implement the logging controller...(Read whole news on source site)