Ria Services offer an easy solution to the main problems of a typical Business Silverlight application, specifically:
- Data Validation. As discussed in a previous post, Ria Services offer support for a data validation based on Data Annotations defined on the server side classes.
- Communication with the server and remote validation. Several configuration details of the web service definitions are automatically handled by Ria Services. Moreover, as discussed previously, if the definition of some custom validation attribute is not available on the client side, validation is performed remotely on the server (please refer to the above post for more information).
- Ria services automatically set up Asp.net Authentication, Authorization and User Profile Web Services for the Silverlight client.
Unluckily, it is not always possible to use Ria Services, because the Web Services created by Ria Services are specific for Silverlight. Therefore, if one needs a interoperable general purpose service layer that is compatible with various technologies Ria services can not be used.
In such a case the only acceptable option should be the configuration of a Silverlight specific endpoint in a general purpose Web Services. However, often I see developers that do a partial duplication of code implementing a parallel Ria Services Layer specific for the Silverlight clients just to take advantage of the opportunities offered by Ria Services.
In this post I will show a simple alternative way to obtain the same advantages offered by Ria Services with general purpose Web Services.
Let start with the support for Data Annotations.We can proceed as follows ( I assume knowledge of the Data Annotations issues discussed in my previous posts here and here.) :
- When we define the meta classes of our business classes we furnish a complete implementation of those classes with the right property types. Moreover, in order to make them serializable we decorate them with the [DataContract] attribute and their properties with the [DataMember ] attribute, since we want they be compatible with Silverlight that has no implementation of the [Serializable] attribute.
- We use the above meta classes as View Models or as part of the View Models, both in the server and in Silverlight projects. I advice just linking the same code to both the Silverlight and the server projects.
- We define our Web Services according to general design constraints, and not only according to Silverlight needs.
- We generate the Silverlight proxy, with the option to use already existing classes. This way, we use the original View Models we have linked to the Silverlight project instead of View Models provided automatically by Visual studio during proxy generation.
- Once in Silverlight, we wrap the View Model with the Validation Toolkit for Wpf & Silverlight wrapper, in order to furnish it support for both Data Annotations and INotifyPropertyChanged.
With the above procedure we have View Models with Data Validation support without duplicating code, and with the same effort required by the definition of a Ria Domain Service.
The Validation Toolkit for Wpf & Silverlight offers also all tools needed to perform the Remote Validation. On the server we pack all validation errors into an IEnumerable<ValidationErrorInfo> and then we throw a fault Exception: FaultException<IEnumerable<ValidationErrorInfo>> containing the above IEnumerable.
The exception is passed to the client if we decorate the Wcf interface definition with the FaultContract<IEnumerable<ValidationErrorInfo>>] attribute.This is enough for all clients but Silverlight to receive the validation errors. In fact Silverlight is a browser plug-in and as all browser plug-ins it can receive the details of a response only if the status code of the response is either 200(OK) or 404(Not Found), and the status code associated with a fault error normally is not one of them. To overcome this problem we apply the SilverlightFaultBehavior defined in the BindToolkit.Behaviors namespace of the Validation Toolkit for Wpf & Silverlight to the endpoint specific for Silverlight. This endpoint behavior change the status code of the Wcf error response from whatever it is into a 200 status code, thus allowing Silverlight to receive the FaultException.
Once the FaultException is available to the silverlight client,we need just to call the AddValidationFaultExceptionContent(IEnumerable<ValidationErrorInfo> errors) method of the top level wrapper, to send all error messages in their adequate places in the User Interface.
The binary distribution of the Validation Toolkit for Wpf & Silverlight contains a Silverlight example that shows both how to use the wrapper and how to handle remote validation.
Finally, the set up of Asp.net Authentication, Authorization and User Profile Web Services for the Silverlight client is easy because Asp.net has standard implementations for these Web Service.
For the authentication service we just need to add to our web project an .svc file containing just:
<%@ ServiceHost
Language="C#"
Service="System.Web.ApplicationServices.AuthenticationService"
Factory="System.Web.ApplicationServices.ApplicationServicesHostFactory" %>
No code behind or explicit implementation needs to be furnished since the Asp.net class System.Web.ApplicationServices.AuthenticationService offers a standard implementation of the Authentication Service. However, we need to configure a Membership provider on our Web Site.
In the configuration file we must enable the Authentication Service:
<system.web.extensions>
<scripting>
<webServices>
<authenticationService enabled="true"
requireSSL = "true"/>
</webServices>
</scripting>
</system.web.extensions>
and we must configure it to use basicHttpBinding(for Silverlight compatibility) and Https:
<services>
<service name="System.Web.ApplicationServices.AuthenticationService"
behaviorConfiguration="AuthenticationServiceTypeBehaviors">
<endpoint contract=
"System.Web.ApplicationServices.AuthenticationService"
binding="basicHttpBinding"
bindingConfiguration="userHttps"
bindingNamespace="http://asp.net/ApplicationServices/v200"/>
</service>
</services>
<bindings>
<basicHttpBinding>
<binding name="userHttps">
<security mode="Transport" />
</binding>
</basicHttpBinding>
</bindings>
A detailed reference is here.
Analogously, for the Authorization service we have:
<%@ ServiceHost
Language="C#"
Service="System.Web.ApplicationServices.RoleService"
Factory="System.Web.ApplicationServices.ApplicationServicesHostFactory" %>
<system.web.extensions>
<scripting>
<webServices>
<roleService enabled="true"/>
</webServices>
</scripting>
</system.web.extensions>
<services>
<service name="System.Web.ApplicationServices.RoleService"
behaviorConfiguration="ApplicationServiceTypeBehaviors">
<endpoint contract=
"System.Web.ApplicationServices.RoleService"
binding="basicHttpBinding"
bindingConfiguration="userHttps"
bindingNamespace="http://asp.net/ApplicationServices/v200"/>
</service>
</services>
<bindings>
<basicHttpBinding>
<binding name="userHttps">
<security mode="Transport" />
</binding>
</basicHttpBinding>
a Detailed reference is here.
While for the User Profile we have:
<%@ ServiceHost Language="C#"
Service="System.Web.ApplicationServices.ProfileService"
Factory="System.Web.ApplicationServices.ApplicationServicesHostFactory" %>
<system.web.extensions>
<scripting>
<webServices>
<profileService enabled="true"
readAccessProperties="Birthday, FavoriteColor"
writeAccessProperties="Birthday, FavoriteColor" >
</webServices>
</scripting>
</system.web.extensions>
As you can see, while enabling the profile service we need to specify read and write permissions for each property.
The service configuration is quite standard:
<services>
<service name="System.Web.ApplicationServices.ProfileService"
behaviorConfiguration="MyServiceTypeBehaviors">
<endpoint contract=
"System.Web.ApplicationServices.ProfileService"
binding="basicHttpBinding"
bindingNamespace="http://asp.net/ApplicationServices/v200"/>
</service>
A detailed Reference is here.
Well. As you can see, the set up of a Silverlight application with all features described in points 1), 2), and 3) is quite easy and can be carried out quickly also without the use of Ria Services. Therefore, there is no need to force the use of Ria Services also when a different solutions should be more adequate.
That’s all for now!. But…..
Stay Tuned !
Francesco
For more information or consulences feel free to contact me
Tags: Data Validation, Data Annotations, Wcf Faults in Silverlight, ValidationException, MVVC, INotifyDataError, Object level validation, Silverlight, FaultContract