einfaches WCF (asynchron mit MVVM) Tutorial

    • C#
    • .NET (FX) 4.0

    Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von Thias.

      einfaches WCF (asynchron mit MVVM) Tutorial

      Hallo,

      ich habe vor einiger Zeit zwecks meiner Ausbildung ein Praktikum angefangen und arbeite deswegen in meinem zweiten Ausbildungsjahr komplett in einer Firma als Praktikant. Dort wurde mir die Aufgabe zugeteilt, die bisherige Schnittstelle, die mit DCOM arbeitet zu ersetzen. Hier setzt WCF (Windows Communication Foundation) an. Sie ist der "Nachfolger" von diversen Diensten und stellt ein recht mächtiges Framework zur Verfügung. Damit kann man recht "einfach" Server-Client-Applikationen realisieren...

      In diesem Tutorial möchte ich eine einfache Möglichkeit zeigen, wie man von einem Client einen Server anfunkt und dieser dann eine gewisse Aufgabe ausführt. Damit der Client während der Wartezeit nicht einfriert läuft das ganze asynchron. Zur Übersichtlichkeit wurde beim Client das MVVM-Pattern verwendet (näheres dazu findet sich hier)


      Ein WCF-Projekt ist nach dem ABC (Address, Binding, Contract) aufgebaut...ohne das läuft nichts. Wenn man weiß, was für Funktionen man hat/braucht kann man auch von hinten anfangen und nach CBA das ganze aufbauen

      C -> Contract

      nach Möglichkeit durch ein Interface (Schnittstelle) zu lösen, welche druch eine Klasse aufgerufen wird (siehe CdatenVertrag/Ivertrag/IvertragAsynchron)

      B -> Binding

      Angabe des Transportprotokolls (zb. TCP oder Http) in meinem Projekt habe ich TCP gewählt (NetTcpBinding). Bei Microsoft findet man auch noch mehr. Je nach Einsatzzweck wählt man hier das passende aus oder kreiert sich selbst eines...

      A -> Address

      Beinhaltet Angabe zum Protokoll, IpAdresse, Portnummer und Pfad zur Anwendung

      Binding//IpAdresse:Portnummer/PfadzurAnwendung -> in meinem Projekt: net.tcp://localhost:2121/IvertragAsynchron (anstatt localhost kann man auch eine Ipadresse eintragen)

      Damit es am Anfang keine Probleme gibt sollte man

      C#-Quellcode

      1. SecurityMode.None
      setzen.... (siehe im Code zb. Bei Server -> Program Zeile 28)

      Folgender Aufbau:

      Man startet mit einer leeren Projektmappe und fügt dieser folgende Projekte hinzu:

      Client -> WPF-Application
      HilfeTools -> Class Library ("Klassenbibliothek") (wird für das MVVM benötigt)
      Server -> Console-Application
      Vertrag -> Class Library

      Am besten fängt man mit dem Server an...

      Dem Serverprojekt fügt man zwei Klassen hinzu (bzw eine, da eine ja schon standardmäßig angelegt wird) "Cservice" und "Program" oder wie man sie auch immer nennen möchte...

      Die Klasse Cservice führt das aus, was der Server machen soll...zum Beispiel rechnet es Primzahlen aus oder gibt einfach nur nen String "Hallo Welt" zurück
      Die Klasse Program baut eine Verbindung zur "Außenwelt" auf...

      Program:
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.IO;
      3. using System.Linq;
      4. using System.Net;
      5. using System.Net.Sockets;
      6. using System.ServiceModel; //unabdingbar für WCF
      7. using System.Windows.Forms;
      8. using Vertrag;
      10. namespace Server
      11. {
      12. class Program
      13. {
      14. static void Main(string[] args)
      15. {
      16. using (ServiceHost sh = new ServiceHost(typeof(Cservice)))
      17. {
      18. string Host = System.Net.Dns.GetHostName();
      19. var IPAddress = Dns.GetHostEntry(Host).AddressList.First(adr => adr.AddressFamily != AddressFamily.InterNetworkV6); //gibt ipv4 zurück
      21. FileInfo fi = new FileInfo(Application.ExecutablePath); // Pfad von .txt-Datei im Debug-Verzeichnis vom Server
      22. string path;
      23. path= fi.DirectoryName + "\\Portnummer.txt";
      24. string portnummer;
      25. portnummer = File.ReadAllText(path); // liest Portnummer aus .txt heraus
      26. Console.WriteLine("Der Service läuft auf dem Port: " + portnummer);
      27. Console.WriteLine("");
      28. sh.AddServiceEndpoint(typeof(Ivertrag), new NetTcpBinding(SecurityMode.None), "net.tcp://" + IPAddress + ":" + portnummer + "/IvertragAsynchron");
      29. sh.Open();
      30. Console.WriteLine("Server läuft auf: " + "net.tcp://" + IPAddress + ":" + portnummer + "/IvertragAsynchron");
      31. Console.WriteLine("");
      32. Console.WriteLine("Zum Beenden bitte Taste drücken!");
      33. Console.Read();
      34. }
      35. }
      36. }
      37. }


      Hier ließt der Server die Ip-Adresse des Rechners aus, auf dem er gestartet wird und öffnet einen Port. Die Portnummer wird im Debugverzeichnis des Servers als .txt Datei hinterlegt. So kann man recht einfach die Portnummer anpassen/ändern. Nachdem der Server diese Portnummer ausgelesen hat, baut er aus der Ip-Adresse und dem Port sowie dem zugehörigen Vertrag (dazu später mehr) eine Verbindung auf... Dann wartet der Server auf eine Anfrage vom Client...


      Cservice:
      Spoiler anzeigen

      C#-Quellcode

      1. using Vertrag;
      3. namespace Server
      4. {
      5. class Cservice : Ivertrag
      6. {
      7. public bool Ping()
      8. {
      9. return true;
      10. }
      12. public CdatenVertrag DoIt() //public Cvertrag DoIt()
      13. {
      14. System.Threading.Thread.Sleep(1000);
      16. string ergebnis = null;
      17. int n = 0;
      18. n = 100000; // Obergrenze (bis dahin wird nach Primzahlen gesucht)
      19. bool[] prime = new bool[n];
      20. for (int i = 2; i <= n - 1; i++)
      21. {
      22. prime[i] = true;
      23. }
      24. if (true)
      25. {
      26. int i = 2;
      27. while (i * i < n)
      28. {
      29. if (prime[i])
      30. {
      31. ergebnis = ergebnis + " " + i.ToString();
      32. int j = i * i;
      33. while (j < n)
      34. {
      35. prime[j] = false;
      36. j = j + i;
      37. }
      38. }
      39. i += 1;
      40. }
      41. while (i < n)
      42. {
      43. if (prime[i])
      44. {
      45. ergebnis = ergebnis + " " + i.ToString();
      46. }
      47. i += 1;
      48. }
      49. }
      51. return new CdatenVertrag
      52. {
      53. Content = ergebnis//"Daten vom Server!"
      54. };
      56. }
      57. }
      58. }


      Hier werden einfach Primzahlen berechnet...(hier jetzt mal bis 100.000). Das Ergebnis wird in einen String geschrieben und an den Client dann zurück geschickt... return new CdatenVertrag -> Content = ergebnis


      Das war es auch schon zum Server...zu beachten sind die References (Verweise) und Usings

      Jetzt zum Client...

      Dem Client verpasst man eine nicht allzu aufwändige Oberfläche mit WPF/XAML...

      Textbox1 = Eingabefeld für die Ipadresse -> Name: hostNameFeld
      Textbox2 = Eingabefeld für die Portnummer -> Name: portnummerFeld
      Textbox3 = Ausgabefeld des Ergebnisses welches man vom Server erhält -> Name: Ausgabe

      Button = zum Verbindung aufbauen/zum Starten des Clients...
      Den Controlls gibt man halbwegs sinnvolle Namen, sodass man damit später auch was anfangen kann...

      Im XAML-Code sind noch 6 Zeilen wichtig:

      Spoiler anzeigen

      XML-Quellcode

      1. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      2. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      3. mc:Ignorable="d"
      4. d:DesignHeight="300" d:DesignWidth="300"
      5. xmlns:vm="clr-namespace:Client.Viewmodel"
      6. d:DataContext="{d:DesignInstance Type=vm:MainModel}" >


      genaueres ließt man hier

      Ebenfalls wichtig im XAML-Code sind die folgenden Dinge:

      in der Textbox für die IP-Adresse und die Portnummer

      XML-Quellcode

      1. Text="{Binding IpAddress, UpdateSourceTrigger=PropertyChanged}"


      bei der Textbox der Portnummer lautet der Code entsprechend

      XML-Quellcode

      1. Text="{Binding PortNumber, UpdateSourceTrigger=PropertyChanged}"


      beim Button

      XML-Quellcode

      1. Command="{Binding GetDataCommand}"


      beim Ausgabefeld

      XML-Quellcode

      1. Text="{Binding StringContent}"


      so wird der entsprechende Inhalt gebunden.

      Spoiler anzeigen

      XML-Quellcode

      1. <Window x:Class="Client.MainWindow"
      2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      4. Title="Client" Height="345" Width="786" WindowStartupLocation="CenterScreen" ResizeMode="NoResize"
      5. xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
      6. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
      7. mc:Ignorable="d"
      8. d:DesignHeight="300" d:DesignWidth="300"
      9. xmlns:vm="clr-namespace:Client.Viewmodel"
      10. d:DataContext="{d:DesignInstance Type=vm:MainModel}" >
      11. <!--die 4 letzten Zeilen ermöglichen Binding-Picking-->
      12. <!--https://www.vb-paradise.de/index.php/Thread/83442-MVVM-Binding-Picking-im-Xaml-Editor/-->
      13. <Window.Resources>
      14. <Style TargetType="{x:Type TextBlock}">
      15. <Setter Property="Margin" Value="5,0,4,0" />
      16. <Setter Property="VerticalAlignment" Value="Center" />
      17. </Style>
      18. <ImageBrush x:Key="blue" ImageSource="/Bilder/black1.jpg" />
      19. <ImageBrush x:Key="technik" ImageSource="/Bilder/mm1.png" />
      20. </Window.Resources>
      22. <Grid Height="328"
      23. VerticalAlignment="Top"
      24. Background="{StaticResource blue}" Margin="0,0,0,-28">
      25. <Grid.ColumnDefinitions>
      26. <ColumnDefinition/>
      27. <ColumnDefinition Width="0*"/>
      28. </Grid.ColumnDefinitions>
      29. <Grid.RowDefinitions >
      30. <RowDefinition Height="217.28"/>
      31. </Grid.RowDefinitions>
      32. <Menu Name="menu1" Grid.Row="0" VerticalAlignment="Top" Height="21">
      33. <MenuItem Header="Datei">
      34. <MenuItem.ToolTip>
      35. <ToolTip>
      36. <StackPanel>
      37. <TextBlock FontWeight="Bold">Speichern/Laden/Beenden</TextBlock>
      38. <TextBlock>Zum Speichern der Ip-Adresse und der Portnummer</TextBlock>
      39. <TextBlock>Zum Laden der Ip-Adresse und der Portnummer</TextBlock>
      40. <TextBlock>Zum Beenden des Programms</TextBlock>
      41. </StackPanel>
      42. </ToolTip>
      43. </MenuItem.ToolTip>
      44. <MenuItem Header="Speichern"
      45. Command="{Binding Speichern}"/>
      46. <MenuItem Header="Laden"
      47. Command="{Binding Laden}"/>
      48. <Separator/>
      49. <MenuItem Click="OnBeenden"
      50. Header="Beenden"/>
      51. </MenuItem>
      52. </Menu>
      53. <!--UpdateSourceTrigger aktualisiert den Inhalt der TextBox...so wird das erkannt, was hinein geladen wird-->
      54. <TextBox Margin="216,72,376,118"
      55. FontWeight="Medium"
      56. FontSize="16"
      57. Name="hostNameFeld"
      58. Text="{Binding IpAddress, UpdateSourceTrigger=PropertyChanged}"
      59. AcceptsReturn="False">
      60. <TextBox.ToolTip>
      61. <ToolTip>
      62. <StackPanel>
      63. <TextBlock FontWeight="Bold">Ip-Adresse/Host Name</TextBlock>
      64. <TextBlock>Tragen Sie hier die Server-Ip-Adresse oder den Server-Hostnamen ein</TextBlock>
      65. </StackPanel>
      66. </ToolTip>
      67. </TextBox.ToolTip>
      68. </TextBox>
      69. <!--UpdateSourceTrigger aktualisiert den Inhalt der TextBox...so wird das erkannt, was hinein geladen wird-->
      70. <TextBox Margin="424,72,206,118"
      71. FontWeight="Medium"
      72. FontSize="16"
      73. Name="portnummerFeld"
      74. Text="{Binding PortNumber, UpdateSourceTrigger=PropertyChanged}"
      75. AcceptsReturn="False">
      76. <TextBox.ToolTip>
      77. <ToolTip>
      78. <StackPanel>
      79. <TextBlock FontWeight="Bold">Server Portnummer</TextBlock>
      80. <TextBlock>Tragen Sie bitte die Portnummer des Servers ein, mit dem sich der Client verbinden soll</TextBlock>
      81. </StackPanel>
      82. </ToolTip>
      83. </TextBox.ToolTip>
      84. </TextBox>
      85. <TextBox Name="Ausgabe"
      86. Margin="30,138,30,-78"
      87. TextWrapping="Wrap"
      88. Background="{StaticResource blue}"
      89. Foreground="Red"
      90. VerticalScrollBarVisibility="Hidden"
      91. AcceptsReturn="False"
      92. Text="{Binding StringContent}">
      93. <TextBox.ToolTip>
      94. <ToolTip>
      95. <StackPanel>
      96. <TextBlock FontWeight="Bold">Ausgabe</TextBlock>
      97. <TextBlock>Gibt die Antwort des Servers zurück</TextBlock>
      98. </StackPanel>
      99. </ToolTip>
      100. </TextBox.ToolTip>
      101. </TextBox>
      102. <Label Foreground="Red"
      103. Margin="216,37,322,146">Server Ip-Adresse / Hostname
      104. </Label>
      105. <Label Foreground="Red"
      106. Margin="424,37,222,146">Server Portnummer
      107. </Label>
      108. <Label Foreground="Red"
      109. Margin="30,105,660,85">Ausgabe
      110. </Label>
      111. <Label Background="{StaticResource technik}"
      112. Margin="30,21,594,90"/>
      113. <Button Margin="594,72,30,118"
      114. Background="White"
      115. Command="{Binding GetDataCommand}"
      116. Focusable="True"
      117. IsDefault="True"
      118. >Client starten
      119. <Button.ToolTip>
      120. <ToolTip>
      121. <StackPanel>
      122. <TextBlock FontWeight="Bold">Client starten</TextBlock>
      123. <TextBlock>Startet den Client und baut eine Verbindung zum gewünschten Server auf</TextBlock>
      124. </StackPanel>
      125. </ToolTip>
      126. </Button.ToolTip>
      127. </Button>
      128. </Grid>
      129. </Window>


      Das ist der vollständige Code meines Fensters...Ich habe zwei Bilder als Hintergrund verwendet...Entweder ihr löscht den entsprechenden Code raus oder fügt selbst zwei beliebige Bilder hinzu...Einfach dem Client-Projekt einen neuen Ordner hinzufügen ("Bilder") und in diesen zwei Bilder hinzufügen

      dann in die Namen im Code anpassen

      XML-Quellcode

      1. <ImageBrush x:Key="blue" ImageSource="/Bilder/black1.jpg" />
      2. <ImageBrush x:Key="technik" ImageSource="/Bilder/mm1.png" />
      (black1 und mm1 durch eure entsprechenden Namen austauschen (die der Bilder im Ordner "Bilder"


      Jetzt geht man in die Codebehind-Klasse vom Client... -> MainWindows.xaml.cs

      Dort ist eigentlich nur eine Zeile Code von elementarer Bedeutung:

      C#-Quellcode

      1. this.DataContext = new Viewmodel.MainModel();
      Mit deren Hilfe wird das Binding weitergeleitet

      Spoiler anzeigen

      C#-Quellcode

      1. using System.Windows;
      3. //View (inkl. MainWindow.xaml)
      4. namespace Client
      5. {
      6. public partial class MainWindow : Window
      7. {
      8. public MainWindow()
      9. {
      10. InitializeComponent();
      11. this.DataContext = new Viewmodel.MainModel();
      12. // fürs Binding/MVVM hergestellte "Verknüpfung"
      13. }
      15. private void OnBeenden(object sender, RoutedEventArgs e)
      16. {
      17. this.Close();
      18. }
      19. }
      20. }


      jetzt kann man das Viewmodel dem Client hinzufügen...

      Man fügt dem Client eine neue Klasse hinzu und benennt diese jetzt Viewmodel oder wie auch immer (dann muss man die elementare Zeile Code aber wie folgt ändern: [...] = new WieAuchImmerName.MainModel();

      der Viewmodel-Klasse fügt man jetzt die Gegenstücke der im XAML-Code vorbereiteten Bindings hinzu

      C#-Quellcode

      1. public string _IpAddress = "";
      2. public string IpAddress
      3. {
      4. get { return _IpAddress; }
      5. set { _IpAddress = value; NotifyPropertyChanged("ipAddress"); }
      6. }


      Die in im Anführungszeichen stehenden Begriffe ("ipAddress") sind die im XAML genannten

      XML-Quellcode

      1. Text="{Binding IpAddress, UpdateSourceTrigger=PropertyChanged}"


      So weiß das Programm wohin damit...Der UpdateSourceTrigger ist später interessant (bei den HilfeTools)

      Wenn man dem Client eine Ip und eine PortNr. eingetragen hat, kann man diese auch Speichern (über die Menuzeile). So muss man nicht immer beides neu eintippen. Damit der Client das auch übernimmt, muss man die Textboxen "aktualisieren" dafür ist der UpdateSourceTrigger da...

      Wenn man jetzt auf den Button klickt baut der Client die Verbindung zum Server auf...wichtig hierbei ist, dass man die bei Ip und PortNr. die Werte eintippt, die der Server hat, da der Client ja eine Verbindung zum PC aufbaut, auf dem der Server läuft.

      Spoiler anzeigen

      C#-Quellcode

      1. using System.ServiceModel;
      2. using System.Windows.Input;
      3. using Vertrag;
      4. using HilfeTools;
      5. using System.Threading;
      6. using System.Net;
      7. using System.Windows;
      8. using System;
      9. using System.Diagnostics;
      10. using System.IO;
      12. //Viewmodel
      13. namespace Client.Viewmodel
      14. {
      15. public partial class MainModel : Chilfe
      16. {
      17. private IvertragAsynchron objProxy;
      19. public string _StringContent = "";
      20. public string StringContent
      21. {
      22. get { return _StringContent; }
      23. set { _StringContent = value; NotifyPropertyChanged("StringContent"); }
      24. }
      26. public string _IpAddress = "";
      27. public string IpAddress
      28. {
      29. get { return _IpAddress; }
      30. set { _IpAddress = value; NotifyPropertyChanged("ipAddress"); }
      31. }
      33. public string _PortNumber = "";
      34. public string PortNumber
      35. {
      36. get { return _PortNumber; }
      37. set { _PortNumber = value; NotifyPropertyChanged("portNumber"); }
      38. }
      40. private Cbefehl _GetDataCommand;
      41. public ICommand GetDataCommand
      42. {
      43. get { return (_GetDataCommand ?? (_GetDataCommand = new Cbefehl(OnStart))); }
      44. //Der Operator ?? wird NULL-Sammeloperator genannt.
      45. //Der linke Operand wird zurückgegeben, falls dieser NICHT NULL ist.
      46. //Andernfalls wird der rechte Operand zurückgegeben.
      47. }
      49. private Cbefehl _Speichern;
      50. public ICommand Speichern
      51. {
      52. get { return (_Speichern ?? (_Speichern = new Cbefehl(OnSpeichern))); }
      53. }
      55. private Cbefehl _Laden;
      56. public ICommand Laden
      57. {
      58. get { return (_Laden ?? (_Laden = new Cbefehl(OnLaden))); }
      59. }
      61. public void OnSpeichern()
      62. {
      63. Microsoft.Win32.SaveFileDialog dialog = new Microsoft.Win32.SaveFileDialog();
      64. dialog.Filter = "Txt-Files(*.txt)|*.txt";
      66. Nullable<bool> result = dialog.ShowDialog();
      67. if (result == true)
      68. {
      69. File.WriteAllText(dialog.FileName, IpAddress);
      70. }
      71. Nullable<bool> result2 = dialog.ShowDialog();
      72. if (result2 == true)
      73. {
      74. File.WriteAllText(dialog.FileName, PortNumber);
      75. }
      76. }
      78. public void OnLaden()
      79. {
      80. Microsoft.Win32.OpenFileDialog dialogo = new Microsoft.Win32.OpenFileDialog();
      81. dialogo.Filter = "Txt-Files(*.txt)|*.txt";
      83. Nullable<bool> result = dialogo.ShowDialog();
      84. if (result == true)
      85. {
      86. IpAddress = File.ReadAllText(dialogo.FileName);
      87. }
      88. Nullable<bool> result2 = dialogo.ShowDialog();
      89. if (result2 == true)
      90. {
      91. PortNumber = File.ReadAllText(dialogo.FileName);
      92. }
      93. }
      95. public void OnStart()
      96. {
      98. string rmAddres = null;
      99. rmAddres = "net.tcp://" + IpAddress + ":" + PortNumber + "/IvertragAsynchron";
      102. NetTcpBinding nettcpbinding = new NetTcpBinding(SecurityMode.None); // new NetTcpBinding(hier MUSS was stehen!! sonst tuts ned)
      103. ChannelFactory<IvertragAsynchron> chFactory = new ChannelFactory<IvertragAsynchron>(nettcpbinding);
      104. nettcpbinding.MaxReceivedMessageSize = 10485760; // 10485760 entspricht 10 MB
      106. TimeSpan mSpan = default(TimeSpan);
      107. mSpan = new TimeSpan(1200000000); // entspricht 2 Minuten (1 Millisekunde = 10.000 Ticks) -> 2min = 120.000ms = 1.200.000.000Ticks
      108. nettcpbinding.SendTimeout = mSpan;
      110. EndpointAddress epAddress = new EndpointAddress(rmAddres);
      111. objProxy = chFactory.CreateChannel(epAddress);
      113. this.StringContent = "Anfrage läuft...währenddessen kann das Fenster frei bewegt werden";
      114. if (objProxy.Ping())
      115. {
      116. objProxy.BeginDoIt(asyncResult =>
      117. {
      118. this.StringContent = objProxy.EndDoIt(asyncResult).Content; // hier wird die Fehlermeldung geworfen... -> CallbackException
      119. }, null);
      120. }
      122. }
      123. }
      124. }


      In der OnStart-Methode (beim Klicken auf den Button) ist noch was dabei, was verhindert, dass die Verbindung fehlschlägt, da es zu lange dauert oder die Nachricht zu groß ist. TimeSpan und MaxReceivedMessageSize ...Je nachdem wie groß der String ist, kann es sonst zu Problemen führen...ist aber nicht zwingend notwendig


      Damit die erwähnten Bindings/UpdateSourceTrigger funktionieren ist noch ein weiteres Projekt wichtig. Die HilfeTools

      hier braucht man zwei Klassen...nichts aufwändiges...

      Cbefehl:
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Windows.Input;
      4. namespace HilfeTools
      5. {
      6. public class Cbefehl : ICommand
      7. {
      8. private Action _execute;
      10. public Cbefehl(Action execute)
      11. {
      12. _execute = execute;
      13. }
      15. public bool CanExecute(object parameter)
      16. {
      17. return true;
      18. }
      20. public event EventHandler CanExecuteChanged;
      22. public void Execute(object parameter)
      23. {
      24. _execute();
      25. }
      26. }
      27. }


      Hier ist wichtig, dass man von ICommand erbt -> siehe Viewmodel Speichern/Laden


      Chilfe
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.ComponentModel;
      4. using System.Diagnostics;
      5. using System.Linq;
      6. using System.Linq.Expressions;
      7. using System.Reflection;
      9. namespace HilfeTools
      10. {
      11. public abstract class Chilfe : INotifyPropertyChanged
      12. {
      13. public event PropertyChangedEventHandler PropertyChanged;
      14. public void NotifyPropertyChanged(string info)
      15. {
      16. if (PropertyChanged != null)
      17. {
      18. PropertyChanged(this, new PropertyChangedEventArgs(info));
      19. }
      20. }
      21. }
      22. }

      hier ist wichtig, dass man von INotifyPropertyChanged erbt -> siehe Viewmodel Properties für die Textboxen


      Wichtig ist auch, dass man das Projekt HilfeTools dem Client als Verweis hinzufügt...

      Jetzt kommt das Herzstück des Ganzen...

      Der Vertrag:

      Hier legt man 1 Klasse an -> CdatenVertrag
      und zwei Schnittstellen (Interface) -> Ivertrag und IvertragAsynchron

      der CdatenVertrag sieht wie folgt aus:
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Runtime.Serialization;
      5. using System.ServiceModel;
      6. using System.Text;
      8. namespace Vertrag
      9. {
      10. [DataContract(Name = "DemoData")]
      11. public class CdatenVertrag
      12. {
      13. [DataMember(Name = "Content")]
      14. public string Content { get; set; }
      15. }
      16. }


      Bei den beiden Schnittstellen Ivertrag und IvertragAsynchron ist wichtig, dass diese den selben Namen bekommen...
      Ja ich war hier etwas unkreativ und mir ist nichts sinnvolles eingefallen

      Beide müssen in dieser Zeile den Namen identisch haben:

      C#-Quellcode

      1. [ServiceContract(Name = "Grapefruit")]


      Ivertrag:
      Spoiler anzeigen

      C#-Quellcode

      1. using System.ServiceModel;
      3. namespace Vertrag
      4. {
      5. [ServiceContract(Name = "Grapefruit")]
      6. public interface Ivertrag
      7. {
      8. [OperationContract()]
      9. CdatenVertrag DoIt();
      11. [OperationContract()]
      12. bool Ping();
      13. }
      14. }


      IvertragAsynchron:
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.ServiceModel;
      4. namespace Vertrag
      5. {
      6. [ServiceContract(Name = "Grapefruit")]
      7. public interface IvertragAsynchron
      8. {
      9. [OperationContract(AsyncPattern= true)]
      10. IAsyncResult BeginDoIt(AsyncCallback callback, object asyncState);
      11. CdatenVertrag EndDoIt(IAsyncResult result);
      13. [OperationContract(AsyncPattern = false)]
      14. bool Ping();
      15. }
      16. }


      Das ist eigentlich auch schon alles... Der OperationContract mit bool Ping(); kann auch gelöscht werden...das war eigentlich nur zu Testzwecken...


      hier noch ein Paar nähere Infors zu einigen Sachen im Code

      Channelfactory (im Viewmodel)
      MVVM und MVVM2
      Vertrag
      WCF
      Binding

      Ich hoffe ich kann hiermit dem ein oder anderen helfen...Ich hab mir das hier alles selbst beigebracht und es hat einiges an Kraft gekostet durch zu halten, da ich hier nur das Forum hatte, wo ich um Hilfe fragen konnte, weil in meiner Firma keiner mit WCF vertraut ist...


      [edit]

      Auf Wunsch von @ErfinderDesRades habe ich auf meiner Platte noch zwei Beispiele gesucht (VB.Net und C#)...

      das VB-Beispiel ist ein wenig "verkrüpelt" und nicht auf dem aktuellen Stand...
      Das C# Beispiel sollte jetzt dem Tut entsprechen
      Dateien

      • VB-Beispiel.zip

        (2,35 MB, 322 mal heruntergeladen, zuletzt: )

      • WCFeinfachBSP.zip

        (1,64 MB, 475 mal heruntergeladen, zuletzt: )

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Runshak“ ()

      Vielen Dank für das Tut.

      Ich hab fleissig dran rum-studiert - es ist ja eine WCF-Variante ohne Konfigurations-Dateien. Hab auch bischen recherchiert, auch in Richtung Chat, und fand dieses hier: CodeProject: WcfChat
      Das ist aber konfigurations-basiert.
      Letztendlich habe ich dein Teil dann spasseshalber auch auf konfigurations-basiert umgefrickelt. Vorteil davon ist, dass man MetadataExchanging konfigurieren kann, und dem Client-Projekt dann eine "Service-Reference" zufügen, die einen kompletten Client bereitstellt, sodass man im Code ein Objekt verfügbar hat, bei dem man gar nicht mehr merkt, dass man einen Service addressiert.
      Bisher fand ich leider noch nicht, wie man MetadataExchange codeseitig konfiguriert, also ohne eigentümliche Sachen ins Server-Config-File einfügen zu müssen.

      Paar weitere Hinweise auch im Readme.
      Dateien

      vllt hilft dir das weiter:

      Spoiler anzeigen
      ​

      C#-Quellcode

      1. ​class ProxyFactory
      2. {
      3. private static ServiceEndpoint endpoint;
      4. public static FlugServiceClient CreateProxy(string mexUrl)
      5. {
      6. if (endpoint == null)
      7. {
      8. EndpointAddress mexAddress = new EndpointAddress(mexUrl);
      9. MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress);
      10. MetadataSet metadataSet = mexClient.GetMetadata();
      11. WsdlImporter importer = new WsdlImporter(metadataSet);
      12. SerciceEndpintcollection endpoints = importer.ImportAllEndpoints();
      13. endpoint = endpoints[0];
      14. }
      15. FlugSercieClient client = new FlugSercieClient(endpoint.Binding, endpoint.Address);
      16. return client;
      17. }
      18. }


      das ist ein Beispiel aus dem Buch

      Steyer, Manfred/ Schwichtenberg, Holger/ Fischer, Matthias/ Krause, Jörg: Verteilte Systeme und Services mit .NET 4.5 - Konzepte und Lösungen für WCF 4.5 und ASP.NET Web-API, 2. Auflage, Carl Hanser Verlag, München, 2013

      Hier noch ein kleiner Nachtrag zur Sicherheit...

      In meinem Tut habe ich die Sicherheit auf

      C#-Quellcode

      1. new NetTcpBinding(SecurityMode.None)
      gestellt...

      So wird weder auf der Transportebene noch auf der Nachrichtenebene Sicherheit "bereitgestellt"...Aus diesem Grund sollte man das nur für Testzwecke verwenden oder in Ausnahmefällen (wobei ich keine Ausnahme wüsste ;) )


      Transport: Sicherheit wird auf der Transportebene durch das Transportprotokoll bereitgestellt

      Message: SOAP-Nachrichten werden gemäß der WS-Security Standards geschützt und sind für die Authentifizierung zuständig

      TransportWithMessageCredentials: Sicherheit wird mit der Transportsicherheit gewährleistet während die Client-Authentifizierung über Nachrichtensicherheit realisiert wird. Sicherheit ist nur von Endpunkt zu Endpunkt gegeben; es können keine SOAP-Vermittler verwendet werden

      TransportCredentialOnly: Die Client-Authentifizierung wird auf der Transportebene realisiert, es gibt aber keien Integrität und Vertraulichkeit der Nachrichten im Vergleich zu (TWMC). Der Modus ist nur für Umgebungen geeignet, in denen die Übertragung durch andere Mittel sichergestellt wird (bsp: IPSec)

      Both: Es wird sowohl MSMSQ-Transportsicherheit als auch SOAP-Nachrichtensicherheit angewendet für die maximale Sicherheit...allerdings wird hierfür sehr viel Leistung benötigt und es ist nur für das NetMsmqBinding vorhanden...

      Transport und Message kann einfach eingebaut werden wie das "None" (siehe CodeBeispiel ganz am Anfang) für TWMC und TCO werden Zertifikate benötigt, was die Implementierung etwas komplexer gestaltet...sollte ich noch Zeit finden dafür, werde ich das hier nachreichen...

      [edit] Auch bei Transport und Message werden Zertifikate benötigt...das merkt man aber erst wenn man das Projekt nicht mehr lokal ausführen möchte :-/ sorry dafür...bei den andern wird schon beim Kompilieren ein Fehler gezeigt...

      Sicherheitsmodus ->NoneTransportMessageTransportWith MessageCredentialTransport CredentialsOnlyBoth
      Binding v





      BasicHttpBindingStandardjajajajanein
      WSHttpBindingjajaStandardjaneinnein
      WSDualHttpBindingjaneinStandardneinneinnein
      WSFederationHttpBindingjaneinStandardjaneinnein
      NetTcpBindingjaStandardjajaneinnein
      NetPeerTcpBindingjaStandardjajaneinnein
      NetNamedPipeBindingjaStandardneinneinneinnein
      NetMsmqBindingjaStandardjaneinneinja
      MsmqIntegrationBindingjaStandardneinneinneinnein
      WebHttpBindingStandardjaneinneinjanein

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Runshak“ ()

      Hallo,

      erst einmal vielen Dank für dieses nützliche Beispiel!

      Auch wenn es nichts mit WCF zu tun hat, so doch ein Verbesserungsvorschlag zum Code für alle welche dieses Beispiel noch studieren werden.

      Das berechnen der Primzahlen in der Server-Subroutine "DoIt" dauert bei mir ca. 11 Sekunden.

      Dabei benötigt aber nicht die eigentliche Primzahlberechnung so lange, sondern die wiederholt aufgerufene Zeile:

      C#-Quellcode

      1. ergebnis = ergebnis + " " + i.ToString();


      Von daher ist es besser und dramatisch schneller eine String-Liste zu definieren und die Daten zuerst in diese zu speichern.
      Am Ende dann das Ergebnis mit String.Join ermitteln:

      C#-Quellcode

      1. string ergebnis = null;
      2. List<string> ergebnisLst = new List<string>();


      Dann wie folgt:

      C#-Quellcode

      1. // ergebnis = ergebnis + " " + i.ToString();
      2. ergebnisLst.Add((i.ToString()));


      Und zum Schluss der entscheidende String.Join:

      C#-Quellcode

      1. while (i < n)
      3. {
      5. if (prime[i])
      7. {
      9. // ergebnis = ergebnis + " " + i.ToString();
      11. ergebnisLst.Add((i.ToString()));
      13. }
      15. i += 1;
      17. }
      19. ergebnis = String.Join(" ", ergebnisLst);
      21. }


      Bzw. im Spoiler noch einmal der komplette Code

      Spoiler anzeigen


      C#-Quellcode

      1. using System;
      3. using System.Collections.Generic;
      5. using System.Linq;
      7. using System.Text;
      9. using Vertrag;
      11. namespace Server
      13. {
      15. public class Cservice : Ivertrag
      17. {
      19. public bool Ping()
      21. {
      23. return true;
      25. }
      27. public CdatenVertrag DoIt()
      29. {
      31. // System.Threading.Thread.Sleep(1000);
      33. string ergebnis = null;
      35. List<string> ergebnisLst = new List<string>();
      37. int n = 0;
      39. n = 10000000; // Obergrenze zur Berechnung von Primzahlen
      41. bool[] prime = new bool[n];
      43. for (int i = 2; i <= n - 1; i++)
      45. {
      47. prime[i] = true;
      49. }
      51. if (true)
      53. {
      55. int i = 2;
      57. while (i * i < n)
      59. {
      61. if (prime[i])
      63. {
      65. // ergebnis = ergebnis + " " + i.ToString();
      67. ergebnisLst.Add((i.ToString()));
      69. int j = i * i;
      71. while (j < n)
      73. {
      75. prime[j] = false;
      77. j = j + i;
      79. }
      81. }
      83. i += 1;
      85. }
      87. while (i < n)
      89. {
      91. if (prime[i])
      93. {
      95. // ergebnis = ergebnis + " " + i.ToString();
      97. ergebnisLst.Add((i.ToString()));
      99. }
      101. i += 1;
      103. }
      105. ergebnis = String.Join(" ", ergebnisLst);
      107. }
      109. return new CdatenVertrag
      111. {
      113. Content = ergebnis//"Daten vom Server!"
      115. };
      117. }
      119. }
      121. }