I have a service contract with about 40 operations. After adding a new method to the contract, I get an error from the WCF Test Client:

Error: Cannot obtain Metadata from http://localhost:8731/Design_Time_Addresses/CDA.Services/ApplicationService/mex If this is a Windows (R) Communication Foundation service to which you have access, please check that you have enabled metadata publishing at the specified address.  For help enabling metadata publishing, please refer to the MSDN documentation at http://go.microsoft.com/fwlink/?LinkId=65455.WS-Metadata Exchange Error    URI: http://localhost:8731/Design_Time_Addresses/CDA.Services/ApplicationService/mex    Metadata contains a reference that cannot be resolved: ‘http://localhost:8731/Design_Time_Addresses/CDA.Services/ApplicationService/mex’.    There is an error in XML document (1, 110009).    The value for the ‘base’ attribute is invalid - ‘q1:EntityObject’ is an invalid value for the ‘base’ attribute..HTTP GET Error    URI: http://localhost:8731/Design_Time_Addresses/CDA.Services/ApplicationService/mex    There was an error downloading ‘http://localhost:8731/Design_Time_Addresses/CDA.Services/ApplicationService/mex’.    The request failed with HTTP status 400: Bad Request.

Same error if i attempt to add this service to a project. The message seems to change depending on which method I leave out, or put in. It seems to be getting hilarious, but it’s not. Accidentally, i got this error(truncated):

There is an error in XML document The maximum nametable character count quota (16384) has been exceeded while reading XML data.

After a bit of searching online, I found out that this is a recognized issue with the default metadata exchange binding, here. The workarounds didn’t look good at all to me, so I continued searching. Then, I came across this, which looks a lot more promising.

I created a custom wsHttpBinding that I used for the meta data contract. Now the task was to get the Visual Studio IDE and the WCF Test Client to use this binding when adding or updating a service reference. In order for this, corresponding bindings must be configured for each tool, in its .exe.config file. The binding must be identical with the one on the service side, and it must have a name that corresponds to the protocol used by it (http, https, net.tcp).

There are 3 places(files) that need to be updated: devenv.exe.config, WcfTestClient.exe.config and SvcUtil.exe.config. Actually, if you have several versions of the Windows SDK installed, you might have more than 3 places to modify. My advice is to do a search for each of the config file names and change as many of them as required in order to get your work back on track.

I would have thought that the mexHttp(s)Binding would allow for custom quotas for the reader. Perhaps in .NET 4.0? (vote here if it hurts)

The role of the Communication Broker is to cover the communication with the Streaming Service. By doing so, the code required of client applications is simplified, and less duplicate code will be generated for each application using the system. the broker also caches all variable changes and periodically sends all changes accumulated to the service, thus reducing the number of calls per second required by a single client to a predictable amount.

The broker uses a synchronized queue to accumulate changes and a timer to periodically clear the queue and send the resulting TimeSlice to the Streaming service. A receive background worker is used to reconstruct changes received from the Streaming service and raise appropriate UpdateProperty events.

The main operations provided by the broker are:

Start: used to start the processing of the broker by registering with the Streaming service. If the game is run in broadcast mode, this method starts the timer for the periodical TimeSlice send. If in observer mode, the broker requests the whole state from the Streaming service and raises the UpdateGameState event, to allow the application to initialize its state.

Stop: used to stop broker processing and to unregister from the Streaming service.

The events exposed by the broker are UpdateProperty, UpdateGameState and OutOfSynch. The first two events are to be sued by the application to change the value of a single property, or of all properties controlled by the XNA Streaming system. The OutOfSynch event is raised whenever the intervals between two consecutive slices do not match. The application can decide what to do at this point; for example, it could ask for the whole state of the game from the broker, which in turn would make the request to the Streaming service.

The application has to implement the GetCurrentState method of the IObservableGame interface in order to provide the broker with the current state of the application when needed.

Considerations for Writing Applications

There are some aspects that have to be taken into account when writing or adapting applications that use the XNA Streaming system.

User input has to be converted to changes of values. For example, mouse movement in a 3D environment can be translated into a set of 3 camera angles that completely define the way the camera is pointing. Pressing a button can be translated into a boolean flag set to true.

For simplicity, (most) user input should be ignored when in observe mode in order to avoid conflicts in UI commands that could have unpredictable effects.

One should take into careful consideration whether a piece of information is a “user input” variable, or a result of a law being applied to an initial value. Variables that are not broadcast have a high chance of being out of synch between the broadcaster and the observers. If the effect of such a variable is not critical (e.g. hit/miss decision) then it can be left out of the TimeSlice. Otherwise, one might discover that it is possible to miss a target, but hit it at the replay.

Results

The resulting prototype of the XNA Streaming system was presented at the 2008 edition of the Romanian Microsoft Community Bootcamp.

Conclusion

The XNA Streaming system is a good first prototype or toy, but it is by no means a decent communication framework. Aspects such as security, collaboration, dynamic send permissions, multicast, unicast and data conflict resolution have to be solved in order to obtain a communication framework.

The information is encoded in (<property name>, <value>) pairs. All serializable data types are supported for values. Users register with the Stream Service either as Broadcaster or as Observer. After this step, the Broadcaster uses the service to send updates for information (property-value pairs). Observers get notified by the service of the updated information via a IXNAStreamCallback callback contract, a feature of WCF services.

Updates for a certain variable can occur at a very high frequency (camera angle in a 3D application). If a separate call to the service would be generated every few milliseconds, then the service would easily become overwhelmed by the calls. The solution chosen is to “buffer” several information changes and send them all at time, at set time intervals. We name this “buffer” a TimeSlice. A time slice has a Duration and several time slice entries. A TimeSliceEntry has a PropertyName, a Value and a SliceOffset, used to express the time since the beginning of the TimeSlice when the value change has occurred. This way we gain control over the number of calls made to the service.

The Stream Service provides the following operations:

RegisterCallback: used to register with an application (given by name) for a role (given as a member of a GameMode enumeration). Only one Broadcaster can exist. This operation involves storing a user’s callback interface instance in a dictionary that has the application’s name as key and a list of callback interfaces (IXNAStreamCallback) instances.

UnregisterCallback: used to safely end a registration with an application (if a client does not unregister, sending updates or requesting the overall state would fail).

UpdateStateVariables: used to send a TimeSlice to all subscribers of an application. This is the actual method that performs the broadcast. It uses a method defined in the callback contract to broadcast the TimeSlice to all registered clients except the broadcaster.

GetCurrentState: to be used by an Observer in order to resynchronize with the broadcaster. This method should be called right after registering with an application. The GameState returned is a collection of game state entries. Each GameStateEntry contains a Key (the name of the variable) and a Value. The Stream Service request the current GameState from the Broadcaster via the callback contract.

The IXNAStreamCallback contract contains the following operations:

StateVariablesChanged: service calls this method for Observers whenever it receives a TimeSlice from the Broadcaster. It is up to the client to reconstruct the information changes in the TimeSlice with proper timing.

GetCurrentState: service calls this method for the Broadcaster whenever it receives a corresponding request from an Observer. The method returns the current GameState.

The Stream Service does not provide complex functionality, in order to make the actual information broadcast as fast as possible. The more complex functionality is implemented in the Communication Broker, that will be described in the next part of the series.

The main responsibility of the File Transfer Service is to provide access to streamable games. The service stores the game files in a database table, together with their relative file paths. This way the file system structure can be recreated when downloading the game. The game’s name, author and a short description are also stored in another table.

The operations that the File Transfer Service supports are:

• Create a game with no files: This operation simply creates a game entity with the game’s name, author and description with no files.
• Upload a file for an already created game: This operation stores a file together with it’s relative path to the game’s folder for a previously created game. This operation gets invoked for each file in a game’s folder.
• Delete a game: Removes a game from the database together with its files.
• Get all uploaded games: This operation returns a collection of general information about uploaded games (game name, uploader and description).
• Get all relative file paths for a game: This operation returns a collection containing the relative paths for all the files of a game. This list can be used to download each file and save locally.
• Download a file from a game: This operation downloads a file specified by the game to which it belongs and its relative path to the game folder.
• Get start up information for a game: This operation returns the game’s name, which is used to identify the streamed game at runtime, the address and endpoint name for the Streaming service. This information is used to start a game, both in observe or in broadcast mode.

The download/upload of each file takes place through streaming. This limits the in memory portion of a potentially large file at any moment to the size of the buffer of the stream. Stream parameters and return values are a feature of WCF services.

The File Streaming Service has as UI an XBAP that helps in uploading, downloading and starting a game.

As I mentioned in my previous post, at this year’s Microsoft Community Bootcamp I entered in the demo competition together with Adi. We’ve had some issues in the past with (cheap) broadcasting of presentations. There are plenty of professional tools out there that accomplish this goal, but that’s not my point. My point is that I have not yet found a cheap (free) utility that will allow me to give a presentation to several viewers that may not be in the same room (or the screen isn’t big enough for the whole audience).

Given this background, Adi proposed we create a way in which several people can see the same thing that a broadcaster transmits. Further, the “thing” that everyone sees is actually an XNA game, that could might as well be an interactive presentation in 3D.

Description

The main idea is that, given an XNA game (possibly a game that did not take into consideration broadcasting though our “system”), produce a mechanism such that a broadcaster can transmit the content on the screen to any number of observers. As infrastructure for communication a WCF service was chosen. The reason for this is because it is relatively quick to implement and set up, it supports binary protocols and also bidirectional, asynchronous communication via service callbacks.

The first idea that comes to mind when deciding what to broadcast is whole images, pixel by pixel. The trouble with this is that if we have an application with resolution of 800×600 pixels, 32 bit color depth, at 60 frames/second, then we would require at least 109 MBytes/second/observer. This is totally unacceptable. Even with video compression, it would still require substantial bandwidth.

Instead, we decided that we could reduce the whole state of a game to a few state variables and a few “laws” that govern how these state variables evolve in time. Transmitting only some state variables proves to require much less bandwidth than transmitting the whole image. To further reduce the size of the messages transmitted, we identified 2 categories of state variables: the ones that are directly influenced by a user (through keyboard input for example), and the ones that have an initial value, and a law that dictates it’s evolution in time. The state variables that evolve independent of user input can be left out of the “frame-by-frame” transmissions, and just the initial value has to be transmitted.

XNA Streaming Components

Given the initial description of the system proposed, we decided initially on three components:

The Streaming Service, that would receive calls from the broadcaster when state variables change and then transmit those changes through callbacks to all the subscribed observers. Aside from this main communication channel, the Streaming Service also provides initial synchronization for observers, meaning the service prompts the broadcaster (through a callback) to send the whole game state each time a new observer connects.

The File Transfer Service is responsible for storing all “broadcastable” game binaries,  delivering them to clients and providing startup information for each game (Streaming Service address).

The actual game, which has to be able to run in two modes: broadcast and observer. The game makes service calls to transmit/request state variables and responds to the callbacks of the Streaming Service.

At this point we analysed the communication between the game and the Streaming Service. Everything seemed fine, except for one detail: if we have a camera component that provides tens if not hundreds of new values every second, and we take into consideration that we have more than just the camera in a game, we can see that the number of service method calls performed by the broadcaster to transmit state variable changes is in the order of hundreds (at least) per second. This will cripple the service, regardless of the hardware it runs on (provided we stick to the “cheap” area…). A way to seriously cut down the number of service method calls was needed.

One way to reduce the service calls is to buffer the state variable changes, i.e. store each value together with the time at which the change occurred, and after a specific amount of time, send all buffered variable changes to the service, which in turn redistributes them to the observers, which reconstruct the sequence of state variable changes using the information received and timers. We call each such buffer a TimeSlice, and a touple of the form <VarName, VarValue, TimeSpan> a SliceEntry, where the TimeSpan is the time interval passed since the beginning of the current TimeSlice.

At this point we decided to call the new component a CommunicationBroker. It became clear that all code that would involve the Streaming Service would now be placed in the CommunicationBroker, and that sending calls/responding to the Streaming Service can be abstracted through this broker. In fact we now obtained an XNA Streaming Framework. This significantly reduces the complexity of the code that is necessary in the streamed game. Further more, now we had an actual streaming part, we stream the variable changes.

This is the end of part one of the article. In subsequent parts, I will describe each component in more detail and present some preliminary test results.

We all received a book on blogging and one on how to overcome disadvantages that prevent you from continuing your path on the road to (more) success (yes, it sounds a bit cheesy, but the book might be insightful). Keeping the inspirational note, the event’s T-shirt featured Microsoft’s Blue Monster, and the attached slogan: "Change the world or go home".

The first day was dedicated to MSP presentations. We started with some laughs as each university team lead stepped up and presented last year’s achievements in a rather "fashionable" way…

An interesting point was the demo competition. Myself and Adi participated with a project named XNA Streaming (Cata will, again, correct me into saying it’s XNA Framework Content Streaming) that uses WCF to transmit a set of data from one XNA Framework application to another one, the aim being to obtain the same "content" on each machine. I’ll get back with a post on how we did it (for real this time ). The only competition was Mihai Nadas, with Acoustic Fingerprints. The two ideas were really nice (as nice as the one that won last year’s competition), but I was a bit disappointed by the lack of competition. The outcome? Both projects were declared winners, and each won an XBOX 360 for their MSP team.

The rest of the day was filled with more presentations on being a good technology evangelist. No fun in the first day… well, at least not "organized" fun. We managed to spread across the hotel’s lobby and use it’s wireless network to play some LAN games in the evening.

Saturday morning there was a common session for MSPs and professionals on where Microsoft is going in the next year. After lunch, we had a bit of luck as the rain stopped and we went "out in the open" for some ATV, horseback riding, biking and Tyrolean traverse. Things went ok, considering it got quite cold, I had to ride a 700cc ATV with no helmet and one ATV crashed by tumbling through the air (I’m not kidding) and into someone’s yard, but no one got (seriously) hurt.

In the evening, we had a few games of Mafia. It’s quite a tradition at the Community Bootcamp, possibly because there’s never a shortage in supply of great players. It was my first time playing the game and I enjoyed it.

On the last day, each team had a private talk with the academic program leader, Todi. After that, we had lunch and went home tired, but (at least a bit) happier…

The main attraction for (part) of our university’s team were the squirrels in the park near our hotel. Apparently all Romanian squirrels answer to the name of Mariana, and they come to feed if you start making noise by knocking 2 nuts against each other. I can say that the squirrels respond well to food, as for the Mariana part… I’m not so convinced. Or maybe it’s (somehow) my fault that they wouldn’t answer my calls.

Some while ago I did a post on how to create a Vista Sidebar gadget using JavaScript. I also mentioned that I tried to create the gadget using XBAP or Silverlight, but due to the limitations in those technologies at that time, I decided that I had to give up on too much of the Sidebar gadget specific functionality (flyouts, cross domain data retrieval).

More than 6 months have passed since then and now I am pleased to announce that I’ve changed my opinion regarding Silverlight Sidebar gadgets. Due to the fact that the Silverlight technology has matured a lot (version 2.0 beta 2 is now available), Sidebar gadgets can be developed using this technology, without sacrificing any Sidebar gadget specific functionality. This is due to the fact that there is full interoperability between Silverlight and the JavaScript code. Also, cross domain calls are now allowed in Silverlight, so retrieving data is no longer an issue. Furthermore, it has been greatly enhanced due to the fact that one can consume WCF services using Silverlight.

Getting Started

The first step is to have a look over the "classic" way of developing Sidebar gadgets. Even though most of the "hard work" can now be done in Silverlight, the "wiring", the guts of the whole gadget are still the classic ones, relying on JavaScript and HTML. Next, if you are not familiar with Silverlight development, I recommend you spend some time getting comfortable with Silverlight. For this you can visit http://www.silverlight.net and try out the tutorials there.

The result of my inquiries in this subject is a Visual Studio project template that can be used to quickly start development for a Silverlight Sidebar gadget. I got inspired by the template Tim Heuer has created for jump starting Sidebar gadget development using just JavaScript/HTML. The requirements for installing and using the template are:

• Microsoft Visual Studio 2008 (Standard or better)
• Microsoft Silverlight 2.0 beta 2
• Silverlight Tools Beta 2 for Visual Studio 2008

After downloading the template installer from here, in order to install it, just run the downloaded file. The Visual Studio Content Installer will handle the rest (click next and ignore security warnings, because I did not sign the template).

After installing the template, in order to create a new Sidebar gadget, in Visual Studio click File->New->Project. You will notice that under the C# node, at the bottom, under "My Templates", a new entry has appeared: "Silverlight Sidebar Gadget". Give the solution a name and then click Ok.

You will notice that 6 projects have been automatically added to the newly created solution: SilverlightSidebarGadgetWeb, SilverlightGadgetDocked, SilverlightGadgetUnDocked, SilverlightGadgetSettings, SilverlightGadgetFlyout and SilverlightGadgetUtilities. In order, these correspond to: the main gadget web site project that will actually end up being deployed (all content and code is added to this site), the Silverlight control that is displayed when the gadget is docked, the Silverlight control that is displayed when the gadget is undocked, the Silverlight control that is displayed on the settings page of the gadget, the Silverlight control that is displayed on the flyout page of the gadget and a utilities library for Silverlight, providing a managed code API for Sidebar gadgets. This API translates to calls in the JavaScript Sidebar Gadget API.

IMPORTANT: Due to limitations in the way the template is built, the Silverlight applications have to be added to the gadget’s main project manually. This can be done by going to the Property Pages for the website project, the Silverlight Applications tab and then click add for each additional Silverlight project. Clear the "Add a test page that references the control" checkbox, and make sure the "Enable Silverlight debugging"checkbox is checked if you want debugging capabilities for Silverlight. Silverlight and JavaScript simultaneous debugging is not possible at the current time (Silverlight debugging requires disabling Script debugging from IE).

In a later version of the project template this will no longer be required, but for that I have to add a custom Wizard to the project template that can prepare the projects in the template.

The code is commented, so I’m not going to cover it in detail. Also, for Sidebar gadget development guidance, read my previous post on the topic. The gadget is set up to use Silverlight controls for each page of the gadget. This is not required, and Silverlight controls can be removed from the project (along with their projects form the solution) as needed. There are 2 main classes defined in the SilverlightGadgetUtilities class: SilverlightGadget and SilverlightGadgetEvents. The first is used to access the JavaScript Sidebar Gadget API. The second is used to expose the JavaScript events related to a gadget as managed events in the Silverlight controls.

Known "bumps"

There are some things that will simply not work, no matter how hard you try to get them to work. Usually this is due to the fact that the current Sidebar gadget API or the gadget user experience provided by Microsoft does not allow it. These "hick-ups" are specified in the documentation comments of the classes or directly as comments.

Due to the fact that the Gadget JavaScript object does not allow attaching multiple event handlers for the same event, one must take care what event handler is registered for a particular event. Possible outcomes are: events that do not get triggered at all in the Silverlight controls, events that get triggered only in some Silverlight controls.

Due to the user experience with Sidebar gadgets, some events cannot be triggered in Silverlight controls: the Docked, Undocked events, all gadget events in the flyout, etc.

Some properties from the SilverlightGadget class are read-only even though the Sidebar gadget JavaScript API specifies that they are read-write. This is due to the fact that attempting to set those properties resulted in exceptions at runtime and those exceptions are most probably caused by the JavaScript API itself.

I tried to "discover" all such "bumps" that might appear and document them in the template directly. If there is something I missed or you have a question, please contact me or post a comment and I will try to modify the template to fix or document the issue. Also, any suggestions on improving this project template are welcomed.

I’m looking forward to seeing many Silverlight Sidebar gadgets being developed. If you create such a gadget using this project template, please let me know by posting a comment with a link to the Live Gallery page of the gadget or a link to a page describing it.

Once again, the link for the Visual Studio project template is displayed below.

FILE: SilverlightSidebarGadget.vsi

UPDATE: If you have Microsoft Visual Studio 2008 SP1 installed, you will need the Microsoft Visual Studio Tools Beta 2 for Visual Studio 2008 in order to be able to create Silverlight projects. This also means that you cannot use the provided template without installing the new version of the Silverlight Tools.

UPDATE 2: I’ve upgraded the projects in the template for Silverlight 3 Beta. The corresponding template can be found here.

UPDATE 3: I’ve created a version of the template for Silverlight 2 final. The corresponding template can be found here.

UPDATE 4: I’ve upgraded the projects in the template for Silverlight 3 RTW. The corresponding template can be found here.

UPDATE 5: I’ve created a version of the template using Visual Basic projects. The corresponding template can be found here.

UPDATE 6: I’ve created a version of the template for Visual Studio 2010, using the new extension format. The corresponding template can be found here.

Introduction

It is very common when entering a search string in a textbox to get a small list of valid search results that match the search string entered so far. This feature is called auto complete and it has been widely used in web pages and desktop applications alike.

From the developer’s point of view, the auto complete feature has been implemented as part of the TextBox control in Windows Forms. That being said, I had a bit of a surprise when I could not find the functionality in the Windows Presentation Foundation TextBox control. Upon further online searches on the matter, I discovered that, in fact, auto complete has not been implemented for textboxes in WPF. The purpose of this post is to suggest (no pun intended) an implementation for the missing feature.

Functional Description

The entity we wish to create is a WPF user control that can be instantiated both through Xaml and code (C# or VB). We can either inherit from TextBox and add properties and methods required for auto complete, or we can create a control that can "wire up" the auto complete feature for any targeted TextBox control. The first approach not recommended due to the fact that a ListBox must be added to a TextBox. I chose to follow the second approach, perhaps being inspired by the AutoCompleteExtender in the ASP.NET AJAX Control Toolkit and also because it requires minimum intervention on existing WPF code (no need to change the type of many TextBox controls). Also, I did not include the targeted TextBox inside the custom control, in order to be able to apply this functionality on already existing code. The variant with the TextBox included can be found here.

A finite number of suggestions should be displayed as soon as a minimum number of  characters are typed, and then the suggestion list should be updated with each new modification to the search string. The maximum number of suggestions displayed should be configurable by means of a property. The user should be able to highlight a suggestion using the up/down keys, and be able to select a suggestion by pressing Tab or Enter in order to set the text of the target TextBox to that value. The means by which the suggestions are returned (from a web service, or simple method, etc.) should be as configurable as possible.

Implementation

The starting point for the TextBoxAutoCompleteProvider is a UserControl. This control will contain a Popup (named pop) and a ListBox (named lstBox) inside the Popup. the Popup is used to hide and show the suggestions list next to the targeted TextBox.

The control will use dependency properties instead of classic properties in order to facilitate data binding. It will also implement the INotifyPropertyChanged interface in order to automatically update data bindings. A routed event named SelectionChanged is defined in order to be raised every time the selected suggestion changes.

The DisplayMemberPath and SelectedValuePath are strings representing properties available in the objects returned as suggestions. If the strings are empty or null, then the ToString method will be used. The SelectedItem and SelectedValue properties connect directly to their namesakes from the ListBox. The MovesFocus property determines whether the focus changes to the next control after selecting a suggestion. The MinTypedCharacters property sets the minimum length of the search string in order to start displaying suggestions. MaxResults controls the maximum number of suggestions to be displayed and AvailableSuggestions shows the number of suggestions currently displayed in the ListBox (it might be smaller than MaxResults).

SearchMethod is a delegate of type AutoCompleteEventHandler, used to store the method that will be called in order to obtain suggestions. The delegate signature takes the search string and the maximum number of results as parameters and returns a collection of objects. In order to be as least restrictive as possible, the type of collection returned is IEnumerable. By using a delegate, the source of the data behind the suggestions can be arbitrary (database, web service, memory objects, etc.).

The main property of the control is TargetControl, of type TextBox. Whenever the value of the property changes, the event handlers are removed from the old TextBox and added to the new one. The code for those event handlers, together with the code that makes the changes is displayed below.

   1: private static void TargetControl_Changed(DependencyObject d, DependencyPropertyChangedEventArgs e)

   2:         {

   3:             if (e.OldValue != e.NewValue)

   4:             {

   5:                 TextBoxAutoCompleteProvider me = d as TextBoxAutoCompleteProvider;

   6:                 TextBox oldv = e.OldValue as TextBox;

   7:                 TextBox newv = e.NewValue as TextBox;

   8:                 if (oldv != null)

   9:                 {

  10:                     oldv.LostFocus -= new RoutedEventHandler(me.TargetControl_LostFocus);

  11:                     oldv.GotFocus -= new RoutedEventHandler(me.TargetControl_GotFocus);

  12:                     oldv.KeyUp -= new KeyEventHandler(me.TargetControl_KeyUp);

  13:                     oldv.PreviewKeyUp -= new KeyEventHandler(me.TargetControl_PreviewKeyUp);

  14:                     oldv.PreviewKeyDown -= new KeyEventHandler(me.TargetControl_PreviewKeyDown);

  15:                     

  16:                 }

  17:                 if (newv != null)

  18:                 {

  19:                     me.pop.PlacementTarget = newv;

  20:                     newv.LostFocus += new RoutedEventHandler(me.TargetControl_LostFocus);

  21:                     newv.GotFocus += new RoutedEventHandler(me.TargetControl_GotFocus);

  22:                     newv.KeyUp += new KeyEventHandler(me.TargetControl_KeyUp);

  23:                     newv.PreviewKeyUp += new KeyEventHandler(me.TargetControl_PreviewKeyUp);

  24:                     newv.PreviewKeyDown += new KeyEventHandler(me.TargetControl_PreviewKeyDown);

  25:                 }

  26:             }

  27:         }

  28:  

  29:         private void TargetControl_PreviewKeyDown(object sender, KeyEventArgs e)

  30:         {

  31:             if (e.Key == Key.Tab && lstBox.SelectedItem != null)

  32:             {

  33:                 pop.IsOpen = false;

  34:                 TargetControl.Text = String.IsNullOrEmpty(DisplayMemberPath) ?

  35:                                      lstBox.SelectedItem.ToString() :

  36:                                      lstBox.SelectedItem.GetType().GetProperty(

  37:                                      DisplayMemberPath).GetValue(lstBox.SelectedItem, null).ToString();

  38:                 if (MovesFocus)

  39:                     TargetControl.MoveFocus(new TraversalRequest(FocusNavigationDirection.Next));

  40:                 e.Handled = true;

  41:             }

  42:         }

  43:  

  44:         private void TargetControl_PreviewKeyUp(object sender, KeyEventArgs e)

  45:         {

  46:             if (e.Key == Key.Escape)

  47:             {

  48:                 pop.IsOpen = false;

  49:                 lstBox.SelectedItem = null;

  50:                 e.Handled = true;

  51:             }

  52:             if (IsTextChangingKey(e.Key))

  53:             {

  54:                 Suggest();

  55:             }

  56:         }

  57:  

  58:         private bool IsTextChangingKey(Key key)

  59:         {

  60:             if (key == Key.Back || key == Key.Delete)

  61:                 return true;

  62:             else

  63:             {

  64:                 KeyConverter conv = new KeyConverter();

  65:                 string keyString = (string)conv.ConvertTo(key, typeof(string));

  66:  

  67:                 return keyString.Length == 1;

  68:             }

  69:         }

  70:  

  71:         private void TargetControl_KeyUp(object sender, KeyEventArgs e)

  72:         {

  73:             if (e.Key == Key.Up)

  74:             {

  75:                 if (lstBox.SelectedIndex > 0)

  76:                 {

  77:                     lstBox.SelectedIndex--;

  78:                 }

  79:             }

  80:             if (e.Key == Key.Down)

  81:             {

  82:                 if (lstBox.SelectedIndex < lstBox.Items.Count - 1)

  83:                 {

  84:                     lstBox.SelectedIndex++;

  85:                 }

  86:             }

  87:             if (e.Key == Key.Enter)

  88:             {

  89:                 SetTextAndHide();

  90:             }

  91:         }

  92:  

  93:         private void SetTextAndHide()

  94:         {

  95:             pop.IsOpen = false;

  96:             if (lstBox.SelectedItem != null)

  97:             {

  98:                 TargetControl.Text = String.IsNullOrEmpty(DisplayMemberPath) ?

  99:                                      lstBox.SelectedItem.ToString() :

 100:                                      lstBox.SelectedItem.GetType().GetProperty(

 101:                                         DisplayMemberPath).GetValue(lstBox.SelectedItem, null).ToString();

 102:                 itemsSelected = true;

 103:                 if (MovesFocus)

 104:                     TargetControl.MoveFocus(new TraversalRequest(FocusNavigationDirection.Next));

 105:             }

 106:         }

 107:  

 108:         private void TargetControl_GotFocus(object sender, RoutedEventArgs e)

 109:         {

 110:             if (itemsSelected)

 111:                 itemsSelected = false;

 112:             else Suggest();

 113:         }

 114:  

 115:         private void TargetControl_LostFocus(object sender, RoutedEventArgs e)

 116:         {

 117:             if (!pop.IsKeyboardFocusWithin)

 118:                 pop.IsOpen = false;

 119:         }

 120:  

 121:         private void Suggest()

 122:         {

 123:             // Skip if TargetControl are not defined or if not enough characters typed

 124:             if (TargetControl == null) return;

 125:             if (TargetControl.Text.Length < MinTypedCharacters)

 126:             {

 127:                 pop.IsOpen = false;

 128:                 lstBox.ItemsSource = null;

 129:                 return;

 130:             }

 131:             if (SearchMethod == null) throw new NullReferenceException("SeachMethod cannot be null.");

 132:  

 133:             IEnumerable res = SearchMethod(TargetControl.Text, MaxResults);

 134:  

 135:             lstBox.ItemsSource = res;

 136:             if (lstBox.Items.Count > 0)

 137:             {

 138:                 lstBox.SelectedIndex = 0;

 139:             }

 140:  

 141:             pop.VerticalOffset = TargetControl.ActualHeight;

 142:             pop.IsOpen = true;

 143:         }

The private Suggest method gets called whenever the targeted TextBox receives the input focus, or the search string has changed as a result of user input. This method is responsible for invoking the method stored in the SearchMethod delegate if some conditions are met (minimum number of characters, Search method and TargetControl specified).

When a suggestion is selected (either by pressing Enter, Tab or by using the mouse), reflection is used to obtain the value of the property specified by DisplayMemberPath within the SelectedItem and to set the Text of the TextBox to this value. If DisplayMemberPath is empty or null, then the ToString method is used to fill in the TextBox.

The other properties defined by TextBoxAutoCompleteProvider offer customization options for the list of suggestions (ItemTemplate, ItemTemplateSelector, ItemsPanel).

Source code for the whole project, as well as a sample application can be found here.

Conclusion

The auto complete functionality is not difficult to implement, and by not extending the functionality of TextBox, applying auto complete to new and existing projects is easy. The only restriction is that one cannot specify the method to store in the SeachMethod delegate from Xaml code, only from C#(or VB.NET). Further development can be targeted at providing more customization properties for the suggestion list and at creating a converter from string to a delegate, in order to be able to specify the search method from Xaml code.

Update

After the feeback provided, I changed the control to allow selecting an option in the ListBox through mouse clicks. The new source code is available here. Tracking the position of the target control is not supported for the Popup control. An adorner would have to be used for this. If I find the time to redesign the control to use adorners, then I will publish the update.

Update 2

After Harry’s comment, I fixed a bug that would reset the SelectedIndex property on the list box. Also I exposed the SelectedIndex property. The new source code is available here.

Introduction

There always comes a time while developing an application when a programmer has to introduce some “constants”. These may be Id’s, names, time intervals. The first action is to just put the literal constant where it’s needed first.

Once the value of the constant is needed in additional places, a decision has to made: where to store the “constant”. The really bad answer would be to just reuse the literal constant. A better approach would be to create a “const” or “readonly” field with the required value. This is perfectly fine if the constant has a very little chance of changing it’s value (due to specifications change some of the constants may change). Changes to constants defined in this way can only be performed by recompiling the code and redistributing the new build.

Sometimes the probability of change for a “constant” is so high, that it actually becomes a “global variable” (even though it may continue to be called a “constant”). Recompiling the whole solution now becomes unfeasible.

In the following, I will propose a pattern to apply to some of these “unstable” “global constants”. I am referring to the constants that have a high probability of change and change only though one mechanism: by changing the requirements (for example, the maximum time interval during which a response for a client request must be sent). In other words, the application only reads the value of the constant.

The basic idea is to have a static class that holds all such “constants” either as fields or as properties. The values for the fields or properties should be loaded from a “source” before any of the constants are used. This source can be a file, a database, a web service, etc. The advantages of choosing a remote source for the values of the constants is that the application does not have to be versioned (have it’s version number increased and redistributed) just because a few constant values have changed. I will demonstrate the use of a SQL Server database table as a source for values.

The code for this article is written in C#, but it can easily be adapted to any .NET language. The required tools are Microsoft Visual Studio 2005 and SQL Server. “Express” versions of the two tools are the minimum required. The source code for the article can be found here. The solution was written in Visual Studio 2008. If you wish to use Visual Studio 2005, you can open the project file (.csproj) instead of the solution file (.sln).

The testing environment is simple: just a console application that prints the values of the defined constants. The constants are held in the GlobalConstants class.

static void Main(string[] args)

{

    Console.WriteLine("String constant value is {0}", GlobalConstants.StringProperty);

    Console.WriteLine("Numerical constant value is {0}", GlobalConstants.NumericalProperty);

    Console.WriteLine("DateTime constant value is {0}",GlobalConstants.DateTimeField);

}

Database Setup

The SQL Server Express database used is named ConstDatabase and is included with the project. The constant values are stored in the table ConstantTable. Each property has a Name(string), a Value(string) and a GUID (global unique identifier). The values are stored as strings and later converted into the required formats in the application. The GUIDs are used in order to refer to a constant in a “name independent” way. Also, the GUIDs avoid collisions with other identically named constants that may appear (when using several constant classes).

NOTE: You may need to change the connection string for the database from the one found in the source code archive.

Application Constant Initialization

We make use of a static constructor in order to ensure that the values of the constants are retrieved as soon as the class is loaded. The main idea is to set the value of the field(property) to the one found in the ConstantTable in the row that has a matching GUID. For this we need to map each field(property) to a GUID. A good way to do this is to create and use a custom attribute. The declarations of the constants would look like this:

private static string _stringProperty = "Default Value";

[DatabaseConstant("bfd5bf83-ed8a-4bcc-bbca-c97bf1b89182")]

public static string StringProperty

{

    get { return _stringProperty; }

    set { _stringProperty = value; }

}

private static decimal _numericalProperty = -1.0M;

[DatabaseConstant("e3a68ed7-5a7a-4987-b53e-bc61d04efa96")]

public static decimal NumericalProperty

{

    get { return _numericalProperty; }

    set { _numericalProperty = value; }

}

[DatabaseConstant("821b8fcb-d052-4039-967f-aa89229dcb95")]

public static DateTime DateTimeField = new DateTime();

The DatabaseConstant attribute receives a GUID either as a string or a Guid .NET structure. The point is to have the static constructor “look” at each field and property that the class defines and, for the ones that have the DatabaseConstant attribute applied, get the value from the database, convert it to the proper .NET type and store it in the field (property).

The code for the custom attribute can be found in the archive containing the whole source code for this article.

Note that, even though I mentioned that the values do not change in the application code, we need setters for the properties in order to be able to set the values from the database.

The static constructor uses reflection in order to get all the fields and properties that have the DatabaseConstant attribute applied and to set the values. The ChangeType method of the Convert class is used to convert the string value returned by the database to the type of the property, without specifying each conversion using a switch depending on the data type of the field (property).

static GlobalConstants()

{

    StringBuilder errors = new StringBuilder();

    try

    {

        FieldInfo[] fiarr = typeof(GlobalConstants).GetFields();

        foreach (FieldInfo fi in fiarr)

        {

            try

            {

                // Iterate through all the Attributes for each field.

                foreach (Attribute attr in

                    Attribute.GetCustomAttributes(fi))

                {

                    // Check for the DatabaseConstant attribute.

                    DatabaseConstantAttribute atr = attr as DatabaseConstantAttribute;

                    if (atr != null)

                    {

                        string cVal = GetDatabaseConstantValue(atr.GUID);

                        fi.SetValue(null, Convert.ChangeType(cVal, fi.FieldType));

                    }

                }

            }

            catch (Exception)

            {

                // fallback action

                errors.AppendFormat("Could not initialize constant {0} from the database. Fallback used.\n",

                                    fi.Name);

            }

        }

    }

    catch (Exception)

    {

        // fallback action

        Console.WriteLine("Could not initialize constants from database. Fallback values used.");

    }

    if (errors.Length > 0)

    {

        // log the errors

        Console.Write(errors);

    }

}

Reflection significantly reduces the amount of code needed to initialize every single field/property. The code for initializing the properties is the same as for the fields, except that we call GetProperties() and use PropertyInfo instead of FieldInfo. The GetDatabaseConstantValue is a simple method that uses a query to retrieve the value for the constant based on the GUID.

Error Handling

The advantages of remotely initializing constants have been covered. But there is also a serious drawback: what happens if for some reason the initialization fails? The database could be offline, the string stored values can be invalid for conversion (eg. numbers). As much as possible, we should have a backup set of values that could provide minimum reliability to the application (instead of just crashing, or reporting that the application cannot continue to run). Also, a logging feature would also be welcomed.

To do all these, try catch blocks are added around the initialization for each field/property, and for each call to the database. If the database call throws an exception, then there might be some connectivity issues. Otherwise, most likely a conversion error occurred. these errors are accumulated in the errors StringBuilder.

After the constructor finishes, if there are errors, they can be logged, or, in this case, displayed in the Console. It is a good practice to make sure that no exceptions will get thrown by the static constructor.

Conclusion

The pattern presented above provides a quick and convenient way to initialize global constants for an application. I am perfectly aware that there are several discussions to be had regarding constant initializations (error handling, complex constants, etc.). I would welcome these discussions, as well as alternative proposals in the comments section of this post.

Rock on.