Charlie Calvert's Community Blog

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

2009-11-07T23:45:00Z

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

Classic, Lightweight and ScriptFree MSDN Library Views

2009-11-07T00:58:56Z

There have been a number of changes to the MSDN library of late, and to the way it is integrated with Visual Studio 2010. Kathleen McGrath and Mark D'Urso have created a nice little video that walks you through some of the new features such as the classic, lightweight and script-free views, as well as the new feedback mechanism. If you have questions about how the new features in the library work you might find that this is a useful way to spend 9 minutes and 36 seconds.

You might also enjoy Kathleen’s video interview with Ryan Linton. It focuses on using help from inside Visual Studio.

New Article by Bill Wagner on Dynamic Method Bags in C# 4.0

2009-11-03T22:30:32Z

C# MVP and wunderkind Bill Wagner has written an article entitled Dynamic Method Bags which is now available on MSDN. Bill explores the new dynamic feature in C# 4.0. Most posts on this subject explain how to use dynamic to call Python, Ruby or Office. In his article, Bill explains how dynamic can be used not to call another language or tool, but to call your own C# objects without directly using the reflection API’s. The solution he provides combines generics, expression tress and dynamic to create a “type that allows developers to add new methods at runtime” and call those methods through dynamic dispatch.

Resources

Bill’s Dynamic Method Bags article
Bills Blog
Download a Doc file providing an Overview of C# 4.0 Language Features
C# Future Samples
Visual C# 2010 Resources
VS 2010 Walkthroughs
Some Dynamic Walkthroughs
IronPython on CodePlex
IronRuby

New Article on Detecting Memory Leaks . NET Applications

2009-11-02T23:49:40Z

MSDN has published an excellent article by Fabrice Marguerie entitled “How to Detect and Avoid Memory and Resource Leaks in .NET Applications.” In the article, the author explains how memory leaks are introduced into .NET applications, and what you can do to discover and eliminate them. The code shown in the article is in C#, but the topics covered will likely be useful to a broad range of .NET developers.

Figure 1: Fabrice Marguerie is a Microsoft MVP, French Software Architect and Web Entrepreneur with an in-depth understanding of .NET technology.

Fabrice explains his subject in great depth, providing information that will be useful both to advanced developers, and to those with an intermediate-level understanding of .NET development. Features included in the text include:

An explanation of how memory and resource leaks occur in .NET application
A demonstration of how to detect those leaks
A list of common causes of memory leaks and how to avoid them
A useful reference section listing a number of tools that can be used to help you find and manage leaks

This is a well written article with a wealth of information in it. Hurry on over to the Dev Center and take a look.

References

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

2009-11-01T20:54:40Z

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.

VSL at DevConnections

2009-10-31T08:38:02Z

The following talks will be given by Visual Studio Languages team members at the DevConnections Conference in Las Vegas.

Tuesday, November 10, 2009	Title	Speaker
10:00am - 11:00am	VMS01: The Future of C#	Charlie Calvert
11:15am - 12:15pm	VMS02: Future Directions for Visual Basic	Jared Parsons
1:45pm - 2:45pm	VMS03: Microsoft Visual C# IDE Tips and Tricks	Charlie Calvert
3:15pm - 4:15pm	VMS04: Microsoft Visual Basic IDE Tips and Tricks	Jared Parsons

For additional Information see:

Visual Studio 2010 Beta 2 does not Load: The “Application Cannot Start” and Raster Font Errors

2009-10-29T22:13:43Z

I was working at home the other night with a freshly installed copy of Visual 2010 Beta 2. I closed the IDE for a moment, and when I tried to reopen it, I got an error that read: “The application cannot start.” I found I could start the IDE by using the Jump Lists in Windows 7 to start a specific application rather than simply opening the IDE without loading a project. After getting back inside the development environment, I rummaged about for a bit and finally fixed the problem, probably by resetting my profile (Tools | Import Export Settings). That may or may not work for you, but these two excellent and authoritative posts are more likely to solve your problem if you encounter a similar error:

How to fix the “Application Cannot Start” Error
Work around for the Raster Font Settings Issue (“Object reference not set to an instance of an object.”)

Figure 1: There is no joy in Mudville, Visual Studio 2010, Beta 2 will not start!

I was having an excellent time working inside VS 2010 Beta 2, so I was frustrated to hit this glitch. I don’t want you to wander into the same troubled climes, so I’m posting here this good information from two experts on the VS IDE. By the way, these issues are all fixed in our new internal builds, and those fixes will be part of the final release of Visual Studio 2010.

A Chance to Influence the MSDN Visual Studio Documentation (Help System)

2009-10-27T21:43:37Z

The docs team here at Microsoft has created a new survey to solicit your opinion on the help system found in the MSDN technical library. This the same information you see if you press F1 in Visual Studio to get help on the IDE or your development language. I know the people who create and process this survey, and I can assure that any feedback you give will be processed and carefully considered. The team is strongly driven by input from our users, and this is your chance to have your say. I’ve taken the survey myself, and found that it consists of about 10 pages with an average of 2 or 3 questions per page. I didn’t spend much time contemplating each question, and was therefore able to finish the survey in about 5 minutes.

Links

Thank you for your input!

Running IronPython Scripts from a C# 4.0 Program

2009-10-26T06:41:52Z

IronPython is a scripting language hosted on the .NET platform. This posts shows how you can use the Dynamic Language Runtime (DLR) and the new C# 4.0 dynamic keyword to call an IronPython script from a C# program.

Before going any further, it might be helpful to take a moment to explore the architecture that makes this technology possible. The key building block is the DLR, which sits on top of the .NET 4.0 CLR and provides the tooling for adding dynamic programs such as Python to the family of .NET languages. C# 4.0 adds the dynamic keyword and some related technologies to integrate support for dynamic binding into the language. The end result is that developers can arbitrary Python scripts directly from C# or other .NET languages.

Download Source from the LinqFarm

Setting up a C# Project to Call IronPython

In two previous posts I described how to install and run a simple IronPython program:

If you don’t already have the latest version of IronPython installed or if you need a little refresher course in writing Python scripts, then you might want to glance at these posts. Otherwise, you can just keep reading to learn how to call Python from C#.

After the IronPython installation, its interpreter and its libraries will be installed in your Program Files directory, as shown in Listing 1. The interpreter is installed in ipy.exe, where ipy is pronounced “Eye-Pie.” The interpreter remains dormant when you call Python from C#, so our focus here should be on the assemblies shown in the second half of the listing, with a particular emphasis on IronPython.dll.

Listing 1: At the command prompt you can easily see the core files that form the basis for the IronPython installation.

C:\Program Files (x86)\IronPython 2.6 CTP for .NET 4.0 Beta 2>dir *.exe *.dll
 Volume in drive C has no label.
 Volume Serial Number is 4C6B-EE0E

 Directory of C:\Program Files (x86)\IronPython 2.6 CTP for .NET 4.0 Beta 2

10/18/2009  01:47 PM            12,624 ipy.exe
10/18/2009  01:47 PM            12,624 ipyw.exe

 Directory of C:\Program Files (x86)\IronPython 2.6 CTP for .NET 4.0 Beta 2

10/18/2009  01:47 PM         1,433,424 IronPython.dll
10/18/2009  01:47 PM           435,536 IronPython.Modules.dll
10/18/2009  01:47 PM           875,856 Microsoft.Dynamic.dll
10/18/2009  01:47 PM            58,192 Microsoft.Scripting.Debugging.dll
10/18/2009  01:47 PM           159,056 Microsoft.Scripting.dll
               7 File(s)      2,987,312 bytes
               0 Dir(s)  16,881,614,848 bytes free

To run a Python script inside a C# program, you should include some or all of the libraries shown in Listing 1 in the References section of your project. To get started, choose File | New Project (Ctrl-Shift-N) from the Visual Studio 2010 menu and create a new console application. Then open the Solution Explorer (Ctrl-W, S) and go to the References section for your project. Right click and choose Add Reference. Take a moment to appreciate how quickly the Add References dialog appeared (the team worked hared on this performance improvement), and then select the Browse tab and navigate to the directory where IronPython resides. The path to the directory hosting IronPython will probably be similar to the one shown in Listing 1. For now, the simplest choice is to select all the assemblies found in that directory, as shown in Figure 1. If you wish to keep things simple, then you only need to select IronPython.dll, Microsoft.Dynamic.dll and Microsoft.Scripting.dll to compile and run the program shown in this example.

Figure 1: Using the Add References dialog to select the assemblies found in that directory.

When you are done, the IronPython libraries should appear in the References section of the Solution Explorer, as shown in Figure 2.

Figure 2: The References node of the Solution Explorer for a C# program that calls an IronPython script.

Writing the Code for Calling IronPython

Now that you have your project set up correctly you need to do two things:

Write or find a script containing Python code that you want to run
Write C# code to call the script.

Listing 2 shows a very simple IronPython script that contains a single method called Simple() that writes a few strings to a console window. Save this script to a file called Test.py, and add it to your project, as shown in Figure 2. There are several ways to do this. One is to right click on your project in the Solution Explorer, and choose Add | New Item. Add a text file, and call it Test.py. Click on the new node when it is added to your project, and set its Copy to Output Directory property to Copy Always. If the Properties window is not visible, you can bring it up by selecting Ctrl-W, P.

Listings 3a and 3b show the C# code for calling the script, and Listing 4 shows the output from the C# program that hosts the script.

Listing 2: A Simple Python script stored in a file called Test.py. This code prints out some basic information about the environment in which Python is running.

import sys

def Simple():
	print "Hello from Python"
	print "Call Dir(): "
	print dir()
	print "Print the Path: " 
	print sys.path

Listing 3a: A simple C# program for calling a Python script

Code Snippet

using System;
using IronPython.Hosting;
using Microsoft.Scripting.Hosting;
 
public class dynamic_demo
{
    static void Main()
    {
        var ipy = Python.CreateRuntime();
        dynamic test = ipy.UseFile("Test.py");
        test.Simple();
    }
}

Listing 3b: The same C# program shown in Listing 3a, but this presentation is easier for you to block copy into your own version of the program.

using System;
using IronPython.Hosting;
using Microsoft.Scripting.Hosting;

public class dynamic_demo
{
    static void Main()
    {
        var ipy = Python.CreateRuntime();
        dynamic test = ipy.UseFile("Test.py");
        test.Simple();
    }
}

The code in Listing 2 is a very simple Python script. Before calling it from C#, you might want to see it in action. That way you can be sure the script works and you can verify what the script is supposed to do. To get started, block copy the code in Listing 2. Use the Windows Start Menu to open up the Python Console window and paste in the code. Finally, you should explicitly call the Simple() method, as shown in Figure 3. When looking at this screen shot, you can see the version of the Python Console on the first two lines. The next 8 lines show the code that I pasted into the console. Finally, you see where I typed in the call to Simple(), and after that the output from the script. Once again, this has nothing to do with calling the code from C#, it is just a way of verifying that you have a valid script, and of confirming how it should perform.

Figure 3: A screenshot showing a run of the Python script that we will be calling from our C# program.

Now let’s look at the 3 lines of code used to call this script from a C# program. This code is shown in Listings 3a and 3b. It first creates an instance of the Python runtime, as shown in line 9:

var ipy = Python.CreateRuntime();

The call to CreateRunTime loads or sets up the core Python libraries and the DLR code needed to to execute the Python script. The second line of code, found on line 10, calls UseFile to load our simple Python script into memory. Notice that the result of this call is a dynamic object. The dynamic keyword is a new feature in C# 4.0 and Visual Studio 2010 which tells the compiler to resolve this particular call not at compile time, but at runtime.

It’s very important to understand that the dynamic keyword breaks the strong type checking that has always been a hallmark of C# development. There is no doubt that the ability to call dynamic objects is a useful and important feature. However, it should be used sparingly since it sidesteps the strict type checking that makes C# such a powerful and useful language.

The dynamic keyword is needed here because Python is an interpreted scripting language where calls are bound at run time, not at compile time. There is no simple or practical way to bind calls to Python at compile time because Python is designed to be a dynamic language which is resolved at runtime. Since C# is a strongly typed language it expects to resolve calls at compile time with strict type checking. In short, we are at an impasse. C# binds statically at compile time, Python dynamically at runtime. Something has to give, and the only valid solution was for C# to allow runtime binding for method calls.

It is important to grasp that calls into Python are not strictly type checked at compile time, and are therefore not guaranteed to succeed at runtime. Just because your program compiled without error does not mean that you have properly bound each call in your program. In this case we call the method named Simple(), which does in fact exist. As a result, the call succeeds, as shown by the output from the program found in Listing 4.

Listing 4: The output from the C# program which calls a Python script.

Hello from Python
Call Dir():
[]
Print the Path:
['.', 'C:\\Users\\Charlie\\Documents\\SyncData\\Source\\ProjectsShared\\Python\\CallPython\\CallPython\\bin\\Debug\\Lib', 
'C:\\Users\\Charlie\\Documents\\SyncData\\Source\\ProjectsShared\\Python\\CallPython\\CallPython\\bin\\Debug\\DLLs']
Press any key to continue . . .

Listing 4 shows the good side of working with dynamic code. Now let’s take a moment to consider the dark side. Suppose we called a method on our dynamic test class that does not exist. For the sake of argument, let’s call the method NonexistentMethod(), which is shown in Listing 5.

Listing 5: This code contains a call to a method called NonexistentMethod() that does not exist in our Test.py file. As a result, the call will fail at runtime.

 var ipy = Python.CreateRuntime();
dynamic test = ipy.UseFile("Test.py");
test.Simple();            // Succeeds
test.NonexistentMethod(); // Fails

The code in Listing 5 contains a call to the method Simple() that will succeed, since the Python script shown in Listing 2 does contain a method called Simple(). However, the call to the method NonexistentMethod() will raise an exception at runtime. This happens because the call cannot be resolved at runtime. At compile time, however, the compiler knows nothing about the object called test. It makes no attempt to see whether or not the call will succeed. It simply takes your word for it and allows the compilation to succeed. At runtime, however, the error raises its head, as shown in Figure 4 and Listing 6.

Figure 4: The exception raised inside the IDE at runtime when you attempt to call a method that does not exist.

Listing 6: The details of the exception that you receive at runtime when you attempt to call a method that does not exist.

Microsoft.CSharp.RuntimeBinder.RuntimeBinderException was unhandled
  Message='Microsoft.Scripting.Hosting.ScriptScope' does not contain a definition for 'NonexistentMethod'
  Source=Anonymously Hosted DynamicMethods Assembly
  StackTrace:
       at CallSite.Target(Closure , CallSite , Object )
       at System.Dynamic.UpdateDelegates.UpdateAndExecuteVoid1[T0](CallSite site, T0 arg0)
       at dynamic_demo.Main() in C:\Users\Charlie\Documents\SyncData\Source\ProjectsShared\Python\CallPython\CallPython\Program.cs:line 12
       at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
       at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       at System.Threading.ThreadHelper.ThreadStart()
  InnerException:

The team went to lengths to ensure that the error you get at runtime looks almost exactly like the error you would have received at compile time had you attempted to call a static method that did not exist. Everything possible is done to make this experience easy for your to understand and handle, including giving you an exception that you can catch with your own custom code.

It goes without saying that everyone on the Visual Studio Languages team at Microsoft understands the implications of introducing the dynamic keyword into the C# language. We understand completely the advantages of statically linked code, and believe that strict type checking is a powerful tool that helps developers create robust code. In most cases, you should still use statically linked calls in your program. There are, however, scenarios that cannot be efficiently supported from the C# language without the introduction of dynamic programming. One is calling a dynamic language such as Python, and another is calling into a some COM objects, such as those used in those used by Microsoft Office. In order to make it easy for you to use dynamic languages and to perform COM Interop, the dynamic keyword was introduced into the C# 4.0 language, and the DLR became a built-in extension of .NET 4.0. Use these tools judiciously, and they will be your friend. Abuse them, and you are on your own.

Summary

In this article you learned how to call a simple Python script from a C# application. You saw how to set up the References section for your program so that it contains the assemblies used when calling an IronPython script. You then saw how to write a simple Python script, and how to call it from a C# program.

The dynamic technology on display in this example makes use of a body of code called the DLR, or Dynamic Language Runtime. The dynamic keyword that is part of C# 4.0 provides supports when you call dynamic languages or COM objects, and particularly when you use C# 4.0 to call into Microsoft Office applications. Coverage of calling into Office is separate subject, and will be covered in another post. A third topic deserving of coverage is using the dynamic keyword in scenarios where you previously used reflection.

Download Source from the LinqFarm

Getting Started with IronPython

2009-10-26T01:03:46Z

I recently spent some time getting IronPython up and running on my system; I will review what I learned in this post.

Hosted inside an interpreter, Python belongs to the same family of scripting tools as VBScript, JavaScript, Perl and Ruby. You can fairly compare Python to a general purpose language such as C#. Developers praise this loosely typed, dynamic language for its ease of use and rapid development capabilities. IronPython is Microsoft’s free version of the open source Python language.

IronPython can be hosted inside a C# program as a scripting language. Nonetheless, Python is a powerful standalone language frequently used as the glue in web based applications. Before I came to work for Microsoft I enjoyed using it as part of my daily toolkit.

In this post I explore the simple steps needed to run IronPython as a standalone tool from the command prompt. In other posts I will show how to call Python from inside a C# application.

Installing Python

I started by downloading IronPython from CodePlex and installing it. The whole process from first visit to the IronPython web site until IronPython was installed probably took me little more than a minute. Below are the links to retrieve the code. If you are reading this article in 2009 or early 2010, consider using the first link, if the date is later than that then use the second link and look for a newer release:

The Beta 2 Release of IronPython (2.6 CTP for .NET 4.0 Beta 2)
IronPython Site

Download the IronPython MSI Windows install file, then double click on it to run setup. When you are done, your IronPython installation will probably be located in a directory similar to this one:

C:\Program Files (x86)\IronPython 2.6 CTP for .NET 4.0 Beta 2

Once you have the IronPython interpreter installed, you need to follow these steps to run a sample program:

Put IronPython on your Path
Create an IronPython program
Compile and run the program.

In the next few sections of this post I’ll walk you through these steps. When you are done, you will have IronPython up and running on your system.

Setting Up Your Path

You can run IronPython from inside Visual Studio, but the tools for doing so are still primitive. Most Python developers work inside a lightweight editor and run Python from inside the IronPython interpreter or from the command line. This post focuses on building Python from the command line. To get started with that process, you will probably want to begin by ensuring that the IronPython interpreter is on your System Path.

They say there must be fifty ways to set the system path. In this post I will outline two of them as practiced by developers on Vista or Windows 7. In both cases you can begin with a four step process to bring up the Environment Variables Dialog:

Method One
- Press the Windows Key to bring up the Start Menu
- Right click on Computer and choose Properties
- Click Advanced Computer Settings
- Click Environment
Method Two
- Press the Windows Key to ring up the Start Menu
- Type Control Panel and press enter
- You should be taken automatically to the search box on the top right of the control panel, if not, press Ctrl-E to get there and type Environment. (The first three letters should be all that’s necessary)
- Hit tab twice to select Edit Environment Variables, and then hit enter.

Which ever technique you use, the dialog shown in Figure 1 should appear. You can use this dialog to edit the system path.

Figure 1: In this screenshot, a variable called Path has been added to the list of User Variables. It lists the path to the IronPython Interpreter.

Once the dialog appears, click New (Alt-N) to add a Path variable for your account. A small dialog appears. Paste the path to IronPython into this dialog and click the OK button. The path should be similar to the path shown above which points to the directory where IronPython was installed. Click OK to close the Environment Variables dialog. From now on, and Command prompt window that you open should have an environment automatically set up to point to the IronPython interpreter. To test that everything is working correctly, go to the command prompt and type ipy. If everything has gone well, you should see a result like the following.

C:\Users\Charlie\Documents\Python\PythonPost>ipy
IronPython 2.6 (2.6.10920.0) on .NET 4.0.21006.1
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

As shown above, you can type exit() and then enter to quit the interpreter. You can also execute Python code from inside the interpreter. Working interactively inside the interpreter is a useful and powerful way to write code, but I will not cover it in this post.

Create a Python Program

Now that you have Python on your path, you can easily compile your projects from the command line. Depending on your tastes, you can edit your program in Visual Studio, in NotePad, or in NotePad++. The goal is to create a simple text-based source file with the letters py as an extension. Here, for example, is the complete contents of a simple Python source file:

print "Very Simple Test"

You can save this source file as VerySimpleTest.py, and process and run it by passing its name to the Python interpreter. The interpreter will process and run the program:

C:\Users\Charlie\Documents\Python\PythonPost>ipy VerySmipleTest.py.
Very Simple Test

Now that you understand the basics, the next step is to understand how to create functions, classes and multiple module projects.

Python uses indentation rather than keywords or syntax to define blocks of code. Here, for instance, is how to define a function in Python:

def WriteTest():
	print "This is a test"

The keyword def followed by a name and a colon defines the header for the function. The next line begins with tab character. This defines the beginning of main block for the function, which in this case contains a single line of code. If you had multiple lines in the function, then you would indent each line with a tab character. An empty line defines the end of the function.

To define a class, you repeat the same process, but use the keyword class rather than def:

class SimpleLocalClass:
	def SimpleMethod(self):
		print "Simple Local Class"

Here you see the definition for a class called SimpleLocalClass which has a single method called SimpleMethod. Not everyone likes the Python syntax for defining classes and methods, but I have found intuitive and easy to use.

Listings 1 and 2 contain a project with two files that demonstrates how to use functions and classes in Python:

Listing 1: Here is the main module for the project. It is a simple source file called Project.py containing a function and a simple class. This source file also has a dependency on a class called SimpleClassTest that is shown in Listing 2

from SimpleClass import SimpleClassTest

class SimpleLocalClass:
	def SimpleMethod(self):
		print "Simple Local Class"

def WriteTest():
	print "This is a test"
	
WriteTest()

simpleLocalClass = SimpleLocalClass()
simpleLocalClass.SimpleMethod()

simpleClass = SimpleClassTest()
simpleClass.SimpleMethod()

Listing 2: The second file in this project is called SimpleClass.py. The file shown in Listing 1 depends on this class.

class SimpleClassTest:
	def SimpleMethod(self):
		print "Simple Class"

Notice the from statement at the top of Listing 1. It is used to import the class found in Listing 2. I should also point out that there is no main() method shown in listing 1. The word main does not have the same significance in Python that it does in C#. The entry point for this Python program is the last set of un-indented statements found in Project.py. In this case the entry point begins with the call to WriteTest().

Compiling and Running the Program

Now that you have the two source files for your project, all you need do is compile and run them. The Python interpreter is designed to make this task as simple as possible. You need only reference the primary file for your project, the interpreter is smart enough to to parse the from import statement at the top of Listing 1 and figure out from that how to include SimpleClass.py in the project.

Listing 3: Here is the command to process and run the files shown in Listings 1 and 2. The output from the command is also shown.

C:\Users\Charlie\Python\PythonPost>ipy Project.py
This is a test
Simple Local Class
Simple Class

Summary

In this post I have reviewed how to download and install IronPython, and how to get some simple Python scripts up and running on your system. You saw how to run a simple program from the command line, how to create:

A simple function
A simple class
And a mutli-module project.

In future posts I will focus on calling IronPython from a C# program.

New Video on Sharepoint and C# by Kathleen McGrath

2009-10-22T20:24:09Z

Microsoft guru Kathleen McGrath has created an elegant and informative new video on SharePoint features found in Visual Studio 2010, Beta 2. In the video programming writer Norm Estabrook demonstrates how to create a model for the Business Data Connectivity service that returns information about contacts in a sample database. You can read Kathleen’s post on the interview or zoom directly to Channel 9 to view it.

IronRuby and IronPython for .NET 4.0 Beta 2 Available

2009-10-22T19:45:17Z

The third preview of IronRuby and IronPython running under the Dynamic Language Runtime and .NET 4.0 is now available. You can easily use IronPython and IronRuby objects and types as .NET 4.0 dynamic objects from within the pre-release versions of C# 4.0 and Visual Basic 10.0 found in Visual Studio 2010. The IronRuby and IronPython binaries are roughly equivalent to the functionality found in IronRuby 0.9 and IronPython 2.6.

Community Convergence LVI

2009-10-19T20:21:00Z

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

The XNA Role Playing Game Starter Kit

2009-09-27T20:18:06Z

In my spare time I’ve been looking at the C#code for the XNA Role Playing Game starter kit. This kit is not new, but I’m interested in Role Playing Games (RPGs), so I thought I’d keep some notes on what I’m learning as I play with it. Though not especially fancy, I like this code as it represents something that a developer with intermediate level skills can pick up without too much effort. It would be fun to write the next Fallout or WarCraft during my spare time on the weekend, but since my resources and patience are limited I thought it might be more rewarding to work on a simpler project.

The starter kit comes as an MSI installable package. It adds a new template into Visual Studio, making it possible for you to choose File | New | Role Playing Game from the menu. This one step process initiates the creation of a new solution containing the source for a complete tile-based role playing game. In Figure 1 you can see the Solution Explorer and Class View for the created project. By viewing this screen shot you can get some sense of what is available inside the start kit. Obviously this is a fairly extensive bit of source code with lots of logic for you to digest and learn from, especially if you are new to game development.

Figure 1: Class View and the Solution Explore for the XNA Role Playing Starter Kit.

The Tile Engine

The kit features a simple tile engine written in C# which supports several layers. The first layer allows you to define a basic landscape or the interior of a building. A second layer allows you to decorate it with trees, chairs, or other objects. A third layer contains your sprites, and a fourth layer defines the boundaries inside which the sprites can move.

As is usually the case with tile engines, this code base allows you to work with a series of two dimensional numerical arrays, each of which contain simple integers defining offsets into a set of tiled bit maps. For instance, if you stare hard enough at Figure 2, you can see that it can be broken out into six separate “tiles”, three on the top, and three on the bottom, where the middle tile on the bottom row looks a bit like grass.

Figure 2: A tiny excerpt from the tile map used in the starter kit.

If you mentally assigned numbers to the tiles in the bitmap then you could use these digits as names for each of the six tiles in this source bitmap. The numbers 1, 2 and 3 would range across the top row, and 4, 5 and 6 across the bottom row. You can now create a two dimensional array like this which would represents offsets into the tiles:

4 5 5 6

The tile engine then reads the array, calculates the offsets into the source bitmap, and blits out the tiles designated into a final map, as shown in Figure 3. Here you see the two outermost tiles on the bottom row of the source bitmap, plus the center tile on the bottom row repeated twice. None of the tiles on the top row of the source tile map are used in this example.

Figure 3: A small world map created from calculating offsets into the tiles seen in the second row of Figure 2.

If you have a larger source and destination tile map, a larger array, and a larger world map with multiple layers, then you can create entire landscapes inhabited by characters, such as the one shown in Figure 4. This screen shot is taken from the world map used in the starter kit. The water and land are defined by the bottom array in the tile engine, the trees are defined in the second layer, and the two characters are defined in the third layer. The fourth layer is used to ensure that characters are not able to walk out onto the water. In short, the fourth layer defines boundaries for the movement of sprites in the game.

Figure 4: The playing screen from the starter kit. Click the screen shot to see a full size image.

Of course, this is a two dimensional tile map, and not a 3D engine. If you want a 3D engine, XNA can support one, and there are starter kits and many game engines that can help you get started. However, if you just want to hack around a bit without burning up the midnight oil, your career, your marriage, and the best years of your life, a 2D engine is both convenient and practical.

The tile engine and other tools from the starter kit are reasonably well designed and fairly modular. If you develop an urge to do so, you should have little trouble stripping them out of this game and putting them to use in your own custom projects. Additionally, they provide examples of best practices, so studying them may be a productive exercise. You might find this true even if you want to create a very different game driven by a 3D engine.

Questions about licensing issues should be addressed to the XNA team, but I’ll express some muted optimism here because the starter kit is released under the MSPL, and because the team explains at some length how to use the code in your own projects. In particular, the XNA team provides additional information about reusing the tile engine in your own game. I suggest you read through all the text on the tile engine, as it provides useful information about the structure of the RPG Starter Kit.

The Quest Engine

Another important feature of the game is the quest engine. role playing games generally feature a series of tasks that the player is expected to complete. For instance, in many RPGs one might have to crawl through a dungeon and find a jewel, or go to war against a series of trolls that have taken over a house. When you have completed the task, you generally report back to some non-playing character (NPC) who gives you a reward for completing the job. When you have finished all the tasks supplied with the game, then a screen comes up with lots of flashing graphics, and you are told that you have won. Why I find it enjoyable to do this I have no idea, but my experience is that many people, including myself, are drawn to this kind of experience.

The XNA RPG Starter Kit comes with C# code demonstrating how to construct a quest engine. The engine is driven by a series of XML files. By manipulating the text in these files you can modify existing quests and add new quests. This means that there is a rough separation of the data, which is stored in the XML files, and the actions, which are written in C#. At least in theory, you need never change the C# code, all you need do is modify the XML. This kind of design is a best practice, and one that developers can learn from – if you haven’t already implemented a similar scheme in your own code. (Note that the two dimensional arrays defined in the tile engine provide a similar functionality for that code base. Clearly the developers of this starter kit believe in separating data and code.)

Here is information on how to use the quest engine. It is a simple tutorial you can complete in about 20 or 30 minutes. In it you learn how to modify quests, and how to create your own quests.

Acquiring the Starting Kit

The downloads for the RGP Starter Kit are broken out into versions for XNA Game Studio 2.0 and 3.0. There is also a distinction between code that targets Windows and code for the XBox:

Here are some additional links

Home page and some documentation for the starter kit.
Forum thread for discussing the kit.
Information on the quest engine.
Information the the tile engine.

Here is the documentation for the Microsoft Cross Platform Audio Creation Tool (XACT). I’ll try to find time to describe it in a future article, as the music included with this game should come with warnings about its potential affect on your mental health. It turns out to be very easy to take MP3s of your favorite music and add them to the game so that you can tinker in peace.

Summary

The rains will be settling in here in Redmond in just a few more weeks. As we contemplate the coming of winter, its nice to prepare a little something to do to wile away a peaceful, but wet, Saturday afternoon. Tinkering with the source for a game is one rewarding option. In this post I’ve accomplished almost nothing that I set out to do, but I have managed to introduce the XNA RPG Starter kit. Hopefully I can find time to come back and explore some of the modifications I’ve been making to the kit, and to explain a little about how it works and what useful lessons we might learn from it.

.NET University is Live

2009-09-22T00:05:20Z

Doug Turnure and Mark Dunn just reopened the .NET University site. This resource includes approximately 40 developer-oriented presentation kits that include slides, speaker notes, demos, demo scripts and webcast videos. You can use these materials in your own presentations, or simply access the valuable information that they contain. You can also find free, sequenced online training at http://myrampup.com. Ramp Up is a free, online, community-based learning program, with a number of different tracks that will help you build your portfolio of professional development skills.

Charlie Calvert's Community Blog

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

The C# Side

Summary

Resources

Classic, Lightweight and ScriptFree MSDN Library Views

New Article by Bill Wagner on Dynamic Method Bags in C# 4.0

Resources

New Article on Detecting Memory Leaks . NET Applications

References

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

VSL at DevConnections

Visual Studio 2010 Beta 2 does not Load: The “Application Cannot Start” and Raster Font Errors

A Chance to Influence the MSDN Visual Studio Documentation (Help System)

Links

Running IronPython Scripts from a C# 4.0 Program

Setting up a C# Project to Call IronPython

Writing the Code for Calling IronPython

Summary

Getting Started with IronPython

Installing Python

Setting Up Your Path

Create a Python Program

Compiling and Running the Program

Summary

New Video on Sharepoint and C# by Kathleen McGrath

Links

IronRuby and IronPython for .NET 4.0 Beta 2 Available

Links

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

The XNA Role Playing Game Starter Kit

The Tile Engine

The Quest Engine

Acquiring the Starting Kit

Summary

.NET University is Live