Break it, fix it

DateTimePicker and DateTime.MaxValue

2011-08-08T14:51:00.000+02:00

For some unknown reason, the Winforms DateTimePicker control does not allow for dates higher than 9998-12-31. Trying to set the DateTimePicker MaxDate property of DateTime.MaxValue will result in an exception. This is a limitation imposed by the component itself.

Good news is there is a small trick to overcome this limitation. It requires to update the static MaxDateTime property to an arbitrary value (DateTime.MaxValue in our case). Lets put up some reflection code for that purpose:

var dtpType = typeof(DateTimePicker);

var field = dtpType.GetField("MaxDateTime", BindingFlags.Public | BindingFlags.Static);

if (field != null)

{

    field.SetValue(new DateTimePicker(), DateTime.MaxValue);

}

Just copy and paste this code into the startup method. Basically it needs to run before any DateTimePicker control is created.

Please note that running this code can have side effects because it is not known why this limitation is present in the first place. Use it at your own risk.

Create UserControl with inline content

2010-09-13T15:28:00.001+02:00

Let's say you want to create a user control that contains some literal text:

<uc1:InlineContent>
    This is some standard text message
</uc1:InlineContent>

Here is the simplest UserControl that matches this description:

using System.Web.UI;

[ParseChildren(ChildrenAsProperties = true,
               DefaultProperty = "Content")]
public partial class InlineContent : System.Web.UI.UserControl
{
    [PersistenceMode(
        PersistenceMode.EncodedInnerDefaultProperty)]
    public string Content { get; set; }
}

Adding a delay before processing Textbox events

2010-09-06T20:00:00.002+02:00

Typical scenario: You provide the user with a TextBox he can use to type a filter over a big chunk of data that takes a lot of time to process. Most of the time, you would handle the TextChanged event of the TextBox and issue a filter operation over the data source using the character(s) available in the TextBox. Typical problem: The user complains because he has to wait between the key strokes even if he already knows a filter that would allow the search to take place in a matter of a few seconds. Solution: Introduce a delay between the last key stroke and the processing using a timer. Walkthough: Create a new Winforms project with a Form. Add a TextBox (named textBox), a ListBox (named listBox). To mimic a very slow data source, we will create a dummy class:

public class VerySlowDataAccess
{
    private static string[] data = null;
    static VerySlowDataAccess()
    {
        data = new[]
        {
            "AAAAAA1", "AAAAAA2", "AAAAAA3", "AAAAAA4",
            "AAAAAA5", "AAAAAA6", "AAAAAA7", "BBBBBB1",
            "BBBBBB2", "BBBBBB3", "BBBBBB4", "BBBBBB5",
            "BBBBBB6", "BBBBBB7", "BBBBBB8"
        };
    }
    public static string[] GetItems(string filter)
    {
        Thread.Sleep(3000);
        return data.Where(d => d.StartsWith(filter)).ToArray();
    }
}

Now we can build our very simple form to highlight the concept. Go back the form, add a timer attribute using the System.Threading.Timer and not the System.Windows.Forms.Timer (very important).




private System.Threading.Timer timer;

Then create a thread safe method to populate the ListBox based on the textbox value. By thread-safe, I actually UI-thread safe.

public void LoadData() 
{
    if (this.InvokeRequired)
    {
        this.Invoke(new Action(LoadData));
    }
    else
    {
        this.listBox.Items.Clear();
        this.listBox.Items.AddRange(VerySlowDataAccess.GetItems(textBox.Text));
    } 
}

Next step is to initialize the timer in the Form constructor. We will hook it up with our LoadData method and set the timeout to Infinite to deactivate it (for now):

public MainForm()
{
    InitializeComponent();
    timer = new System.Threading.Timer((c) => LoadData(), null, Timeout.Infinite, Timeout.Infinite);
}

Last but not least, as you may expect, we will add the handler for the TextChanged event of the TextBox.


private void textBox_TextChanged(object sender, EventArgs e)
{
    // 250ms is the maximum time between key strokes before the delegate is called (LoadData in that case)
    timer.Change(250, Timeout.Infinite);
}

So, what is happening here? Basically what we do is simply reset the timer every time the text is changed. Then after the 250 ms delay and if no key was pressed, the delegate will be called, thus refreshing the ListBox. This works because we always set the timer's repeat time to Infinite, it will fire only once after a key stroke sequence. The delay is arbitrarily set to 250 ms. Based on my own experience, it is sufficient for a regular user (with Internet-grade typing skills) and it is not so long as to be noticeable. Possible improvements:

Prevent the load to be triggered again until it is finished. A thread-safe boolean in the LoadData method can do the job here.
Encapsulate all this behavior into a black-box control.

Visual Studio 2010 Training Kit

2010-02-02T21:14:00.004+01:00

For those who are looking for a good place to start with .NET 4.0 and Visual Studio 2010, you can download from Microsoft a complete training kit containing a whole lot of first class information about the next major .NET release and its sidekick. :)

Here is the link to the download page : http://www.microsoft.com/downloads/details.aspx?FamilyID=752CB725-969B-4732-A383-ED5740F02E93&displaylang=en

Things I love about Visual Studio 2010: IntelliTrace

2009-12-15T20:20:00.003+01:00

IntelliTrace is the next step in evolution for debuggers. It allows you to track everything that is happening during a debug session. It can track actions like clicking on a button, reading for a file, executing an ADO.NET call (including the actual call !) and a lot of other things.
You can think of IntelliTrace as some sort of log for all actions of the program.

You can also record the call stack for each event but it will slow down the debugging experience and you won't be able to use the "Edit and Continue" feature anymore, but it will allow to have much more details about the execution context of each event.

SSL problem when installing TFS 2010

2009-10-27T21:53:00.005+01:00

I had this error when trying to install TFS 2010 Beta 2 on a shiny new Windows Server 2008 R2 :

TFxxxxxx: SQL Server Reporting Services is configured to require a secure connection, however no HTTPS URL is configured with a valid certificate

So first thing was to remove the SSL binding from the report server (using the Reporting Services Configuration Manager), but it did not change anything from the TFS configuration checker point of view.
The fact is this checker does not care about whether SSL is actually in use for the report server, it simply checks IF SSL can be enabled in the report server. That means that you must completely disable SSL and this can only be done by modifying the .config file of the report server.

Just navigate to your report server folder (usually \MSRS10.MSSQLSERVER\Reporting Services\ReportServer), open the rsreportserver.config file for editing and locate the parameter named SecureConnectionLevel and set its value to 0 to deactivate security).

Re-run the configuration checker and it should not complain anymore.

Entity Framework 4.0 and POCO

2009-06-02T23:27:00.002+02:00

One of the thing that annoyed me most in Entity Framework 1.0 was the lack of support for POCO. I like to use a specific vertical layer for entities, and I like those entities to have only properties and to be POCO to say it simply. The problem in EF 1.0 is that entities are forced to inherit from a class. I could also use the IPOCO interfaces but it was a lot of code for little benefit.
The great thing I love in EF 4.0 (even if it is a beta) is that I can generate the edmx file without generating the classes. So basically, I have a EDMX file containing all the XML stuff (conceptual model, physical model and mappings) and I create my classes that Object Services will use. That way, I can put real POCOs in my entity layer.

This is an entity that I can create and use with EF (and the corresponding EDMX) :

public class Client
{
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public Address Address { get; set; }
}

EF will manage the related entities the same way it does with generated entities. That means, you can also benefit from the lazy-loading or deferred-loading mecanism, and change tracking.

As a side note, EF 4.0 nows supports complex types (even in the designer).

WCF tuning tips

2009-05-29T10:20:00.004+02:00

To obtain significantly better response time and decreased the load on the service, you apply a set of best practices depending on your needs.
1. If you do not need sessions in your services, you may want to disable them to reduce the memory consumption of the service.
2. If you are transfering large amounts of data between client and server, the minimum is to enable MTOM enconding. MTOM is an optimized encoding for transmitting binary data. And even better than MTOM, you can also use streaming for the data transfers. Streaming avoids loading the complete message in memory which is what happens when you do not use streaming. Performance will be vastly increased when dealing with large amounts of binary data.
3. If you have control over client and server, you may also want to choose a more efficient but less interoperable binding (like NetTcpBinding for example). This will avoid the overhead that comes with all the WS-* protocols.
4. Be carefull when modifying the instance and concurrency mode. A single instance and a single thread will avoid concurrency issues but will only serve one request at a time. Multiple instances and multiple threads per instances will enable much more requests to be processed simultaneously but it will need a really good concurrency management system. Depending on the constraints, the "good" solution lies between those two models.

These are the basic checks you can apply on your services.
Happy coding :)

Databinding and XtraReport

2009-05-14T07:48:00.003+02:00

I had a problem recently using object data sources in my XtraReports. I was assigning an object hierarchy to the DataSource property and was getting weird exceptions.
The problem is XtraReport does not handle well one object as a data source, it prefers to have a collection of objects.
The simple fix was to use a BindingSource as the data source and assign my object to the BindingSource's DataSource property. And yes, I should have been using a BindingSource from the start, I know :)

Some news about EF 4.0

2009-05-14T07:24:00.004+02:00

The ADO.NET team posted a list of the upcoming features of Entity Framework 4.0. We will get automatic lazy-loading, POCO and much more. This is definitely something you want to read.
Click on the title to read the complete article.

400 Bad Request when trying to add a Web Reference

2009-04-23T14:56:00.004+02:00

This morning, I had a hard time adding a Web Reference in my CF application pointing to a WCF service. I checked the service several times, re-built it several times as well, but each time I got a HTTP 400 Bad Request when clicking the "Go" button of the Add Web Reference wizard.
And then, I copied/pasted the URL one more time deleting the mex part at the end but leaving the ending slash. And it worked. I had removed the ending slash and thus caused this annoying behavior. I lost 5 minutes over such a stupid problem...

Hope it will help one of you someday :)

Accessing a WCF service using Compact Framework

2009-04-22T20:36:00.002+02:00

A few constraints when connecting to a WCF service from a Compact Framework application :

The binding must be set to basicHttpBinding, CF does not know what to do with a wsHttpBinding.
The XmlSerializerFormat attribute must be set on the service contract, the default WCF serialization is not suitable for the CF. It would throw an exception when deserializing.
Make sure you configure your endpoints correctly, "localhost" is not accessible from the mobile device (emulated or not), you can use ppp_peer as the hostname in the CF WCF proxy (a lot of CFs, I know).

Happy CF coding :)

Change the deployment URL of a ClickOnce application

2009-04-10T17:12:00.002+02:00

I use ClickOnce everyday for several internal applications. Recently, I had to move the publishing website to a new host.
Here is how you can acheive a completely transparent move without annoying your users or forcing them to uninstall and reinstall the application.

First, you need to publish the deployment files on the new server. The deployment configuration is as follows :

Publishing folder : URL on the new server
Installation Folder : URL on the new server
Updates Folder : URL on the new server
Revision : last revision + 2 (very important)

Then you need to deploy a new version on the old server with an updates folder on the new server. This way, next time the application launches, it will get the new version from the new server, and voila. Here is the configuration for the last deployment on the old server :

Publishing folder : URL on the old server
Installation Folder : URL on the old server
Updates Folder : URL on the new server
Revision : last revision + 1 (very important)

Enjoy :)

Migrate a SVN repository using VisualSVN Server

2009-04-10T14:15:00.003+02:00

Today, I needed to relocate a SVN repository to a fancy new virtual server. I was planning on painful command lines and dumps and all the nerdy stuff. But in fact migrating using VisualSVN Server was surprisingly easy.
First I installed VisualSVN Server on the new host, then stopped the service on the old host. I copied the repositories files from the old server to the new one. And started the service after doing a little configuration (svn address, authentication mode, etc.). And then, I relocated my working copies using the svn relocate command (from TortoiseSVN).

Could it be easier ? I don't think so.
Happy source control :)

Code Contracts

2009-03-19T20:25:00.003+01:00

A few days ago I discovered Code Contracts. It is a tool and a framework that enables us to define constraints on parameters and return values.
For example, here is a simple code :

///<summary>
/// Dummy base class
/// </summary>
public class Entity
{
}

/// <summary>
/// Simple cache
/// </summary>
static class Cache
{
private static Dictionary<int,Entity> cachedEntities = new Dictionary<int,Entity>();

public static Entity GetCachedEntity(int entityId)
{
Contract.Requires(cachedEntities.Keys.Contains(entityId));
Contract.Ensures(Contract.Result<Entity>() != null);

return cachedEntities[entityId];
}

// ...
}

Notice the use of the Contract class (in the System.Diagnostics.Contracts namespace of the Microsoft.Code Contracts assembly). This class contains methods that we can use to define input constraints (Requires) and output constraints (Ensures).
The Code Contracts framework can perform a static analysis at compile time, and verify if the callers satisfy the requirements. It can also inject code into the method to enable dynamic constraint checking. If a constraint is not satisfied, a ContractException will be thrown at runtime.
This is configurable from the properties of the project in Visual Studio (for example).

TechDays 2009

2009-03-12T23:14:00.004+01:00

I just came back from the TechDays in Belgium and I saw some truly amazing things coming soon (some are in CTP) like from example :

Windows Azure,
PEX,
Code Contracts,
C# 4.0 and dynamic programing
Geneva,
and many more.

The one that I found the most interesting was the Geneva Framework/Server for claims based authentication and federated security.

I also got to play (a little) with Microsoft Surface and the only word that can describe it is "Uber-cool" (and expensive unfortunately) :)

Simple file content summary

2009-02-25T23:07:00.005+01:00

A few days ago, I was reviewing some old samples to teach C# and I came across one that instructed the user to write a simple program. The goal was to read a text file and display on the Console a small summary containing, for example, the number of characters and the number of lines. The solution provided for this exercise was to iterate over the content of the file character by character and increment a few counters based of Char.IsSomething tests.

Here is a much cooler way to do that using a LINQ query :

string content = File.ReadAllText(path);

var contentByGroups =
from c in content
group c by Char.GetUnicodeCategory(c) into groups
select new { Category = groups.Key,
Count = groups.Count() };

foreach (var group in contentByGroups)
{
Console.WriteLine("Category {0} : {1}",
group.Category,
group.Count);
}

The Char.GetUnicodeCategory is used to get the corresponding category of each character of the file.

Thread-safe form method

2009-02-25T22:25:00.005+01:00

If you use threads in a winforms application, you probably have already encountered the classic InvalidOperationException saying that you are trying to make an illegal cross-thread operation. This is because you cannot modify a control from a thread other than the one that created it.
Here is a simple way to write your methods in the form to avoid that exception :

void SomeMethod(SomeType parameter)
{
if (this.InvokeRequired)
{
this.BeginInvoke(new MethodInvoker(delegate()
{ this.SomeMethod(parameter); }));
}
else
{
// Do what SomeMethod is supposed to do.
}
}

You can use Invoke instead of BeginInvoke if you want to make an asynchronous call to the delegate.
Notice the anonymous method (delegate() {...}) used to invoke the same instruction in the correct thread.

Converting a List using a lambda expression

2009-02-16T21:02:00.009+01:00

Here is a little construct I use when I need to convert a List<T> to a List<U> or when I need to pass a list of concatenated values as a string.
First, to convert a List<T> to a List<U> :

List<Guid> guidList = // Initialize list here or get it as a parameter or whatever :)
List<String> stringList = guidList.ConvertAll<String>(g => g.ToString());

It is really simple, I just use the ConvertAll method parameterized with the target type and pass it the lambda responsible for converting from the source type (Guid) to the target type (String). This example is obvious but the important thing is the combination of ConvertAll and a lambda.

For the second use ("passing a list of concatenated values as a string"), it is also really simple :

String stringValue = String.Join(
" separator ",
myGenericList.ConvertAll<String>(
/* Insert lambda here that return a string value */).ToArray());

The trick is simply to call ToArray on the converted list to be able to pass it to the String.Join method.

You can also use a extension method like this one :

public static class ListExtensions
{
public static String Join<T>(this List<T> list, string separator)
{
return String.Join(
separator,
list.ConvertAll<String>(t => t.ToString()).ToArray());
}
}

And then just write something like that:

static void Main(string[] args)
{
List<DateTime> list = new List<DateTime> { DateTime.Now, DateTime.Today };

String joinedList = list.Join(", ");
}

Happy coding :)

Handling exceptions the right way in WCF (part 2)

2009-02-07T17:26:00.015+01:00

In my previous post I talked about FaultExceptions and how they are transmitted from the server to the client.
First, let's have a look at the sample service contract :

[ServiceContract]
public interface ITimeService
{
[OperationContract]
[FaultContract(typeof(TimeExceptionDetails))]
DateTime GetTime();
}

The service implementation :

public class TimeService : ITimeService
{
#region ITimeService Members

public DateTime GetTime()
{
return DateTime.Now;
}

#endregion
}

And the Fault details class :

public class TimeExceptionDetails
{
public static readonly TimeExceptionDetails Default = new TimeExceptionDetails();

[DataMember]
public String Message { get; private set; }

public TimeExceptionDetails()
{
this.Message = "There is a problem in the spacetime continuum, Marty";
}

public TimeExceptionDetails(String message)
{
this.Message = message;
}
}

Now we'll how to ease the process of creating FaultExceptions by using the IErrorHandler interface. This interface allows the customization of exceptions and provide a centralized location for responding to exceptions in a very generic way.
This interface contains two methods :

HandleError
ProvideFault

The first one is called each time an exception is raised by the service (logging for example). The second one is more subtle, it allows to change the message that will be sent to the caller. Here for example you could create a FaultException, generate the corresponding message and set it as the message to be sent.
The following code is a simple implementation of the IErrorHandler interface. It simply create a new FaultException and send it to the caller.

public class TimeServiceBehavior : IErrorHandler
{
#region IErrorHandler Members

public bool HandleError(Exception error)
{
// Log the error here
EventLog.WriteEntry("TimeService", error.ToString());

// Let the other ErrorHandler do their jobs
return true;
}

public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
return;

// Creates the exception we want to send back to the client
var exception = new FaultException<TimeExceptionDetails>(
TimeExceptionDetails.Default,
new FaultReason(TimeExceptionDetails.Default.Message));

// Creates a message fault
var messageFault = exception.CreateMessageFault();

// Creates the new message based on the message fault
fault = Message.CreateMessage(version, messageFault, exception.Action);
}

#endregion
}

The implementation here is really simple, you will probably need to add some logic in the ProvideFault method to distinguish between technical exception and business exceptions and create the appropriate type of fault.

The next step is to associate this error handler with the service. Each ChannelDispatcher of a ServiceHost have a property named ErrorHandlers that contains a list of error handlers applied to the channel. One easy way to add a error handler to the channel dispatcher is to create a ServiceBehavior. To create a new service behavior, we simply need to implement IServiceBehavior in the TimeServiceBehavior class :

public class TimeServiceBehavior : IErrorHandler, IServiceBehavior
{
#region IErrorHandler Members

[...]

#endregion

#region IServiceBehavior Members

public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters)
{
}

public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
// Adds a TimeServiceErrorHandler to each ChannelDispatcher
foreach (var channelDispatcherBase in serviceHostBase.ChannelDispatchers)
{
var channelDispatcher = channelDispatcherBase as ChannelDispatcher;
channelDispatcher.ErrorHandlers.Add(new TimeServiceBehavior());
}
}

public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
}

#endregion
}

The only method of interest here is ApplyDispatchBehavior used to apply a specific behavior on the dispatchers (which is exactly what we are trying to achieve here).
Unfortunately, in its current state, our service behavior is not easy to use unless we are creating the service host and all its configuration by hand. For example, it is not possible to use our behavior from a configuration file.

Let's make this service behavior a little more developer friendly. We have two possible solutions :

Make it compatible with the file-based configuration infrastructure (app/web.config),
Make it an attribute that can decorate our service implementation.

We will implement the app.config version first. We simply need to create a class that inherit from BehaviorExtensionElement. This class will allow us to add our service behavior as an extension in the App/Web.config file. Here is the TimeServiceBehaviorElement class :

public class TimeServiceBehaviorElement : BehaviorExtensionElement
{
public override Type BehaviorType
{
get { return typeof(TimeServiceBehavior); }
}

protected override object CreateBehavior()
{
return new TimeServiceBehavior();
}
}

The code is pretty straight-forward, it just links our service behavior to a configuration element.

Here is an example of a configuration file making use of the TimeServiceBehavior :

<system.serviceModel>
<services>
[...]
</services>
<behaviors>
<serviceBehaviors>
<behavior name="WcfErrorSample.Service1Behavior">
<serviceMetadata httpGetEnabled="true" />
<serviceDebug includeExceptionDetailInFaults="false" />
<timeService />
</behavior>
</serviceBehaviors>
</behaviors>
<extensions>
<behaviorExtensions>
<add name="timeService" type="WcfErrorSample.TimeServiceBehaviorElement,
WcfErrorSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
</behaviorExtensions>
</extensions>
</system.serviceModel>

That's it for the configuration model. Now let's make the behavior a little easier to use from a developer perspective. We are simply going to make the service behavior a custom attribute. This attribute will then be applied on the service itself. To transform the behavior into an attribute, TimeServiceBehavior will now inherit from Attribute, that's it :

public class TimeServiceBehavior : Attribute, IErrorHandler, IServiceBehavior
{
[...]
}

Now, the service implementation is decorated with our attribute :

[TimeServiceBehavior]
public class TimeService : ITimeService
{
[...]
}

This will have exactly the same effect than the configuration based implementation.

You can implement both solutions for your behaviors and have the choice of using one way or another depending on your policy ("all in config", "fixed service behavior", etc.).

Binding two Windows Forms controls

2009-02-05T13:57:00.003+01:00

Recently, I came across a small windows application where the developer had difficulties to activate controls based on a another one. Typical example is when you want to activate a textbox sitting next to a checkbox. The developer chose to use the CheckedChanged event of the Checkbox, and to modify the Enabled property of the Textbox accordingly. The problem is you have to properly initialize the CheckState, and Enabled property of the controls to keep them both in sync from the beginning.

Then I showed him how to bind two controls directly. Most developers know about binding a control to datasource, but few of them know that it is also possible to bind to another control.

The following line shows how to do that :

myTextbox.DataBindings.Add("Enabled", myCheckbox, "Checked");

This line simply binds the Enabled property of the Textbox to the Checked property of the Checkbox. By doing that, there is no need to initialize each property nor to respond to any event.
The only drawback is that there is no designer support. You have to create the binding manually, the designer only supports binding to data. Usually, I put this line in a InitializeBinding method (called just after InitializeComponent).

Methods taking variable number of args (part 2)

2009-02-04T21:06:00.008+01:00

In my previous post, I talked about the choice I made about taking a variable number of parameters. At that time, I used a simple params object[], and the logic was built into the method (in the constructor of the underlying form in fact, but it is not relevant here).

The problem with this approach is how to handle parameters with the same type but different meanings. A very simple example is the caption and the text of the InformationBox. Both are strings but how to differenciate between the two. I had to force the first parameter to be the text, but it was beginning to look like the MessageBox.

For those who are familiar with C# 3.0, you may have already guessed what I could have used if .NET 3.5 had been available at that time. I could have used object initializers. It is a simple constructor syntax that allow the developer to specify only the properties he (or she) wants to define.

For example, assuming the Client class is already defined with two properties "Name" and "FirstName" :

var myClient = new Client { Name = "Blais", FirstName = "Johann" };

So basically, I could have changed the API a little to use this particular syntax. The main benefit would have been to throw away the "guessing part" of the Show method because the value would directly reference the property.

The main disadvantage is that (internally) the parameter validation would have taken place later in the process. The params approach allows the parameters to be validated on the spot and not when we start the process of showing the window. I am aware that this particular point is subject to discussion but as the only developer of the component, I tend to agree with myself. :)

I did not change this behavior in the last release because I did not want to introduce breaking changes in the API given the potentially important number of existing users.

Methods taking variable number of args (part 1)

2009-02-04T20:14:00.009+01:00

A few months ago, I started a small project on Codeplex, its goal was simple : providing an alternative to the default Windows Forms MessageBox. One of the things that annoyed me with the MessageBox was to be forced to provide values for parameters I did not want to change.
Here is a little example :

MessageBox.Show("Text", "Caption", MessageBoxButtons.OK, MessageBoxIcon.Information);

Clearly in this case, I should not have to specify the third parameter since it is already the default value.

So basically, I needed to create a method (Show in this case) that take a variable number of parameters. The problem was with the types of the parameters, I have a whole lot of different types.

At that time, I had two ways to achieve that :

Providing an overload of Show for each combination of parameters.
Using params and the only type shared by all the parameters : object.

The first one is nice when you have two parameters, but in InformationBox we are now dealing with up to 25 parameters at the same time (note : the number of possibilities is 29 digits long).

So I went for the second solution and this is the currently implemented in the 0.8 release. What I do is simply iterate over every parameter and affect it to the corresponding property based on its type.

Next time we'll see how I would have achieved my goal by using the C# 3.0 features.

Handling exceptions the right way in WCF (part 1)

2009-02-04T11:34:00.010+01:00

Control over exceptions is very important in WCF because exceptions can contain a lot of information about the internals of your service potentially leading to security issues. WCF allows to define not only data, service or message contracts but also fault contracts. Fault contracts are used to materialize potential exceptions in the metadata of your service.

To do that, you just have to declare on your service contract which exception might be raised by a specific method.

Here is a simple service contract :

[ServiceContract]
public interface IService1
{
[OperationContract]
[FaultContract(typeof(SomeFault))]
void DoSomething();
}

Here, we are telling the WCF runtime to expose a fault contract in the service metadata. The object containing the fault detail is named SomeFault. Here is the definition of the SomeFault class :

[DataContract]
public class SomeFault
{
[DataMember]
public String SomeInfo { get; set; }
}

As you see, SomeFault is a data contract. Its use is only to transfer data through the wire, nothing more, nothing less.

Then you just have to throw exceptions of the right type. You may have already noticed that if an exception is thrown on the service side, you get a simple FaultException on the client side.
Now that we have defined a fault contract, the following code demonstrates how to properly throw an exception from the service :

throw new FaultException<SomeFault>(new SomeFault { SomeInfo = "Some useful data" });

We are simply throwing a generic exception based on the fault contract defined earlier.
Then for the client perspective, we will be able to catch the same type of FaultException. For example :

try
{
proxyInstance.DoSomething();
}
catch(FaultException<SomeFault> ex)
{
// SomeInfo is accessible here
Debug.Print(ex.Detail.SomeInfo);
}

This is possible because the proxy generator (either "Add service reference" or svcutil.exe) produces client side equivalents of the fault contract (SomeFault in this case). This was made possible by including the fault contract in the metadata (adding the FaultContractAttribute on the service contract).

Note : it is very important that you deactivate the IncludeExceptionDetailsInFault on the production server to avoid disclosing sensitive exception details (like the stack trace).

Next time we will see how it is possible to automate parts of this process by using the IErrorHandler interface.

Get newly added entities in an Entity Framework query

2009-02-04T09:09:00.006+01:00

A few days ago, a colleague of mine ran into a little problem using Entity Framework. He was adding new entities to the context and then wanted to display these entities. Unfortunately, since the new entities are only in memory, they are not fetched by the query.
In fact, you have to use the ObjectStateManager accessible from the context to query in-memory entities. This object manages the entity cache in the context.

You can use the following code to obtain every entity already in the cache. Assuming the type of the objects you want to query is Client :

var listInMemory =
context.ObjectStateManager
.GetObjectStateEntries(EntityState.Added)
.Select(e => e.Entity).OfType<Client>().ToList();

listInMemory will contain only the new added entities from the current context. You can combine EntityState values to retrieve entities in different states.

You can also use an Union construct to add those entities to the list of entities returned by a standard Entity query. For example :

var completeList =
context.Clients.AsEnumerable()
.Union(context.ObjectStateManager.GetObjectStateEntries
(EntityState.Added)
.Select(e => e.Entity)
.OfType<client>()).ToList();

You may also want to filter out the deleted records from the context.Clients by using a Where clause just before the AsEnumerable(). I leave that as an exercice to the reader :)

Note the use of AsEnumerable(). It is related to the way LINQ to Entities handles comparisons (for the Union method in this case). You can find more information about comparisons on the MSDN.

Welcome

2009-02-04T09:02:00.001+01:00

This blog will enable me to post a few tips and tricks I learned playing with the latest technologies. I will mostly talk about WCF, LINQ and also about a few interesting (I hope) things I want to share with everyone :)