Paul van Brenk.com

Links for 2009-06-12 [del.icio.us]

2009-06-13T00:00:00-07:00

Matasano Chargen » Blog Archive » Typing The Letters A-E-S Into Your Code? You’re Doing It Wrong!
Encryption is hard, do not attempt!

Links for 2009-06-10 [del.icio.us]

2009-06-11T00:00:00-07:00

Breaking All The Rules with WCF
Scott has a nice article about the flexibility in WCF, which allows you to bend the rules when needed.
Visual Studio 2010 Performance Part 2: Text Editor

Links for 2009-06-09 [del.icio.us]

2009-06-10T00:00:00-07:00

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

2009-06-09T00:00:00-07:00

Code Contracts Primer – Part 1: Introduction - Derik Whittaker - Devlicio.us

Links for 2009-06-05 [del.icio.us]

2009-06-06T00:00:00-07:00

A scalable reader/writer scheme with optimistic retry

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

Links for 2009-05-25 [del.icio.us]

2009-05-26T00:00:00-07:00

Schneier on Security: Secret Questions
secret questions as a password backup are a huge seciurity hole

Links for 2009-05-23 [del.icio.us]

2009-05-24T00:00:00-07:00

Code Contracts
Tools to use with the new codecontracts in vs2010
BCL Team Blog : What's New in the BCL in .NET 4 Beta 1 [Justin Van Patten]
Good overview of the new features in the BCL for 4.0

.NET Services March 2009 CTP

2009-04-08T10:14:36.1375234-07:00

Clemens has posted a number of interesting posts about the .NET Services March 2009 CTP and SDK.

Introduction and new features

Queues and Service Bus Routers
Both are new for this release and look very promising for a number of (reliable) messaging scenarios between parties separated with various NAT and firewall devices.

Miscellaneous

Host a Public Website At The Kitchen Table or from a Coffee Shop! No Kidding.

To get a great overview of all these posts you can also watch the recording of his Mix09 session.

This is an ongoing series, so I’ll update this post when he posts a new article. (Or you can just subscribe on his site.)

Book: Concurrent Programming on Windows

2009-04-03T11:58:48.0347443-07:00

Today I finally finished reading Concurrent Programming on Windows by Joe Duffy. It took me this long, not because it’s a boring book (it’s not!), but because it covers a lot of ground and a goes into a lot depth.

This is not a book for someone looking for a 3-step program to start writing flawless concurrent programs, simply because there is no such program. As Joe points out throughout the book, writing concurrent programs is hard and error prone. It’s definitely not a simple case of running running all the items in your for or foreach loop on a new thread and automagically your program got a n-times faster.

Amount of subjects the book covers easily explains it’s size (900 pages), it covers a wide range of subjects from low level Memory models, via threads and lock object, to concurrent containers and finally to Parallel Containers for .NET CTP. I think this is a must read book for all serious developers, who in the near or not so near future expect to be writing concurrent programs. Considering the future of CPU’s and cloudcomputing, I believe that will be all of us.

Single Click dasBlog installation

2009-03-18T09:20:31.842-07:00

Announced today: the Microsoft Web Application Gallery. Combined with the WebPI 2.0 it's a single click experience for installing popular and free applications on IIS, where the tool takes care of all dependencies.

For example use this button to install the most recent (2.3) version of dasBlog:

More info @ScottHanselman.

Updated to dasBlog 2.3

2009-03-16T01:38:40.3472117-07:00

In anticipation of a big announcement on Wednesday we decided to do an interim release of dasBlog 2.3.9074.18820. This is a service release containing only bugfixes. Until Wednesday you can get this release on the daily build page (scroll to the bottom) or on CodePlex, after Wednesday there is an additional distribution and installation method.

dasBlog on Windows Azure (local for now)

2009-02-28T08:59:57.4896038-08:00

It doesn’t let you save anything, Windows Azure doesn’t like it when you try to write to the filesystem, but it shows the posts & loads the theme. And with only minor changes!

I used the manual from “Cloudy in Seattle” to get an existing ASP.NET app running on Windows Azure, to get started. Because ASP.NET is an older application we still had a referce to MSBuild 8.0 in the proj. file and the Azure packaging tool didn’t like that so I removed the following from the web project.


          <
          Import
          Project
          ="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v8.0\WebApplications\Microsoft.WebApplication.targets"
          

          Condition
          =" '$(Solutions.VSVersion)'
== '8.0'"
          />

Further I added a dummy log file to the logs directory to make sure that directory was avaialble got created. And made sure all files which are required have the Build action set to content:

The final thing to do is make sure you use the IIS 7 web.config file and disable tracing.


          <
          trace
          enabled
          ="false"
          />

Project Geneva Overview

2009-02-24T02:09:28.6235867-08:00

In November last year Kim Cameron wrote a series of posts about Project Geneva. It’s a little late, but still very interesting.

And the PDF with the Identity Software + Services Roadmap.

How I build the SilverLight LiveStream

2009-02-20T07:42:30.7038774-08:00

Since today there is a beta version of a SilverLight livestream control on the homepage of this site, which shows my activity on Twitter, Delicious and this blog. It’s not the most original idea, but it was a small enough project to learn something about SilverLight.

Loading the items

You can use the WebClient class (which internally uses the WebRequest class) to load data from the internet, this has some restrictions. To successfully connect to a site different from the site where the control is hosted, the site has to have a clientaccesspolicy.xml file or a crossdomain.xml which allows remote connections.

For performance reasons all methods on the WebClient class are asynchronous and since I request 3 different streams, I request those using using workitems in the ThreadPool (from a Timerevent every 5 minutes).


            public
            void ProcessFeeds(object state)
{ // twitter crossdomain.xml is very strict, so we have to have
to // use a proxy ThreadPool.QueueUserWorkItem(new WaitCallback(StartLoadFeed), new Uri("http://feeds2.feedburner.com/paulvanbrenk/twitter"));
ThreadPool.QueueUserWorkItem(new WaitCallback(StartLoadFeed), new Uri("http://feeds2.feedburner.com/paulvanbrenk/clean"));
ThreadPool.QueueUserWorkItem(new WaitCallback(StartLoadFeed), new Uri("http://feeds.delicious.com/v2/rss/paul.van.brenk"));
} privatevoid StartLoadFeed(object url)
{ WebClient client = new WebClient(); client.OpenReadCompleted
+= new OpenReadCompletedEventHandler(client_OpenReadCompleted);
client.OpenReadAsync((Uri)url); } void client_OpenReadCompleted(object sender,
OpenReadCompletedEventArgs e) { SyndicationFeed feed; using (var
xReader = XmlReader.Create(e.Result)) { feed = SyndicationFeed.Load(xReader); } foreach (var
item in feed.Items) { Dispatcher.BeginInvoke(new AddItem(delegate(FeedItem
x) { feedItems.Add(x); }), FeedItem.Create(item)); } } privatedelegatevoid AddItem(FeedItem
item);

We need to use the Dispatcher to add the items to the collection, since the collection is bound to a UI element, which responds to changes in the collection.

Binding the items to the UI

The items are bound to the panel which renders them, using the DataContext. This makes it easy to use the Binding Markup Extension to extract information from the bound items and allows the panel to monitor the collection for changes (if the collection implements the INotifyCollectionChanged interface).

Render the items

The items are rendered using an ItemsControl, with the ItemsPanelTemplate set the WrapPanel from the SilverLight Toolkit, this way the items are wrapped over multiple lines. The items are renderd using a DataTemplate in the ItemsTemplate. The image for each type of feed is converted from the type of the item using to an ImageBrush using a class implementing the IValueConverter interface.

Improvements:

Implement an ICollectionView instead of wrapping an ObservableCollectionin a custom collection;
Use some smart caching for the feeditem collection;
Add an info button, instead of the the info in the bottom left;
Improved the design;
Add filtering and sorting;
Make the SilverLight plugin resize with the browser;
Support more feed types like flickr and youtube.

[Download the project from http://code.msdn.microsoft.com/LiveStream]

ASP.NET MVC Experience and what data to send to the view

2009-02-18T08:56:48.6730634-08:00

Shawn Wildermuth wrote about his experience using ASP.NET MVC for a new site he developed.

One of the things he does is sending "complex" models to the view to render, I'm not sure that's something you should do. I believe that you should stick so simple strings and have the controller do all the heavy lifting. It's a slippery slope you're stepping on, before you know, you're sending 'models' straight from the Entity Model to the view.

Not sure if that's really feasible (or the simplest/easiest) in all situations, but it ensure a clean separation between business logic in the controller and the model and the UI in the view.

More info:Enforcing Strict Model-View Separation in Template Engines (pdf)