I had xUnit installed (with TestDriven.NET support enabled). I also had the TestDriven.NET 2.14 release installed (which is the latest stable build).

My test project had a reference to xunit.dll and my test methods were decorated with the [Fact] attribute.

But for some reason, when I tried to run the tests using TestDriven.NET, it would give the dreaded 0 passed, 0 failed, 0 skipped result, meaning it didn’t run any tests.

I’m not sure what the problem was, but the solution was simple: Install the latest TestDriven.NET beta build (currently 2.19.2409).

Apparently there is an issue with TestDriven.NET on 64-bit Windows (alluded to on the xUnit 1.1 release page).

Not sure if the problem is xUnit-specific or it occurs with other test frameworks as well.

Some of the overrides for System.Net.Mail.Attachment take a Stream parameter. The Attachment class will hold on to that stream until you send the corresponding MailMessage.

To ensure that the stream is cleaned up properly you need to call Dispose() on the MailMessage instance when you are finished with it:
using (MailMessage message = BuildMessage()) { SmtpClient client = new SmtpClient(); client.Send(message); }
Using .NET Reflector, you can see that disposing the MailMessage disposes each Attachment, which will in turn close each Stream.

If you don’t dispose the MailMessage, you are at the mercy of the garbage collector. For a FileStream that can cause unexpected, and seemingly unrelated, problems.

namespace Foo.Extensions { public static class StringExtensions { public static string Truncate(this string value, int maxLength) { if (value.Length > maxLength) return value.Substring(0, maxLength - 3) + "..."; return value; } } }

To use the extension method:

The magic happens when you add the this keyword to the first parameter of the static method. This tells the compiler to add the method to the specified type (string is this example). The method behaves as an instance method, though your extension method can only access public members of the type.

You can also call the extension method the old way: StringExtensions.Truncate(longText, 20);

It’s important to note that you MUST add a using statement to import the namespace where you defined the extension method (Foo.Extensions in this example), otherwise the compiler (and intellisense) won’t add the methods to the specified types.

Extension methods are one of the most useful additions to C# 3.0. They are simple to use and in many cases you can convert an existing method to be an extension method without breaking existing code.

Unfortunately it has one big flaw: it’s auto update feature is not optional.

I regularly work disconnected, either because I’m not near a hotspot or because I’m running a VM without internet access.

If Reflector determines that it is out-of-date it will refuse to run until you update it. This is a huge pain because I usually don’t hit the problem unless I need to use Reflector.

Yes, I know complaining about free software is lame, but please Lutz, make the update functionality optional. I promise I’ll update the next time I’m connected.

Update: Red Gate has acquired .NET Reflector. Please visit my forum post and share your opinion!

The update took maybe 30 minutes. I was not prompted to backup my settings or media, so make sure you perform a sync before updating.

Some initial observations:

• Adding my Exchange account was painless (especially compared to adding the same account using IMAP).
• Exchange ActiveSync works great. I’m getting emails on my phone before I receive them on my laptop.
• Syncing your Exchange calendar erases all other calendars from the phone and disables calendar syncing within iTunes.
• If you aren’t syncing an Exchange calendar, the phone now provides access to all of your iCal calendars, including Entourage (if you have enabled iCal syncing within Entourage).
• The AppStore is working (from the phone at least). So far I’ve installed Twitterrific, Remote, Google Mobile App, and AP Mobile News.

public T Deserialize<T>(string data); public object DeserializeObject(string data);

A notable omission from the API is a non-generic method for deserializing to a specific type, i.e.:

This method would be useful when dynamically deserializing objects, using reflection for instance.

Digging around with Reflector I found that the generic method just delegates to an internal helper, passing the generic parameter T as typeof(T). It would be a simple matter then to provide the necessary overload that accepts the Type directly.

Hopefully the ASP.NET team will add the missing overload, but in the meantime I decided to "cheat" with the following extension method:

Unfortunately he links to the Silverlight video player for the videos which apparently doesn’t work for a lot of people. Here are direct links to the .WMV files (hosted by Microsoft):

ScottGu’s presentation on MVC:
ScottGuOnMVCatALTNET.wmv

ScottHa’s presentation on MVC+DLR:
ScottHaOnDLRandMVCatALTNET.wmv

Enjoy!

Porting ZFS to Linux is complicated by the fact that the GNU General Public License, which governs the Linux kernel, prohibits linking with code under certain licenses, such as CDDL, the license ZFS is released under.[21]

I can’t understand why people still use the GPL, or even bother to incorporate GPL-licensed code. I don’t know a single developer who likes the GPL or would ever release code licensed under it.

Even Linus Torvalds seems to be wary of the aggressive nature of the GPL:

NOTE! This copyright does *not* cover user programs that use kernel services by normal system calls - this is merely considered normal use of the kernel, and does *not* fall under the heading of "derived work". Also note that the GPL below is copyrighted by the Free Software Foundation, but the instance of code that it refers to (the linux kernel) is copyrighted by me and others who actually wrote it. Linus Torvalds

(snipped from the Linux Kernel license file)

I wonder what percentage of people who license their code under the GPL understand the restrictions they are imposing on other developers, or if they just choose the GPL because it’s a well known name and no one wants to take the time to read and compare a few different software licenses. Personally I prefer the (new) BSD license. It’s short and sweet and doesn’t attempt to masquerade a social agenda as freedom.

public class Sample { static readonly string StaticString = "StaticString"; const string ConstString = "ConstString"; public void SetValues(StringCollection strings) { strings[StaticString] = "foo"; strings[ConstString] = "bar"; } public void GetValues(StringCollection strings) { string value1 = strings[StaticString]; string value2 = strings[ConstString]; } }

The disassembly of that code shows something surprising:

It doesn't look like the const string is being used at all, while it's obvious that the static string is. This can't be right. Let's take a look at the IL:

Same odd result, though we can see that the const string is defined as a static field (with the literal modifier instead of the initonly modifier). What gives? I refuse to believe that const strings are duplicated all over the assembly. Opening the assembly in a hex editor (I used Visual Studio's Binary Editor), you can see that there are only 2 instances of the string (not the 3 you would expect):

In fact, if we add the following method to our class:

We can see that it does not add any additional strings to our assembly. There are still only the 2 instances:

So, const string is not as bad as it initially looks. I am curious why there are 2 instances of the string though, and why the field isn’t referenced…

The two classes you need are in the System.Security.Principal namespace:

• SecurityIdentifier
• NTAccount

You need to create a new instance of a SecurityIdentifier using the constructor that takes a WellKnownSidType enum value. The WellKnownSidType value specifies the built-in security object you are interested in.

// Assume using System.Security.Principal SecurityIdentifier si = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);

Given the instance of the SecurityIdentifier, you obtain the name via the Translate() method, passing typeof(NTAccount) and casting the result to an NTAccount instance.

The Value property of the NTAccount instance contains the name of the security group or user.

And for bonus points, here's a PowerShell function to do the same thing:

Sample usage: