1 / 113

Välkommen till Sommarkollo 2006 Windows Communication Foudnation

2006. Välkommen till Sommarkollo 2006 Windows Communication Foudnation. Windows Communication Foundation. Johan Lindfors. Agenda. Vad är WCF Programmera WCF Kontrakt ”Hostning” och uppträdanden Bindningar och metadata Andra koncept Migrering eller integration Monitorering Säkerhet

reed-dale
Télécharger la présentation

Välkommen till Sommarkollo 2006 Windows Communication Foudnation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related