Or: “Where has Start Without Debugging gone?”
I'm a fan of C# Express; it is great tool for quick/scratch code, and if you find my machine without at least one Express window in the task-bar, then it must be Patch Tuesday.
It looks like the Express editions of 2010 have different menu configurations for basic and advanced users:
This makes a lot of sense, but caught me off guard - especially since many of the key chords work in both modes.
I won’t attempt to list all the differences; but if you can’t find your menu items… try switching to Expert mode.
Lots of changes are underway:
In particular, beta 2 now includes the “Express” line-up, and TFS now supports installation on client OS and has a simplified install; maybe getting a CI server (on just the Microsoft stack) will soon be practical for the individual / small team.
Feeling stupid – moving files between guest and host
I’ve downloaded the new VS2010 line-up – onto my host OS; obviously, this is beta software with the potential for mayhem (or more likely: not be 100% uninstallable), so I want to install it on the guest. In case you haven’t tried Windows Virtual PC yet (perhaps you haven’t got Windows 7 yet), then note that it loses the Microsoft Virtual PC feature to drag files between host and guest. And my guest can only really see http (no local network). So how to get the files there?
I sat there looking silly… USB was an option (Windows Virtual PC can grab USB devices), but seemed overkill. It turns out that the answer is blindingly obvious. So obvious that it didn’t even occur to me to try it. Copy… Paste. D’oh! (this does need the integration features enabled, but that isn’t a problem).
So there you go; I’ll admit to being a muppet, and hopefully it’ll save somebody a few minutes wondering.
The other day, I posted about using anonymous types to pass multiple pieces of state into a method - reminder:
byte[] resp = client.Post(destUri, new {
id = 100021,
dob = DateTime.Today,
caption = "Hello world"
});About the same time Ayende Rahien posted about a related but different use in Entity Framework - example:.Case(
e => new {
manager = e.Manager.Id
thisIsADiscriminator = “E”
}
)
There is an important distinction between the two; in the first example, the property names (in the anonymous type) are only relevant to the caller. In the second (EF), the names are relevant to the callee. This is a huge difference. I don't know enough about EF to say more, but just a note: if you are doing something like this for your own types, please use a named property object to pass expected state into a method. Think of the kittens.
Novel uses of anonymous type initializers
On a related note; there was an interesting stackoverflow question today that shows another use of the anonymous type syntax - for specifying multiple members in a type-safe way:
IncludeProperties<IUser>(u => new {
u.ID, u.LogOnName, u.HashedPassword });The important thing to note is that the above is an Expression (not a delegate), and the code inside tears the Expression apart to find the properties that we are interested in. It never actually invokes the code as a delegate, nor does it ever actually instantiate the anonymous type. It might just be me, but I thought that was quite cute ;-p
.NET 4.0 is looming (lurching?) ever-closer, and one of the many interesting developments in this release is the mainstream DLR. I’ve been trying very hard to find time to get into this, but I’ve failed horribly – every time I get some spare time, something comes up. Fortunate, then, that there are plenty of code-geeks around.
In particular, I urge you to have a look at Michael Foord’s recent articles; in particular Python for .NET Programmers (but a few more here). Rest assured that there is also plenty more in both “IronPython in Action” (from the IronPython side), and books like (not yet complete) “C# in Depth, Second Edition” (from the C# consumer side of “dynamic” – lets face it, I’m primarily a C# developer).
I’m sure that Michael could suggest a hundred other uses, but I’ve got some configuration script scenarios in mind that I really need to find time to investigate.
One of the really nice things that is common to both jQuery and ASP.NET MVC is how it passed multiple values around. They both avoid the complexity of things like dictionaries (or alternatively forcing specific types) by letting the caller use ad-hoc objects; by which I mean either a jQuery “post” method like:
$.post("test.php", { name: "John", time: "2pm" } );Or an ASP.NET MVC ActionLink of the kind:
<%= Html.ActionLink(category.CategoryName,
new { action="List", id = category.CategoryName})%>
In both cases, we are passing caller-specific data (not callee-specific data, so optional / named parameters wouldn’t help), but without the pain that we might have used in the past. Of course, we could also pass it one of our domain entities, and as long as the names all matched up, it wouldn’t care. Which is nice.
I’m going to concentrate on the second of these mainly – this is a hugely versatile tool; and while it shouldn’t be used for every job, it sure is handy. Here’s an example of using the same approach for a more readable Format syntax:
string s = Format("You are {age} years old and your last name is {name}",
new {age = 18, name = "Foo"});There are a myriad of opportunities for this type of use. My main aim here is just to show some of the possibilities – and let your collective imaginations run wild. For example, to bring the jQuery “post” approach into regular C#:
using (WebClient client = new WebClient())
{
byte[] resp = client.Post(destUri, new {
id = 100021,
dob = DateTime.Today,
caption = "Hello world"
});
string html = client.Encoding.GetString(resp);
}
With supporting code:
public static class WebClientExtensions
{
public static byte[] Post(this WebClient client,
string address, object values)
{
if (client == null)
throw new ArgumentNullException("client");
if (values == null)
throw new ArgumentNullException("values");
NameValueCollection valueLookup =
new NameValueCollection();
foreach (PropertyDescriptor prop in
TypeDescriptor.GetProperties(values))
{
object val = prop.GetValue(values);
string sVal = prop.Converter
.ConvertToInvariantString(val);
valueLookup.Add(prop.Name, sVal);
}
return client.UploadValues(address,
WebRequestMethods.Http.Post, valueLookup);
}
}
Sure, this is just a basic example and there are lots of things I could do to provide more flexibility, but it shows the key points.
Posts
All Comments
