<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Andrew Stellman on O&apos;Reilly Broadcast</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/" />
<link rel="self" type="application/atom+xml" href="http://broadcast.oreilly.com/atom.xml" />
<id>tag:broadcast.oreilly.com,2008-08-07://53</id>
<updated>2011-04-09T20:23:03Z</updated>

<generator uri="http://www.sixapart.com/movabletype/">Movable Type Pro 4.21-en</generator>

<entry>
<title>Functions are values: explore C# lambda types in Visual Studio</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2011/04/functions-are-values-exploring.html" />
<id>tag:broadcast.oreilly.com,2011://53.46111</id>

<published>2011-04-09T20:23:03Z</published>
<updated>2011-04-09T20:23:03Z</updated>

<summary><![CDATA[I love that a college professor of mine from long ago, Bob Harper, is tackling the tricky issue of how to teach students about the nature of functions in his new Existential Type blog. His post got me thinking about how you'd go about teaching this concept to a learner&mdash;specifically, in my case, a C# learner. I've given it a bit of thought, and here's what I've come up with.]]></summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="dotnet" label="dotnet" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
<![CDATA[I love that a college professor of mine from long ago, Bob Harper, is tackling the tricky issue of how to teach students about the nature of functions in his new Existential Type blog. His post got me thinking about how you'd go about teaching this concept to a learner&mdash;specifically, in my case, a C# learner. I've given it a bit of thought, and here's what I've come up with.]]>
</content>
</entry>

<entry>
<title>Don&apos;t be a micromanager!</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/11/dont-be-a-micromanager.html" />
<id>tag:broadcast.oreilly.com,2010://53.43445</id>

<published>2010-11-29T21:15:07Z</published>
<updated>2010-11-29T21:15:07Z</updated>

<summary><![CDATA[I recently made a post on Building Better Software about micromanagement ("Demoralize Your Teams Quickly And Efficiently With Micromanagement") and how it drains a development team's will to live. I've been studying micromanagement for a long time&mdash;not often voluntarily. It's...]]></summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="books" label="books" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="management" label="management" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="projectmanagement" label="project management" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="teamwork" label="teamwork" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
<![CDATA[I recently made a post on Building Better Software about micromanagement ("Demoralize Your Teams Quickly And Efficiently With Micromanagement") and how it drains a development team's will to live. I've been studying micromanagement for a long time&mdash;not often voluntarily. It's...]]>
</content>
</entry>

<entry>
<title>Understanding C#: Nullable Types</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/11/understanding-c-nullable-types.html" />
<id>tag:broadcast.oreilly.com,2010://53.43290</id>

<published>2010-11-07T21:28:44Z</published>
<updated>2010-11-07T21:28:44Z</updated>

<summary>Every C# developer knows how to work with value types like int, double, boolean, char, and DateTime. They&apos;re really useful, but they have one flaw: they can&apos;t be set to null. Luckily, C# and .NET give you a very useful tool to for this: nullable types. You can use a nullable type any place that you need a variable that can either have a value or be null. This seems like a simple thing, but it turns out to be a highly flexible tool that can help make your programs more robust. In this tutorial, I&apos;ll show you the basics of nullable types, and give you a quick example of a program that uses them to handle unpredictable user input.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="dotnet" label="dotnet" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
Every C# developer knows how to work with value types like int, double, boolean, char, and DateTime. They&apos;re really useful, but they have one flaw: they can&apos;t be set to null. Luckily, C# and .NET give you a very useful tool to for this: nullable types. You can use a nullable type any place that you need a variable that can either have a value or be null. This seems like a simple thing, but it turns out to be a highly flexible tool that can help make your programs more robust. In this tutorial, I&apos;ll show you the basics of nullable types, and give you a quick example of a program that uses them to handle unpredictable user input.
</content>
</entry>

<entry>
<title>Understanding C#: Simple LINQ to XML examples (tutorial)</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/10/understanding-c-simple-linq-to.html" />
<id>tag:broadcast.oreilly.com,2010://53.43133</id>

<published>2010-10-16T14:21:23Z</published>
<updated>2010-10-16T14:21:23Z</updated>

<summary>XML is one of the most popular formats for files and data streams that need to represent complex data. The .NET Framework gives you some really powerful tools for creating, loading, and saving XML files. And once you&apos;ve got your hands on XML data, you can use LINQ to query anything from data that you created to an RSS feed. In this post, I&apos;ll show you two simple LINQ to XML tutorial style examples that highlight basic patterns that you can use to create or query XML data using LINQ to XML.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="dotnet" label="dotnet" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="headfirst" label="headfirst" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="linq" label="Linq" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="xml" label="xml" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
XML is one of the most popular formats for files and data streams that need to represent complex data. The .NET Framework gives you some really powerful tools for creating, loading, and saving XML files. And once you&apos;ve got your hands on XML data, you can use LINQ to query anything from data that you created to an RSS feed. In this post, I&apos;ll show you two simple LINQ to XML tutorial style examples that highlight basic patterns that you can use to create or query XML data using LINQ to XML.
</content>
</entry>

<entry>
<title>Understanding C#: Equality, IEquatable, and Equals()</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/09/understanding-c-equality-iequa.html" />
<id>tag:broadcast.oreilly.com,2010://53.43016</id>

<published>2010-09-29T20:48:13Z</published>
<updated>2010-09-29T20:48:13Z</updated>

<summary>What does it really mean for two objects to be equal? How can you tell if object #1 is equal to object #2? Do you compare all of their properties? What about private properties or fields? Is it possible for two objects to have exactly the same state, but to not be equal? It&apos;s more complex than it seems. In this post, I&apos;ll detangle some of those ideas, and show you how to use IEquatable, the Equals() and GetHashCode() methods, and overloading the == and =! operators so that you can compare objects in your own code.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
What does it really mean for two objects to be equal? How can you tell if object #1 is equal to object #2? Do you compare all of their properties? What about private properties or fields? Is it possible for two objects to have exactly the same state, but to not be equal? It&apos;s more complex than it seems. In this post, I&apos;ll detangle some of those ideas, and show you how to use IEquatable, the Equals() and GetHashCode() methods, and overloading the == and =! operators so that you can compare objects in your own code.
</content>
</entry>

<entry>
<title>A Few More Things Every Job-Seeking Programmer Should Know About Project Management</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/09/a-few-more-things-every-job-se.html" />
<id>tag:broadcast.oreilly.com,2010://53.43015</id>

<published>2010-09-25T14:44:04Z</published>
<updated>2010-09-25T14:44:04Z</updated>

<summary>There are a lot of programmers who really don&apos;t like project management -- they toss all things project management related into the &quot;pointy haired boss&quot; category and try not to think about them again. But if you&apos;re a job-seeking programmer, or a programmer looking to move your career ahead, then there are a few really basic things that could do you really well on an interview.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="careers" label="careers" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="projectmanagement" label="project management" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
There are a lot of programmers who really don&apos;t like project management -- they toss all things project management related into the &quot;pointy haired boss&quot; category and try not to think about them again. But if you&apos;re a job-seeking programmer, or a programmer looking to move your career ahead, then there are a few really basic things that could do you really well on an interview.
</content>
</entry>

<entry>
<title>Understanding C#: Raising events using a temporary variable</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/09/understanding-c-raising-events.html" />
<id>tag:broadcast.oreilly.com,2010://53.42899</id>

<published>2010-09-10T03:33:14Z</published>
<updated>2010-09-10T03:33:14Z</updated>

<summary><![CDATA[A lot of C# developers notice that there's something odd about how we normally raise events in C#. We're always told to set a temporary variable equal to the event first, and then raise the event using that variable. It looks very strange&mdash;how could that variable do anything at all? But it turns out that there's a very good reason for using the temporary variable, and understanding that reason can help you become a better C# developer. This post shows a quick example of why you need that variable.]]></summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="threading" label="threading" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
<![CDATA[A lot of C# developers notice that there's something odd about how we normally raise events in C#. We're always told to set a temporary variable equal to the event first, and then raise the event using that variable. It looks very strange&mdash;how could that variable do anything at all? But it turns out that there's a very good reason for using the temporary variable, and understanding that reason can help you become a better C# developer. This post shows a quick example of why you need that variable.]]>
</content>
</entry>

<entry>
<title>5-minute Sandcastle tutorial: build C# code documentation</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/09/build-html-documentation-for-y.html" />
<id>tag:broadcast.oreilly.com,2010://53.42859</id>

<published>2010-09-03T21:43:25Z</published>
<updated>2010-09-03T21:43:25Z</updated>

<summary>If you&apos;ve ever used a library that has accurate MSDN-style API documentation, you know how useful it can be. There are lots of ways to create HTML documentation. But the easiest way that I&apos;ve found is to use Sandcastle. It&apos;s an open source documentation generator from Microsoft that reads your assemblies (DLL or EXE files) and their XML Comments and automatically generates HTML documentation. Sandcastle is a very flexible tool, which means it&apos;s also a very complex tool. Luckily, there&apos;s a companion tool, Sandcastle Help File Builder, that makes it really easy to get up and running with Sandcastle in minutes.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="documentation" label="documentation" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
If you&apos;ve ever used a library that has accurate MSDN-style API documentation, you know how useful it can be. There are lots of ways to create HTML documentation. But the easiest way that I&apos;ve found is to use Sandcastle. It&apos;s an open source documentation generator from Microsoft that reads your assemblies (DLL or EXE files) and their XML Comments and automatically generates HTML documentation. Sandcastle is a very flexible tool, which means it&apos;s also a very complex tool. Luckily, there&apos;s a companion tool, Sandcastle Help File Builder, that makes it really easy to get up and running with Sandcastle in minutes.
</content>
</entry>

<entry>
<title>Why project managers should care about development</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/08/why-project-managers-should-ca.html" />
<id>tag:broadcast.oreilly.com,2010://53.42009</id>

<published>2010-08-31T16:35:58Z</published>
<updated>2010-08-31T16:35:58Z</updated>

<summary>In a recent post on Building Better Software, I wrote about why developers should care about project management. But I think it&apos;s worth making the opposite case: why project managers should care about development.
</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="projectmanagement" label="project management" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
In a recent post on Building Better Software, I wrote about why developers should care about project management. But I think it&apos;s worth making the opposite case: why project managers should care about development.

</content>
</entry>

<entry>
<title>Understanding C#: String.Intern makes strings interesting</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/08/understanding-c-stringintern-m.html" />
<id>tag:broadcast.oreilly.com,2010://53.41945</id>

<published>2010-08-22T21:01:11Z</published>
<updated>2010-08-22T21:01:11Z</updated>

<summary>One of the first things a new C# developer learns is how to work with strings. We teach the basics of strings early on in Head First C#, and it&apos;s the same way with practically every other C# book I own. So it shouldn&apos;t be surprising that novice and intermediate C# developers feel like they&apos;ve got a pretty good handle on strings. But strings are more interesting than they appear. One of the more interesting aspects of strings in C# and .NET is String.Intern, and understanding it can help make you a better C# developer. In this post, I&apos;ll go through a quick String.Intern tutorial to show you how it works.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="syntax" label="syntax" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
One of the first things a new C# developer learns is how to work with strings. We teach the basics of strings early on in Head First C#, and it&apos;s the same way with practically every other C# book I own. So it shouldn&apos;t be surprising that novice and intermediate C# developers feel like they&apos;ve got a pretty good handle on strings. But strings are more interesting than they appear. One of the more interesting aspects of strings in C# and .NET is String.Intern, and understanding it can help make you a better C# developer. In this post, I&apos;ll go through a quick String.Intern tutorial to show you how it works.
</content>
</entry>

<entry>
<title>Understanding C#: Use System.Console to build text-mode games</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/08/understanding-c-text-mode-games.html" />
<id>tag:broadcast.oreilly.com,2010://53.41884</id>

<published>2010-08-17T23:54:16Z</published>
<updated>2010-08-17T23:54:16Z</updated>

<summary>I&apos;m a sucker for an old-school text-mode console game. Text-mode games rendered their &quot;graphics&quot; by drawing text characters at different positions on the screen using 16 background and foreground colors. They&apos;re also easier than ever to build in C# and .NET, thanks to the System.Console class, which lets you position the cursor, do animation by moving blocks of the buffer, use colors and special characters, and handle input from the user. In this tutorial post, I&apos;ll walk you through all of the tools you need to create a retro MS-DOS style text-mode video game, including a complete game that you can build yourself.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="games" label="games" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
I&apos;m a sucker for an old-school text-mode console game. Text-mode games rendered their &quot;graphics&quot; by drawing text characters at different positions on the screen using 16 background and foreground colors. They&apos;re also easier than ever to build in C# and .NET, thanks to the System.Console class, which lets you position the cursor, do animation by moving blocks of the buffer, use colors and special characters, and handle input from the user. In this tutorial post, I&apos;ll walk you through all of the tools you need to create a retro MS-DOS style text-mode video game, including a complete game that you can build yourself.
</content>
</entry>

<entry>
<title>Essential developer skills: Refactoring C# in Visual Studio 2010</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/08/essential-developer-skills-ref.html" />
<id>tag:broadcast.oreilly.com,2010://53.41843</id>

<published>2010-08-08T16:55:46Z</published>
<updated>2010-08-08T16:55:46Z</updated>

<summary><![CDATA[If you've been reading my blog posts, you know that I try to help novice and intermediate C# programmers improve their skills, and help progress along the developer career path. I think this goes beyond simply getting better at programming C# and .NET. There are additional skills that, in my opinion, really make a difference in your ability to code. It's possible to become an advanced programmer without them, but it's a lot easier with them. Refactoring is one of those skills, and I think that any C# developer&mdash;even a novice one&mdash;can benefit from it. If you're a C# developer looking to take the next step on your career path and you don't refactor your code regularly, this is a great starting point to help move to the next level.
]]></summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="careers" label="careers" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="development" label="development" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="refactoring" label="refactoring" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
<![CDATA[If you've been reading my blog posts, you know that I try to help novice and intermediate C# programmers improve their skills, and help progress along the developer career path. I think this goes beyond simply getting better at programming C# and .NET. There are additional skills that, in my opinion, really make a difference in your ability to code. It's possible to become an advanced programmer without them, but it's a lot easier with them. Refactoring is one of those skills, and I think that any C# developer&mdash;even a novice one&mdash;can benefit from it. If you're a C# developer looking to take the next step on your career path and you don't refactor your code regularly, this is a great starting point to help move to the next level.
]]>
</content>
</entry>

<entry>
<title>Understanding C#: Explore types using the Type class and GetType()</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/08/understanding-c-explore-types.html" />
<id>tag:broadcast.oreilly.com,2010://53.41834</id>

<published>2010-08-05T23:40:32Z</published>
<updated>2010-08-05T23:40:32Z</updated>

<summary>One of the most powerful aspects of the C# programming language is its rich type system. But until you&apos;ve got some experience building programs, it&apos;s difficult to appreciate it -- in fact, it can be a little baffling at first. But we want to give you at least a taste of how types work in C# and .NET. This tutorial helps get you started exploring the type system. In it, you&apos;ll create a console application that gives you an introduction to some of the tools you have at your disposal to work with types.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
One of the most powerful aspects of the C# programming language is its rich type system. But until you&apos;ve got some experience building programs, it&apos;s difficult to appreciate it -- in fact, it can be a little baffling at first. But we want to give you at least a taste of how types work in C# and .NET. This tutorial helps get you started exploring the type system. In it, you&apos;ll create a console application that gives you an introduction to some of the tools you have at your disposal to work with types.
</content>
</entry>

<entry>
<title>Understanding C#: Namespaces and assemblies (a quick .NET tutorial)</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/07/understanding-c-namespaces-and.html" />
<id>tag:broadcast.oreilly.com,2010://53.40232</id>

<published>2010-07-12T16:03:20Z</published>
<updated>2010-07-12T16:03:20Z</updated>

<summary>I recently had a reader e-mail me with a question about assemblies and namespaces because he had trouble on a job interview that asked a lot of interview questions about .NET assemblies. Luckily, I had a good answer for him that covered the .NET assembly basics: what an assembly is, how to create a class assembly DLL, how to use that assembly DLL in another program, how to use the Add References window in Visual Studio, and where Visual Studio gets its assemblies to list in that window. At the end of Head First C#, we have a section about it that also uses the IDE as a teaching tool to explore how assemblies work. </summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="net" label=".net" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="netframework" label=".net framework" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
I recently had a reader e-mail me with a question about assemblies and namespaces because he had trouble on a job interview that asked a lot of interview questions about .NET assemblies. Luckily, I had a good answer for him that covered the .NET assembly basics: what an assembly is, how to create a class assembly DLL, how to use that assembly DLL in another program, how to use the Add References window in Visual Studio, and where Visual Studio gets its assemblies to list in that window. At the end of Head First C#, we have a section about it that also uses the IDE as a teaching tool to explore how assemblies work. 
</content>
</entry>

<entry>
<title>Understanding C#: BackgroundWorker tutorial for multithreaded GUIs</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/06/understanding-c-using-backgrou.html" />
<id>tag:broadcast.oreilly.com,2010://53.40076</id>

<published>2010-06-28T16:19:12Z</published>
<updated>2010-06-28T16:19:12Z</updated>

<summary>Someone once told me that he could tell a form was built by a novice C# developer if it stopped responding when he pressed a button. I&apos;m not 100% sure I agree, but I definitely think that an intermediate or advanced C# developer should be able to build a form that stays responsive even when the program is doing something CPU intensive. Luckily, C# and .NET give us a simple way to do that using the BackgroundWorker class. This post walks you through a simple BackgroundWorker example that shows you how to use it to let your form report progress while doing work in the background on another thread.</summary>
<author>
<name>Andrew Stellman</name>
<uri>http://www.stellman-greene.com</uri>
</author>

<category term="c" label="c#" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="csharp" label="csharp" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="headfirst" label="head first" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="headfirst" label="headfirst" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="microsoft" label="microsoft" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="programming" label="programming" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="threading" label="threading" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
Someone once told me that he could tell a form was built by a novice C# developer if it stopped responding when he pressed a button. I&apos;m not 100% sure I agree, but I definitely think that an intermediate or advanced C# developer should be able to build a form that stays responsive even when the program is doing something CPU intensive. Luckily, C# and .NET give us a simple way to do that using the BackgroundWorker class. This post walks you through a simple BackgroundWorker example that shows you how to use it to let your form report progress while doing work in the background on another thread.
</content>
</entry>

</feed> 
