Charlie Calvert's Community Blog : Video

Official Publication of Creating Windows Azure Applications with Visual Studio Videos

Charlie Calvert — Mon, 30 Nov 2009 18:15:14 GMT

Though they were previewed earlier this month, we have now officially released the first of Windows Azure series of How Do I videos. Below you find a list of the videos that have been created, along with links to their location in the How Do I Video library.

The Developing Windows Azure Applications with Visual Studio Video Series

In this series of videos Jim Nakashima shows how to develop Windows Azure applications with the tools provided in Visual Studio.

All these videos were created by Charlie Calvert

#1 | Windows Azure: Getting the Tools, Creating a Project, Creating Roles and Configuration
(14 minutes, 26 seconds)

#2 | Running and Debugging a Windows Azure Application Locally with Visual Studio
(6 minutes, 11 seconds)

#3 | Deploying Windows Azure Applications from Visual Studio
(6 minutes, 56 seconds)

HDI Video: Generate from Usage in Visual Studio 2010 with Karen Liu

Charlie Calvert — Sat, 07 Nov 2009 23:45:00 GMT

Karen Liu, the Lead Program Manager for the Visual C# and Visual Basic IDEs, has created a new video on Generate from Usage (GFU), a feature found in Visual Studio 2010, Beta 2. This post recaps what is included in the video, including the sections that show how GFU can be used to enhance test first development. The video is shot in both VB and C#. Since this is a C# blog, I’ll show only C# code, and will translate the VB code that Karen shows into C#.

Download the source code from the LINQ Farm

Generate from Usage (GFU) is a new feature in 2010 that allows you to write code that consumes a library or API before that API even exists. Using Visual Studio menus or shortcuts, you can automatically generate classes, constructors, methods, fields and properties from the code you typed in the editor.

As the video begins, Karen first types in the code to initialize a class called Automobile that does not yet exist:

Code Snippet
 var myCar = new Automobile(Make: "Honda", Model: "Accord");
 

Notice that the class name Automobile is not colored in teal, which is Visual Studio’s way of telling you that it does not yet it exist. When seen inside Visual Studio, the word Automobile will also have red squiggly (or wavy) underline, and a small blue smart tag under the letter A, as shown in Figure 1.

Figure 1: The red squiggle is Visual Studio’s way of telling you that the type Automobile will not compile. The blue smart tag under the letter A let’s the user know that an expansion tip is available by simultaneously pressing the Control key and a period (Ctrl + .).

The smart tag under the letter A is Visual Studio’s way of telling you to press the control and period keys to bring up a special expansion tip, as shown in Figure 2. Here we see two options, one for directly creating a class called Automobile, and the other for bringing up a dialog which allows us to define or tweak the details of the type of we create.

Figure 2: Viewing an expansion tip in Visual Studio.

You can also bring up the options to create a new class or type by right clicking on the word Automobile and selecting Generate from the popup menu, as shown in Figure 3.

Figure 3: A second way to generate a class is to right click the word Automobile and choose Generate from the popup menu.

If you select the option to create a new class, then Visual Studio will automatically generate a new file called Automobile.cs and place inside it a new class called Automobile. The entire generated file is shown in Listing 1.

Listing 1: The code generate when you choose to create a new class based on an undefined identifier in Visual Studio 2010.

Code Snippet
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace DeleteMe
{
    class Automobile
    {
    }
}
 

You can now go back to your original source file where you will see that there is still a red squiggly and blue tool tip, as shown in Figure 4. These hints are shown because we have not yet created a constructor for the Automobile class. If we again press control plus period, then the option to generate these code elements is made available to us, as shown in Figure 4.

Figure 4: Selecting the smart tag a second time brings up an option to automatically generate the constructor and associated fields for your class.

The code that is generated by selecting the expansion tip is shown in Listing 2. Notice that on lines 10 and 11 fields were created for your class and on lines 16 and 17 code was generated inside the constructor for initializing them. A comment in the form of a TODO item is also added to your class. These TODO items are visible in the Visual Studio Task List. You can access the Task List by choosing View | Task List from the menu, or by pressing Ctrl+W, T. Be sure to choose the Comments option from the drop down at the top of the Task List.

Listing 2: The code for the Automobile’s constructor is automatically generated by the IDE.

Code Snippet
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace GenerateFromUsageSample
{
    class Automobile
    {
        private string Make;
        private string Model;
 
        public Automobile(string Make, string Model)
        {
            // TODO: Complete member initialization
            this.Make = Make;
            this.Model = Model;
        }
    }
}
 

Karen next types in code for a TurnLeft method, and for a property called IsFacingNorth. As she types each item, a smart tag appears, and again she has the option to press Ctrl+. to automatically generate code for the Automobile class. The code typed in the program’s entry point is shown in Listing 3, and the code generated by the IDE is shown mostly in Listing 4. Notice, however, that code for a private object called distance was automatically generated in the Main method. The IDE actually gives you the option to create either a private field, as shown here, or a public property.

Listing 3: The complete code for Karen’s first sample includes a constructor, a method called TurnLeft, and a property called IsFacingNorth.

Code Snippet
  
namespace GenerateFromUsage
{
    class Program
    {
        private static object distance;
        static void Main(string[] args)
        {
            var myCar = new Automobile(Make: "Honda", Model: "Accord");
            myCar.TurnLeft(distance);
            myCar.IsFacingNorth = true
        }
    }
}
 

Listing 4: The code generated by the IDE for the TurnLeft method and the IsFacingNorth property.

Code Snippet
 using System;
 
namespace GenerateFromUsage
{
    class Automobile
    {
        private string Make;
        private string Model;
 
        public Automobile(string Make, string Model)
        {
            // TODO: Complete member initialization
            this.Make = Make;
            this.Model = Model;
        }
 
        internal void TurnLeft(object distance)
        {
            throw new NotImplementedException();
        }
 
        public bool IsFacingNorth { get; set; }
    }
}
 

When looking at Listing 4, notice that code for generating a NotImplementedException is automatically generated in the TurnLeft method. The IDE was also smart enough to discern that the IsFacingNorth property returns a bool. All the lines of code shown in Listing 4 were generated by typing just three lines of code in the main method found in Listing 3.

The C# Side

In the second part of the video Karen shows how you can use generate from usage (GFU) to enhance your experience when creating unit tests. Many theorists advocate using a test first methodology in which you first create a test, and then write the code that you want to test. You will see that GFU can be used to make this style of development quite natural and simple to use inside of Visual Studio.

NOTE: This section of the post requires high end versions of Visual Studio that contain the test wizards. Even if you don’t have those tools, you can still follow along to see how Generate from Usage can be used in all versions of Visual Studio to make it easier to create unit tests.

Begin by starting a new console application called Customer. Choose Tests | New Test from the Visual Studio menu. Select Basic Unit Test from the dialog, and name it Customers, as shown in Figure 5. When you press OK in the Add New Test dialog you will be prompted for the name of your unit test project. Type in CustomerTests. When you are done, the Solution Explorer for your project should look as it does in Figure 6.

Figure 5: Create a new unit test project that will house a file called Customers.

Right click on the Customer node in the solution explorer and choose Add | New Folder to create a new directory called Models. When you are done you should see a new node in the solution explorer, as shown in Figure 6.

Figure 6: This solution contains two projects, one a simple console application called Customer that contains a folder called Models. The other project is called CustomerTests and it is designed to hold unit tests.

I want to check if my Customer list is create correctly. In the Customers file from your test project, create a method called IsCustomerListValid. Inside the method create code to initialize a CustomerList object, as shown in Listing X.

Listing 5: A simple unit test with the code to initialize a class called CustomerList. Note that the CustomerList is not colored in Teal, since its declaration has not been created yet.

Code Snippet
 using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace CustomerTests
{
    [TestClass]
    public class Customers
    {
        [TestMethod]
        public void IsCustomerListValid()
        {
            CustomerList cust = new CustomerList();
        }
    }
}
 

At this stage, there is no CustomerList, so in Visual Studio you will again see the red squiggles and the blue smart tag, just as I showed in Figure 2. Without needing to take your hands off the keyboard, you can press control plus dot to bring up the expansion tips as in Figure 2. This time select New Type. A dialog comes up like the one shown in Figure 7. In the dialog we can change the accessibility, the kind of code to generate and the project file and directory where we want to place it. Set the Access to public and the Kind to class. Use the Project drop down to select the Customer project and the the Create new file drop down to select the Model directory. Type in CustomerList.cs as the name of the file to create.

Figure 7. Selecting the kind of type that you want to create, as well as the project, folder and file in which you want to place it.

When you press OK in the Generate New Type dialog, the new type will be created, and the IDE will add the using directive and the correct references. You can now fill out your test and your generated class as shown in Listing 6 and 7. Note that we have used generate from usage to enhance the CustomerList class with a method called Add. I then manually wrote code to create a list into which the text we pass can be inserted.

Listing 6: A simple unit test.

Code Snippet
 using Customer.Models;
using Microsoft.VisualStudio.TestTools.UnitTesting;
 
namespace CustomerTests
{
    [TestClass]
    public class Customers
    {
        [TestMethod]
        public void IsCustomerListValid()
        {
            CustomerList cust = new CustomerList();
            cust.Add("Karen");
            Assert.IsNotNull(cust);
        }
    }
}
 

Listing 7: The using directive, namespace, CustomerList class and header for the Add method were auto-generated. I manually created the list and inserted the call to Add an item into it.

Code Snippet
 using System.Collections.Generic;
 
namespace Customer.Models
{
    public class CustomerList
    {
        List<string> list = new List<string>();
 
        public void Add(string p)
        {
            list.Add(p);
        }
    }
}
 

You can now use the Test | View menu to bring up the Test List Editor and Test View to select and run your test.

Summary

In this post you got a second look at the code used in Karen Liu’s generate from usage video. You saw that GFU can be used to create classes, constructors, parameters, properties and fields. You also explored the powerful Generate New Type dialog which gives you the flexibility to choose the kind of type you want to create, as well as the project, directory and file in which you want to insert it. Finally, you saw that generate from usage can be powerful aid when you are engaged in test first development.

Resources

CSharp “How Do I Videos (Podcasts)” for the Zune Software

Charlie Calvert — Sun, 01 Nov 2009 20:54:40 GMT

It can be handy to create custom RSS feeds for the Zune so that it is easy to download and watch selected videos. You can watch these videos either on your PC, or on the Zune itself. Here is a custom feed I created that contains all the new C# 4.0 language and IDE How Do I Videos, plus a selection of other How Do I videos. In total, at this time, there are 35 videos in the feed. The RSS I created uses a simple and quite minimal syntax tested only with Internet Explorer 8 and the software for Zune 4.0.740.0. The source for the C# program that generated the feed includes regular expressions, LINQ to Objects and LINQ to SQL. I discuss that program briefly at the bottom of this post.

Charlie’s Custom C# and Visual Studio Feed
The How Do I Video Home Page with over 500 Videos
How Do Videos for Visual Studio
How Do I Videos for C#
Download the source for this post from the LINQ farm.

You can use this custom feed from inside IE, as shown in Figure 0. However, I really created this feed to run on the Zune, so you should import the feed into the Zune software as a series of podcast. I explain this latter process in the next section of this post.

Figure 0: Viewing a simple RSS feed in IE 8. Click the image to expand it.

Using the Feed in the Zune Software

In this section I provide a quick tutorial for those who’ve never used Podcasts with a Zune. Open the custom RSS feed in IE and grab the URL from the address bar. Alternately, you can just right click on any of the links to the feed in this document and choose Copy Shortcut or whatever the equivalent command is in Firefox or other browsers. Open the Zune software and turn to the Collection | Podcasts page. Click the button on the bottom left of the page called Add a Podcast. The Subscribe dialog appears. Paste in the URL for the feed, as shown in Figure 1, and then click the Subscribe button. The various How Do I podcasts included in the feed should begin downloading to your system, as shown in Figure 2.

Figure 1: Subscribing to an RSS Podcast feed in Zune Software 4.0.740.0

Figure 2: Viewing a feed in the Zune Software.

You can then plug in your Zune and right click on the feed and choose to sync the videos to your device. I’ll confess, however, that many of these videos look best on a PC, since you need a certain amount of screen real estate to adequately view the code typed in by the presenters.

Creating the RSS Feed by Screen Scrapping

I created this feed by the time honored hack of screen scraping. I first copied the URL for the home page of each video and passed it to C# code designed to download the HTML associated with the URL. The program parsed the HTML looking for the elements I needed in my feed. LINQ to XML provided a handy tool for creating my simple RSS feed. I simply passed in the data retrieved from the HTML file to a set of LINQ routines designed to produce the XML for an RSS feed.

This technique is simple to implement. Screen scraping is nevertheless a very brittle practice, as my code will last only so long as the basic structure of the HTML pages that I’m parsing remains static. How long such conditions will prevail one can only suppose.

I called my quick and dirty program CreateRssFeed, and its source is available for download. The program is based on two custom classes, one for generating the RSS feed, the other for using Regular Expressions to parse the HTML file. I store the URLs for the 35 HDI video pages in a file called UrlsToProcess.txt. I won’t bore you with the complete listings for this code, but I show the main body in Listing 1, and a short excerpt from the RSS feed is shown in Listing 2.

When you download the source, you will find versions for both VS 2008 and VS 2010, Beta 2. The latter solution contains both a console and a windows forms app. They each have their advantages, but I tend to prefer the former.

Listing 1: The main body of the program.

Code Snippet
 using System;
using System.Collections.Generic;
using System.IO;
using CreateRssVideo.Code;
 
namespace CreateRssVideo
{
    class ProgramConsole
    {
        static void Main(string[] args)
        {
            string[] urls = File.ReadAllLines("UrlsToProcess.txt");
            List<string> items = new List<string>();
 
            ParseHdiVideoPages parser = new ParseHdiVideoPages(items);            
            foreach (var url in urls)
            {
                parser.ProcessUrl(url);
                Console.WriteLine(items[items.Count-1]);
            }
 
            File.WriteAllText(@"..\..\CSharpZuneReadyHowDoIVideos.rss", parser.RetrieveXml());
        }
    }
}
 

Listing 1: An abbreviated version of the RSS Feed created by the code for the CreateRssVideo program.

Code Snippet
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
<!--Charlie's RSS Feed for Videos-->
<rss version="2.0">
  <channel>
    <title>CSharp How Do I Video Custom Feed for Zune Software</title>
    <description>VS 2010 Related Videos</description>
    <link>http://blogs.msdn.com/charlie</link>
 
    <item>
      <title>Add Tool Windows to the Visual Studio IDE?</title>
      <description>This video demonstrates how to</description>
      <link>http://msdn.microsoft.com/en-us/vstudio/dd250814.aspx</link>
      <enclosure url="http://download.microsoft.com/CreatingToolWindows.wmv" type="video/x-ms-wmv" />
    </item>
 
  </channel>
</rss>
 

The C# code for the CreateRssVideo program uses the build-in WebClient object to download the HTML for the video home page as a string:

private static string RetrieveHtmlFromSite(string urlName)
{
    WebClient objWebClient = new WebClient();
    byte[] requestedUrl = objWebClient.DownloadData(urlName);
    UTF8Encoding utf8 = new UTF8Encoding();
    string htmlAsString = utf8.GetString(requestedUrl);
    return htmlAsString;
}

It then uses bits of Regular Expression code to parse the HTML and extract the title, description and video URL from it:

private string FindStringInHtmlFile(string htmlAsString, string regEx)
{
    Regex r = new Regex(regEx, RegexOptions.IgnoreCase);

    MatchCollection matchCollection = r.Matches(htmlAsString);
    string groupItem = "";

    if (matchCollection.Count > 0)
    {
        foreach (Group groupItemFound in matchCollection[0].Groups)
        {
            groupItem = groupItemFound.Value;
        }
    }
    return groupItem;
}

Below is a sample of one of the simple regular expressions that I pass into the FindStringInHtmlFile method. This particular bit of code is used to retrieve the description of the video from the HTML file:

private static string regExDescriptionText = @"([A-Z\s0-9#\.,\(\)\-]+)";
private string regExDescription = @"<p><strong>About this Video</strong></p><p>" + regExDescriptionText;

While we are parsing the HTML, the program works step by step to create the RSS document using LINQ to XML. The first stage in the RSS creation is to new-up an outline or shell that will hold the meat of the document:

public void Start()
{
    string link = "http://blogs.msdn.com/charlie";
    string title = "CSharp How Do I Video Custom Feed for Zune Software";
    string description = "VS 2010 Related Videos";

    theDocument = new XDocument(new XDeclaration("1.0", "utf-8", "yes"),
        new XComment("Charlie's RSS Feed for Videos"),
        GetChannel(link, title, description));
}        

private static XElement GetChannel(string link, string title, string description)
{
    return new XElement("rss", new XAttribute("version", "2.0"),
        new XElement("channel",
                        new XElement("title", title),
                        new XElement("description", description),
                        new XElement("link", link)));
}

The Start method creates the document itself, including an XML declaration and a comment. The GetChannel method adds a few simple fields to the document that describes its purpose and which list the URL for my home page. Compare this code with the first few lines from Listing 1 to be sure you understand its purpose.

As the information for each HDI video is discovered, a new <item> node is created for the RSS feed. This node lists the title for the video, describes the video, and references the URL for the HTML page where the video is stored. Finally, and most importantly, the code includes the <enclosure> node which stores the URL of the actual video. It is the <enclosure> node that the Zune software uses to locate the video which it downloads to your system:

private static XElement GetItem(string itemTitle, string description, string linkUrl, string videoUrl)
{
    XElement item = new XElement("item",
                new XElement("title", itemTitle),
                new XElement("description", description),
                new XElement("link", linkUrl),
                new XElement("enclosure",
                    new XAttribute("url", videoUrl), new XAttribute("type", "video/x-ms-wmv")));
    return item;
}

Once the <item> node has been created, it is added to the XML document itself:

public void AddItem(string itemTitle, string description, string linkUrl, string videoUrl)
{            
    XElement item = GetItem(itemTitle, description, linkUrl, videoUrl);            

    var linkNode = from x in theDocument.Descendants("link")
                   select x;
    
    linkNode.First().AddAfterSelf(item);            
}

Note that this code includes a simple LINQ query used to discover the proper insertion point in the XML document, and then employs the LINQ to XML AddAfterSelf operator to insert the new <item> XML node into the code for the RSS feed. The program enters and loop and repeats the process of creating and inserting <item> nodes into our RSS feed multiple times. Once all the URLs in our UrlsToProcess.txt document have been examined the program exits.

Summary

The primary purpose of this post is to provide an RSS feed that you can use to download videos for viewing in the Zune software or in the Zune itself. I also showed a simple, and very brittle, screen scraping program that I used to create the feed. I wrote this program for my own use, and pass it on to you with only minimal claims of its value. If nothing else, it provides some examples of how to have fun writing Regular Expressions, and demonstrates how easy it is to use LINQ to Objects and LINQ to XML to create XML documents.

The video feed.
The source from the LINQ farm.

Community Convergence LVI

Charlie Calvert — Mon, 19 Oct 2009 20:21:00 GMT

Welcome to the fifty-sixth community convergence. As you probably know by now, Visual Studio 2010 Beta 2 has been released on MSDN and will be available to the general public on Wednesday, October 21, 2009. I’ve worked with the team to create a wide range of technical material designed to support this release, and I will call out each item out here in this post. Be sure to check out the new How Do I and Interview videos, the samples, and the great posts by Alexandra Rusina. In other news, we’ve gotten word that the SoCal code camp will be held right after PDC this year. If you live in the LA area, this is a great chance to see some of the Microsoft speakers who will be presenting at PDC.

From the C# Team

How Do Videos on C# 4.0

How Do I Use Named and Optional Parameters in C# 4.0? (with Sam Ng)
How Do I Use COM Interop and Office in C# 4.0? (with Sam Ng)
How Do I Use Covariance and Contravariance in VS 2010 Part I? (with Eric Lippert)
How Do I Use Covariance and Contravariance in VS 2010 Part II? (with Eric Lippert)

How Do Videos on the Visual Studio 2010 IDE

How Do I Use Highlight References in the Visual Studio 2010 IDE (with DJ Park)
How Do I use Code Snippets in the Visual Studio IDE (with Karen Liu)
How Do I Use Generate from Usage in Visual Studio 2010? (with Karen Liu)
How Do I Use the Call Hierarchy? (with DJ Park)
How Do I Step with the Debugger in Visual Studio? (with Dustin Campbell)
How Do I Refactor my Code in Visual Studio Part I? (with Dustin Campbell)
How Do I Refactor my Code in Visual Studio Part II? (with Dustin Campbell)

Interview Videos on Channel 9

C# 4.0 Dynamic with Chris Burrows and Sam Ng

Alexandra Rusina

Eric Lippert

What is this thing you call "thread safe"?
As Timeless As Infinity (On Delphi, VB Script and Exceptions)
Absence of evidence is not evidence of absence (On Constructors)
What's the difference between "as" and "cast" operators?
Why No Extension Properties?
Why does char convert implicitly to ushort but not vice versa?

Kirill Osenkov

Luca Bolognese

Becoming really rich with C#

Beta 2

Visual Studio 2010 Samples
MSDN Subscribers: Download the Beta
A Video on How to Download and Install the Beta
Walkthroughs and Related Content

From the C# Community at Microsoft

Scott Guthrie

Scott Hanselman

Dan Fernandez

MSDN Magazine

Mitsu

Surface Academy Toolkit with Card Game, plus Dick Lantim!

From the Community

September INETA Newsletter

CodeRush Xpress 9.2 Ships

Charlie Calvert — Fri, 28 Aug 2009 22:47:57 GMT

The free CodeRush Xpress from DevExpress provides C# and VB developers with powerful extensions to Visual Studio. These features include editing and refactoring tools that make it easier for you to quickly produce well designed code. Version 9.2 of CodeRush Xpress, which shipped on August 25, 2009, has greatly improved memory and performance characteristics.

CodeRush Express comes with a set of selection, navigation and declaration features, as well as over 60 refactorings which are grouped into the following categories:

Changing Signatures
Conditionals
Declaration and Initialization
Expressions
Lambda Expressions and Anonymous methods
Loops and Blocks
Properties and Fields
Moving/Extracting Methods
Resource Files and Strings
Types and Visibility

Figure 1: Dustin Campbell and Mark Miller discuss the cool features in CodeRush Xpress.

The new features in CodeRush Xpress 9.2 include:

Faster Performance
Reduced Memory Consumption
Support for Preprocessor Directives
Background Processing Progress Bar

To learn more, watch the CodeRush Xpress 9.1 introductory video with Microsoft’s Dustin Campbell and CodeRush creator Mark Miller. You can also read an in-depth review of the new features in CodeRush Xpress 9.2 on Mark’s blog. A few months back, Dustin posted on some of the updated features in a May release of CodeRush Xpress, including

Duplicate Line,
Highlight All References
Increase or Reduce Selection
Smart Clipboard
Generate from Using
Quick Navigation Window
Quick File Navigation

Many of the features in CodeRush Xpress are also explained in depth on the DevExpress web site. For instance, you can click here for an explanation of the navigation features. In Figure 2 you can see a screen shot from the video which highlights some of the features of CodeRush Xpress.

Figure 2: A screen shot from the CodeRush Xpress introductory video shows the Refactor menu and New Field Active tip window. Click the picture to see a larger version.

CodeRush Xpress provides lots of tools designed to make coding inside Visual Studio easier. Take a look and see if it can help you get more work done in less time.

Jeff Richter Video on Asynchronous Programming and his Power Threading Library

Charlie Calvert — Thu, 04 Dec 2008 09:23:19 GMT

I recently had the chance to sit down with Jeff Richter and discuss his Power Threading Library. This library provides a simple technique for handling asynchronous development. By making clever use of C# Iterators, Jeff is able to make asynchronous code looks as though it is synchronous code the executes in a linear fashion. Jeff's library greatly simplifies the asynchronous programming model, making it easy for you to navigate waters that you may have once considered formidably perilous.

Figure 1: Jeff Richter explains how to use his Power Threading Library.

Many of you who've had experience with asynchronous development know how difficult such code can be to write. Asynchronous code is typically non-linear, and jumps from one portion of a program to another. It is difficult to debug, and is difficult to tame if errors occur.

To understand the difficulties inherent in asynchronous development it helps to first consider a simple example. Suppose you begin an IO operation of some kind, perhaps the download of a large file. The download is going to take several minutes. To avoid locking up your program during the download, you set up a thread on which the operation can run. You start the thread, call it from your main thread, and set up a callback method which can be executed when the operation completes. Because the download is run on a secondary thread, the main thread of your program is still responsive during the download, and can interact with the user. When the task completes, the callback is executed, thereby announcing the termination of the download. You might then have a new asynchronous task that you might want to begin, such as processing the downloaded file and adding portions of its content to a database. Again, this task is going to take some time, and so you start another thread, providing another callback method that can be executed when the task is completed.

The model outlined in the previous paragraph is common, but awkward. The problems inherent in this scenario are numerous, but two of the worst problems can be summed up as follows:

The code does not execute in serial fashion, but instead jumps from one callback to another, thereby making it difficult to debug. Someone new to the code might find it hard to understand which callback will execute next, or which thread is currently active.
If something goes wrong during the execution of the code, it can be very difficult to clean up the current operation and exit the process smoothly. Operations are occurring on multiple threads, or inside some seemingly random callback. Allocations, open files, and initialized variables are hard to clean up, and it is difficult to define which code should execute next after you enter an error condition. Setting up a try..catch block is difficult at best, and sometimes impossible. The result can be a mass of spaghetti code that is difficult for the original developer to understand, and nearly incomprehensible to others who are assigned the unfortunate task of maintaining it.

All of these problems are commonly encountered by developers who create asynchronous code. What Jeff has done is write a library that allows you to write asynchronous code in a synchronous style, as if each operation were occurring in a linear, or serial, sequence. In other words, you can write a single method in which the file is first downloaded, then parsed, and data is then inserted in a database. The code looks like synchronous code, and appears to execute in a linear fashion. Behind the scenes, however, the code is actually asynchronous, and uses multiple threads. As mentioned earlier, the library is built around C# Iterators, which bear the weight of handling the multiple threads that are spawned during your asynchronous operations.

Take a look at the movie to learn exactly how it works, and then download Jeff's free library to try it yourself. Jeff is, of course, a great speaker, and his explanation of this library is a joy to hear. Not only does he show a simple way to write asynchronous code, but he also does a great job of explaining exactly how C# Iterators are put together. It's one of the best explanations of that important subject I've ever heard.

Download or view the video: http://channel9.msdn.com/posts/Charles/Jeffrey-Richter-and-his-AsyncEnumerator/
Visit Jeff's Web Site and download the library: http://wintellect.com/PowerThreading.aspx

Anders Hejlsberg Video on C# Dynamic

Charlie Calvert — Thu, 13 Nov 2008 12:17:58 GMT

In this Channel 9 video C# architect Anders Hejlsberg answers some commonly asked questions about the new Dynamic features that will be included in C# 4.0. Building on the talk that he gave at PDC, Anders chats with C# Community PM Charlie Calvert. They discuss questions that community members have asked and riff on themes of import to developers who have been following the latest news from the C# team.

Video: New Error Checking Feature in Visual Studio Service Pack 1

Charlie Calvert — Fri, 25 Jul 2008 22:06:58 GMT

In this 12 minute video I talk with C# IDE PM DJ Park about a new feature in Visual Studio 2008 Service Pack 1 beta called Live Semantic Errors or Squiggles. This feature gives an increased level of live feedback on potential errors that might be found in your code. In the past, many of these errors would only surface after you tried to compile your code, but now you can see them interactively as you type code in the IDE. This feature should help developers become more productive by allowing them to find errors quickly.

You have the choice of either watching video correctly or downloading it as zip file:

Thanks to Beth Massi who filmed this video and produced a WMV file for us to share with the community.

Anders Hejlsberg Film Festival: The C# and other VS Language Teams at the Movies

Charlie Calvert — Sat, 29 Mar 2008 09:09:46 GMT

It's a bit rainy and snowy today in Redmond. What an excellent time to curl up by the fire and watch a movie! Here are some suggestions.

Video of Luke Hoban's In-Depth Look at C# 3.0

Charlie Calvert — Fri, 22 Feb 2008 23:52:13 GMT

Last fall in Barcelona, Spain two PM's from the C# team gave talks on key parts of the new LINQ technology found in Visual Studio 2008:

Luca Bolognese: LINQ to SQL: Accessing Relational Data with Language Integrated Query
Luke Hoban: Microsoft Visual C# Under the Covers: An In-Depth Look at C# 3.0

Luke Hoban was the PM who drove the development of LINQ to Objects, and the man who created the now famous implementation of a ray tracer in a single, very long, LINQ query expression. He is now focusing his efforts on F#. By listening to his talk on C# 3.0 features you will get a chance to see a detailed and specific analysis of how LINQ works. Listening to him give this talk marked a turning point in my understanding of LINQ. For the first time I understood how the team folded extension methods and query expressions together to create the marvelously supple and deceptively simple syntax that we know as LINQ.

Figure 1: Luke Hoban's vision of the inner workings of LINQ to Objects gives developers significant insight into the beauty of C# 3.0.

Luca Bolognese is the Principal Program Manager Lead on the C# team. His talk on LINQ to SQL endows developers with the knowledge necessary to wield the tools that drive data driven application development under C# 3.0. A consummate speaker, Luca skillfully guides his audience through the elements that comprise LINQ to SQL development.

Here are the links you need to get started.

The Talks discussed in this post:

More talks from the TechEd Developers Event Link:

http://www.microsoft.com/emea/msdn/spotlight/event.aspx?id=82

LINQ and Deferred Execution Video

Charlie Calvert — Fri, 14 Dec 2007 10:14:51 GMT

Here is a video version of the Deferred Execution post I published on December 9. You can watch the video on SoapBox, or you can access it directly from the Microsoft Downloads site. To download the video, just right click on this link and choose Save target as or Save link as from the popup menu.

Many people might find it easiest to watch the video once, then go to the original post to pursue this subject in more depth. The full Visual Studio 2008 project shown in the video is attached to the article. You can also go to the post to read about the subject matter of the video at your own pace, or to cut and paste code shown in the video.

Original Article: LINQ and Deferred Execution
Video: Deferred Execution
Soapbox Video: Deferred Execution, or just click on the video below.
Source Code: DeferredExecutionWithDatabase.zip

The URL of the video:

http://download.microsoft.com/download/1/a/3/1a38e40f-e68c-4cf9-874f-23dd5a91a8a7/DeferredExecution.wmv

LINQ to SQL Pipeline Video with Luca Bolognese and Matt Warren

Charlie Calvert — Tue, 07 Aug 2007 00:49:58 GMT

C# Principal Architect Matt Warren and Lead PM Luca Bolognese detail the pipeline that hastens your LINQ queries to execution. Matt did most of the design and implementation of this code. His explanations are vivid and useful. The drawings are well organized, well executed, and clearly explained. Matt and Luca have worked together for years, and they make an excellent team.

You can see the 40 minute video by clicking on the Soapbox graphic shown in Figure 1. There are also two downloadable versions of this video. The smaller one is roughly equivalent in quality to the embedded Soapbox video found in this blog, the other is of much higher quality, but also much larger. Both versions of the video are in WMV format and are stored in zip files.

High quality video (318,630 KB)
Compact version of video for smaller devices (35,198 KB)

Figure 1: Video: LINQ Pipeline

Topics covered in the video:

A step by step in depth explanation of the LINQ Pipeline that transforms a LINQ query into SQL and returns a result to the user.
A detailed explanation of updates and calls to SubmitChanges() including discussions of:
- Transactions
- Injecting stored procedures into the update pipeline.
A discussion of the history of LINQ and its roots. Matt and Luca talk about the many years of hard work necessary to bring LINQ to fruition, and the roles that such luminaries as Erik Meijer and Anders Hejlsberg had in that process. Both Luca and Matt have been with LINQ since its inception. They know the whole story, and no one could possibly be better poised to explain it than these two who had so much to do with its creation and implementation.

LINQ to SQL Introductory Video

Charlie Calvert — Wed, 20 Jun 2007 20:43:25 GMT

This video shows the basic steps required to create a LINQ to SQL video using Visual Studio 2008 Beta 1 (aka as Orcas Beta 1). You will be introduced to following concepts:

Using the LINQ to SQL designer to map data in your database to classes in your program.
1. Generating a DataContext used to connect to your database and access its tables and field
2. Exploring the auto-generated ORM-style entity classes that wrap the tables in your database
Writing LINQ to SQL code
1. Instantiating an instance of the DataContext
2. Writing a SQL Expression to query data
3. Iterating over LINQ to SQL data with a foreach loop
4. Using Anonymous Types to create a projection, or custom view, of data in a table
5. Creating a LINQ style join between two tables that are linked by a foreign key
6. Using the ObjectDumper class from Visual Studio 2008 (Orcas)
7. Using Type Inference and the var keyword

There is nothing very fancy in this video, but it will provide you with an easy to follow introduction to LINQ to SQL.

Stream the Video (Flash and JavaScript required)
Download the video: (Size 6.6 MB. Flash required. JavaScript required unless you have a standalone flash player.)

del.icio.us Tags: C#, LINQ

Videos

Charlie Calvert — Mon, 18 Jun 2007 20:36:49 GMT

I'm trying to pull together lists of available C# videos. I'll be working on this list over time, but here are few preliminary pointers.

Luca at Tech Ed 2007: (The .NET Language Integrated Query (LINQ) Framework (Level 300))
Anders at Mix (You can just right click on this link to save it to disk.)
FebCtp Video: Stream it
FebCtp Video: Download Video
LINQ Overview
C# 3.0
Anders on LINQ and Functional Programming
Anders on Ask the Experts, Jan 17, 2007
Anders on LINQ from 2005
Anders on LINQ from the LANG.NET Conference
Anders Chatting about LINQ and ADO.NET
Anders, Herb Sutter, Erik Meijer, Brian Beckman on Software Composability
Anders with Chris McConnell
Eric Lippert on Type Inference
Peter Hallam on Automatic Properties
Performance Issues in Visual Studio (Anson Horton, C# PM, only tangentially related to LINQ)
Luca Bolognese (Lead PM, C# Team) on "What's New in the May LINQ Preview"
C# PM's Karen Liu and DJ Park on the C# IDE, LAF, and support for LINQ.
An Interview with Wes Dyer (Download)
Raj Pai, C# GPM, on the C# Team

Beginning Developer Series

Thanks to Kathleen McGrath who helped track some of these down.

Older Videos

Thanks to Kathleen McGrath who helped track some of these down.

Charlie Calvert's Community Blog : Video

Official Publication of Creating Windows Azure Applications with Visual Studio Videos

The Developing Windows Azure Applications with Visual Studio Video Series

HDI Video: Generate from Usage in Visual Studio 2010 with Karen Liu

The C# Side

Summary

Resources

CSharp “How Do I Videos (Podcasts)” for the Zune Software

Using the Feed in the Zune Software

Creating the RSS Feed by Screen Scrapping

Summary

Community Convergence LVI

From the C# Team

Beta 2

From the C# Community at Microsoft

My Picks for PDC 2009

The Coding4Fun Show: Advanced Rendering with Silverlight, Rick Barraza

From the Community

CodeRush Xpress 9.2 Ships

Recent Videos from the C# Team (2008-2009)

Jeff Richter Video on Asynchronous Programming and his Power Threading Library

Anders Hejlsberg Video on C# Dynamic

Video: New Error Checking Feature in Visual Studio Service Pack 1

Anders Hejlsberg Film Festival: The C# and other VS Language Teams at the Movies

Video of Luke Hoban's In-Depth Look at C# 3.0

LINQ and Deferred Execution Video

LINQ to SQL Pipeline Video with Luca Bolognese and Matt Warren

LINQ to SQL Introductory Video

Videos

Beginning Developer Series

Older Videos