One major drawback of ReSharper 4.5 was the fact that when navigating to a compiled class, ReSharper always opened the Visual Studio Object Bowser. However, personally I prefer the Metadata View of Visual Studio:

 

With Version 5.0 ReSharper (currently available as EAP) there comes a major improvement. The first time you navigate to a pre-compiled class, ReSharper offers you to choose your favorite view: Object Browser, Metada View or directly the .NET framework sources.

In case your change your mind (or the selected sources is not available) you can define the order for the code navigation within Visual Studio at the ReSharper Options from ReSharper / Options… / Tools / External sources:

My Web Page Starter Kit is a lightweight content management system, entirely written in ASP.NET 2.0. It comes with a wide range of components that can be easily arranged and set up. However, it seems there is no possibility to include external application into the navigation structure of MWPSK.

In the following example you will learn how to integrate a application using the URI http://blog.example.org into a website using MWPSK at http://www.example.org.

Log into the site and navigate to select Administration / Pages and Navigation. Select New Page to create a new

Choose a virtual path such as blog. This will allow you to use a new URI in the form of http://www.example.org/blog.aspx.

Now open the global.asax file located in the root folder of your MWPSK installation and add the following method.

void Application_BeginRequest(object sender, EventArgs e)
{
    if (HttpContext.Current.Request.Url.ToString().ToLower().Contains
        ("www.example.org/blog.aspx")) 
    { 
        HttpContext.Current.Response.Status = "301 Moved Permanently"; 
        HttpContext.Current.Response.AddHeader("Location", 
            Request.Url.ToString().ToLower().Replace( 
                "www.example.org/blog.aspx", 
                "blog.example.org/")); 
    } 
}

This will cause an URL rewrite of the HTTP-request, which is then sent to the external application at http://blog.example.org.

Today, I run into a quite annoying error message while developing a application for Windows Mobile 6.1.

"An error message is available for this exception but cannot be displayed because these messages are optional and are not currently installed on this device. Please install ‘NETCFv35.Messages.EN.wm.cab’ for Windows Mobile 5.0 and above or  ‘NETCFv35.Messages.EN.cab’ for other platforms. Restart the application to see the message."

The required files are located at C:\Program Files (x86)\Microsoft.NET\SDK\CompactFramework\v3.5 \WindowsCE\Diagnostics, assuming you have installed the Windows Mobile SDK. I copied the file NETCFv35.Messages.EN.wm.cab to my device and run the installation. So far it worked fine, until the same exception popped up again.

Using the .NET CF Logger, from Power Toys for .NET Compact Framework 3.5, I was able to track it down to the following error:

"Failed to load [System.SR, Version=3.5.0.0, Culture=neutral, PublicKeyToken=969DB8053D3322AC]"

To do so, you choose the device you want to log and select which logging options you want. The log files can be found then in your application folder on the mobile device.

With this new input, I found Martijn Hoogendoorn's blog entry. He came across the same issue some time ago and provided a solution to this miracle. If you have a look inside the .cab file, check the _setup.xml file.

 

Extract and rename the file SYCCFA~1.001 to System.SR.dll and include it into your project. Rebuild, deploy and debug it - it should work fine.

 

 

If you are interested, go to Manning Publications Co. and get an (almost) free White (green) paper about IronRuby. It will cost you only your e-Mail address and clicking the opt-out link as soon as you received the first newsletter.

"IronRuby is an implementation of the Ruby language on the .NET Framework. That means when it’s complete it will have the same language features as Matz’s Ruby Implementation (MRI) 1.8.6 but backed up by the intrinsic power that the .NET Framework harnesses."

Source: http://manning.com/free/green_carrero.html

Sometimes it is maybe necessary to bring some order into your unit tests in Visual Studio. Indeed, this is not really the idea of unit testing, however it might be necessary for a variety of reasons. Facing this issue, I had to search the MSDN documentation for a while.

I was desperately looking for some syntax like:

[TestMethod(Order = 1)]

However, the only way to bring some order in your tests is, by creating some ordered tests in addition to your unit tests.

To do so, you first create a set of unit tests. In my case, some of the tests should be only executed after other run successfully. Otherwise the result might look like:

Now we create a new test project called Order Test:

When opening the project you actually can arrange the order of the previously written unit tests:

Running the test then is possible by selecting the test from the Test View window. Your tests will actually only appear as one entry in the list but you will see that all the selected tests run successfully - in the correct order.

I am going to implementing a publish/subscribe mechanisms for our recent Web-based research prototype. Therefore, I am interested what others already thought about this pattern. Looking for the  pub/sub paradigm, Google returns the corresponding Wikipedia article on the first place. Screening the article, there are a few starting points worth to be remembered:

• Pub/sub is a sibling of the message queue paradigm
• Subscribers typically receive only a sub-set of the total messages published; selecting messages for reception is called filtering
• In topic-based systems messages are published to topics or named logical channels
• In content-based systems, attributes or the content of messages must match constraints defined by the subscriber
• In hybrid systems, publishers post messages to topics; subscribers only receive content-based subscriptions on a particular topic
• Brokers might be used to maintain subscriptions, store and forward messages and perform the filtering
• The first time a pub/sub mechanism was described was in Exploiting Virtual Synchrony in Distributed Systems [pdf] by K. Birman and T. Joseph.
• Publishers and subscribers remain ignorant of the system topology; publishers don't know about the existence of any subscribers; this allows to create a loosely-coupled system
• Scalability for pub/sub under high load in large deployments currently remains a research question

Looking for more information on the Web I cam across the Publish/Subscribe integration pattern from Microsoft's patterns & practices. The problem statement seems reasonable:

• How can an application in an integration architecture only send messages to the applications that are interested in receiving the messages without knowing the identities of the receivers?

In the context description, the following communication infrastructures are mentioned:

• Bus
• Broker
• Point-to-Point

In contrast to to the Wikipedia article, we learn about three different types of mechanisms:

• List-based Publish/Subscribe
• Broadcast-based Publish/Subscribe
• Content-based Publish/Subscribe

Having a closer look, the List-based Publish/Subscribe mechanism maintains a list of subscribers, similar to the Observer pattern. Attach() and Detach() operations allow to modify the list of subscribers while a Notify() operation is used to send updates to the subscribers. Seems to be well suited if you have one publisher and many subscribers, but does not look suitable if subscribers watch many subjects. The core functionality of List-based Publish/Subscribe can thus be identified as

• The publisher maintains a list of all subscribers
• The publisher notifies each one individually

If we understand subscription lists as named channels, the List-based Publish/Subscribe represents a topic-based subscription mechanism.

The Broadcast-bases Publish/Subscribe mechanism simply dumps messages to the local are network. Each subscriber is responsible for listening and inspecting the subject line of the message. If the subject line matches, the subscriber processes the message. This approach seems to be a optimum in decoupling the system. Clearly, this can be identified as some kind of a topic-based system. If the publisher needs to know about subscribers to a particular topic, a hybrid approach can be chosen, where a additional process requests information about interested subscribers. To establish the hybrid system, however, every subscriber must respond to the request. Another name mentioned in the article is publish/subscribe channel with reactive filtering due to the responsibility of each subscriber to filter the messages on its own.

In difference to the Wikipedia article, in this article the author differentiates between topic-based and content-based mechanisms. In this context, both, List-based Publish/Subscribe and Broadcast-based Publish/Subscribe are understood as topic-based mechanisms.

While topics are considered as a pre-defined set of subjects, each message in a content-based system can be understood as a  single dynamic logical channel. This idea was proposed in The Evolution of Publish/Subscribe Communication Systems [pdf]. We will come back to this paper later.

Where to implement the pub/sub functionality depends on your underlying communication structure:

• Bus: Implement the subscription mechanism in the bus interface
• Broker: Implement the mechanism through subscription lists to the broker
• Point-to-Point: Implement the mechanism through subscription lists in the publisher

The article also differentiates between fixed subscriptions and dynamic subscriptions. While applications cannot control their subscriptions, dynamic subscriptions allow to modify subscriptions through certain control messages.

Some more keywords are listed in the article:

• Initial subscription: How communicate subscribers their subscription to the communication infrastructure when they are initially added
• Wildcard subscription: If supported, subscribers can subscribe to multiple topics through one subscription
• Topic discovery: How can subscribers discover available topics if dynamic subscriptions are supported

How to implement a dynamic list-based publish-subscribe pattern is illustrated in the MSDN library.

I found also some article about the way EDA (event-driven architecture) extends SOA including a nice depiction of the idea behind EDA. There, EDA is proposed for a publish/subscribe mechanism rather than a command/control mechanism as provided by SOA. EDA seems especially suitable when you are facing

• Workflow type of processes and
• Processes that cross functional organizations borders.

It is also mentions that some good support for the EDA pub/sub pattern would be a declarative model.

I also came along this article giving a brief overview of Publish-Subscribe Channel pattern from the book Enterprise Integration Patterns by G. Hohpe and B. Woolf. It basically tells that the channel delivers a copy of the message to each of the output channels where each output channels has only one subscriber. After the message is consumed, it is removed from the channel.

Having a look into Exploiting Virtual Synchrony in Distributed Systems, mentioned in the beginning, gives you an insight into several issues in distributed systems. One interesting fact to bear in mind is about synchrony vs. asynchrony. If your publisher requires responses this could be 0, 1 or n for n subscribers. If you expect 0 responses you actually run a asynchronous system. For so-called process groups an interface is provided, allowing to join or leave a group but also to receive updates on the group memberships. Sounds similar? The Observer pattern, I see here. In the described news service, one already realizes the common concepts described before: "Each subscriber receives a copy of any message having a 'subject' for which it has enrolled on the order they were posted.". The overall description is rather abstract, but gives a interesting insight into the development of the mechanism.

Afterwards I ended up directly with The Evolution of Publish/Subscribe Communication Systems, providing a well written summary of the publish/subscribe paradigm. Especially the decoupling fact has been structured into

• Anonymity: parties do not need to know each other,
• Decoupling in time: interacting parties do not need to be up at the same time,
• Decoupling in flow: sending and receipt does not block parties.

Again, we see content-based and topic-based mechanisms which makes me think twice of the classification proposed in the Wikipedia article. Back to the paper, the authors state that content-based pub/sub systems cannot rely on

• Centralized architectures based on
• Network level solutions.

A single server simply cannot deal with a high number of subscribers and the limited number of IP multicast addresses does not fit the large number of logical channels. Rather they propose a application-level realization through a set of event-brokers, exchanging information on a point-to-point basis. For broker interaction the following issues are pointed out:

• Subscription and information routing: I.e. creating a mapping between subscriptions and subscribers and the matching and forwarding  of operations.

Maybe its worth to mention, that both papers address communication systems on network and overlay network infrastructure-levels than on application-level. However, the concepts are the same.

Baldoni comes up with the concept of ad-hoc subscription languages, compared to SQL for databases. This, however, requires a-priori knowledge of the structure of the information space. At least, the idea of selecting subscriptions or topics using a query language sounds quite appealing. As future research direction, a potential formal specification of the subscription service, provided by a pub/sub system is proposed.

• Notification semantics would provide the conditions if, when and how many times an information is delivered to a subscriber. This is pointed out as a mandatory feature if the pub/sub mechanisms would be applied to mission-critical or dependable applications.
• Publishing semantics should allow to define the lifetime of information. I an pub/sub-based system, the subscriber has no rights to remove elements from a queue. To avoid overflow, the information must be removed from the queue. This, however, is clearly publisher dependent.

Another often cited paper I have a look at is The Many Faces of Publish/Subscribe [pdf]. Similar to the paper before, the three decoupling dimensions time, space and synchronization are considered to extract the common concepts of different variants of the pub/sub paradigm. We learn that individual point-to-point and synchronous communication leads to rigid and static applications. Three types of pub/sub mechanisms are introduced:

• Topic-based
• Content-based
• Type-based

The basic terms for sending and receiving messages through a software bus/event used here are

• Event for the message to be delivered and
• Notification for the act of delivering this event.

The core system should provide a

• Event notification service providing
• Storage and management for subscriptions and
• Efficient delivering of events.

The events used here are called subscribe(), unsubscribe() and publish() - not that different from the ones we know from the Observer pattern. Some new operation is called advertise() to advertise the nature of future events of an publisher. That way, the event service can adjust to the expected event flows and subscribers can learn when new types of information come available. We also learn about alternative communication paradigms here:

• Message passing is just about sending and receiving messages through communication channels. For the sender, the process is asynchronous, while the receiver must act synchronous. Both parties must be active at the same time and the sender must know its receivers. Consequently, the parties a coupled both, in space and time.
• RPC (mentioned the first time in Implementing Remote Procedure Calls [pdf] and A Survey of Remote Procedure Calls [pdf]) makes remote interactions appear the same way as local ones. Here we have a strong space and time coupling since the the invoking object hold a reference to the invoked one. One attempt for removing synchrony was e.g. applied by CORBA using one-way modifiers. In this context, the authors mention the expression fire-and-forget.
• Notifications allow a decoupling of synchronization by performing two independent invocations. The first (sent from client to server) provides a callback reference used by the server to notify the client about changes. This is mentioned to be a limited version of pub/sub mechanism and directly related to the Observer pattern we already learned before.
• Shared spaces are definitely not what I am going to use, however it is interesting to read the summary. All communication between parties takes place using tuple spaces (e.g. known from Linda) using three operations in(), out() and read(). This approach is both, time and space decoupled but remains synchronized and is thus somewhat limited in scalability. 
• Message queuing often uses some pub/sub mechanism.In difference to tuple spaces, message queues provide some transactional, timing and ordering guarantees. In difference to the pub/sub mechanism we learned before, messages are concurrently pulled by the consumer. 

For the three pub/sub forms we find some more detailed information:

• Topic-based pub/sub is based on the notion of topics or subjects, extending the notion of channels. Subscribers can subscribe topics, identified by keywords and are related to the concept of groups and group communication. When you think now of the paper we discussed before: The Isis system, described in Exploiting Virtual Synchrony in Distributed Systems is also mentioned as the one introducing the pub/sub concept the first time. Some nice expression I read in the related section was the concept of event space. In topic-based systems, the event space can be addressed hierarchically, while groups usually offer only a flat structure.
• Content-based pub/sub (aka property-based) should introduce a subscription scheme based on the particular event. Some properties events to be used for structuring could be: internal attributes of data structures or meta-data associated to events. Here again, we read about subscription languages but more in detail about filters on form of name-value pairs combined with simple operators (=, <, >, <=, >=) resulting in so-called subscription patterns.
• Type-based pub/sub is meant to replace the name-based classification of topics by a scheme according to the type of events.

Having a closer look at events we learn about the classification into messages (delivery through a single operation e.g. notify) and invocations (event triggers some specific operation on the subscriber). Furthermore, invocations are directed to a certain kind of objects and provide some well-known semantics. You can also differentiate between on-way invocations (COM+ or CORBA Event Service) and those requiring some return value.

We see different kinds of architectures there:

• Centralized architectures are using a centralized component for storing and forwarding events. Consequently, this component is a single source of failure.
• Distributed architectures omit this centralized component and are well suited for efficient delivery of messages.
• Hybrid approaches provide a decentralized notification and storage service.

Dissemination of messages is also discussed but relies a lot on the underlying concepts. Efficient multicast in content-based pub/sub systems, however, is pointed out to be still an issue.

Some more points to be considered are related to QoS:

• Since the publisher does not know about when and if the sent messages are processed some mechanism is required to ensure persistence of the information.
• More QoS features deal with priorities (only relevant for messages in transit) and transaction if multiple messages are combined to atomic operations.
• Reliability is finally pointed out as one of the most important features in distributed information systems.

Bearing this information in mind, I now have a look into the Publish-Subscribe Notification for Web Services [pdf] whitepaper as part of the WS-Notification family. The document deals with the notification pattern for notification-based or event-driven systems in the Web service context. Here we see the same pattern as learned before:

• Subscribers  register dynamically with the publisher
• Multiple subscribers can register with a publisher
• The distributing Web service sends one separate copy to each of the subscriber

The spec defines (among others) some interesting requirements:

• Support of resource-constrained devices
• Support both, direct and brokered notification
• Transformation and aggregation of brokered topics
• Publishing of runtime meta-data (for discovering available elements)
• Allow federation of brokers

In the terminology section we find another interesting statement saying "a Subscription is a WS-Resource" where a WS-Resource is defined as follows:

"A Web service having an association with a stateful resource, where the stateful resource is defined by a resource properties document type and the association is expressed by annotating a WSDL portType with the type definition of the resource properties document"

Got it? At least let us think of subscriptions as resources. This idea lines up well with my current research.

Also the fact of hierarchically structured topics is considered: Especially topic trees are hierarchically structured topics and topic spaces are a set of topic trees grouped together into the same namespace (obviously due to administrative reasons).

It is actually the first document dealing with security aspect, listing the following classes of attacks:

• Message alteration
• Message disclosure aka confidentiality
• Key integrity
• Authentication
• Accountability, i.e. a function of the type and string of the key/algorithm used
• Availability, e.g. DoS attacks
• Replay of messages

Finally, I found the Distributed Publish/Subscribe Event System on CodePlex: In the whitepaper, the various types of pub/sub are characterized by

• Coupling
• Brokered subscriptions
• Persistent vs. transient subscriptions
• Delivery of events and
• Routing.

The Web Solutions Platform (WSP) is designed as a distributed pub/sub system and works both, intra-machine and inter-machine. Applications here subscribe to event types, so it looks like an event-based pub/sub system. The document provides some more descriptions on the system itself but no more  information on publish/subscribe mechanism in general.

That's a lot of stuff and now I have to spend some time in reflecting all these information for my design.

Shawn Burke shows how to debug .NET source code in Visual Studio. all you need is to install the Visual Studio 2008 QFE [1] and then follow Shawn's instructions [2].

[1] https://connect.microsoft.com/VisualStudio/Downloads/...
[2] http://blogs.msdn.com/sburke/...

Since I read "Design Patterns. Elements of Reusable Object-Oriented Software" by the GoF the very first time in 1999, I am a big fan of patterns at all. Making heavy use of factory patterns such as the Factory Method or Abstract Factory I came along with a useful pattern we call a Declarative Factory. A Declarative Factory is based especially on the Attribute construct in the .NET Framework and allows you to extend new classes with factory capabilities in a zero-effort manner. The idea behind this pattern is to extend your application with new constructs in form of extensions without touching already existing code. This is possible when your extensions are provided by container objects. The key element here is about the new elements which you are not aware in your code yet.

This pattern is much like a Abstract Factory, however, there is no need  to create a concrete Factory class.
Also you add factory capabilities to  a new class by only adding the corresponding attribute.

First we have a look at the actual container object. Here we tell the container object to provide factory capabilities to create ConcretePrototype instances. The FactoryContainer can be any class we are using within our application, as example this could be a sub-class of ListViewItem in a WPF-based application.

[DeclarativeFactory(typeof(ConcretePrototype))]
public class FactoryContainer { }

The declaration of the ConcretePrototype is also straightforward. The IPrototype is the common interface for all prototypes that can be created by the Declarative Factory. If this pattern is applied to a WPF-based object this could also something like a DependencyObject or a FrameworkElement. In this case the DeclarativeFactory cold provide factory capabilities for the corresponding types.

public class ConcretePrototype : IPrototype

The attribute itself looks as following:

The magic now, lies in the way how to invoke the factory method provided by the Declarative Factory.

FactoryContainer container = new FactoryContainer();

DeclarativeFactoryAttribute[] a_attrib =
   (DeclarativeFactoryAttribute[]) container.GetType().GetCustomAttributes(
      typeof(DeclarativeFactoryAttribute), true);

IPrototype prototype = a_attrib[0].Create() as IPrototype;

You just resolve the factory attribute and call the factory method. Very easy, isn't it? However, you have to keep a few things in mind about this pattern.  First of all, it makes no sense if you already know about the class you want to instantiate. So, there is absolutely no reason to apply the Declarative Factory to the class itself. In this case you should definitely stay with common patterns such as the Factory Method. If you are going to make you project extensible where new types are provided through container objects this pattern appears to be very handy .

You can download the example source code for this pattern (under MS-Pl) at CodePlex [1].

 

[1] http://www.codeplex.com/declarativefactory

After reading about dzone [1] in Matthias' blog [2], I signed up an account there and published my first article [3]. Having only a very quick look on this portal, it looks to me like one of those few, providing additional value.

[1] http://www.dzone.com/
[2] http://unmaintainable.wordpress.com/2007/12/22/one-year-of-blogging/
[3] http://www.dzone.com/links/wcf_net_35_and_http_request_content.html

Sometimes, simple things end up as epic battles. If you try to MSN Search and Google for the nasty "You have create a Service" page for IIS hosted WCF services, you will and up with a lot of pre-release information and noise in the search results. Actually, you might spend days in finding some relevant information.

Yesterday, I was finally pointed to the right place in the MSDN documentation [1] where you can find this specific information:

<serviceDebug httpHelpPageEnabled="Boolean"
    httpHelpPageUrl="Uri"
    httpsHelpPageEnabled="Boolean"
    httpsHelpPageUrl="Uri"
    includeExceptionDetailInFaults="Boolean" />

With the serviceDebug tag it should be possible to get rid of the page. It is easy to find as long as you know you have to search for HTML help page.

[1] http://msdn2.microsoft.com/en-us/library/ms788993.aspx

I just found this nice LINQ to XML summary [1] on The Code Project.

[1] http://www.codeproject.com/KB/vista/LINQ_3.aspx#LoadingXML

The new Web Programming Model [1] of WCF and the .NET Framework brings some very useful features such as the WebGet and the WebInvoke Attribute and the capability to deal directly with HTTP requests. But how do we access the HTTP request in these methods? Dealing with HTTP requests and responses using the System.Net namespace is quite straight forward. Therefore, we have a look in sending and receiving a simple HTTP request:

HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(myUrl);
byte[] a_dataBytes = Encoding.UTF8.GetBytes(data);

request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = a_dataBytes.Length;

Stream requestStream = request.GetRequestStream();
requestStream.Write(a_dataBytes, 0, a_dataBytes.Length);


WebResponse response = request.GetResponse();
StreamReader responseReader = 
    new StreamReader(response.GetResponseStream(), Encoding.UTF8);

var content = responseReader.ReadToEnd(); 

Now we want to access the HTTP context within a operation with the following signature:

[OperationContract]
[WebInvoke(Method = "PUT", UriTemplate = "{uri}")]
bool Put(string uri);

Accessing the context of the incoming request is straightforward using the WebOperationContext class.

IncomingWebRequestContext context =
    WebOperationContext.Current.IncomingRequest;

var length = context.ContentLength;
var type = context.ContentType;
var headers = context.Headers;

Since the documentation does not provide many example code, and the ORCAS samples do not cover this yet, I had to figure out how to access the content of the incoming request. After spending hours on MSN Search, Google and the MSDN Library I finally tried out something. In some general examples, either a Message or a Stream is passed over as single parameter to the operation. Hence, I changed the contract as follows:

[OperationContract]
[WebInvoke(Method = "PUT", UriTemplate = "{uri}")]
bool Put(string uri, Stream stream);

Reading the content then is easy:

var reader = new StreamReader(stream);
string content = reader.ReadToEnd();

This solution however comes up with one major drawback: If you try to access your foo.svc via browser you will end up some error telling you "For request in operation Post to be a stream the operation must have a single parameter whose type is Stream.". Also calling foo.svc?wsdl will end up in some exception in the WSDL export extension.

 

[1] http://msdn2.microsoft.com/en-us/library/bb412169(VS.90).aspx

If you are going to un-install Visual Studio 2008 beta 2 due to the installation of  the final version, you should have a look at [1] to make sure you haven't missed anything during this procedure.

[1] http://blogs.msdn.com/buckh/archive/2007/11/20/how-to-uninstall-vs-2008-beta-2-before-installing-the-final-version-of-vs-2008.aspx

One of the features I was looking for, is the LINQ to XML capability of the .NET Framework 3.5. In [1] you find an overall introduction it this topic.

[1] http://msdn2.microsoft.com/en-us/library/bb308960.aspx

The current issue of Communications of the ACM features an interesting article about the philosophies behind the two approaches covering components and services [1]. Both topics have been major parts of my studies in computer science and it's definitely worth thinking about since too often decisions about these kinds of architectures and which to choose are made on hypes rather than on facts.

[1] http://portal.acm.org/...

What's all about

The widgets offered by Last.fm are not really customizable. The latest Flash-based quilts are literally flashy and the image-based charts are quite unconvincingly to design. So I sat down wrote a small ASP.NET control to be used as Last.fm Widget with the goal to use it within my dasBlog installation. For that reason I made usage of the data feeds provided by Last.fm.

 

Prerequisites

1. You need a Last.fm account which you can create here.
   
   
2. You might want to download any media player plug-ins from here to scrobble your music.

How to install on a ASP.NET Web Application

1. Download the .zip file and unpack it's content into your web application's directory.
   
   
2. Add the following line below your page tag to register the control with your ASP.NET web page:

   <%@ Register Src="LastFmControl.ascx" TagName="lastfm" TagPrefix="uc" %>

3. At the place where you want to add the control similar to

   <uc:lastfm 
     id="Lastfm1" 
     runat="server" 
     Url="http://ws.audioscrobbler.com/1.0/user/aheil/recenttracks.xml"
     User="http://www.last.fm/user/aheil/">
   </uc:lastfm>

4. Change the username from aheil to your username unless you want to display my recently played music on your site.

How to install on a dasBlog installation

1. Download the .zip file an unpack it's content into your dasBlog installation directory.
   
   
2. Open the hometemplate.blogtemplate file of your dasBlog theme and use the ASPNETControl makro to add the control on the page.

   <%newtelligence.ASPNETControl("LastFmControl.ascx")%>

3. Open the LastFmcontrol.ascx.cs file and change the username at

   private string _url 
     = "http://ws.audioscrobbler.com/1.0/user/aheil/recenttracks.xml";

and


private string _user 
  = "http://www.last.fm/user/aheil/";

unless you want to display my recently played music on your blog.

How to Customize

The control makes heavy usage of several CSS div classes to be maximum customizable. The classes used are

.lastFmMain {}
.lastFmHeader{}
.lastFmItem {}
.lastFmItemTitle {}
.lastFmItemArtist {}
.lastFmFooter {}

Simply modify and add these div classes in your CSS file to make the control look seamless integrating into your web page.

The classes are used as following where the lastFmItem is reapeating.

Download

• Download .zip file (3KB)

Some Comments

I did not spent much effort into this control. Writing this entry took longer that writing the control, not only since the pre-release Windows Live Writer versiopn I am using crashed twice. There are several improvements, which could be done to this control, including reducing the paramters to only the user name, adding the Last.fm icon etc. If you are looking for a more sophisticated dasBlog makro, you might have a look at Alexander Groß' Last.fm makro, which I was pointed to wafter I had written the above one.

Share this post :

I just surfed on Geekpedia. I did not have a lot of time to look though the site, but is seem as there are tons if interesting articles and information about cool stuff there. So if I find I will seek though their archives for some useful tips and tutorials

 

Source: http://www.geekpedia.com/

Share this post :

I just spend some minutes this evening updating the LibraryThing Widget CSS styles.

The DIV classes used by LibraryThing are as follows:

.LTwrapper
.LTheader
.LTitem 
.LTprovided

LTwrapper is for the whole widget, LTheader only for the "Random books I have" line, Ltitem for each book and finally .LTprovided for the footer "powered by LibraryThing".

However, to get some more flexibility in the layout you should make usage of the cascading property in CSS and define the .LTitem img class to position the images. It could look like the following then:

.LTitem img
{
  float: right;
  margin: 0px 0px 0px 10px;
}

Maybe this is a bug: Creating a ContextMenu as child of a Canvas, the event handlers CanExecute and Execute have never been executed? This took me almost two hours to figure out why. Basically I do my command binding like

CommandBinding exitCmd =
    new CommandBinding(DesignerCommands.Exit);
exitCmd.CanExecute +=
    new CanExecuteRoutedEventHandler(exitCmd_CanExecute);
exitCmd.Executed +=
  new ExecutedRoutedEventHandler(exitCmd_Executed);
CommandBindings.Add(exitCmd);

To me, it looks like there is a minor problem in command binding [1] whilst using command binding this manner in controls which never get the focus (such as a Canvas). Since the handlers are never fired. An easy workaround is to add additional command binding within your XAML code.

<ContextMenu.CommandBindings>
    <CommandBinding Command="e:MyCommands.Exit"
                    CanExecute="exitCmd_CanExecute"
                    Executed="exitCmd_Executed"/>
</ContextMenu.CommandBindings>

I checked a couple of web sites and found also [2], where the problem is described a bit more in detail. Also Aaron describes a second work around that requires some lines of code.

[1] http://msdn2.microsoft.com/en-us/library/ms741839.aspx
[2] http://www.wiredprairie.us/journal/2007/04/commandtarget_menuitem_context.html

I am working on a user interface (UI) for a client tool of our current project. Though, the last two have been a epic battle fighting with a various of minor things. However, each and every of these things does cost a remarkable amount of time.

Starting with WPF many developers will spend mcuh time with skinning in WPF. It's a cool thing, but you should leave these things to designers. It is a enormous time sink. You make huge progress in the beginning but end up with endless fine-tuning in the end. The first have a look at the Windows Vista User Experience Guidlines [1]. The really thing: you don't have to read everything online, just download the 630 pages as PDF document [2]. You will see that skinning should be used carefully. Much more important are some new guidlines to keep in sync with the Vista UI. BTW: if you are looking for the Vista icons you should have a look at [3] (but I haven't told you that and so use them only to inspire you by creating own icons).

Well, what's about the cool stuff such as the new Command Link in Vista? Should be a new control? Well, not that easy. Daniel Moth found out [4] to check the Vista Bridge Samples [4] comming with the Windows SDK. you should go definitely for the Windows SDK Update for Vista [6]. Daniel also gives a first impression how to use the TaskDialogs provided by the VistaBridgeLibrary [7].

Now you will definitely run into trouble if you don't create a manifest file for you application using the following dependency:

<dependency>
  <dependentAssembly>
    <assemblyIdentity
      type="win32"
      name="Microsoft.Windows.Common-Controls"
      version="6.0.0.0"
      processorArchitecture="x86"
      publicKeyToken="6595b64144ccf1df"
      language="*"
    />
  </dependentAssembly>
</dependency>

In my case I also had to use strong-named assemblies since they are used within VSIP [8] packages. You will realise that the VistaBridgeLibrary uses friendly assemblies, Junfeng gives a short introduction into friendly assemblies at [9]. You'll discover that is not as easy since there have been some changes in Visual Studio 2005. Adrian figured out how it works at [10]. David cover's the further steps in [11] and also provides a small tool to obtain the public key token of a signed assembly ready to be copy 'n' pasted into your Assembly.cs file.

[1] http://msdn2.microsoft.com/en-us/...
[2] http://download.microsoft.com/download/...
[3] http://www.istartedsomething.com/20060924/vista-fitted-nearly-finished/
[4] http://www.danielmoth.com/Blog/2006/06/vistabridge_12.html
[5] http://msdn2.microsoft.com/en-us/library/...
[6] http://www.microsoft.com/downloads/...
[7] http://www.danielmoth.com/Blog/2006/06/...
[8] http://www.microsoft.com/downloads/...
[9] http://blogs.msdn.com/junfeng/archive/2004/07/...
[10] http://geekswithblogs.net/dotnetrodent/archive/...
[11] http://davidkean.net/archive/2005/10/06/1183.aspx

Best points to start understanding WPF data binding are the MSDN articles "Windows Presentation Foundation Data Binding" at [1] and [2]. More can be found in the MSDN magazine article "Customizing Controls For Windows Presentation Foundation" at [3]. To learn how to bind to element properties the forum entry at [4] may help. A somehwat twisted introduction to Styles and Templates can be found at [5].

[1] http://msdn2.microsoft.com/en-us/library/aa480224.aspx
[2] http://msdn2.microsoft.com/en-us/library/aa480226.aspx
[3] http://msdn.microsoft.com/msdnmag/issues/07/05/WPF/default.aspx
[4] http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=1496636&SiteID=1
[5] http://www.nickthuesen.com/?page_id=18

A while ago Microsoft release the Consolas Font for Visual Studio 2005 [1]. I haven't thought [2] of it for a while until I set up my machine during the last days. There is a significatn difference while using the Consolas font (all characters the same width, optimized for ClearType and quite a bit smaller than the old typewriters). The pictures shows a direct comparison of both fonts...

[1] http://www.microsoft.com/downloads/details.aspx?...
[2] http://blog.aheil.de/ConsolasFontForVisualStudio2005.aspx

Another new download featureing WPF examples [1].

"The Panel is the place to collect showcases of new user experiences and provide insights on how they were implemented. WPF applications and Windows Live gadgets are featured."

[1] http://go.microsoft.com/?linkid=6515578

Here we go, the Windows SDK Update for Vista [1]:

"The Microsoft® Windows® Software Development Kit (SDK) Update for Windows Vista provides documentation, samples, header files, libraries, and tools designed to help you develop Windows applications using both native (Win32) and managed (.NET Framework) technologies. This release of the SDK supplies"

[1] http://go.microsoft.com/?linkid=6515574

Ther are two versions of the Windows SDK out there. The fist one is a .iso download [1], the second one the Web setup [2]. They should be the same, however the .iso is version 5.0 while the Web setup is version is Orcas_March07CTP...

[1] http://www.microsoft.com/downloads/...
[2] http://www.microsoft.com/downloads/...

Coming back from Redmond I found the Visual Studio Update for Vista RTM [1] available.

[1] http://www.microsoft.com/downloads/...

Some of of the advancements in Service Pack 1 for Visual Studio 2005 [1] which is available for download [2]:

• "New processor support (e.g., Core Duo) for code generation and profiling"
• "Performance and scale improvements in Team Foundation Server"
• "Team Foundation Server integration with Excel 2007 and Project 2007"
• "Tool support for occasionally connected devices and SQL Server Compact Edition"
• "Additional support for project file based Web applications"
• "Windows Embedded 6.0 platform and tools support"

Especially the Core Duo support sound quite nifty to me. However, running Vista you have to wait some more weeks for some additional features.

"For developers using Visual Studio 2005 on Windows Vista, Microsoft is in current development on an update to Service Pack 1 called the ‘Visual Studio 2005 SP1 Vista Refresh Beta’. This update builds on the improvements made in SP1 and delivers a first class experience for developers wanting to take advantages of the new features in Windows Vista. The Visual Studio 2005 SP1 Update for Windows Vista is expected to ship after the consumer availability of Windows Vista in Q1 of 2007 and is now available in bet"

Just in case you are wondering why the two service packs are separated you can find more over here [3].

[1] http://msdn.microsoft.com/vstudio/support/vs2005sp1/default.aspx 
[2] http://www.microsoft.com/downloads/...
[3] http://blogs.msdn.com/somasegar/archive/2006/09/26/772250.aspx

Some hints on Visual Studio on Windows Vista at [1].

[1] http://msdn2.microsoft.com/en-us/vstudio/aa964140.aspx

Looking for svnserve [1] I realized that the link is dead. Instead I found some hints that subversion from version 1.4 .x on supports to be started as a service out of the box. After running

sc create svn.local binpath= "\"c:\program files\subversion\bin\svnserve.exe\" --service --root c:\svn" displayname= "Subversion Repository" depend= Tcpip

I just had to change the service settings to be automatically started.

More information on this topic can be found at [2].

[1] http://blog.aheil.de/SVNService.aspx
[2] http://svn.collab.net/repos/svn/tags/1.4.0/notes/windows-service.txt

Aspect oriented development community [1].  

"The Aspect-Oriented Software Association is a non-profit organization whose mission is to be the primary sponsor for the annual Conference on Aspect-Oriented Software Development."

[1] http://www.aosd.net/aosa.php

A parser for LL(k) grammars, supporting also C# output is Grammatica [1]. I just tried it and I am highly pleased. Unfortunately the tool is under LGPL [2]. Unfortunately the created classes require the Grammatica runtime.

[1] http://grammatica.percederberg.net/index.html
[2] http://www.gnu.org/licenses/lgpl.html

"I know what to do, and how to solve the problem, but I do not know the bloody API." - I just met the guys implementing the Krugle [1] search engine over here at ICWE 2006. And it does work quite well.

[1] http://www.krugle.com

Microsoft's community development portal [1] and the Shared Source portal [2].

[1] http://www.codeplex.com/ 
[2] http://www.microsoft.com/resources/sharedsource/default.mspx

Havin some trouble in remebering regualr expressions, I use the MSDN site [1] to get the basics to create them.

[1] http://msdn2.microsoft.com/en-us/library/2k3te2cs.aspx

Learn Python in 10 minutes [1]. Exactly what i was looking for. 

[1] http://www.poromenos.org/tutorials/python

While I was working with Web Services in one of my projects, I got some compiler errors: The type of namespace foobar could not be found. Actually I checked the line and it looked as the namespace (a Web reference) was not found - but in the Solution Explorer everything looked fine. If you click the namespace identifier which seems to be wrong, a smart tag appears which allows you to extend the namespace to it's full identifier. And there you can see, why the compiler finds an error.

Cool feature if you know that it is there.

Just another description [1] of the Model-View-Controller pattern.   

[1] http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpatterns/html/DesPageController.asp

I have just added the MSDN TV [1] and MSDN Webcast [2] feeds to my blogroll.

[1] http://msdn.microsoft.com/msdntv/
[2] http://msdn.microsoft.com/events/webcasts/default.aspx

Maria brought the Consolas Font Pack for Visual Studio 2006 [1] to my attention. After installing, the Consolas font is set up as default font in Visual Studio 2005. At least on my Portégé M200 it is very readable.

[1] microsoft.com/downloads

An article about the Kids Programming Language can be found at the Coding4Fun site.

For all those developers who prefer Emacs there it is. Emacs shortcuts put of the box supported by the Visual Studio 2005.

"The following shortcut key combinations mimic commands available in Emacs and are used while editing code in the integrated development environment (IDE)."

Link: http://msdn2.microsoft.com/en-us/library/ms165528.aspx

If you have some trouble in updating GUI elements since they are not created by the thread just running

delegate void onSensorChangeParameterDelegate(int index, int sensorValue);
void kit_OnSensorChange(int index, int sensorValue)
{
  if (InvokeRequired)
  {
    BeginInvoke(new onSensorChangeParameterDelegate(kit_OnSensorChange), new object[] { index, sensorValue });
    return;
  }
  txtInfo.Text = String.Format("Index={0}, Value={1}", index, sensorValue);
}

So the method is handed over to the GUI thread, where txtInfo is a TextField, and processed there. Jon has written a great article [1] about threading in .NET and how it can be done.

[1] http://www.yoda.arachsys.com/csharp/threads/winforms.shtml

If you have to use orften contracts in Microsoft Communication Foundatation aka Indigo, sometimes you become really bored by implementing all the interfaces. Visual Studio 2005 helps you saving a lot of time by choosing the interface your class inherits from. Using the Implement Interface menu item you will get all the methodes required by the interface.

Ups, I've done it. It's fubar [1] now.

However it's possible to send an error report using the errorreport switch: csc *.cs /errorreport:prompt

Actually I found why the compiler screw up. I use a lot of plattform invokes and because I am lazy I use a constant with the library name.

private const string LIB = "MyNativeDll.dll";

[DllImport(LIB)]
//...

While changing the code, I removed the const modifier by accident, which causes the compiler to fail...

[1] dict.tu-chemnitz.de
[2] msdn.microsoft.com

I found a blog entry written by the C# Team, about how to to update user interface from a thread that did not create it [1]? This blog about C# questions could be really awesome, but unfortunately the entries are once in a blue moon.

[1] http://blogs.msdn.com/csharpfaq/archive/2004/03/17/91685.aspx
[2] http://blogs.msdn.com/csharpfaq/default.aspx

Hat man ein ArrayList und will die darin gespeicherten Integer-Werte in ein Array auslesen, klappt dies in C# ganz umständlich aber zuverlässig mit folgendem Befehl:

int[] args = (int[]) arrayList.ToArray(typof(int));

 

Jetzt, da die echte Domain für sämtliche Request verwendet werden kann, habe ich begonnen einige kleine Probleme auf der Seite zu beheben. Ein Problem trat regelässig auf, wenn man im Kalender von dasBLog einen Tag ausgewählt hatte. dasBlog ruft darauf die Seite default.aspx?date= auf. Natürlich klappt das nicht, wenn die default.aspx Seite in blog.aspx umbenannt wurde. Wie fast alle in .NET kann das Problem mit einem Dreizeiler gelöst werden:

if (Request.QueryString["date"] != null)
{
    string query = "blog.aspx?date=" + Request.QueryString["date"];
    Server.Transfer(query);
}

Das reicht und jeder Request der auf der Startseite eingeht und vom Kalender stammt wird abgebochen und es wird anstelle dessen die Seite blog.aspx zurückgeliefert. Beliebig verfeinern lässt sich das Ganze, indem beispielweise noch auf die Referrer-Url abgefragt wird. Eine Bedingung in der Form

Request.UrlReferrer.ToString().Substring("blog.aspx") < 0

genügt da schon.

Hack The Planet!