.NET 3.0 i 3.5

.NET 3.0 i 3.5
.NET 3.0


Składa się z:
−
.NET Framework
−
Microsoft Windows Communication Foundation
−
Microsoft Windows Presentation Foundation
−
Microsoft Windows Workflow Foundation
.NET Framework – jak w wersji 2.0
WCF


Zarządzane podejście do systemów
rozproszonych
Model programowania zorientowany na serwisy
(service model)
−

Mapowanie pomiędzy serwisami a elementami CLR
– mapowanie wiadomości do implementacji w C#
lub VB
Wsparcie dla wielu rodzajów aplikacji
rozproszonych, architektura warstwowa
−
Kanały umożliwiające asynchroniczne przesyłanie
wiadomości, bez wsparcia dla typów
−
Protokoły wykorzystujące ww. kanały
Przykład użycia WCF
http://msdn2.microsoft.com/en-us/library/ms731082(VS.85).aspx
Założenia

System (serwer) musi być dostępny zarówno
wewnątrz organizacji, jak i na zewnątrz, przy
użyciu różnych klientów:
−
Aplikacja kliencka wewnątrz organizacji (call
center), używająca .NET i WCF
−
Aplikacja kliencka J2EE, konieczna z powodu
współpracy z inną firmą i mająca dostęp do nowego
systemu.
−
Aplikacje klienckie z dostępem przez Internet –
zróżnicowane pod względem platform
Bez WCF

Konieczność wykorzystania następujących
technologii:
−
ASP.NET Web services (ASMX) – do komunikacji z J2EE
i klientami przez Internet
−
.NET Framework remoting – do komunikacji z call center,
ponieważ zarówno klient, jak i serwer wykorzystują .NET.
Umożliwia „przezroczystą” komunikację aplikacji .NET
−
Enterprise Services – definiują rozproszone transakcje i
czas życia obiektów
−
Web Services Enhancements (WSE) – dla zapewnienia
lepszego bezpieczeństwa ASMX
−
Microsoft Message Queuing (MSMQ) – wsparcie dla
komunikacji z klientami Windows
Z wykorzystaniem WCF

WCF zapewnia następującą funkcjonalność:
−
Ponieważ może komunikować się z wykorzystaniem web
services (przez SOAP) – współpracę z J2EE
−
Komunikację z wykorzystaniem web services przez inne
protokoły (np. RSS)
−
Wysoką wydajność w porównaniu z innymi rozproszonymi
platformami firmy Microsoft
−
Szybszą niż tekstowa komunikację binarną z innymi
aplikacjami WCF (struktura danych jest nadal zgodna z
SOAP)
−
Zarządzanie czasem życia obiektów i rozproszonymi
transakcjami
−
Bezpieczeństwo
Architektura WCF
http://msdn2.microsoft.com/en-us/library/ms733128(VS.85).aspx
Kontrakty

Określa jak komunikować się z serwisem:
−
Data – parametry wiadomości (przy pomocy XSD)
−
Message – fragmenty wiadomości (przy pomocy
SOAP)
−
Service – sygnatury metod (np. w C#)
−
Policy and binding – warunki komunikacji z
serwisem (co najmniej transport – np. HTTP,
kodowanie i wymogi bezpieczeństwa)
Service runtime

Zachowania dotyczące pracy serwisu, np.:
−
Throttling – ile wiadomości przetwarzać żeby nie
zablokować serwisu
−
Error – co robić w przypadku błędu
−
Instance – ile egzemplarzy serwisu może działać
−
Transaction – umożliwia 'rollback' nieudanych
transakcji
Messaging

Składa się z kanałów. Kanał w pewien sposób
przetwarza wiadomości. Zespół kanałów to
stos. Wyróżnia się kanały:
−
Transportu – czytają i piszą wiadomości z/do sieci
(lu innego medium komunikacyjnego). Np. HTTP,
TCP, MSMQ. Mogą stosować różne rodzaje
kodowania
−
Protokołu – implementują protokoły przetwarzania
wiadomości, zwykle poprzez czytanie/pisanie
dodatkowych nagłówków wiadomości. Np. WSSecurity
Activation and hosting

Serwis – ostatecznie – to program który musi
być wykonywany. Może być:
−
Samodzielny (exe) – tzw. self-hosted
−
Zarządzany przez zewnętrzne środowisko (np. IIS,
WAS)
Przykładowe użycie WCF - serwer
http://msdn2.microsoft.com/en-us/library/ms731835(VS.85).aspx



Utworzyć projekt
Zdefiniować kontrakt (kolekcja i struktura wiadomości
wymaganych do dostępu do serwisu):
−
Dodać odwołanie do System.ServiceModel
−
Utworzyć odpowiednie interfejsy, zastosować atrybut
ServiceContract
−
Utworzyć metody w interfejsie, zastosować atrybut
OperationContract
Domyślny kontrakt wykorzystuje schemat żądanieodpowiedź. Inne schematy można wymusić poprzez
własności atrybutów OperationContract i
ServiceContract
Kod
using System;
using System.ServiceModel;
namespace Microsoft.ServiceModel.Samples
{
// Define a service contract.
[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
public interface ICalculator
{
[OperationContract]
double Add(double n1, double n2);
[OperationContract]
double Subtract(double n1, double n2);
[OperationContract]
double Multiply(double n1, double n2);
[OperationContract]
double Divide(double n1, double n2);
}
}
Przykładowe użycie WCF - serwer

Zaimplementować kontrakt – klasę
implementującą interfejs
Kod
public class CalculatorService : ICalculator
{
public double Add(double n1, double n2)
{
double result = n1 + n2;
Console.WriteLine("Received Add({0},{1})", n1, n2);
Console.WriteLine("Return: {0}", result);
return result;
}
public double Subtract(double n1, double n2)
{
double result = n1 - n2;
Console.WriteLine("Received Subtract({0},{1})", n1, n2);
Console.WriteLine("Return: {0}", result);
return result;
}
public double Multiply(double n1, double n2)
{
double result = n1 * n2;
Console.WriteLine("Received Multiply({0},{1})", n1, n2);
Console.WriteLine("Return: {0}", result);
return result;
}
public double Divide(double n1, double n2)
{
double result = n1 / n2;
Console.WriteLine("Received Divide({0},{1})", n1, n2);
Console.WriteLine("Return: {0}", result);
return result;
}
}
Przykładowe użycie WCF - serwer

Uruchomić serwis:
−
Utworzyć adres bazowy dla serwisu

Utworzyć odpowiednie uri, np.:
Uri baseAddress = new Uri("http://localhost:8000/ServiceModelSamples/Service");
−
Utworzyć hosta dla serwisu

Utworzyć obiekt typu ServiceHost:
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);

Dodać punkt końcowy z określonym transportem
serviceHost.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(),
"CalculatorService");
−
Umożliwić wymianę metadanych

−
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
serviceHost.Description.Behaviors.Add(smb);
Otworzyć hosta serwisu
Kod
class Program
{
static void Main(string[] args)
{
Uri baseAddress = new Uri("http://localhost:8000/ServiceModelSamples/Service");
ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService), baseAddress);
try
{
serviceHost.AddServiceEndpoint(
typeof(ICalculator),
new WSHttpBinding(),
"CalculatorService");
ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
smb.HttpGetEnabled = true;
serviceHost.Description.Behaviors.Add(smb);
serviceHost.Open();
Console.WriteLine("The service is ready.");
Console.WriteLine("Press <ENTER> to terminate service.");
Console.WriteLine();
Console.ReadLine();
serviceHost.Close();
}
}
}
catch (CommunicationException ce)
{
Console.WriteLine("An exception occured: {0}", ce.Message);
serviceHost.Abort();
}
Service – strona serwisu
Przykładowe użycie WCF - klient

Utworzyć projekt

Dodać odwołanie do System.ServiceModel

Uruchomić serwer (serwis)

Uruchomić Service Model Metadata Utility Tool
(SvcUtil.exe) - część Windows SDK
−

svcutil.exe /language:cs /config:app.config http://localhost:8000/ServiceModelSamples/service
Dodać wygenerowany plik z kodem do projektu
Przykładowe użycie WCF - klient

Skonfigurować klienta
−
Dodać do projektu plik konfiguracyjny
wygenerowany przez Svcutil
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.serviceModel>
<bindings>
<wsHttpBinding>
<binding name="WSHttpBinding_ICalculator">
</binding>
</wsHttpBinding>
</bindings>
<client>
<endpoint address="http://localhost:8000/ServiceModelSamples/Service/CalculatorService"
binding="wsHttpBinding"
bindingConfiguration="WSHttpBinding_ICalculator"
contract="Microsoft.ServiceModel.Samples.ICalculator"
name="WSHttpBinding_ICalculator">
</endpoint>
</client>
</system.serviceModel>
</configuration>
Przykładowe użycie WCF - klient

Używać klienta:
−
Utworzyć obiekt klasy EndpointAddress
EndpointAddress epAddress = new EndpointAddress
("http://localhost:8000/ServiceModelSamples/Service/CalculatorService");
CalculatorClient client = new CalculatorClient(new WSHttpBinding(), epAddress);
−
−
Wywoływać operacje udostępniane przez serwis
Zamknąć klienta
using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
namespace ServiceModelSamples
{
Kod
class Client
{
static void Main()
{
EndpointAddress epAddress = new EndpointAddress("http://localhost:8000/ServiceModelSamples/Service/CalculatorService");
CalculatorClient client = new CalculatorClient(new WSHttpBinding(), epAddress);
double value1 = 100.00D;
double value2 = 15.99D;
double result = client.Add(value1, value2);
Console.WriteLine("Add({0},{1}) = {2}", value1, value2, result);
value1 = 145.00D;
value2 = 76.54D;
result = client.Subtract(value1, value2);
Console.WriteLine("Subtract({0},{1}) = {2}", value1, value2, result);
value1 = 9.00D;
value2 = 81.25D;
result = client.Multiply(value1, value2);
Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);
value1 = 22.00D;
value2 = 7.00D;
result = client.Divide(value1, value2);
Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);
client.Close();
Console.WriteLine();
Console.WriteLine("Press <ENTER> to terminate client.");
Console.ReadLine();
}
}
}
Windows Presentation Foundation
(WPF)
http://msdn2.microsoft.com/en-us/library/aa970268(VS.85).aspx


Umożliwia tworzenie klienckich aplikacji dla
Windows
Większość klas opiera się na jednej z:
−
−
−
−


UIElement
FrameworkElement
ContentElement
FrameworkContentElement
Interfejs użytkownika jest zbudowany jako
drzewo
Zdarzenia w elementach mogą być
przekazywane zgodnie ze strukturą drzewa
Windows Presentation Foundation
(WPF)

UI jest konstruowane przy użyciu Extensible
Application Markup Language (XAML),
opartego o XML:
<Window
Xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<Button>Hello, XAML!</Button>
</Window>
Standardowe kontrolki

Control – klasa bazowa
−
edycja: CheckBox, ComboBox, PasswordBox, RadioButton, RichTextBox,
Slider, TextBox
−
listy: ListBox, ListView, TreeView
−
informacje: Label, ProgressBar, Popup, ToolTip
−
czynności: Button, ContextMenu, Menu, Separator, StatusBar, Thumb,
ToolBar
−
wygląd: Border, BulletDecorator, Decorator, Image, Viewbox
−
Okienka dialogowe: OpenFileDialog, PrintDialog, SaveFileDialog
−
pojemniki: Expander, GroupBox, RepeatButton, ScrollBar, ScrollViewer,
TabControl
−
rozkład: Canvas, DockPanel, Grid, GridSplitter, Panel, StackPanel,
VirtualizingStackPanel, WrapPanel.
−
nawigacja: Frame, Hyperlink
−
dokumenty: DocumentViewer, FlowDocumentPageViewer,
FlowDocumentReader, FlowDocumentScrollViewer
Praca z danymi

Możliwość powiązania różnych źródeł danych z
elementami UI
<Window ... xmlns:src="clr-namespace:ApplicationNameSpace">
...
<!-- Binding Source -->
<Window.Resources>
<src:Person x:Key="myDataSource" PersonName="Joe"/>
</Window.Resources>
...
<!-- Binding Target -->
<TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=PersonName}" />
...
</Window>
Standaryzacja wyglądu

Możliwośc definiowania wspólnego wyglądu dla
grupy elementów
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Window.Resources>
<SolidColorBrush x:Key="defaultBackground" Color="Red" />
</Window.Resources>
< StackPanel>
<Button Background="{StaticResource defaultBackground}">One Button</Button>
<Label Background="{StaticResource defaultBackground}">One Label</Label>
</StackPanel>
</Window>

Możliwośc stosowania styli
<Style TargetType="{x:Type Button}">
<Setter Property="Background" Value="Yellow"/>
</Style>
Możliwość zmiany wyglądu kontrolki
przy zachowaniu funkcjonalności

Wykorzystuje control templates
<Button Content="Not Pressed">
<Button.Template>
<ControlTemplate TargetType="{x:Type Button}">
<Border x:Name="border" CornerRadius="80" Background="LightBlue">
<ContentPresenter Name="content" HorizontalAlignment="Center"
VerticalAlignment="Center"/>
</Border>
<ControlTemplate.Triggers>
<Trigger Property="IsPressed" Value="True">
<Setter TargetName="border" Property="Background" Value="Aqua" />
<Setter TargetName="content" Property="Content" Value="Pressed" />
</Trigger>
</ControlTemplate.Triggers>
</ControlTemplate>
</Button.Template>
</Button>
Możliwość zmiany wyglądu
zawartości kontrolki

Wykorzystuje data templates
<DataTemplate x:Key="myTaskTemplate">
<Border Name="border" BorderBrush="Aqua" BorderThickness="1"
Padding="5" Margin="5">
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition/>
<RowDefinition/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition />
<ColumnDefinition />
</Grid.ColumnDefinitions>
<TextBlock Grid.Row="0" Grid.Column="0" Text="Task Name:"/>
<TextBlock Grid.Row="0" Grid.Column="1"
Text="{Binding Path=TaskName}" />
<TextBlock Grid.Row="1" Grid.Column="0" Text="Description:"/>
<TextBlock Grid.Row="1" Grid.Column="1"
Text="{Binding Path=Description}"/>
<TextBlock Grid.Row="2" Grid.Column="0" Text="Prioirty:"/>
<TextBlock Grid.Row="2" Grid.Column="1"
Text="{Binding Path=Priority}"/>
</Grid>
</Border>
</DataTemplate>
Rozplanowanie UI przy pomocy
paneli

Kontrolki: Canvas, DockPanel, Grid,
StackPanel, VirtualizingStackPanel, WrapPanel
<DockPanel>
<DockPanel.Resources>
<Style TargetType="{x:Type Border}">
<Setter Property="BorderBrush" Value="Black" />
<Setter Property="BorderThickness" Value="1" />
</Style>
<Style TargetType="{x:Type TextBlock}">
<Setter Property="Margin" Value="5" />
<Setter Property="FontWeight" Value="Medium" />
</Style>
</DockPanel.Resources>
<Border Background="SkyBlue" DockPanel.Dock="Top">
<TextBlock>Dock = "Top"</TextBlock>
</Border>
<Border Background="SkyBlue" DockPanel.Dock="Top">
<TextBlock>Dock = "Top"</TextBlock>
</Border>
<Border Background="PaleGoldenrod" DockPanel.Dock="Bottom">
<TextBlock>Dock = "Bottom"</TextBlock>
</Border>
<Border Background="PaleGreen" DockPanel.Dock="Left">
<TextBlock>Dock = "Left"</TextBlock>
</Border>
<Border Background="White">
<TextBlock>This content "Fills" the remaining, unallocated space.</TextBlock>
</Border>
</DockPanel>
Wsparcie dla multimediów

Grafika 2D:
−
−
−

Grafika 3D
−



Proste kształty
Własne kształty
Maski
Wykorzystanie sprzętowej akceleracji
Animacja
Strumienie audio
Strumienie wideo
Windows Workflow Foundation
(WWF)
http://msdn2.microsoft.com/en-us/library/ms734631(VS.85).aspx




Model, engine i narzędzia do budowy
aplikacji typu workflow
Workflow jest rozumiany jako zestaw
jednostkowych elementów (activity)
połączonych w sposób opisujący
kolejność ich wykonywania i zależności
między nimi
Wiele egzemplarzy workflow może być
wykonywanych jednocześnie
Workflow może być umieszczony w
każdym procesie Windows (aplikacji
konsolowej, serwisie, aplikacji ASP .NET)
i komunikować się z tym procesem
Czynności (activities)



Czynności są dodawane programowo do
workflow
Czynność może zawierać pojedynczą akcję,
może też zawierać zbiór innych czynności
Czynności mają dwa rodzaje zachowania:
−
−

W momencie projektowania – jak czynność jest
prezentowana podczas procesu projektowania
W momencie wykonania
WWF zawiera bibliotekę standardowych
czynności i wsparcie dla tworzenia własnych
czynności
Wsparcie dla typowych zachowań
wymaganych przez workflow




Compensation – przywrócenie stanu sprzed
wykonania czynności (potrzebne np. do obsługi
wyjątków)
Persistence – zapisywanie workflow tak aby
mógł być kontynuowany w przypadku restartu
aplikacji
Tracking – logowanie zdarzeń w workflow, np.
do bazy danych
Serialization – zapis i odczyt workflow i
czynności
Elementy decyzyjne

Decyzje dotyczące przebiegu workflow mogą
być budowane w oparciu o:
−
−
Warunki: czynności IfElseBranchActivity i
ConditionedActivityGroup
Reguły – definiowane programowo lub poprzez plik
XML. Reguły mogą być zmieniane podczas pracy
workflow
.NET 3.5

Zmiany w stosunku do 3.0:
−
ASP .NET:



−
Lepsze wsparcie dla technologii AJAX, zarówno od
strony serwera, jak i klienta
Wsparcie dla serwisów WCF
Kilka nowych kontrolek
Wsparcie dla „rozszerzalnych” aplikacji
(System.AddIn.dll)
.NET 3.5
−
CLR:









Nowa kolekcja – HashSet
Wsparcie dla diagnostyki – EventSchemaTraceListener
Pipes – anonymous i named
Możliwość wpływu na działanie garbage collector
Poprawa wydajności synchronizacji i wątków thread pool
Nowe struktury dal czasu i daty
Nowe elementy dla kryptografii
Wsparcie dla sieci Peer-to-Peer
Poprawa wydajności socketów
.NET 3.5
−
−
−
−
−
Połączenie Windows Workflow Foundation i
Windows Communication Foundation
Zmiany i rozszerzenia w WCF
Zmiany i rozszerzenia w WPF
Rozszerzenia w Windows Forms
Language-Integrated Query (LINQ) – możliwość
formułowania zapytań w C# i VB