Välkommen till Sommarkollo 2006 Windows Communication Foudnation

1. 2006 Välkommen till Sommarkollo 2006 Windows Communication Foudnation

2. Windows Communication Foundation Johan Lindfors

3. Agenda • Vad är WCF • Programmera WCF • Kontrakt • ”Hostning” och uppträdanden • Bindningar och metadata • Andra koncept • Migrering eller integration • Monitorering • Säkerhet • Transaktioner • Köhantering

4. Hur ser det ut idag? J2EE Microsoft JAX-RPC ASMX / WSE RMI Remoting CORBA DCOM EJB Enterprise Services JMS System.Messaging Sockets Sockets

5. WCF byggstenar • Förenar teknikerna för distribuerad kommunikation • ”On-machine”, ”Cross-machine”, ”Cross-Internet” • Brett stöd för WS-* specifikationerna • Kompatibelt med existerande tekniker från Microsoft • Förenklar utvecklingen av löst kopplade tjänster • Konfigurationsbaserad kommunikation Enhetlig Interoperabilitet Tjänsteorienterat

6. Lite om generiska klasser • En samlingsklass för olika typer • Lagra instanser i strukturen • Hämta instanser public class Stack {object[] items; public void Push(object item){…} public object Pop(){…} } Stack stack = new Stack(); int i; string s = null; stack.Push(i); stack.Push(s); // Inkonsekvens i typer! string s = (string)stack.Pop(); //Paying for cast

7. Utan generiska klasser • Hur kul är det här egentligen? public class IntegerStack { int[] items; public void Push(int item){…} public int Pop(){…} } public class StringStack { string[] items; public void Push(string item){…} public string Pop(){…} }

8. Med generiska klasser • Mallen • Användningen public class Stack<T> //T är generisk typparameter { T[] items; public void Push(T item){…} public T Pop(){…} } Stack<int> integerStack = new Stack<int>(); integerStack.Push(1); Stack<string> stringStack = new Stack<string>(); stringStack.Push(“Hello, World!”);

9. Detaljer… • Flera typer vid definition • Använda aliaser • Begränsningar public class Point<X,Y>{…} Point<int,int> point = null; using IntegerPoint = Point<int,int>; IntegerPoint point = null; public class Stack<T> where T: IComparable public class Node<T> where T: new() { private T item = new T(); }

10. Mer detaljer… • Kan bara konvertera typparametrar till ”interface” • Ärva från en generisk klass class MyClass<T> { void SomeMethod(T t) { ISomeInterface something = (ISomeInterface)t; SomeClass somethingElse = (SomeClass)t; //Error! } } public BaseClass<T>{…} public ChildClass: BaseClass<string> {…}

11. Mer detaljer… • Generiska metoder public class MyClass { public void MyMethod<T>(T t) { … } } MyClass instance = new MyClass(); instance.MyMethod(3); instance.MyMethod(“Hello, World”);

12. Klienter och tjänster Klient Tjänst

13. “Endpoints” • Endpoints exponerar funktionalitet Klient Tjänst Endpoint Endpoint Endpoint Endpoint

14. Adress, Bindning, Kontrakt • Endpoints exponerar funktionalitet • Adress beskriver VART! • Bindning beskriver HUR! • Kontrakt beskriver VAD! Klient Tjänst A B C C B A A B C A B C

15. Metadata • Endpoints exponerar funktionalitet • Adress beskriver VART! • Bindning beskriver HUR! • Kontrakt beskriver VAD! • WSDL beskriver ”endpoints” WSDL Klient Tjänst A B C C B A A B C A B C

16. Uppträdanden • Uppträdanden beskriver exempelvis • Instansiering och aktivering • Sessionshantering • Transaktioner WSDL Klient Tjänst A B C C B A A B C A B C U U U

17. Definition av kontrakt och tjänst • Kontrakt • Implementation [ServiceContract] public interface IHello { [OperationContract] string Hello(string name); } public class HelloService : IHello { public string Hello(string name) { return "Hello, " + name; } }

18. Hostning av tjänsten • I en egen applikation • IIS/WAS (http://localhost/HelloService/HelloService.svc) class HelloHost { static void Main(string[] args) { ServiceHost host = new ServiceHost(typeof(HelloService)); host.Open(); // Wait until done accepting connections Console.ReadLine(); host.Close(); } } <%@ ServiceHost Language=“C#” Service=“HelloService” %>

19. Konfiguration <?xmlversion="1.0" encoding="utf-8" ?> <configuration> <system.serviceModel> <services> <servicename="HelloService"> <endpoint address="http://localhost/HelloService" binding="basicHttpBinding" contract="IHello" /> </service> </services> </system.serviceModel> </configuration>

20. Implementera klienten • Kod • Konfiguration static void Main(){ IHello proxy =new ChannelFactory<IHello>("HelloEndpoint").CreateChannel(); string r = proxy.Hello("Beat"); Console.WriteLine(r); } <system.serviceModel> <client> <endpointname="HelloEndpoint" address="http://localhost/HelloService" binding="basicHttpBinding" contract="IHello" /> </client> </system.serviceModel>

21. Arkitektur för dagen

22. Agenda • Vad är WCF • Programmera WCF • Kontrakt • ”Hostning” och uppträdanden • Bindningar och metadata • Andra koncept • Migrering eller integration • Monitorering • Säkerhet • Transaktioner • Köhantering

23. Kontrakt • Strukturella – ”Structural” • [DataContract] • [MessageContract] • Agerande – ”Behavioral” • [ServiceContract] • [OperationContract] • [FaultContract]

24. [DataContract] • Oberoende av OO-åtkomstnivåer using System.Runtime.Serialization; [DataContract(Name="PersonType")] public class Person{ [DataMember] public string name; [DataMember(Name="AgeProperty")] private int age; [DataMember] float salary; int positionCode; }

25. [DataContract] • Hantering av samlingar [DataContract] public class LibraryCatalog { [DataMember] System.Collections.Hashtable catalog; }

26. [DataContract] • Använda [KnownType]-attributet [DataContract] [KnownType(typeof(Book))] [KnownType(typeof(Magazine))] public class LibraryCatalog { [DataMember] System.Collections.Hashtable catalog; } [DataContract] public class Book{…} [DataContract] public class Magazine{…}

27. [DataContract] • Vid osäkerhet av datatyper [DataContract] [KnownType(typeof(Book))] [KnownType(typeof(Magazine))] public class PublishedItem { [DataMember] object catalog; [DataMember] DateTime publicationDate; } [DataContract] public class Book{…} [DataContract] public class Magazine{…}

28. [DataContract] • Versionshantering [DataContract] public class Car { [DataMember(IsRequired = true)] public string Model; [DataMember(IsRequired = false)] //default public int HorsePower; }

29. [MessageContract] • För skräddarsydda ”SOAP-headers” • Vilket inte rekommenderas [DataContract] public class PurchaseOrder{...} [MessageContract] public class PurchaseOrderMessage { [MessageHeader] public int Number; [MessageBody(Order = 1)] public PurchaseOrder Order; }

30. [ServiceContract] • Kontrollerar hur strukturella kontrakt serialiseras [ServiceContract] [DataContractFormat(Style=OperationFormatStyle.Document)] //Or Rpc public interface IOrderEntry{...} [ServiceContract] [XmlSerializerFormat(Style=OperationFormatStyle.Document, Use=OperationFormatUse.Literal)] //Or Encoded public interface IOrderEntry{...}

31. [ServiceContract] • Duplex [ServiceContract(Session = true, CallbackContract = typeof(IOrderEntryCallback))] public interface IOrderEntry { [OperationContract(IsOneWay = true)] void PlaceOrder(PurchaseOrder order); } [ServiceContract] public interface IOrderEntryCallback { [OperationContract(IsOneWay = true)] void PlaceOrderCompleted(PurchaseOrderStatus orderStatus); }

32. [ServiceContract] • Implementation • En implementation av ett interface • Klassen kallas då ”Service Type” [ServiceContract] public interface IOrderEntry{ [OperationContract(IsOneWay = true)] void PlaceOrder(PurchaseOrder order); } internal class OrderEntryService : IOrderEntry { void IOrderEntry.PlaceOrder(PurchaseOrder order) { //Your code goes here } }

33. [OperationContract] • Exponera metoder • Egenskapen ”Action” [ServiceContract] public interface IOrderEntry { [OperationContract(IsOneWay=true)] void PlaceOrder(PurchaseOrderorder); } [ServiceContract] public interface IOrderEntry { [OperationContract( Action="http://contoso.com/GetOrder", ReplyAction="http://contoso.com/GetOrderReply")] PurchaseOrder GetOrder(String orderIdentifier); }

34. [OperationContract] • Rekommendation • Använd Action=”*” som en generell funktion [ServiceContract] public interface MyContract{ [OperationContract(IsOneWay = true, Action="urn:crud:insert")] void ProcessInsertMessage(Message message); [OperationContract(IsOneWay = true, Action="urn:crud:update")] void ProcessUpdateMessage(Message message); [OperationContract(IsOneWay = true, Action="urn:crud:delete")] void ProcessDeleteMessage(Message message); [OperationContract(IsOneWay = true, Action="*")] void ProcessUnrecognizedMessage(Message message); }

35. [OperationContract] • Synkront • Asynkront [ServiceContract] public interface IMath { [OperationContract] int Add(int I, int j); } [ServiceContract] public interface IMath { [OperationContract(AsyncPattern = true)] IAsyncResult BeginAdd(int i, int j, AsyncCallback cb, object o); int EndAdd(IAsyncResult result); }

36. [FaultContract] [DataContract] class MyFault{ [DataMember] public string Reason = null; } [ServiceContract] public interface IOrderEntry{ [OperationContract] [FaultContract(typeof(MyFault))] PurchaseOrder GetOrder(String orderId); } public class OrderEntry: IOrderEntry{ public PurchaseOrder GetOrder(string orderId){ try{…} catch(Exception exception) { MyFault theFault = new MyFault(); theFault.Reason = “Some Reason”; throw new FaultException<MyFault>(theFault);} } }

37. [FaultContract] • På klienten [DataContract(Name="MyFault")] public class ClientFault { [DataMember] string Reason = null; } ... try{ PurchaseOrder order = Service.GetOrder(orderId); } catch (FaultException<ClientFault> clientFault){ Console.WriteLine(clientFault.Detail.Reason); }

38. Programmera kontrakt • Kod först • Kontrakt först [ServiceContract] public class OrderEntry{ [OperationContract(IsOneWay = true)] public void PlaceOrder(PurchaseOrder order){ return; } } [ServiceContract] public interface IOrderEntry{ [OperationContract(IsOneWay = true)] void PlaceOrder(PurchaseOrder order); } public class OrderEntry : IOrderEntry{ public void PlaceOrder(PurchaseOrder order) { return; } }

39. WCF och WSDL • WSDL kontrakt genereras i flera filer • Använder <wsdl:import.../> • Scheman separeras alltid från tjänsten • <wsdl:definitions> • <wsdl:portType.../> • <wsdl:binding.../> • <wsdl:service.../> [ServiceContract(Namespace="urn:gadgets-org")] publicinterfaceMyServiceContract {} <endpointname="MyServiceEndpoint" bindingNamespace="http://myservice.com/binding" [ServiceBehavior(Namespace="urn:my-unique-namespace2")] public class MyService : IMyService

40. Agenda • Vad är WCF • Programmera WCF • Kontrakt • ”Hostning” och uppträdanden • Bindningar och metadata • Andra koncept • Migrering eller integration • Monitorering • Säkerhet • Transaktioner • Köhantering

41. Hosting - Implementation • I egna applikationer [ServiceContract] public interface ILenderService {...} internal class LenderService: ILenderService {...} public class Program { static void Main(string[] args) { using (ServiceHost host = ServiceHost( typeof(LenderService))) { host.Open(); Console.WriteLine(”Host is active."); Console.ReadLine(); host.Close(); } } }

42. Hosting - Implementation • I hanterad ”Windows Service” • Processens livslängd kontrolleras av OS • Inbyggd “Service Control Manager” public partial class MyNTService : ServiceBase{ private ServiceHost host = null; public MyNTService() { InitializeComponent(); } protected override void OnStart(string[] args){ this.host = new ServiceHost(typeof(LenderService)); host.Open(); } protected override void OnStop(){ host.Close(); } }

43. Hosting - Implementation • IIS 5.1 och 6 • Bara över HTTP • Med WAS • HTTP, TCP, NamedPipes using System.ServiceModel; namespace MyNamespace { [ServiceContract] public interface ILender {…} internal class LenderService: ILender {…} } <%@ ServiceHost Language=“C#” Service=“MyNamespace.LenderService” %>

44. Uppträdanden • Vid utveckling • Instansiering • ”Concurrency” • ”Throttling” • ”Transactions” • Vid driftsättning

45. Instansiering • .PerCall • En instans per anrop • .PerSession, .Shareable • En instans per session • .Single • En instans per tjänst [ServiceContract]public interface IEcho{ … } [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)] internal class MyService: IEcho{ … }

46. Instansiering • .Single • Med ytterligare konstruktorer [ServiceContract] public interface IEcho{ ... } [ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)] internal class MyService: IEcho{private string myData = null; private MyService(){} internal MyService(string startUpData){this.myData=startUpData;} ... } public class MyHost{MyService service = new MyService(“The initial data”); using(ServiceHost host = new ServiceHost(service)){ ...} }

47. Instansiering • .PerSession [ServiceContract] [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)] public class Math { private long sum = 0; [OperationContract] public int Add(int i, int j) { this.sum = this.sum + i + j; return i + j; } [OperationContract] public long GetTotal() { return this.sum; } [OperationContract] [OperationBehavior(ReleaseInstanceMode = ReleaseInstanceMode.AfterCall)] public void Clear() { this.sum = 0; } }

48. “Concurrency” • Kontrollerar trådsäkerhet för ”Service Type” med tre lägen • Single (som är grundinställning) • Multiple • Reentrant • Inte relevant för instansering per anrop [ServiceContract] public interface IEchoContract{ ... } [ServiceBehavior(ConcurrencyMode=ConcurrencyMode.Multiple)] public class EchoService: IEchoContract{ ... }

49. “Throttling” • Kan användas för att begränsa last • Samtidiga anrop, instanser, kopplingar [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)] public class MyService { ... } <behaviors> <behavior> <throttlingmaxConcurrentCalls="2" maxConnections="10" maxInstances="10"/> </behavior> </behaviors>

50. Agenda • Vad är WCF • Programmera WCF • Kontrakt • ”Hostning” och uppträdanden • Bindningar och metadata • Andra koncept • Migrering eller integration • Monitorering • Säkerhet • Transaktioner • Köhantering