En muchos de los ejemplos que podemos ver sobre servicios web las llamadas a los diferentes métodos que proveen son independientes entre ellas. En la vida real es posible que necesitemos mantener el estado entre diferentes llamadas y que, además, éstas tengan que seguir una determinada secuencia.
El Framework 3.0 nos provee de formas muy fáciles para poder controlar estos casos, solo falta añadir unos atributos a los métodos de nuestro servico o al servicio en sí.
Para poder enseñar como hacerlo de una manera fácil de entender he creado un pequeño código de ejemplo.
He creado un servicio web que emula un carrito de compra; un ejemplo básico donde se debe mantener el estado entre diferentes llamadas. No he implementado ningún control de excepciones ya que así nos centramos en lo que toca.
Esta primera parte tratará de mantener el estado y concurrencia, en la otra entrada veremos como definir el orden de ejecución.
Por una parte tendremos la lista de productos; un xml, por otro el servicio web; con su contrato y la clase que lo implementa, una aplicación host; que sirve el servicio usando wsHttpBinding y, por último, el cliente; que consumirá el servicio.
Primero he creado un xml como contenedor de datos, que contiene una lista de productos. Lo he creado serializando un objeto de tipo List<Product>, así luego lo podremos deserializar y trabajar con él de una forma más fácil:
<?xml version=»1.0″ encoding=»utf-8″?>
<ArrayOfProduct xmlns:xsi=»http://www.w3.org/2001/XMLSchema-instance» xmlns:xsd=»http://www.w3.org/2001/XMLSchema»>
<Product>
<Id>0</Id>
<Name>Agua</Name>
<Price>0.5</Price>
</Product>
<Product>
<Id>1</Id>
<Name>Zumo de naranja</Name>
<Price>1.2</Price>
</Product>
<Product>
<Id>2</Id>
<Name>Olivas</Name>
<Price>2.35</Price>
</Product>
<Product>
<Id>3</Id>
<Name>Patatas</Name>
<Price>1.75</Price>
</Product>
<Product>
<Id>4</Id>
<Name>Cerveza</Name>
<Price>0.8</Price>
</Product>
<Product>
<Id>5</Id>
<Name>Refresco</Name>
<Price>0.7</Price>
</Product>
</ArrayOfProduct>
Luego he creado un proyecto tipo librería en Visual Basic y he creado las dos clases que voy a necesitar para tratar los datos: Product y CartItem.
Public Class Product
Private _id As Integer
Public Property Id() As Integer
Get
Return _id
End Get
Set(ByVal value As Integer)
_id = value
End Set
End Property
Private _name As String
Public Property Name() As String
Get
Return _name
End Get
Set(ByVal value As String)
_name = value
End Set
End Property
Private _price As Decimal
Public Property Price() As Decimal
Get
Return _price
End Get
Set(ByVal value As Decimal)
_price = value
End Set
End Property
End Class
Public Class CartItem
Private _product As Product
Public Property Product() As Product
Get
Return _product
End Get
Set(ByVal value As Product)
_product = value
End Set
End Property
Private _cuantity As Integer
Public Property Cuantity() As Integer
Get
Return _cuantity
End Get
Set(ByVal value As Integer)
_cuantity = value
End Set
End Property
End Class
Después he definido el contrato: la Interface.
<ServiceContract()> _
Public Interface IShoppingCart
<OperationContract()> _
Function AddItem(ByVal itemId As Integer) As Boolean
<OperationContract()> _
Function RemoveItem(ByVal itemId As Integer) As Boolean
<OperationContract()> _
Function GetShopingCart() As String
<OperationContract()> _
Function Checkout() As Boolean
End Interface
Y la clase que la implementa: el servicio.
Public Class ShoppingCartSrv
Implements IShoppingCart
Private shoppingCart As New List(Of CartItem)
Private Function getProduct(ByVal productId As Integer) As Product
Dim products As New List(Of Product)
Dim filename As String = «products.xml»
If File.Exists(filename) Then
Dim reader As New StreamReader(filename)
Dim serializer As New XmlSerializer(GetType(List(Of Product)))
products = CType(serializer.Deserialize(reader), List(Of Product))
reader.Close()
End If
Dim product As Product = Nothing
For Each p As Product In products
If p.Id = productId Then
Return p
End If
Next
Return product
End Function
Public Function AddItem(ByVal itemId As Integer) As Boolean Implements IShoppingCart.AddItem
For Each item As CartItem In shoppingCart
If item.Product.Id = itemId Then
item.Cuantity += 1
Return True
End If
Next
Dim product As Product = getProduct(itemId)
If Not IsNothing(product) Then
shoppingCart.Add(New CartItem With {.Product = product, .Cuantity = 1}) Return True
End If
Return False
End Function
Public Function GetShopingCart() As String Implements IShoppingCart.GetShopingCart
Dim list As String = «»
Dim total As Double = 0
For Each item As CartItem In shoppingCart
list += String.Format(«Id: {0} Name: {1} Price: {2} Cuantity: {3}{4}», _ item.Product.Id, item.Product.Name, item.Product.Price, item.Cuantity, Environment.NewLine)
total += (item.Product.Price * item.Cuantity)
Next
If list.Equals(«») Then
list = «Empty Cart»
Else
list += String.Format(«Total: {0} Euro», total) End If
Return list
End Function
Public Function RemoveItem(ByVal itemId As Integer) As Boolean Implements IShoppingCart.RemoveItem
Dim item As CartItem = Nothing
For Each i As CartItem In shoppingCart
If i.Product.Id = itemId Then
item = i
End If
Next
If Not IsNothing(item) Then
shoppingCart.Remove(item)
Return True
End If
Return False
End Function
Public Function Checkout() As Boolean Implements IShoppingCart.Checkout
shoppingCart.Clear()
Return True
End Function
End Class
Ahora que ya tenemos creado el servicio, he creado una aplicación para que lo sirva. Creo un nuevo proyecto de consola, agrego la dos referencias que necesito: System.ServiceModel y al proyecto de librería que representa mi servicio. Y creo el código que necesito para servir el servicio:
Imports ShoppingCartService
Imports System.ServiceModel
Module Host
Sub Main()
Dim host As New ServiceHost(GetType(ShoppingCartSrv))
host.Open()
Console.WriteLine(«Service running»)
Console.WriteLine(«Press ENTER to stop the service»)
Console.ReadLine()
Console.Write(«Closing…»)
host.Close()
Console.WriteLine(«Closed»)
End Sub
End Module
Por último configuro cómo voy a servir el servicio con mi fichero de configuración app.config en la aplicación que hace de host:
<?xml version=»1.0″ encoding=»utf-8″ ?>
<configuration>
<system.serviceModel>
<services>
<service name=»ShoppingCartService.ShoppingCartSrv» behaviorConfiguration=»MyBehavior»>
<host>
<baseAddresses>
<add baseAddress=»http://localhost:9669/ShoppingCartService»/>
</baseAddresses>
</host>
<endpoint address=»ShoppingCartSrv»
binding=»wsHttpBinding»
contract=»ShoppingCartService.IShoppingCart»
name=»WsHttp_ShoppingCartEndpoint»/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name=»MyBehavior»>
<serviceMetadata httpGetEnabled=»true»/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>
Ahora solo falta el cliente.
Creo otra aplicación de consola para el cliente. Ejecuto la aplicación de Host para que se empiece a servir el servicio y poder, así, añadir la referencia al servicio al cliente con la ayuda de Visual Studio:
Escribimos el código que consumirá el servicio: añadirá productos a la cesta y mostrará ésta por pantalla:
Imports Client.ShoppingCartService
Module Client
Sub Main()
Console.WriteLine(«Press ENTER when the service has started»)
Console.ReadLine()
Try
Dim proxy As New ShoppingCartClient(«WsHttp_ShoppingCartEndpoint»)
Dim rand As New Random()
Dim result As Boolean = True
result = proxy.AddItem(rand.Next(0, 5))
result = proxy.AddItem(rand.Next(0, 5))
result = proxy.AddItem(rand.Next(0, 5))
result = proxy.AddItem(rand.Next(0, 5))
Console.WriteLine(proxy.GetShopingCart())
‘result = proxy.Checkout()
‘Console.WriteLine(proxy.GetShopingCart())
Catch ex As Exception
Console.WriteLine(ex.Message)
End Try
Console.WriteLine(«Press ENTER to finish»)
Console.ReadLine()
End Sub
End Module
Ahora ya tenemos preparado el entorno de nuestra aplicación: nuestro cliente y nuestro servicio. Ejecutémoslo a ver que le pasa al carrito, ¿se mantendrá el estado entre diferentes llamadas al servicio?, o sea: ¿al mostrar los elementos de la cesta estarán los añadidos anteriormente?…
(no os olvidéis de que tiene que estar ejecutándose la aplicación que hace de host del servicio antes de ejecutar el cliente)
…pues sí!.
Vamos a ver el por qué.
Si nos paramos a pensar qué debe estar pasando, el servicio crea una variable privada que es creada el crearse la instancia del servicio. Si dos clientes acceden al servicio el Framework crea una instancia del servicio para cada uno de ellos, así que cada uno de ellos va a tener un carrito de compra propio. La instancia del servicio se destruirá en el momento que el cliente cierre el proxy. Bueno,… cuando el Garbage Collector quiera. Pues ya está ¿no?, ya mantenemos el estado. Pero, ¿y si ahora tenemos 10.000 clientes?, tendremos 10.000 instancias del servicio corriendo: el cliente puede estarse media hora pensando qué comprar. No creo que pueda buscar muchos artículos en una máquina sin memoria.
¿Cómo podemos cambiar esto?, cambiando el ContextMode de nuestro servicio. Usando la propiedad InstanceContextMode del atributo ServiceBehavior de nuestro servicio:
<ServiceBehavior(InstanceContextMode:=InstanceContextMode.PerSession)> _
Public Class ShoppingCartSrv
Implements IShoppingCart
‘…
o en C#
[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerSession)]
public class ShoppingCartServiceImpl : IShoppingCartService
{ //…
Esta propiedad puede tomar diferentes valores: InstanceContextMode.PerSession, InstanceContextMode.PerCall y InstanceContextMode.Single.
InstanceContextMode.PerSession
Es el que tiene por defecto. Mantiene una instancia por cliente y la destruye al desconectarse.
InstanceContextMode.PerCall
Crea una instancia solo para servir la petición de uno de sus métodos y la destruye una vez ejecutado.
InstanceContextMode.Single
Crea una instancia la primera vez que se llama al servicio y usa la misma para todos los clientes.
Ahora ya sabemos por qué se mantenía el estado. Pero al ver esto, se nos pueden plantear preguntas respecto a la concurrencia. Si un cliente crea dos «threads» que hagan diferentes llamadas a su servicio, ¿qué hará el servicio?, si le llega una llamada a un método que está ejecutando mantendrá a la llamada «en espera» y, posiblemente el cliente termine por time-out.
Para poder indicarle al servicio como tratar peticiones concurrenciales tenemos otra propiedad del atributo ServiceBehavior llamada ConcurrencyMode. Y puede tomar dos valores ConcurrencyMode.Single (por defecto el servicio usa esta) o ConcurrencyMode.Multiple. Con la segunda opción el servicio será capaz de aplicar concurrencia a las peticiones del cliente.
Podemos probar ahora de cambiar la propiedad InstanceContextMode a nuestro servicio y ver como el resultado del cliente va a cambiar. Si aplicamos InstanceContextMode.PerCall veremos que al imprimir el carrito este sale vacío. En cambio, si usamos InstanceContextMode.Single veremos que aunque cerremos el proxy y abrimos otro, o ejecutamos dos o más clientes, éstos comparten el carrito y entre todos van añadiendo elementos.
Con los diferentes valores de InstanceContextMode podemos controlar el tiempo de vida de nuestro servicio. Esta propiedad es global a todos los servicios y es el Framework el que se encarga de crear o destruir el servicio, pero no tiene en cuenta qué método esta ejecutando el cliente.
Podemos controlar cuando se destruye la instancia con una la propiedad ReleaseInstanceMode del atributo OperationContract de nuestros métodos definidos en el contrato.
Esta propiedad puede tomar cuatro valores:
ReleaseInstanceMode.AfterCall
Una vez el cliente acaba de utilizar el método, el runtime de WCF libera los recursos del servicio para que lo destruya el Garbage Collector. Si el cliente invoca otro método el runtime creará una instancia nueva del servicio.
ReleaseInstanceMode.BeforeCall
Si existe alguna instancia del servicio cuando el cliente invoca el método el runtime, primero destruye esa instancia y luego crea una nueva para servir la petición.
ReleaseInstanceMode.BeforeAndAfterCall
La combinación de las dos anteriores.
ReleaseInstanceMode.None
Este es el valor por defecto de esta propiedad. La instancia del servicio es creada y destruida de acuerdo con el valor de la propiedad InstanceContextMode del atributo ServiceBehavior del servicio.
La idea es jugar con el código del cliente y las propiedades del servicio, y ver como reacciona a los diferentes valores que pueden tomar las propiedades.
