.NET

WCF and EPiServer: Using WCF Web Programming Model Services in EPiServer sites on IIS 7

Stephen Horsfield — Thu, 20 Nov 2008 17:10:58 GMT

I've just managed to get the .NET 3.5 style of WCF Web Programming Model services to work inside an EPiServer 5 R2 site on IIS 7 and Windows 2008. I had a few difficulties finding out how to integrate the new model into IIS/ASP.NET and then further problems getting it working in EPiServer. Here, I outline the solution.

Context

I'm currently designing a site that will be using the Akamai Edge Suite of technologies (www.akamai.com) and so I desire that all client access is through the caching layer. Additionally, I'm motivated towards a REST model for web services to support a greater degree of caching.

The new WCF Web Programming Model is ideal for this purpose as I can wrap service parameters directly into the URL and reduce the coding effort considerably. I had been concerned about the integration of services into the same website as EPiServer because of how the URL mapping works in the Web Programming Model.

Solution

The solution is really easy once you realise that the typical EPiServer installation changes the default ASP.NET configuration. Specifically, you may need the following:

Create a new folder to host your services
Create a small web.config in this folder (or use location tags in the main web.config file) and add service handlers
Create a ".svc" file for the service
Create the supporting .NET service code

Create a new folder to host your services

This is necessary to allow a separate application configuration. You can change the main application configuration at your own risk, however :)

For the purposes of this post, I'll use "~/services/".

Create a small web.config for this folder and add service handlers

You'll need to add the following:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <system.webServer>
    <handlers>
      <add name="svc-ISAPI" path="*.svc" verb="*" modules="IsapiModule" 
           scriptProcessor="%SystemRoot%\Microsoft.NET\Framework\v2.0.50727\aspnet_isapi.dll"
           resourceType="Unspecified" 
           preCondition="classicMode,runtimeVersionv2.0,bitness32" />
      <add name="ServiceHost" path="*.svc" verb="*"
           type="System.ServiceModel.Activation.HttpHandler, System.ServiceModel,
                 Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
           resourceType="Unspecified" preCondition="integratedMode" />
    </handlers>
  </system.webServer>
</configuration>

Now I took this from a cleanly created website with no configuration (using the IIS management console) and I recommend that you do the same.

Create a ".svc" file for the service

This file is created in the service folder and forms part of the URL so name it accordingly. I'll just use "service.svc" for illustration:

<%@ ServiceHost Language="C#" Service="Service" CodeBehind="~/App_Code/service.cs"
    Factory="System.ServiceModel.Activation.WebServiceHostFactory" %>

You should name your services more appropriately, of course.

Create the supporting .NET service code

So, you need to create the classes. Here, I'm using a simple file in the App_Code folder, but you might prefer to use a separate code project and assembly. Here's a simple example:

using System.ServiceModel;
using System.ServiceModel.Web;

[ServiceContract]
public interface IService
{
  [OperationContract]
  [WebGet(UriTemplate = "test?s={s}")]
  string test(string s);
}

public class Service : IService
{
  public string test(string s)
  {
    return "test: " + s;
  }
}

So, this is a very basic service with a single HTTP GET method that returns some data dependent on a single query string parameter. A perfect REST example as the result is defined by the input, there is no change of state (so two identical GET requests result in the same value) and so the response is suitable for caching.

Using the service

So now, you can access the service as http://your_episerver_site/services/service.svc/test?s=YourTestString. ASP.NET integration (and IIS) requires the use of a service extension, in this case ".svc", however this article may help you to remove this issue: http://blogs.msdn.com/bags/archive/2008/08/22/rest-in-wcf-part-ix-controlling-the-uri.aspx but don't forget that EPiServer already does some URL rewriting and so you'll have to make sure they don't conflict!

Metadata

Categories: ASP.NET, EPiServer, SOA, WCF, .NET, Windows Server
Keywords: Web Programming Model, Windows Communication Foundation, Service Oriented Architecture, AJAX, JSON
Technorati Tags: software development, Windows Communication Foundation, .NET, JSON, WCF, SOA, service design, Service Oriented Architecture, EPiServer, ASP.NET, AJAX

.NET: Using Namespaces with XPath in .NET

Stephen Horsfield — Fri, 23 May 2008 07:38:47 GMT

A colleague has been asking how to do this and I've found a great post written years ago. I've linked it here:

XPath & Namespaces (Wayne Allen's Blog)

Versions

Microsoft .NET Framework 2.0

Metadata

Categories: Software Development, .NET, XPath
Additional keywords: namespace manager
Technorati Tags: .NET, software development, XML, default namespace, XML namespace, XPath

.NET: JSON support in WCF

Stephen Horsfield — Thu, 22 May 2008 15:05:30 GMT

This is just a quick addendum to a colleague's post about using JSON in .NET.

Original post

See Dan's post here: Google Translate and .NET (Dan Matthews)

Complete example code

This example translates the phrase "a piece of pie" into French using Google Translate. I do not use any processing on the JSON output except to convert it into an XML document that can be processed in .NET:

using System;
using System.Net;
using System.Web;
using System.IO;
using System.Xml;
using System.Runtime.Serialization.Json;

namespace JSON_Example
{
    class Program
    {
        static void Main(string[] args)
        {
            WebRequest req = WebRequest.Create(
                "http://ajax.googleapis.com/ajax/" +
                "services/language/translate?v=1.0&q=" + 
                HttpUtility.UrlEncode("a piece of pie") + 
                "&langpair=" + "en" + "%7C" + "fr");
            WebResponse res = req.GetResponse();


            XmlDocument doc = new XmlDocument();
            using (Stream s = res.GetResponseStream())
            {
                XmlDictionaryReader xr = 
                    JsonReaderWriterFactory.CreateJsonReader(
                        s,
                        XmlDictionaryReaderQuotas.Max);

                doc.Load(xr);
                xr.Close();
                s.Close();
            }
            Console.WriteLine(doc.OuterXml);

            Console.ReadKey();
        }
    }
}

Required assemblies

System.Runtime.Serialization (3.0)
System.ServiceModel.Web (3.5)
System.Web (2.0)
System.Xml (2.0)
and the other usual suspects

Versions

Microsoft .NET Framework 3.5

Metadata

Categories: Software Development, JSON, XML, Windows Communication Foundation
Additional keywords: JSON parsing, JSON conversion
Technorati Tags: .NET, software development, JSON, WCF, Windows Communication Foundation, integration, Web 2.0

.NET: Changing the default namespace of an XmlDocument

Stephen Horsfield — Thu, 22 May 2008 10:25:45 GMT

Have you ever wanted to change the default namespace of an XmlDocument in .NET. It's not as easy as it might be.

The problem

Sometimes, particularly in middleware systems, you need to pass a source document to a target system. The document may not need any changes, but one system will apply namespace declarations in the document and the other won't work with them, or one won't add them and the other will require them.

There are a few main approaches you can take:

XSL Transforms
Regular expression replacements (or other string manipulations)
XmlNode traversal methods (DOM or XmlReader)

For such a simple replacement process, XSL Transforms are overkill. Regular expressions suffer in being fairly difficult to write well and to work with different encodings, processing instructions and comments. Not impossible though. The third option is my preferred solution.

The third option has two variations. The first, creating a new XmlDocument by traversing the original document is fairly heavy as a second XmlDocument is built in memory. Using the XmlReader allows for a lightweight and efficient method, suitable for handling large documents.

A solution framework

The following solution has a few sections to it:

The creation of an appropriate XmlReader
The creation of an appropriate XmlWriter
Processing of nodes prior to the document element node (XML declaration if present and comments)
Processing of the document element and descendent nodes
Processing of nodes after the document element node (mainly comments)
Clean up

The code that follows uses string I/O. You are more likely to be using a stream as input and output.

The solution

Part 1: Creating an XmlReader

string sourceXml =
    "<?xml version=\"1.0\" ?>" +
    "<!-- comment -->" +
    "<elementName b='doc value'>" +
    "<subelement a='a value'>" +
    "test data" +
    "</subelement>" +
    "<!-- comment -->" +
    "</elementName>" +
    "<!-- comment -->";

StringReader sreader = new StringReader(sourceXml);
XmlReader xreader = XmlReader.Create(sreader);

Note that the source XML does not include a default namespace. The purpose of this exercise is to add one.

Part 2: Creating an XmlWriter

StringWriter swriter = new StringWriter();

XmlWriterSettings wsettings = new XmlWriterSettings();
wsettings.OmitXmlDeclaration = true;
wsettings.ConformanceLevel = ConformanceLevel.Document;
wsettings.Indent = true;
wsettings.NewLineOnAttributes = true;

XmlWriter xwriter = XmlWriter.Create(swriter, wsettings);

The XmlWriterSettings is being used to configure the output, in this case preventing the XmlDeclaration from being output.

Part 3: Processing of nodes prior to the document element

A well-formed XML document has exactly one root element node, however it may have comments and other nodes prior to the element node. These need to be copied verbatim to the output, and that is what the following code does:

xreader.Read();
while (! xreader.EOF)
{
    // look for an XML element node
    if (xreader.NodeType == XmlNodeType.Element)
        break;
    // otherwise write the content to the
    // output.  This also reads the next node
    xwriter.WriteNode(xreader, true);
}

Note that using the WriteNode() method is an efficient way of handling large amounts of content, and it is also used in the following sections.

Part 4: Processing the document element node

The document element consists of one of the following:

An empty element
- doesn't have any contained nodes but may have attributes
A matching pair of start and end element tags
1. may have attributes
2. may have any internal structure

In this example, a default namespace is added to the node. It is straightforward to do the reverse and remove a default namespace. The steps are as follows:

Create an appropriate start element
Copy in the attributes
Process any descendent content
Close the element

Here's the code:

if (!xreader.EOF)
{
    // process the document element
    xwriter.WriteStartElement(
        String.Empty, // no prefix so the default namespace
        xreader.LocalName, // same local name
        "urn:tempuri.org/schema"); // the namespace

    // copy in all attributes
    xwriter.WriteAttributes(xreader, true);

    // check if it is an empty element
    if (xreader.IsEmptyElement)
    {
        // move passed the document element
        xreader.Read();
    }
    else
    {
        // move to descendent content
        xreader.Read();
        while (!xreader.EOF)
        {
            // an end element must close the
            // document element
            if (xreader.NodeType == XmlNodeType.EndElement)
            { 
                // move past the document element
                xreader.Read();
                break;
            }
            // write the entire node to the output
            // and move to the following node
            xwriter.WriteNode(xreader, true);
        }
    }
    // close the document element
    xwriter.WriteEndElement();
}

Step 5: Processing subsequent nodes

The steps are identical to the initial nodes:

while (! xreader.EOF)
{
    xwriter.WriteNode(xreader, true);
}

Step 6: Clean up

There are two main operations to complete as part of clean up:

Flushing the output to the stream using XmlWriter.Flush()
Closing the various streams, readers and writers

These steps are left to the reader.

Versions

Microsoft .NET Framework 2.0

Metadata

Categories: Software Development, .NET, XML
Additional keywords: default namespace, transformation, changing namespace
Technorati Tags: .NET, software development, XML, default namespace, XML namespace,

.NET: Generics and the Badger Example in C#

Stephen Horsfield — Tue, 20 May 2008 14:08:30 GMT

Today I've been talking to some of our developers about generics in C#. As part of it, we worked through an example, the Badger Example, which I've reproduced here for those intrigued!

Overview

This document demonstrates the creation of a generic class called Badger. Its purpose is entirely educational and introduces the use of type parameter constraints.

The Initial Badger Class

class Badger<TBadgerCharacter>
{
    TBadgerCharacter _character;

    public Badger(TBadgerCharacter character)
    {
        // TODO: Use the new operator
        _character = character;
    }

    public void HelloBadger()
    {
        // TODO: Call the Bark method on
        //       _character
    }
}

The constructor for this class is passed an instance of a TBadgerCharacter type. The type passed should provide a Bark() method and this method should be called as part of the HelloBadger() method. Additionally, rather than receiving an instance of the TBadgerCharacter type, one should be created in the constructor.

Enabling the new operator with a default constructor

The first problem can be solved by adding a constraint on the template parameter. The following code will not compile because it does not include such a constraint:

class Badger<TBadgerCharacter>
{
    TBadgerCharacter _character;

    public Badger()
    {
        _character = new TBadgerCharacter();
    }

    public void HelloBadger()
    {
        // TODO: Call the Bark method on
        //       _character
    }
}

This code does not compile: TBadgerCharacter does not provide a default constructor

Here’s the code with the required constraint so that it will compile:

class Badger<TBadgerCharacter>
    where TBadgerCharacter : new()
{
    TBadgerCharacter _character;

    public Badger()
    {
        _character = new TBadgerCharacter();
    }

    public void HelloBadger()
    {
        // TODO: Call the Bark method on
        //       _character
    }
}

This code does compile: The new() constraint requires TBadgerCharacter to provide a default constructor

Enabling the Bark() method with a type constraint

To enable the Bark() method on TBadgerCharacter there are two requirements. Firstly, a class or interface that declares the Bark() method must be created. Secondly, a constraint must be added to require a compatible type. Here’s the first part of the solution:

interface IBadgerCharacter
{
    void Bark();
}

The first step is to create a class or interface that provides the required method. This pattern of creating an interface for a generic type parameter is very common and good practice.

The next step is to require the constraint. Here’s the code beforehand:

interface IBadgerCharacter
{
    void Bark();
}

class Badger<TBadgerCharacter>
    where TBadgerCharacter : new()
{
    TBadgerCharacter _character;

    public Badger()
    {
        _character = new TBadgerCharacter();
    }

    public void HelloBadger()
    {
        _character.Bark();
    }
}

This code does not compile: The TBadgerCharacter type does not implement the IBadgerCharacter interface or provide a Bark() method.

Here’s the code with an appropriate constraint:

interface IBadgerCharacter
{
    void Bark();
}

class Badger<TBadgerCharacter>
    where TBadgerCharacter : IBadgerCharacter, new()
{
    TBadgerCharacter _character;

    public Badger()
    {
        _character = new TBadgerCharacter();
    }

    public void HelloBadger()
    {
        _character.Bark();
    }
}

This code does compile: The TBadgerCharacter type is required to implement a default constructor and also the IBadgerCharacter interface.

A final comment about constraints

Multiple constraints can be placed on a generic template parameter. These constraints fall into the following categories:

either or neither of a Value Type or Reference Type constraint
- use the class keyword for a reference type
- use the struct keyword for a value type
zero or more base class and/or interface implementation requirements
- for instance, the IBadgerCharacter interface in the above example
optionally a default constructor constraint
- use the new() keyword—the parentheses are required

These categories of constraint must be specified in the order shown. The order of individual classes and interfaces in the second category is not important.

Constraints on multiple generic template parameter types must be specified with completely separate where clauses.

Versions

Microsoft .NET Framework 2.0

Metadata

Categories: .NET, Software Development, Generics, C#
Additional keywords: generic template parameters, type constraints, example
Technorati Tags: .NET, software development, CSharp, C#, generics, type parameters, type constraints, example

.NET: Encapsulation, hiding and member binding in C#

Stephen Horsfield — Tue, 20 May 2008 09:30:33 GMT

I've been looking at the C# specification for the new keyword when used on a class member declaration and thought I'd share my findings. If you are a die-hard C# coder then you won't find anything new here, but of course that doesn't mean that you already know it! Maybe it would be better to check...

The basics

Encapsulation

Encapsulation is a term used in object-oriented design. It describes the idea of wrapping some functionality in an outer shell. The outer shell may contain significant functionality or it may just adapt the behaviour of the contained code.

Further, encapsulation protects the consumer of a class from needing to know about the internal operation of that class. It allows the programmer to code against a contract of function, rather than needing to know the detail of its implementation.

Binding modes and invocation

In C#, and in .NET in general, there are two modes of member binding and invocation. In this post, compile-time-binding means that the compiler determines what to use and runtime-binding means that the CLR determines what to use. This will be precisely defined in what follows, after introducing some other terms and keywords.

The "virtual" and "override" keywords

The virtual keyword is used to allow a derived class to change or specify the behaviour of the inherited class. This is usually used for methods but can also be used for properties. There are some constraints: the method signature must match. Additionally, in the inherited class the override keyword must be used to indicate that the method is intended to be an implementation of the virtual method.

The "new" keyword

The new keyword is used to indicate that a member of a derived class with the same name as a member of the inherited class has that name because the author intended to "hide" the member in the inherited class.

Note: the "new" and "override" keywords are mutually exclusive, however "new" and "virtual" can be used together.

Context

Virtual methods are used throughout the .NET framework. They allow you to extend the functionality of a class for specific cases. Sometimes though, a method or property that you would like to be marked as virtual is not. In these cases, the override keyword cannot be used.

The new keyword is not used frequently as it has the effect of hiding the member of the parent class, though with some important caveats that I'll come on to. Its main use is to simplify the use of the inherited class by "hiding" certain functionality.

A particular problem is when you wish to encapsulate some code over which you have no control. The question is then how to encapsulate the code efficiently, whether the issue is the performance of the solution or the time required to implement it. I recently posted about a specific example of this, using a ComboBox control to allow the selection of an enumeration value.

In detail

The virtual keyword indicates to the compiler that the invocation of a method should be bound at runtime. This is more expensive than compile-time-binding, and also prevents certain optimisations and so it is not the default behaviour. In every case that the virtual keyword is not specified and not implied (by a derived class using the override keyword, for example), compile-time-binding is used. Only the virtual keyword instructs the compiler to use runtime-binding.

How does runtime-binding work? In both compile-time-binding and runtime-binding, the compile determines the member to use on the basis of compile-time type information. Only the invocation is different. This is essential to a proper understanding of the virtual and new keywords, particularly when used together. The compile-time type of the object determines member selection.

What does this mean for us? This means that the member selected may differ depending on the declared type of the object. It means that the virtual keyword does not play any role in the selection of a type member to use.

So what does the virtual keyword do? The virtual keyword changes the invocation behaviour. When applied, the bound member is invoked on the derived type. For a non-virtual member, the member is invoked on the declared type.

What about the new keyword? The new keyword specifies that a new member with the same name exists in the derived type in addition to the pre-existing member of the inherited type. Using the new keyword adds an additional member to a derived type.

How does the new keyword interact with binding and invocation? It has no effect at all. In other words, if you declare a type as 'C' then the member will be bound against 'C'. The invocation will follow the normal rules, depending on whether it is marked as virtual or not. The declaration of the inherited type's member is irrelevant to this. The new keyword plays no part in the binding or invocation logic, it only extends the definition of the derived type with an additional member.

Some conclusions

The following conclusions can be drawn from this discussion:

The new keyword cannot impact the behaviour of an inherited type
- To change the behaviour, references must use the derived type explicitly
The new keyword cannot prevent access to a member of an inherited type
- The inherited type can be fully utilised when a reference to a derived type is first cast to the inherited type
The virtual keyword does not impact binding, only invocation
- All member binding in C# occurs at compile-time
The virtual keyword alone allows manipulation of behaviour by a derived class
- But it depends on the use of the virtual keyword in the inherited class which may not be within the same domain as the code being written (for example it may be a class from the .NET framework class library)
True encapsulation that can fully adapt the behaviour of a class requires one of the following models
- The class may be wrapped in an outer class that only exposes a subset of functionality, or else adapts the behaviour of exposed functionality
- A wholly new class may be developed
Software design is important
- Some decisions are difficult to change later, for example not using the virtual keyword

References

The C# Language Specification 3.0

Versions

Microsoft .NET Framework 3.5
Microsoft .NET Framework 2.0

Metadata

Categories: Software Development, .NET, C#
Additional keywords: .NET internals, virtual keyword, new keyword, binding, invocation
Technorati Tags: .NET, software development, CSharp, C#, compilation, .NET internals architecture, encapsulation, invocation, binding, virtual, new, hiding

.NET: Hacking events and manipulating delegates

Stephen Horsfield — Mon, 19 May 2008 15:28:42 GMT

Have you ever wanted to remove a handler from an event, but haven't had a reference to the object receiving the event, or perhaps you don't even know what type the object has! .NET hides the details of events but with a bit of help from the Reflection classes, you can edit the handlers for your own purposes.

Cautionary note

In general, this is a really, really, really bad thing to do! I'm writing about it partly because it is educational, and partly because it was an interesting problem to solve.

Behind the scenes of .NET events

I'm going to be using C# throughout this post, but the comments apply equally to those of you using Visual Basic .NET.

You declare an event in C# using the event keyword. In its simplest form it looks like the following:

public class EventClass
{
  public event EventHandler MyEvent;
}

The compiler converts this into four class members:

A private, instance field named MyEvent of type EventHandler (which is derived from System.MulticastDelegate)
A public, instance event named MyEvent of type EventHandler (which wraps the private field)
A public, instance method named add_MyEvent (to attach an event handler)
A public, instance method named remove_MyEvent (to remove an attached event handler)

To manipulate the handler list you need access to the private field. This cannot be accomplished using C# code directly. Instead, you need to use reflection to access the field.

Getting access to the private field

To get access to the private field, you need to use the reflection classes. In particular you need to specify that you want to bind to a non-public, instance field. This is achieved as follows:

// Add a using statement for System.Reflection
// Assumes an instance of EventClass called e
Type t = e.GetType();
FieldInfo f = t.GetField("MyEvent",
  BindingFlags.Instance |
  BindingFlags.NonPublic);

The name of the field will match the name of the event, in this case it is MyEvent.

Manipulating the handler list

The value of the field is either null or an instance of a MulticastDelegate. A MulticastDelegate wraps a list of System.Delegate instances. The list is ordered and so the order should also be preserved within any manipulation. MulticastDelegates are also immutable so we need to create a new MulticastDelegate with only those handlers we want to keep. The process is as follows:

Retrieve the current value of the private field
Check whether any handlers are currently attached
Get the list of Delegates currently attached
Create a new, filtered list of Delegates
Create a new MulticastDelegate using the filtered list of Delegates
Set the value of the field to the newly created MulticastDelegate

Step 1: Retrieve the current value of the private field

Retrieving the existing value is straightforward:

object originalValue = f.GetValue(e);

Step 2: Check whether any handlers are currently attached

The value of the field will be null if no handlers are attached, so wrap the remaining steps in a conditional block:

if (originalValue != null) {
    ...
}

Step 3: Get the list of Delegates currently attached

The value must be cast to the type System.MulticastDelegate. Then, the instance method GetInvocationList of MulticastDelegate can be used to get the list of attached handlers:

System.MulticastDelegate originalDelegate =
    (System.MulticastDelegate) originalValue;
System.Delegate[] originalHandlers =
    originalDelegate.GetInvocationList();

Step 4: Create a new, filtered list of Delegates

The following code illustrates how to remove all handlers registered by a class DelegateHacking.A. It has not been written particularly efficiently, but it demonstrates the process:

// requires: using System.Collections.Generic;
List<System.Delegate> newHandlers =
    new List<System.Delegate>();

foreach (System.Delegate handler in originalHandlers)
{
    // compare the type of the class containing
    // the event handler with a known type
    // to be filtered
    if (handler.Method.ReflectedType.Equals(
            typeof(DelegateHacking.A)))
    {
        // don't add any matches to the list
        continue;
    }
    // add the handler to the filtered list
    newHandlers.Add(handler);
}

Step 5: Create a new MulticastDelegate using the filtered list of Delegates

You cannot create a Delegate instance directly. Instead, you need to use the static methods of Delegate or MulticastDelegate. In this case, the Combine method of the MulticastDelegate class is used:

System.MulticastDelegate newValue =
    System.MulticastDelegate.Combine(
        newHandlers.ToArray());

Step 6: Set the value of the field to the newly created MulticastDelegate

This final step sets the value of the field to the new delegate. It is interesting to note that if the list of event handlers had been filtered completely, so that none were left, the value returned by MulticastDelegate.Combine would be null.

f.SetValue(e, newValue);

The manipulation in full

using System;
using System.Reflection;
using System.Collections.Generic;

public class EventClass
{
    public event EventHandler MyEvent;
}

public class Test
{
    public static void ManipulateHandlers(EventClass e)
    {
        Type t = e.GetType();
        FieldInfo f = t.GetField("MyEvent",
            BindingFlags.Instance |
            BindingFlags.NonPublic);

        object originalValue = f.GetValue(e);
        if (originalValue != null) {

            System.MulticastDelegate originalDelegate =
                (System.MulticastDelegate) originalValue;
            System.Delegate[] originalHandlers =
                originalDelegate.GetInvocationList();

            List<System.Delegate> newHandlers =
                new List<System.Delegate>();

            foreach (System.Delegate handler 
                        in originalHandlers)
            {
                // compare the type of the class containing
                // the event handler with a known type
                // to be filtered
                if (handler.Method.ReflectedType.Equals(
                        typeof(DelegateHacking.A)))
                {
                    // don't add any matches to the list
                    continue;
                }
                // add the handler to the filtered list
                newHandlers.Add(handler);
            }

            System.MulticastDelegate newValue =
                System.MulticastDelegate.Combine(
                    newHandlers.ToArray());

            f.SetValue(e, newValue);
        }
    }
}

Full example source code

You can download the code for a full console application example here (you'll need to rename it):

HackingDelegates.cs

Acknowledgements

http://netcode.ru/dotnet/?artID=6699 discusses delegates in detail and was helpful in constructing this post

Versions

Microsoft .NET Framework 2.0

Metadata

Categories: Software Development, .NET, Reflection, Events, Delegates
Additional keywords: event handlers, System.Delegate, System.MulticastDelegate
Technorati Tags: .NET, software development, CSharp, C#, reflection, delegates, events, .NET internals

.NET: Literals and expressions in the C# Language

Stephen Horsfield — Sat, 17 May 2008 10:28:27 GMT

Overview

I was recently asked why some expressions didn't seem to be doing what the developer intended. Typically, this was due to the use of the short or byte data types. This post is a brief discussion on the related parts of the C# Language Specification (version 3.0).

Reference

You can find the C# Language Specification here:

Download it here: C# Language Specification 3.0 (MSDN)

Note that page references in this post may vary slightly from your view of the document due to printable page size differences on your computer.

Introducing literals

(pages 40-45 of the specification for those interested)

When you write a constant string or number in a C# program, you are defining a “literal”. The value of the expression is “literally equivalent” to the code. Here are some literals:

“a string”	textual string
5	integer number
2.750	real number
true	boolean value
‘C’	character literal

I’ve been careful to avoid using the C# types for this, because there is a bit more to know in the numeric cases.

Firstly, you can only define the following numeric literal values directly:

int
uint
long
ulong
float
double (default for real numbers)
decimal

Further, the type of literal can be specified with suffixes (case-insensitive) as follows:

u	unsigned (cannot be negative — only for integer literals)
l	long (as opposed to int type — only for integer literals)
d	double (double type — for real literals)
f	float (float type — for real literals)
m	decimal (or money type — for real literals)

If the number does not include an exponent or a decimal point (with following digits) then the suffix is required to indicate a real number.

For an integer literal without a suffix, the type of the constant is the first integer type that can correctly represent the literal from the above list.

Note there are some exceptions to these rules that won’t generally affect you. Read the documentation if you want to find out more.

Secondly, some types cannot be directly defined as literal values:

byte
sbyte
short
ushort

Literal assignments to these types work only when the compiler can deduce that the result is acceptable, otherwise normal implicit conversion rules apply.

Understanding assignments

(pages 218ff.)

The next part of our problem is the assignment operator. In its simplest form, the assignment operator looks as follows:

X = Y

The compiler first determines the variable represented by the expression X. Then it works out the value of Y. Finally it attempts to store the value of Y in X, performing any needed implicit conversions.

Why is this important? The expression Y may not have the same type as X. In particular, there may not be an implicit narrowing conversion to X.

Here’s an example:

short x = 5;

short y = x + 5;

This will not compile. Why? Because the 5 has forced a widening conversion on “x” resulting in an “int” type expression. This can’t be converted to a “short” implicitly.

However, the compiler does perform constant coalescing. This means that a constant expression can be combined into a single constant. Additional rules are also applied to allow narrowing assignments that do not result in a loss of data. For example,

short y = 5 + 5;

This statement does compile and executes correctly. The following statement does not:

short y = 1000 * 1000;

The compile error given is: Error Constant value '1000000' cannot be converted to a 'short'.

Understanding expressions

(pages 129ff.)

Expressions are (mostly) evaluated from left to right. Different operators have different precedences too, so a multiplication takes priority over an addition. Each sub expression is evaluated in turn until the entire expression has been computed. Notice that it will perform widening conversions as needed along the way which may give you unexpected behaviour.

To see an example of this working as you might expect, have a look here:

http://msdn.microsoft.com/en-us/library/3b1ff23f.aspx

Versions

Microsoft .NET Framework 3.5
Microsoft .NET Framework 2.0
C# Language Specification 3.0
C# Language Specification 2.0
Visual Studio 2005/8

Metadata

Categories: Software Development, .NET, C#
Additional keywords: language intrinsics, expressions, assignments, conversions
Technorati Tags: .NET, software development, CSharp, C#, expressions, assignments, compilation, conversion, data types, literals

.NET: Enumeration Selector Controls

Stephen Horsfield — Thu, 15 May 2008 08:14:02 GMT

Overview

I'm in the process of writing a Visual Studio template extension to automate the creation of Windows Communication Foundation components. As part of the Wizard, I want to allow users to configure options based on various enumerations. To help with this, I've developed a generic control that extends a ComboBox to manage a set of allowed values automatically. This way, the same code can be used with any .NET enumeration type.

I've coded it as a generic type but it would be just as easy to use a runtime-provided type for the functionality. Indeed, it already uses Reflection to check that the type is an enumeration.

Solution overview

The code derives a class from ComboBox with the following properties:

The control is a generic class that requires a value-type (struct) as a template parameter
The control can (optionally) allow non-selection using a Nullable<T> value
The control hides the internal Items collection to prevent unintentional manipulation of the collection
The control does not provide localisation or pretty names, but this is simple to add
The control can be used directly in place of an existing ComboBox control
Specific implementations can be created by derivation and used immediately

Class definition

The class definition is as follows:

class EnumerationSelectorControl<T> : ComboBox
    where T : struct
{
    public bool AllowNull { ... }
    public Nullable<T> Value { ... }
    public new ObjectCollection Items { get { throw new NotSupportedException(); } }
    
    public EnumerationSelectorControl() : base()
    {
        ...
    }

    private struct NullMember { ... }
    private struct EnumMember { ... }
}

As always, the implementation is the interesting part.

Firstly, note how the Items collection is hidden to the casual observer.

Secondly, the ComboBox Items collection is populated in the constructor using a combination of the NullMember and EnumMember types. These types allow the separation of item value and item display. The AllowNull property manages the existence of a NullMember item in the collection, and the constructor populates the collection with instances of EnumMember based on the output of Enum.GetNames(typeof(T)).

The implementation of the Value property is responsible for conversion between types and must take into account the value of AllowNull. It is also responsible for selecting the appropriate item in the collection.

I'll leave the complete implementation as an exercise for the reader. Once complete, you can define an enumeration-linked ComboBox as follows:

class ProtectionLevelControl :
  EnumerationSelectorControl<global::System.Net.ProtectionLevel>
{}

Versions

Microsoft .NET Framework 2.0

Metadata

Categories: Generics, Enumerations, Software Development, Reflection
Additional keywords: ComboBox, enumeration selector, control development
Technorati Tags: .NET, software development, control development, reflection, generics, enumerations