Fixing RIA Services’s “An EntityKey value cannot be null” with a CodeProcessor

When updating a small RIA application which has been based on a previous beta of Visual Studio 2010 (and which worked perfectly back then), I noticed an interesting bug, which has in the meantime been confirmed at silverlight.net: if you are using 1:n relationships for which the n part uses a compound primary key consisting of at least one non-nullable type, you can not add items at runtime without explicitly specifying the primary key (and a few other things, like deletes, might also result in the same error:

ArgumentNullException occurred. An EntityKey value cannot be null

This exception happens in the client-side entity’s GetIdentity() method, which looks like the following:

1. public override object GetIdentity()
2. {
3.     return EntityKey.Create(this._invoiceNumber, this._pos);
4. }

(In my case, the string _invoiceNumber and the int _pos determine the primary key).

Based on the post at silverlight.net, this is a bug in the RIA codegen, as the code should actually check whether _invoiceNumber is null, and should simply return null instead of trying to create an EntityKey. The poster also suggested that it would be possible to create a CodeProcessor which changes the generated code.

And that’s what he remainder of this post is about.

In RIA Services, the code generation is performed in a way which is very different from the regular “Add Service Reference …” way of generating a proxy. It is however also very easily extensible so that you can intercept the code generation with just a few lines of code in a class which derives from CodeProcessor.

Instead of directly working with the generated CodeDom elements, I decided to take the easy route and write a processor which simply lets me inject additional code at the beginning of any method. It does this, I first designed a custom attribute which allows me to specify the code to be injected:

1. [AttributeUsage(AttributeTargets.Class)]
2. public class InjectClientsideCodeAttribute : Attribute
3. {
4.     public InjectClientsideCodeAttribute(string methodName, string code)
5.     {
6.         Code = code;
7.         MethodName = methodName;
8.     }
9.     public string Code;
10.     public string MethodName;
11. }

This attribute is used on server side’s partial class implementation for each entity you want to modify. In my application, I simply wanted to prepend the method GetIdentity with the specified code fragment to check the nullness of _invoicenumber:

1. #if !SILVERLIGHT
2. [InjectClientsideCode("GetIdentity", "if (_invoiceNumber == null) return null;")]
3. #endif
4. public partial class InvoiceLine
5. {
6.     // ...
7. }

The codeprocessor which does the actual work is relatively simple as well. It looks for all types which have the [InjectClientsideCode] attribute set, and then iterates over all the methods which match the method name and inserts the code by using a CodeSnippetStatement (which also means that the code in your [InjectClientsideCode]-attribute has to be specified in the correct programming language you are using for your client-side project).

1. public class MethodPatchingCodeProcessor : CodeProcessor
2. {
3.     public MethodPatchingCodeProcessor(CodeDomProvider codeDomProvider) : base(codeDomProvider) { }
4.  
5.     public override void ProcessGeneratedCode(DomainServiceDescription domainServiceDescription,
6.         System.CodeDom.CodeCompileUnit codeCompileUnit,
7.         IDictionary<Type, CodeTypeDeclaration> typeMapping)
8.     {
9.         Dictionary<Type, CodeTypeDeclaration> typesToPatch = typeMapping.Where(tm => tm.Key.GetCustomAttributes(typeof(InjectClientsideCodeAttribute), false).Length > 0).ToDictionary(p => p.Key, p => p.Value);
10.         
11.         foreach (var typeToPatch in typesToPatch)
12.         {
13.             foreach (InjectClientsideCodeAttribute injectionAttribute in typeToPatch.Key.GetCustomAttributes(typeof(InjectClientsideCodeAttribute), false))
14.             {
15.                 var methodsToPatch = typeToPatch.Value.Members.OfType<CodeMemberMethod>().ToList();
16.                 methodsToPatch = methodsToPatch.Where(p => p.Name == injectionAttribute.MethodName).ToList();
17.  
18.                 foreach (var methodToPatch in methodsToPatch)
19.                 {
20.                     methodToPatch.Statements.Insert(0, new CodeSnippetStatement(injectionAttribute.Code));
21.                 }
22.             }
23.         }
24.     }
25. }

To make this work, you can simply add the sourecode for InjectClientsideCodeAttribute and MethodPatchingCodeProcessor to your server-side project and apply the following attribute to your domain service to indicate that you want to customize the code generation:

1. [DomainIdentifier("TTOverviewDomainService", CodeProcessor = typeof(MethodPatchingCodeProcessor))]
2. public partial class ThinktectureDomainService : LinqToEntitiesDomainService<ThinktectureEntities>
3. {
4.     // ...
5. }

Et voilà. Instant code injection for your RIA services.