Paul van Brenk.com

dasBlog 2.3.1 released

2012-04-20T19:34:57.0843038-07:00

This is our official 2.3.1 release.

Use source files if you are developing or pull the source from the "Source Code" tab above.

This is another small point release:

.NET 3.5 support,
Better support for IE8/9 layout in themes, (minor)
Better support for XHTML
Supports the latest version of FreeTextBox (also better XHTML)
For developers, we now support VS 2010
Bug fix for error on comments as Admin reviewer and a comment had no Author element
Search Engine Optimization Patch added
New simple category less thread view, index of all blog posts
Google OpenID handling improvements
Upgraded to DotNetOpenAuth v3.4.5
We now officially support dasBlog on IIS 7 using integrated pipeline mode

https://dasblog.codeplex.com/releases/view/86033

The future of dasBlog

2012-01-08T20:50:42.1594247-08:00

The title is a lie (sort of)... I don't know what the long time future of dasBlog is, but short term the following is going to happen. We will release a .NET 3.5 version soon (which is running on this blog now). We probably will release a .NET 4 version shortly following that. And when Visual Studio 11 is released in Beta, we will release a version of dasBlog for .NET 4.5.

New features? DasBlog is fine for my needs as is, if you have something specific you would like, please let us know. Depending on the complexity we might be able to put it in.

Links for 2011-07-26 [del.icio.us]

2011-07-27T00:00:00-07:00

Alex Mitchell Garden Writer
excellent gardening website and blog

Links for 2011-07-05 [del.icio.us]

2011-07-06T00:00:00-07:00

Fauna Automata: British Wild Boar

Links for 2011-06-08 [del.icio.us]

2011-06-09T00:00:00-07:00

London – where the streets are paved with gold, and the gardens with cement | Environment | guardian.co.uk
Beneath the pavement - the garden!

Links for 2011-05-27 [del.icio.us]

2011-05-28T00:00:00-07:00

Infographic: grow your own | Gardening tips and advice | LoveTheGarden.com
An appealing and interesting 'infographic' showing the growth of interest in food growing in the UK

Typeforwarding Generic Types

2011-04-11T15:41:37.0693426-07:00

When you forward a generic type to another assembly [0] using the TypeForwardedTo attribute, you can’t specify the typeparameters. Instead the number of typeparameters in in the class definition depends the number of comma’s in definition.

using System.Runtime.CompilerServices;

[ assembly : TypeForwardedTo ( typeof (Destination. SomeClass ))] // Non generic

[ assembly : TypeForwardedTo ( typeof (Destination. SomeClass <>))] // equivalent to SomeClass<T>

[ assembly : TypeForwardedTo ( typeof (Destination. SomeClass <,>))] // equivalent to SomeClass<T,U>

More info on typeforwarding

Posted via email from Paul van Brenk's posterous

Links for 2011-03-15 [del.icio.us]

2011-03-16T00:00:00-07:00

How To Save Energy
Some useful tips on environmental living from Chocolate Films
Top 10…Organic Gardening Blogs - Green Living - The Ecologist
We aren't ones to blow our own trumpets but...hey!

Visual Studio 2010 SP1 released!

2011-03-08T15:33:05.444127-08:00

As both Jason and Soma blogged earlier, Visual Studio 2010 SP1 is released today.

MSDN subscriber can download Service Pack 1 today, everyone else has to have a little more patience until March 10, when they can download it from Microsoft downloads.

Posted via email from Paul van Brenk's posterous

Great features in Visual Basic

2011-02-28T16:36:33.9487309-08:00

I’ve been doing a lot of development using Visual Basic in the past couple of months and there are some interesting features in the language which may or may not be very well known. Features that don’t have an equivalent in C#.

Default values for auto implemented properties.

Visual Basic support the option of setting a default value for a property, like you would in a field.

Public Property MyProp AsInteger = 42

MSDN: Auto-Implemented Properties

Key properties in anonymous types

By defining properties in anonymous types as key properties, you can enable specific behavior for the equality behavior of these types. When an anonymous type contains key properties, then for both the Equals and the GetHashCode overridde is generated based on these key properties. Additionally the key properties are readonly, where normal properties are read/write.

Dim one = NewWith {.Name = "one", Key .No = 1}

Dim two = NewWith {.Name = "two", Key .No = 1}

' This is true because the key property for both instances of the same class is equal

Assert.IsTrue(one.Equals(two))

MSDN: Key

Filtered exceptions

Adding a filter to a catch expression in a try/catch block allows you to direct the exception handling based on a condition. This is especially useful when you’re catching a general exception, which should be handled differently based on the error code it contains.

Try

Throw New COMException()

Catch ex AsCOMExceptionWhen ex.ErrorCode = 0

Console .WriteLine("y = 0")

Catch ex AsCOMExceptionWhen ex.ErrorCode <> 0

Console .WriteLine("y <> 0")

End Try

MSDN: Try...Catch...Finally Statement

Posted via email from Paul van Brenk's posterous

Links for 2011-01-12 [del.icio.us]

2011-01-13T00:00:00-08:00

London wildlife recordings featuring birds, mammals, dawn choruses and more | London Sound Survey
A fascinating wildlife sound map of London, includes some files from Abbey Wood

Visual Studio 2010 sp 1 beta announced

2010-12-07T11:47:06.6336587-08:00

Today Jason Zander announced the availability of Visual Studio 2010 SP1 Beta on his blog. It’s available today for MSDN subscriber and will be general available on Thursday.

This service pack consists for the most part of fixes for issues logged through the connect site, but one noticeable new feature is the inclusion of the VB runtime compiler switch. This allows developers to ‘embed’ the Visual Basic Runtime in their assemblies, similar to No-PIA. The compiler figures out which parts of the runtime your program actually uses and embeds only these parts in the generated assemblies.

Download the service pack and report any issues you encounter, that’s the only way we can make it better for you. (Even if the issues you encounter aren’t fixed in the service pack, we still look at them and consider them for a next version of Visual Studio).

Posted via email from Paul van Brenk's posterous

Links for 2010-11-29 [del.icio.us]

2010-11-30T00:00:00-08:00

Capital Bee
Bee keeping in south-east London

What's next for SilverLight

2010-11-18T13:54:49.1745451-08:00

You will not only hear what’s coming next for SilverLight from Scott Guthrie, but after all the other interesting session about databinding, performance, Windows Phone 7 development there’s the After Party! (Sorry, the After Party is not available online).

More info and registration on Silverlight.net for attending in Redmond and online.

Posted via email from Paul van Brenk's posterous

Reviving my blog

2010-06-23T04:30:41.136-07:00

So, it's been over a year..... which I know is a long time, but much has happened in a very short time, so blogging was one of the casualties. But now that things have settled down, I´m back!

So what has happened:

After interning at Microsoft last summer, I got a job offer for a position in the C# IDE QA Team, which I accepted.
I married my wife
We moved to the US (See 1)
Found a place to live
Worked hard on finishing my Bachelor's degree
Helped finish Visual Studio 2010 (a little)

What's next? We'll start working on dev 11 (VS v.Next) soon, which will be exciting since it's the first time I'll be involved in the entire product cycle from planning till release. Hopefully a lot more blogging/tweeting (140 chars should be enough for everyone).

btw. I'm posting this via posterous, it should show on my regular blog. (http://www.paulvanbrenk.com)

Posted via email from Paul van Brenk's posterous

Using dynamic for evil

2009-05-29T22:53:08.736-07:00

The new dynamic keyword and the DLR in C# 4 and the .NET Framework 4.0 can be used for good, as displayed by IronRuby, IronPython and several other samples.

But it’s much more to fun to use it for evil… by making Reflection simple.

In C# 3.0 invoking members through reflection, was kind of odd and certainly not very readable.

var employee = new Employee();
var members = employee.GetType().GetMember("age", MemberTypes.All,
BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
((FieldInfo)members[0]).SetValue(employee, 30);

By wrapping all reflection magic in a dynamic object the same call would look like:

var employee = (new Employee()).AsDynamic();
employee.Name = "Paul van Brenk"; employee.Age = 30; Console.WriteLine("Employee
{0} is {1} years old.", employee.Name, employee.Age);

How this works is relatively easy.. by deriving a wrapper class from the new DynamicObject and overriding the TrySetMember and TryGetMember object to do the dirty work for you.


            static
            class DynamicHelper
{ publicstatic dynamic AsDynamic
(this T source) { returnnew DynamicReflection
(source); } class DynamicReflection
: DynamicObject { public DynamicReflection(T source) : base()
{ this.Source = source; } publicoverridebool TrySetMember(SetMemberBinder
binder, objectvalue) { //
find the member MemberInfo member; if (!TryFindMember(binder.Name, out member))
{ returnfalse; } //
we can only set values to fields and properties// using
reflectionswitch (member.MemberType) { /*
todo: check the type of the incoming value and the type of  the
property. */case (MemberTypes.Field): ((FieldInfo)member).SetValue(Source, value); returntrue; case (MemberTypes.Property):
((PropertyInfo)member).SetValue(Source, value,/*ndex*/null); //
we don't support indexed propertiesreturntrue;
} // didn't workreturnfalse;
} publicoverridebool TryGetMember(GetMemberBinder
binder, outobject result) { //
find the member MemberInfo member; if (!TryFindMember(binder.Name, out member))
{ result = null; returnfalse;
} // we can only set values to fields and properties//
using reflectionswitch (member.MemberType) { /*
todo: check the type of the incoming value and the type of  the
property. */case (MemberTypes.Field): result = ((FieldInfo)member).GetValue(Source); returntrue; case (MemberTypes.Property):
result = ((PropertyInfo)member).GetValue(Source,/*ndex*/null); //
we don't support indexed propertiesreturntrue;
} // didn't work result = null; returnfalse;
} privatebool TryFindMember(string name, out MemberInfo
memberInfo) { // find the member var members = Type.GetMember(name,
MemberTypes.All, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.NonPublic
| BindingFlags.Public); // more than 1 not supported for nowif (members.Length
!= 1) { memberInfo = null; returnfalse;
} memberInfo = members[0]; returntrue;
} private Type Type { get { returntypeof(T);
} } public T Source { get; private set;
} } }

More info about implementing dynamic objects and behavior can be found on the DLR CodePlex site (esp. Getting Started with the DLR as a Library Author).

Source: Program.cs.txt