Introduction [00:00]

Part 1 - .NET 4.5 and Visual Studio 2012
Understand what is new and exciting in .NET 4.5 and Visual Studio 2012, and benefit from learning's, mistakes made and practical guidance.

• [03:25] .NET History
• [09:07] Cadence is increasing. Moving from 2010 to 2012.
• [16:54] Async is very powerful
• [42:21] VS is the best Web Development tool

Part 2 – LightSwitch

• [01:04:47] A super powerful experience

Part 3 – Windows Store Apps

• [01:24:45] Basics of Windows Store Apps
• [01:38:46] Statistics, Telemetry and MarkedUp
• [01:43:21] Feedback

Conclusion [01:47:47]

Related

• ALM Readiness Treasure Map Blogs
• ALM Readiness Treasure Map v1 Paper Map and Sample Source Code
• ALM Readiness Treasure Map v1 Windows Store Application
• ALM Readiness Treasure Map v2.Sprint10 Show-What-We-Have
• ALM Readiness Treasure Map v2.Sprint11 Show-What-We-Have

More information

You can find more information on the ALM Rangers here and submit feedback for the Visual Studio ALM Rangers or ideas for future guides as outlined here.

• [00:10] 100 million licenses, 250 million Store app downloads, 400 million active Outlook accounts
• [00:56] Build will release a public preview of “Windows Blue”
• [01:36] Visual Studio 2012.3 (Update 3) “go-live” CTP is now available (Brian Harry),http://go.microsoft.com/fwlink/?LinkId=290979, http://support.microsoft.com/kb/2835600
• [02:46] Announcing availability of ISOs for Visual Studio Updates (Eric Knox), ISO Recorder 
• [04:12] TFS 2012.2 Power Tools update available (Brian Harry)
• [05:09] Publish Individual Files to your Server in Visual Studio 2012.2 (Rick Strahl)
• [06:18] Announcing TechEd Achievements (D. Begley, Karsten Januszewski)
• [07:18] .NET Crash Dump and Live Process Inspection (Lee Culver)
• [08:42] Windows Store app Development snack: Compress your images! (Robert MacLean )
• [09:41] Channel 9 Highlight: Inside Code Digger (Nikolai Tillmann, Peli de Halleux)

Picks of the Week!

• Dan's Pick of the Week:[11:10] Creative Coding Videos
• Brian's Pick of the Week:[12:03] Unit Test Generator under the bonnet (hood) … aka vsarUnitTestFx (Willy-P. Schaub)

Production Note: Yep, no bumpers... Golnaz wasn't available, leaving Brain and Dan on their own, and well... enough said.

So, how does Code Digger actually work? Why the PCL requirement? What happens when you click on the magic button, Alice?

Nikolai Tillmann and Peli de Halleux, software developers extraordinaire on MSR's RiSE team, join us again to dig into Code Digger in a casual setting (Nikolai's office, so native habitat). There is lots of geeking out at the whiteboard, of course. There is also a brief demo at the end. Tune in.

The NuGet package preview includes these types:

• ImmutableStack<T>
• ImmutableQueue<T>
• ImmutableList<T>
• ImmutableHashSet<T>
• ImmutableSortedSet<T>
• ImmutableDictionary<K, V>
• ImmutableSortedDictionary<K, V>

Interfaces for each of these types are also defined to facilitate exchange of immutable collection types that may be implemented differently to optimize for very specific performance or memory requirements.

See Andrew's blog for more detailed information (on immutable types for .NET and more. Lots of great info...).

Download C# sample code   |  Download VB sample code


 Your App Adventure Starts here. Build your Windows Store and Windows Phone Apps and games here.

Try Windows Azure for free with no cost or obligations, and use any OS, language, database or tool. FREE Download

Tips:

Slides are available on Lucian's blog.

Async void is a "fire-and-forget" mechanism: the caller is unable to know when an async void has finished, and the caller is unable to catch any exceptions from it. The only case where this kind of fire-and-forget is appropriate is in top-level event-handlers. Every other async method in your code should return "async Task".

This video goes into some more difficult cases like the Win8 example "overrides async void LoadSettings()". Here you're overriding the method, and can't change the signature, and can't return a Task from it. The solution is to return a Task some other way, like through a field.

The video also talks about the thorny problem of async void lambdas. WHENEVER you see an async lambda, you need to verify whether it will be a void-returning or Task-returning lambda.

Slides and source code are available on Lucian's blog.

This video introduces a new pattern for dealing with events: you can await them! Now why would you want to do that? Well, in some cases like responding to a button-click, it's fine to handle events in the way that you always have with top-level event handlers. But if you're building a complicated UI that has to orchestrate a whole load of events (StoryboardCompleted, MediaElementCompleted, PointerMoved, PointerReleased, ...) then it makes for cleaner code to await them. The key is the type TaskCompletionSource introduced in .NET4.

Subscribe to our podcast via iTunes or RSS

If you're interested in learning more about the products or solutions discussed in this episode, click on any of the below links for free, in-depth information:

Websites:

• Getting started with Windows 8 Apps
• How to Sell Your Apps and Make Money in the Windows Store
• Attend a Windows 8 Developer Camp and Hackathon in your area!

Blogs & Articles:

• Jerry Nixon’s Blog

Videos:

• Microsoft DevRadio: Managing Your Windows 8 Enterprise Apps with Windows Intune
• Microsoft DevRadio: Your Top Windows Store Questions Answered

Virtual Labs:

• Windows 8  Virtual Labs

Over the last years .NET added many features to make writing multithreaded applications easier. This includes the Task Parallel Library (TPL) as well as the new async/await keywords features to reduce the friction when writing asynchronous code. However, it's still challenging to keep mutable state under control when multiple threads are involved. A common approach is to make use of immutable state that can be passed freely between different threads.
- Immo Landwerth

The NuGet package preview includes these types:

• ImmutableStack<T>
• ImmutableQueue<T>
• ImmutableList<T>
• ImmutableHashSet<T>
• ImmutableSortedSet<T>
• ImmutableDictionary<K, V>
• ImmutableSortedDictionary<K, V>

Interfaces for each of these types are also defined to facilitate exchange of immutable collection types that may be implemented differently to optimize for very specific performance or memory requirements.

See Andrew's blog for more detailed information (on immutable types for .NET and more. Lots of great info...).

This episode demonstrates a couple ways to accomplish this basic - but very important - task. I probably should have covered this much earlier on, but better late than never (hopefully).

.NET Debugging for the Production Environment, Part 8

.NET Debugging for the Production Environment, Part 10

• [0:33] Visual Studio 2012 Update 1 Now Available! (S. Somasegar)
• [3:23] Productivity Power Tools 2012
• [5:09] Build a Companion WP8 App for My Windows 8 App (Joelcitizen)
• [5:55] A Lap Around the Windows Phone 8 SDK (Nick Randolph)
• [7:04] Windows Phone 8 Training Kit
• [8:04] Async pack for Visual Studio 2012: why it’s useful also for Windows Phone 8 projects (Matteo Pagani)
• [9:35] Deploying and Debugging Windows 8 Apps on Microsoft Surface (Bernhard)
• [10:10] Developing an end-to-end Windows Store app using C++ and XAML: Hilo (Windows) - Book Download, Hilo C++ sample, [Found via: Jason Haley - Interesting Finds: November 28, 2012]
• [10:47] Building a LightSwitch HTML Client: eBay Daily Deals (Andy Kung)

Picks of the Week!

• Dan's Pick of the Week: [11:41] Maelstrom
• Brian's Pick of the Week: [14:34] LOTR in LEGO

As explained video on the basics wall clock time investigations, the key to doing such an investigation is focusing in on a 'critical path' of interest.   For ASP.NET scenarios the most obvious such path is the time it takes to respond to any particular request.   PerfView supports this idea by creating the 'ASP.NET Thread Time view', by identifying the snippets of time on individual threads that represent work to respond to the request, and associating this cost to a particular request (and further grouping requests by URL.   This allows you to quickly segregate 'uninteresting' time where threads are simply waiting for work from the 'important' time when it is on the critical path to respond to a request.  The result that it is very straightforward to drill into performance problems on any particular request. 

There is a companion perfView blog entries that you may be interested in.   In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video.  To use the zip file simply open it, and drag the directory inside to your desktop (or other location).   The file contains an HelloWorld.ASPX file (the source code, just view in notepad) as well as the AspNetHelloWorld.ETL.ZIP file (The data file used in this video)   You don't need to unzip this file, simply open it in PerfView.  

You may be interested in the entire PerfView Tutorial video series,  

In the first video the demo was the simplest case, a sequential program with both disk and CPU time.  In this video we discuss the more complex case when there are several threads doing concurrent activity that you wish to analyze.  

The key PerfView feature that helps in cases like these is the 'Thread Time (with Tasks)', but only works if you use the System.Diagnostics.Threading.Tasks.Task class to spawn the concurrent activities.  In this view if one Task spawns another, the time associated with the subtask is attributed to the point at which the new Task was created.  Thus even though the work might be done on another thread, the cost is 'rolled up' based on the code that requested that that action be done.    This allows concurrent applications to be analyzed like the simple sequential case (where the cost of calling a routine is attributed to the routine that called it).  

There is a companion perfView blog entries that you may be interested in.   In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video.  To use the zip file simply open it, and drag the directory inside to your desktop (or other location).   The file contains the EXE and PDB (symbol file), the complete VS2012 source (in the src directory) as well as the BlockedTimeParallel.ETL.ZIP file (The data file used in this video)   You don't need to unzip this file, simply open it in PerfView.  

You may be interested in the entire PerfView Tutorial video series,  

In this tutorial we take the simplest case (a sequential program that scans the file system, which requires both CPU and DISK), to cover the basics of wall clock time investigation.   This tutorial assumes you have already seen the video on CPU analysis as well as the videos on resolving symbols and using the stack viewer.   Frankly taking a quick tour of the whole PerfView Tutorial Series, would not hurt.  

There is a companion perfView blog entries that you may be interested in.   In particular there is a ZIP file of source code and data used in this tutorial, so that you can explore this data and 'follow along' yourself with what was done in this video.   To use the zip file simply open it, and drag the directory inside to your desktop (or other location).   The file contains the EXE and PDB (symbol file), the complete VS2012 source (in the src directory) as well as the BlockedTimeSync.ETL.ZIP file (The data file used in this video)   You don't need to unzip this file, simply open it in PerfView.  

Other videos on wall clock time analysis include

• Leveraging Tasks make sense of Parallel/Asynchronous programs
• Investigating Wall Clock Response Time of ASP.NET scenarios which I talk about in this blog entry.

In addition to the usual support for .NET and JS we're very pleased to announce the release of the C++ Rx library! Now, C/C++ developers get to experience the power of LINQ + Rx!! Rock and roll.

Congratulations to the Rx team!!!

"Compiler in the Cloud?", you ask. 

The idea is pretty simple. First, enter MDIL or Machine Dependent Intermediate Language or .NET hybrid assembly language. MDIL is all about compiling to native assembly instructions whenever possible, and compile the rest to pseudo instructions that can quickly be translated to native instructions on the phone. Thus, this assembly containing a mix of pseudo instructions and native instructions can be shipped to the device (and is portable across the same architecture - example, across all the ARM devices), and on the device we perform a light-weight linking step to convert the entire assembly to a native image. Most of the heavy lifting is done when we compile the IL assembly to the intermediate file between an IL assembly and a native image (this is what MDIL is).

"So what?", you ask. The linking step on the device that converts MDIL assembly to a native image only takes 1/5th the time as traditional NGEN on device. Thus, we get some of the benefits of both pre-compilation (since we are executing off the native image where all instructions are assembly instructions) and JIT-compilation (no heavy compilation on the device during framework updates).

Tune in to meet the program manager for code generation in .NET, Subramanian (Mani) Ramaswamy, and one of the lead developers of "Compiler in the Cloud", Peter Sollich. Peter is an expert in precompilation. We go quite deep here with plenty of whiteboarding. Peter teaches us exactly what MDIL is and why it's designed the way it is. We also talk about the higher level meaning in this (apps start fast, at native speed!). All around, it's a great Going Deep episode. Take the time to watch and learn. Thanks Mani and Peter!!

See Subramanian's BUILD 2012 session where he goes into detail on MDIL/Compiler in the Cloud and other performance/functionality improvement in .NET for Windows Phone 8.

In this show Cory is joined by Nir Mashkowski for the Web Sites Window. Nir explains how to enable Python in Windows Azure Web Sites by using the new Handler Mapping feature. Later in the show, Joe Brinkman from DotNetNuke Corporation talks about their beta release of DotNetNuke Cloud Services.

Show Links

• DotNetNuke World Conference
• Alliance Agreement between DotNetNuke and Microsoft 

Follow Brady Gaster

Follow Cory Fowler

Follow Joe Brinkman

Follow Nir Mashkowski

In this episode, we'll discuss the different types of CLR threads (.e.g., GC thread, finalizer, etc.) and give a walkthrough of how you can identify each one in a dump file.  Knowing this information can aid in your effort to find root cause - as well as avoid inaccurate reasons - for various application issues.

.NET Debugging for the Production Environment, Part 7

.NET Debugging for the Production Environment, Part 9

After watching this video, follow these next steps:

Step #1 – Start Your Free 90 Day Trial of Windows Azure
Step #2 – Download the Tools for Windows 8 App Development
Step #3 – Start building your own Apps for Windows 8

Subscribe to our podcast via iTunes, Zune, or RSS

If you're interested in learning more about the products or solutions discussed in this episode, click on any of the below links for free, in-depth information:

Websites:

• Learn more about Windows Azure

Blogs:

• Brian Hitney’s blog
• Peter Laudati’s blog
• Brady Gaster’s blog

Virtual Labs:

• MSDN Virtual Labs: Windows Azure

Ever have a situation in which your load test isn't passing the SLA, or the test results simply "look wrong"?  Even when your test hardware is exactly like your production hardware?  Is the problem somewhere in the code or... maybe something no one else has considered?  How do you troubleshoot this when - like in the production environment - you can't afford to have invasive troubleshooting tools in place?

.NET Debugging for the Production Environment, Part 6

.NET Debugging for the Production Environment, Part 8

Today's project is one we've highlighted before, yet with this update easily deserves to be mentioned again.

Releasing the new Sample Browser for Visual Studio 2012 and Visual Studio 2010

Developers love code samples.  Samples often serve as the starting point for many developers to learn a new technology.  They also provide straightforward solutions and helpful references when we as developers need to solve tough programming tasks.  Some developers even live by code samples. 

In partnership with Visual Studio Product Team and MSDN Samples Gallery Team, Microsoft All-In-One Code Framework releases Sample Browser Visual Studio Extension for Visual Studio 2012 and Visual Studio 2010 - an effort to evolve the code sample use experience. You can search and download 3500+ Microsoft official code samples and community samples, including over 700 Windows 8 samples and more than 1000 All-In-One Code Framework customer-driven code samples.  With its integrated sample search, flexible sample download and more than ten useful features designed for easier access and management of code samples, we hope to put the power of tens of thousands of code samples at developers’ fingertips.

Yes, VS2010 and VS2012. Many of us are going to be living in both VS worlds for a while, so its great to see this kind of support for both.

Features & Benefits

• Integrated and Rich Sample Search Experience

Sample Browser Visual Studio Extension is integrated with Visual Studio Quick Launch Bar, Toolbar, Code Editor and File Menu.  It gives you quicker access to samples when you are writing code in Visual Studio.  A rich set of sample search conditions allows you to filter search results by language, owner, technology and the targeting Visual Studio version.

• Integrated and Flexible Sample Download Experience

The Sample Browser Visual Studio Extension is integrated with the built-in support of downloading online samples in Visual Studio 2012.  Code samples downloaded in Sample Browser Visual Studio Extension are visible to the built-in code sample feature in Visual Studio 2012.  Vice versa.

• Integrated and Flexible Sample Download Experience

The Sample Browser Visual Studio Extension is integrated with the built-in support of downloading online samples in Visual Studio 2012.  Code samples downloaded in Sample Browser Visual Studio Extension are visible to the built-in code sample feature in Visual Studio 2012.  Vice versa.

...

• Integrated Look and Feel

Sample Browser Visual Studio Extension is integrated with the Visual Studio theme colors.  It supports both light and dark themes.

"What's next?" you ask?

Did you catch how easy it is to request samples?

This really is the one "Sample set and browser to rule them all." If you're looking for a code sample for just about anything Microsoft, start here...

SharpDX 2.3 new version released

General Information

• New release of SharpDX 2.3.0.
• This version is compatible with Windows 8 RTM and Visual Studio 2012 RTM.
• New target assemblies released : Signed-net40, Signed-winrt. Nuget packages are now providing signed assemblies.
• *Lots* of small enhancements, changes, bug fixes. See complete listing below.
• SharpDX.Toolkit, a high level XNA like API for Direct3D11 is under heavy development. The toolkit is not yet part of the distribution but a Beta version should be released by the end of October. Currently implemented:
  • Friendly constructors for all resources (states, textures, rendertargets, buffers).
  • Image and Texture loading & saving for various formats (DDS, JPG, PNG, BMP, TIFF, GIF).
  • A full HLSL Effect / FX system, very similar to legacy FX system, using efficiently Direct3D11, compatible with Windows Desktop and Windows 8 Modern, with a custom compilers. All XNA stock effects (BasicEffect, DualTextureEffect...etc.) were successfully ported to it. The toolkit is coming with its own effect compiler (tkfxc) similar to standard fxc.exe.
• Concerning support for Windows Phone 8 (WP8) nothing to announce yet until the official release of the WP8 SDK.

...

And when they say "*Lots* of small enhancements, changes, bug fixes" they really mean it...!

How do you get it?

Download section

Current stable version of SharpDX is 2.3.0.

SharpDX binaries are directly available from SharpDX google code download page or from nuget packages.

SharpDX is now bundled into 2 separate packages, for all platforms and .NET Framework:

• A Binary only package, SharpDX-Bin-2.3.0.exe that contains only binaries necessary to developed with SharpDX.
• A Full package, SharpDX-Full-2.3.0.exe that contains binaries, full documentation and all samples.
• Or via Nuget Packages, providing binaries for .NET 2.0-4.0 and WinRT, with debugging information and source code stepping.

The content of the archive is structured like this:

Samples? Here's a few snaps from the Win8 Sample solution;

And there's even more for Win7/8 Desktop app's! Here's the VS 2010 Sample Solution

"Wait, what's the big picture? What is SharpDX again?"

The power of DirectX for .Net

SharpDX is an open-source project delivering the full DirectX API under the .Net platform, allowing the development of high performance game, 2D and 3D graphics rendering as well as realtime sound application.

SharpDX is built with a custom tool called SharpGen able to generate automatically a .NET API directly from the DirectX SDK headers, thus allowing a tight mapping with the native API while taking advantages of the great strength of the .Net ecosystem.
SharpDX is fully supporting all Windows platforms including latest Windows 8 Metro. Easily develop multimedia applications for desktop and metro with the same API!

SharpDX is a free and active open-source project that is delivering a full-featured Managed DirectX API that includes support for Direct3D9 & Ex, Direct3D10, Direct3D10.1, Direct3D11, Direct3D11.1 (Win8 only), DirectCompute, Direct2D1, Direct2D1.1 (Win8 only), DirectWrite, WIC, D3DCompiler, DXGI, DXGI 1.1, DXGI 1.2 (Win8 only), DirectSound 8, XAudio2, XAPO, XACT3, X3DAudio, DirectInput 8, XInput and RawInput.

SharpDX supports all Windows OS and .NET Framework, including development for the latest Windows 8 Metro!

In short, if you're a Managed Dev and the new world of DirectX concerns you, you have to check out SharpDX...