Im folgenden Artikel möchte ich über einige Neuerungen in WPF 4.0  schreiben

Visual StateManager

Verbessertes Management von States und Transitions, das Aussehen wird durch VisualStates repräsentiert. Ein VisualState enthält eine Liste von StoryBoard-Objekten, welche beschreiben wie sich ein Element verändert.

• Methoden im VSM: GoToElementState (ohne ControlElement), GoToState (mit ControlTemplate)
• Ersetzt, bzw vereinfacht Trigger
• Von Silverlight übernommen, somit kompatibel
• In Blend 3 verfügbar

Quelle:

• http://windowsclient.net/wpf/wpf35/wpf-35sp1-toolkit-visual-state-manager-overview.aspx

Neue WPF Tools

Die neuen WPF Tools stammen aus dem WPF Toolkit und wurden in der WPF 4.0 übernommen. Dieses sollen 99% kompatibel zu Silverlight sein.

• Datagrid
• Unterstützt Validierung für Zellen und Zeilen
• DatePicker
• Calendar
• Anzeige kann mit DisplayMode verändert werden
• (Größe kann nur über Transformer verändert werden)

Multitouch

Toucheingaben werden unterstützt

• MultiTouch Events für UIElement, UIElement3D und ContentElement über IsManipulationEnabled
• TouchDown
• TouchMove
• TouchUp
• TouchEnter
• TouchLeave
• GetTouchPoint (Returns the current position of the touch device relative to specified element)
• TouchDevice (Get the device, that generated the event)
• Device (Gets the input device the initiated thid event – inherited from InputEventArgs)
• IsManipulationEnabled:
• ManipulationStarted
• ManipulationDelta
• ManipulationStarting
• ManipulationComplited

UIElement unterstützt auch Expansion, Scale, Rotation, Translation (ManipulationStarted, ManipulationDelta,…)

Quellen:

• http://blogs.msdn.com/jaimer/
• http://blogs.msdn.com/llobo/archive/2009/11/24/new-wpf-features-multitouch.aspx

Grafik und Animation in WPF

Pixel Shader 3 Support

• BitmapEffect-Property -> obsolete
• Neu: Effect-Property
• .NET 3.5 unterstützt bis Version 2.0

1
2
3

RenderCapability.IsPixelShaderVersionSupported(majorversion,minorVersion)
RenderCapability. IsPixelShaderVersionSupportedlnSoftware (majorversion,minorVersion)
RenderCapability. MaxPixelShaderlnstructionSlots(majorversion,minorVersion)

Layout-Rounding

• UseLayoutRounding=”true” (erbt von FrameworkElement)
• Vererbbar
• In Silverlight default
• 

Quellen:

• http://blogs.msdn.com/text/archive/2009/08/27/layout-rounding.aspx

ClearTypeHint

Soll das TextRendering erheblich verbessern, in Silverlight 3 wird ClearTypeHint offiziell schon unterstützt. Hierzu muss die Property RenderOptions.ClearTypeHint auf Enabled gestellt werden.

Durch verschiedene Beeinflussung kann die Property den Status verlieren (Effect, OpacityMask, VisualBrush, DrawingBrush, Clip, and Opacity) Kann aber dann aber wieder enabled werden. Folgende mögliche Ausnahmen sollen das verdeutlichen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<Window AllowsTransparency="True" WindowStyle="None" RenderOptions.ClearTypeHint="Enabled">
  <StackPanel>
    <TextBlock Name="Block1">This text will be rendered with ClearType.</TextBlock>
    <TextBlock Opacity="0.9" Nane="Block2" >This text will be rendered with NO ClearType (note the opacity Prop)./>
 
  <Grid Height="l00" Background="White">
    <Grid.Clip>
      <Ellipse3eometry RadiusX="300" RadiusY="200" Center="150, 120" />
    </Grid.Clip>
 
  <Grid. RowDefinitions>
    <RowDefinition />
  </Grid.RowDefinition>
 
  <TextBlock Name="Block3">This text will be rendered with NO ClearType . </TextBlock>
  <TextBlock Name="Block4" Grid.Row="1" RenderOptions.ClearTypeMint="Enabled">This text will be rendered with ClearType</TextBlock>
  </Grid>
 
  <TextBlock Name="Block5">This text will be rendered with ClearType.</TextBlock>
</StackPanel>
</Window>

Here the values are set as per the hierarchy

• Window -> hint enabled
• StackPanel -> inherits Hint (cleartype)
• Blockl -> inherits Hint (cleartype)
• Block2 -> overrides Hint because of Opacity [intermediate rendertarget]
• Grid -> overrides Hint because of Clip [intermediate rendertarget]
• Block3 -> Inherits Grid‘s hint (No cleartype)
• Block4 -> overrides Hint to enabled (Cleartype)

Quellen:

• http://blogs.msdn.com/llobo/archive/2009/10/28/new-wpf-features-cleartypehint.aspx

Cached Composition

Spezieller Videospeicher, der das aktuelle Objekt vorhalten kann. Unterstützt somit das Manipulieren ohne neu zu Rendern. (GPU rendert aus dem Cache und entlastet die CPU)

• Bessere Performance
• CacheModeProperty BitmapCache muss aktiviert werden
• Vererbbar

1
2
3
4
5
6

<Canvas>
  <Canvas.CacheMode>
    <BitmapCache EnableClearType="False" RenderAtScale="2" />
  </Canvas.CacheMode>
  <Canvas.CacheMode="BitmapCache" />
</Canvas>

Text Rendering Stack

Klarerer, sauberer Text. Soll die Schärfe von Win32/GDI entsprechen

• ClearType
• GrayScale
• Aliased

Text Formatting Mode

Bisher war es so, das klein skalierter Text nicht anständig gerendert wurde. Mit TextOptions.TextFormattingMode kann man hier nachhelfen

1
2

<TextBox TextOptions.TextFormattingMode="Ideal" FontSize="15" Text="Hello World" />
<TextBox TextOptions.TextFormattingMode="Display" FontSize="15" Text="Hello World" />

Animation Easing Functions

• Dieses Feature wurde aus Silverlight 3 übernommen und kann in wenigen Schritten eine Animation auf ein Element abspielen
• In WPF wurden zuvor Trigger anstelle dessen verwendet.
• Somit sind auch die Animationen ab WPF 4.0 zu Silverlight kompatibel
• Verfügbar auch in Expression Blend unter -> WorkSpaces/Animation, in Klick in der Timeline auf Effekt, gibt die Auswahl zu Easy Functions

Selection Brush (Caret Brush)

Beeinflusst den Hintergrund von markierten Text

1
2
3

SelectionBrush="RED"
Selectionopacity="O.3" (Default value is 0.6)
CaretBrush="Red"

Binding in WPF 4.0

Unterstützung von dynamischen Objekten (DynamcObject, IDynamicMetaObjectProvider)

Bindable Run

• Im RichTextEditor ist die Dependency Property RUN nun bindable

1
2
3
4
5
6
7
8
9

<FlowDocumentReader>
  <FlowDocument>
    <Paragraph>
      <Run>Sample Text Beginning:</Run>
      <Run Text="{Binding ElementName='tbl' ‚ Path=Text" />
      <Run>End of sample text.</Run>
    </Paragraph>
  </FlowDocument>
</FlowDocumentReader>

Quellen:

• http://blogs.msdn.com/text/archive/2009/09/01/bindable-run.aspx

Binding to dynamic objects

Ermöglich das Binden an einen dynamischen Typen

1
2
3
4
5
6

dynamic dynamicObj = BindPanel.DataContext ;
dynamicObj.A = "Simple Binding";
dynamicObj.B = new DynamicObjectClass();
dynamicObj.B.C = "Nested Prop Binding";
dynamicObj.Addltem("item 0");
dynamicObj[0] = "Indexer Binding";

1
2
3
4
5
6
7
8

<Window.Resources>
  <local:DynamicObjectClass x:Key="MyDynamicObject" />
</Window.Resources>
 
<StackPanel Name="BindPanel" DataContext="{StaticResource MyDynamicObject}">
  <TextBoxText="{Binding Path=A}" />
  <TextBlock Text="{Binding Path=B.C}" />
  <TextBox Text{Binding Path=[(x:int32)0)}" />

Custom Speller Dictionary

Ermöglicht anhand von eigenen Dictionaries eine Rechtschreibprüfung

1
2
3
4
5
6
7
8
9
10

<RichTextBox FontSize="24" SpellCheck.IsEnabled="true" >
  <SpellCheck.CustomDictionaries>
    <sys:Uri>Dictionary1.lex</sys Uri>
    <sys1:Uri>\\dictServer\Dictionary3.txt</sys1:Uri>
  </SpellCheck.CustomDictionaries>
  <FlowDocument>
    <Paragraph>Some Names: Max Musterman</Paragraph>
    <Paragraph>Misspelled: Max Mustermann</Paragrap>
  </FlowDocument>
</RichTextBox>

Windows7 API

• System.Windows.Shell – TaskBar
• Ist das OS < Windows7, wird keine Exception ausgelöst
• Einfacher Verwendung in Xaml
• Window.TaskBarItemInfo
• Overlay
• ProgressState, ProgressValue
• Xaml ThumbButtonInfo
• Application.xaml Jumplist JumpTask !!

1
2
3
4

<Window.TaskbarItemInfo>
  <TaskbarItemlnfo Description="My TaskbarItemInfo Overlay="..\Resources\powerButton.ico>
  <TaskbarItemlnfo.ThumbButtonInfos>
    <ThumbButtonInfos Command="Cut" CommandTarget="{Binding Elementname=textBox} Description="(Binding RelativeSource={RelativeSource Self), Path=Command.Text}" DismissWhenClicked="False" ImageSource="..\Resources\cut.png" />

XBAP Script Interop / Full Trust XBAP Deployment

Via Assemblyeinstellung ist es möglich aus der Sandbox heraus zu kommen und auf das System zuzugreifen. Applikationen wie Excel lassen sich so aus XBAP heraus öffnen und bearbeiten.

FileDialog Update

In der vorherigen Version, sah das Design der DialogBox unter XP und Vista unterschiedlich aus. Durch einige Workarounds konnte man das abgleichen. In der Version 4.0 wurde dieses Problem nun behoben.

XAML Neuerungen

• x:Arguments
• x:FactoryMethod
• x:Reference (anstatt Binding ElementName)

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 12. März 2010 -- Named & Optional Arguments, Co- & Contravariance, Dynamic und COM Interop
• 15. März 2010 -- Expression Blend 4.0 Beta
• 12. März 2010 -- Neuerungen in Visual Studio 2010
• 12. März 2010 -- Weitere Neuerungen im .NET Framework 4.0
• 12. März 2010 -- Parallele Programmierung mit .NET 4.0

Im folgenden Artikel möchte ich über einige Neuerungen in Visual Studio 2010 schreiben

Zu Beginn eine  Übersicht, welche Komponenten in welcher Version enthalten sein werden:

WPF basierter Editor

Der Editor in VisualStudio 2010 ist komplett in WPF umgesetzt.

MultiMonitor Unterstützung

Für alle Fenster wird der Multimonitorbetrieb unterstützt

Stufenloser Zoom

Mit STRG – Mausrad kann der Code vergrößert werden

Navigation

• Quick Search
• Highlight References

UML Designer (UltimateVersion)

• Die Ultimate Edition von Visual Studio unterstützt die Modellierung mit UML (use-case-, class-, sequence-, activity- und componentdiagramme)
• Beinhaltet eine Code-Generierung (T4-TextTemplate) für C# und Visual Basic
• Beinhaltet eine Datenbank Script-Generierung

Quelle: http://www.olegsych.com/2010/01/uml-modeling-and-code-generation-in-visual-studio-2010/

Debugging

Mit den neuen Funktionen von VS2010 können Windows-, Web, .NETbasierende Anwendungen effizienter und komfortabel, sowohl in virtuellen als auch in echten 32- und 64Bit Umgebungen, getestet werden.

Pin to Source

Mit Pin2Source kann man aus dem KontextMenu heraus die entsprechende Variable oder Abschnitt im QuellText “anpinnen”:

Tracepoints, Breakpoints, Conditionals

TracePoints

Im KontextMenü des Editors findet man den Punkt “Insert Tracepoint”. TracePoints sind eine Erweiterung der Breakpoints und erlauben es, das Erreichen einer Ausführungszeile mit einer Aktion zu verknüpfen.

Tracepoints kann man beispielsweise zur Ausgabe von Variablenwerten im Ausgabefenster nutzen und so Konstrukte wie Console.WriteLine und die TraceKlasse ablösen – ohne einen Eingriff in den Quelltext!

Angenommen in folgender Schleife ist man an einen Increment interessiert und möchte laufend dessen Wert ausgeben:

1
2
3

for(var i = 0; i < 100; i++) {
  var x = i;
}

Man klickt hier mit der rechten Maustaste auf die zweite Zeile und wählt im Kontextmenü Breakpoint > Insert Tracepoint. Im folgenden Dialog kann man den Tracepoint konfigurieren und für diesen folgende Ausgabe definieren:

i ist {i}

Während der Debug-Sitzung wird im Ausgabefenster nun einhundert Mal der Wert von i gelistet.

Tracepoints können aber noch mehr.

• Tracepoints können zusätzlich wie ein normaler Breakpoint verwendet werden, wenn die Option Continue execution deaktiviert wird.
• Die Ausgabe kann mittels weiterer Platzhalter wie {$FUNC} um sinnvolle Informationen erweitert werden.
• Beim Erreichen eines Tracepoints kann man ein VisualStudio Makro auslösen.

BreakPoints

• Breakpoint labeln und Export aller Breakpoints
• Breakpoints können per Drag & Drop heraus gezogen werden
• Breakpoint-Pakete können verschickt werden
• Breakpoints im Code definieren, nicht commiten : )
• Breakpoint Gruppen
• Tools/Options/Debugging/General Enable Just my Code ausstellen
• CTRL – B setzt Breakpoint auf beliebige Funktion (use intellisense aus) werden im Tree angezeigt (Breakpoints)

Webcast:

• Breakpoint exportieren [1]

Conditionals

• Rechtsklick auf Breakpoint
• (condition) In C# definieren
• When hit: kann makro ausführen… oder nur print , Anwendung bleibt nicht stehen

IntelliTrace

Mit IntelliTrace reproduzierbare Fehler finden (Ultimate) IntelliTrace sammelt Informationen, die helfen die Fehlersuche und -diagnose zu vereinfachen und verbessert so die Produktivität beim Debugging. Aus der IntelliTrace Daten kann die Test-Session auf einem Entwickler-Rechner wiederhergestellt und die Fehler somit reproduziert werden.

• Wie kann man Probleme debuggen, die nur beim Kunden auftreten
• DumpDebugging
• Prozesse save as dump
• Kann sich selbst dumpen
• File kann debugged werden
• Alle Threads inkl aller Variablen sind dort enthalten
• *.DMP in vs2010 öffnen zeigt Exceptions und den StackTrace
• IntelliTrace hilft beim Debugging von nichtreproduzierbaren Fehlern beim Tester ohne VS
• TraceDebuggerTools beinhaltet IntellTrace
• collectionPlan.xml
• Das entsprechende File kann dann mit IntelliTrace überprüft werden
• Beinhaltet einen ASP.NET Client Proxy für IntelliTrace der Informationen über http-Aufrufe vom Client zum Webserver sammelt.

IntelliTrace muss in den Optionen > IntelliTrace aktiviert und konfiguriert werden

(IntelliTrace unter 64bit nicht möglich (auf x86 stellen))

Debugger Attributes

Im Namensraum System.Diagnostics gibt es eine Reihe von Attributen, die angewandt auf eigene Klassen das Verhalten des Debuggers beeinflussen können. Die Attribute werden für Klassen, Methoden oder Eigenschaften definiert.

Mit DebuggerBrowsableAttribute legt man fest, ob und wie eine Eigenschaft oder ein Feld in den verschiedenen Debugger- Fenstern (Locals, Autos, ..) angezeigt wird. Über die Enumeration DebuggerBrowsableState kann man einen der folgenden Werte wählen:

• Never = keine Anzeige,
• Collapsed = Anzeige,
• RootHidden = Anzeige der Unterelemente, beispielsweise eines Arrays.

DebuggerDisplay

Wird auf Klassenebene deklariert und legt fest, welche Informationen aus der Klasse in den DebuggingFenstern angezeigt werden sollen.

[DebuggerDisplay("Kunde -  {FirstName}  {LastName}"]

DebuggerVisualizer

Wenn man noch mehr Möglichkeiten sucht, um einen Datentyp zu visualisieren, verwendet man das Attribute DebuggerVisualizer. Damit ist beispielsweise möglich, bei einem Datentyp Image sich dieses in Visual Studio anzeigen zu lassen.

Debuggingrechte in Visual Studio

Mit den Attributen DebuggerHidden, DebuggerStepperBoundary, DebuggerNonUserCode und DebuggerStepTrough lässt es sich festlegen, ob und wie VS das Debuggen einer Klasse oder einer Methode erlaubt.

Thread Debugging

• Debugging von mehreren Threads (muss aktiviert werden)
• Icon Diagramm rot grün + aktivieren
• Rechtsklick flag, flagt den entsprechenden Thread
• Freeze kann alle Threads anhalten, ein gezielter kann wieder aktiviert werden

Edit and continue

Hier handelt es sich um ein Feature, das es einem ermöglicht – wie schon lange in Visual Basic – im DebuggingModus Änderungen am Quelltext vorzunehmen und ohne Neuzukompilieren diese zu übernehmen.

Das Feature kann unter Optionen > Debugging > Edit and Continue aktiviert werden

(Edit & Continue funktioniert nicht, wenn IntelliTrace aktiviert ist)

Entity Framework 2

• Model First Development (Generate DataBase from Model)
• Create the database from code (no model needed)
• Ermöglicht das Generieren der Datenbank aus dem Modell -und- auch aus dem Code heraus.

Automatic Pluralization

Bietet eine Pluralisierung an. EF würde in dem Fall an jeder Entität ein “s” anzuhängen. …

Foreign Keys in Models

Man kann Fremdschlüssel im Model verwenden, dazu beim Erstellen Include foreign key columns in the model aktivieren.

Lazy Loading

Der EF-Assistenten erzeugt enumerierbare Eigenschaften für jeden ForeignKey, den er auf einer Tabelle findet. Ein “Include” erzeugt innerhalb einer EF-Abfrage einen Join und bindet somit die Daten der verknüpften Tabelle mit ein. Diese Technik wird Eager Loading genannt und sorgt dafür das immer alle Daten im Join sind.

Das ist natürlich meist das Gegenteil, was man erreichen will, denn man möchte Daten erst dann von der Datenbank laden, wenn man sie auch benötigt.

Im Unterschied zur Nutzung von Include direkt auf der Entitäten-Menge Orders (ctx.Orders.Include(“Customers”)) kann das Load nun gezielt auf einzelne Order-Entitäten bei Bedarf erfolgen:

1
2
3
4
5
6
7
8

using (NorthwindEntities ctx = new NorthwindEntities())
{
    foreach (Orders orders in ctx.Orders)
    {
        orders.CustomersReference.Load();
        Console.WriteLine(orders.Customers.ContactName);
    }
}

Lazy Loading auf Feldebene

Fast noch wichtiger als das Lazy Loading auf Mengen-Ebene ist die Steuerung des Ladeverhaltens einer einzelnen Entität. Nehmen wir an, wir benötigen nur zwei Spalten aus der Customer Tabelle, um eine ComboBox mit den Spalten CustomerID und CompanyName zu binden. Im folgenden Code nutzen wir zunächst die scheinbar einfache Methode:

1
2
3
4
5
6
7
8

using (NorthwindEntities ctx = new NorthwindEntities())
{
    BindingSource bs = new BindingSource();
    bs.DataSource = ctx.Customers;
    cbCustomers.ValueMember = "CustomerID";
    cbCustomers.DisplayMember = "CompanyName";
    cbCustomers.DataSource = bs;
}

Also auf den ersten Blick scheint alles gut. Aber wie sieht es denn hinter den Kulissen aus, Das geschickte SQL-Kommando:

1
2
3
4
5
6
7
8
9
10
11
12
13

SELECT
 [Extent1].[CustomerID] AS [CustomerID],
 [Extent1].[CompanyName] AS [CompanyName],
 [Extent1].[ContactName] AS [ContactName],
 [Extent1].[ContactTitle] AS [ContactTitle],
 [Extent1].[Address] AS [Address],
 [Extent1].[City] AS [City],
 [Extent1].[Region] AS [Region],
 [Extent1].[PostalCode] AS [PostalCode],
 [Extent1].[Country] AS [Country],
 [Extent1].[Phone] AS [Phone],
 [Extent1].[Fax] AS [Fax]
 FROM [dbo].[Customers] AS [Extent1]

Wir fragen also die komplette Tabelle Customers ab, nur um 2 Spalten anzuzeigen bzw. zu nutzen?! Das widerspricht also jeglicher Vernunft. In EF kann man dies durch die Rückgabe anonymer Typen über LINQ lösen:

1
2
3
4
5
6

using (NorthwindEntities ctx = new NorthwindEntities())
{
    var customers = from c in ctx.Customers
                  select new { c.CustomerID, c.CompanyName };
    cboCustomers.DataSource = customers;
}

Dieses SQL Kommando dagegen lässt sich dann schon sehen

1
2
3
4
5

SELECT
1 AS [C1],
[Extent1].[CustomerID] AS [CustomerID],
[Extent1].[CompanyName] AS [CompanyName]
FROM [dbo].[Customers] AS [Extent1]

More LINQ operator Support

.Single(), SingleOrDefault(); …

EF1 vs. EF 2

Neuer Designer

• Unterstützung von POCO
• Unterstützung von .tt Vorlagen
• Unterstützung von Pluralisierung und Singularisierung
• Fremdschlüssel
• Model First Unterstützung
• Lazy Loading Unterstützung
• Missing LINQ Operators
• Generated SQL unlesbar
• N-Tier schwer
• Bessere Unterstützung von Stored Procedures

Workflow Foundation 4.0

• Komplette Neuimplementierung der WF in Version 4.0
• Mit Flowchart modellieren
• Keine State-Machine mehr
• Custom Activities
• Kombinieren von WCF und WF
• Base Activity Library
• BPEL
• Utilities
• Expressions
• Error handling
• WCF Messaging
• DataBase
• WF Primitives
• PowerShell
• Interop
• Control Flow Activities
• Flowcharts
• Sequential
• Rules
• Webcasts:
• http://www.cloudcasts.net/Default.aspx?category=WCF%20WF%204.0
• http://channel9.msdn.com/pdc2008/TL17/
• http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032437931
• http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032437932
• http://msdn.microsoft.com/de-de/wf-screencasts.aspx
• First WorkFlow http://mschnlnine.vo.llnwd.net/d1/ch9/8/5/4/6/2/4/WF_SeqWF.wmv
• Google Suche http://www.google.de/search?hl=en&rlz=1B3GGGL_enDE354DE354&q=workflow+foundation+4.0+filetype%3Awmv&btnG=Search&aq=f&oq=
• Quellen:
• http://msdn.microsoft.com/en-us/netframework/aa663328.aspx
• Überblick http://msdn.microsoft.com/de-de/netframework/cc896557.aspx
• Beginners Guide http://channel9.msdn.com/shows/Endpoint/Endpoint-Screencasts-Creating-Your-First-Sequential-Workflow/
• WF Scenarios Guidance: http://msdn.microsoft.com/de-de/library/ee373755%28en-us%29.aspx

F#

Nach dem Start von J# nun ein erneuter Versuch unter den Namen F# eine Funktionale Sprache die sie nur auf das wesentliche für Mathematiker beschränken soll.

Add-Ons

Für das Installieren eines Addon ist nur noch das Kopieren notwendig (nicht mehr über die Registry).

Architektur Explorer

Ist ein integriertes Tool, das es ermöglicht die bestehende Architektur in einem Projekt oder einer binären Datei zu einen Modell zu erzeugen.

Tipps & Tricks in VS2010

• Call Hierarchy CTRL + K, T
• IntelliSense Suggestion Mode (vs. Completion Mode) CTRL + ALT + Space

Visual Studio 2010 Web Frameworks

• ASP.NET WebForms 4
• Neue Vorlagen mit Masterpages und Stylesheets
• Neues Routingmodell
• ASP.NET MVC 4
• Komplett neue Herangehensweise an Webseiten
• Neues Modell, parallel zum WebForms Modell
• Schwerpunkt: Testbarkeit
• ASP.NET Ajax 4
• Windows Azure SDK & Tools
• Dynamic Data
• .NET RIA Services

Im nächsten Artikel schreibe ich über einige Neuerungen in WPF 4.0

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 12. März 2010 -- Weitere Neuerungen im .NET Framework 4.0
• 12. März 2010 -- Parallele Programmierung mit .NET 4.0
• 12. März 2010 -- Named & Optional Arguments, Co- & Contravariance, Dynamic und COM Interop
• 11. Februar 2010 -- Visual Studio 2010 – Die Unterschiede
• 11. August 2010 -- Design Switching Crash – Visual Studio 2010 Hotfix

Im folgenden Artikel möchte ich über weitere kleine Neuerungen und Veränderungen im .NET 4.0 Framework  schreiben:

GarbageCollection

Komplette Überarbeitung des GC, der GC unterstützt Background GarbageCollection Dieser ersetzt gleichzeitig die bisherigen Versionen und soll auch perfomanter sein.

• So whats new in CLR 4.0 GC [1]

Code Contracts

System.Diagnostics.Contracts

• MSDN [2]

Design-Time-only Interop-Assemblies

Man benötigt nicht mehr die primary interop assemblies (PIAs) in der Arbeit mit COM-Objekten. Für jede Interop Komponente wird nun eine eigene Assembly bereitgestellt.

• Embedding Type Information from Microsoft Office Assemblies [3]

BigInteger und komplexe Zahlen

Die neue Struktur System.Numerics.BigInteger unterstützt alle Standard Integer Operationen, einschließlich Bitmanipulation. Dieser kann aus jeder .NET Framework-Sprache verwendet werden. Zusätzlich verfügen einige der neuen .NET Framework-Sprachen (z. B. F# und IronPython) integrierte Unterstützung für diese Struktur.

Die neue System.Numerics.Complex Struktur stellt eine komplexe Zahl, die arithmetische und trigonometrische Funktionen mit komplexen Zahlen unterstützt dar.

• BigInterger Structure [4]
• Complex Structure [5]

Tupels

Die .NET Framework 4 Beta 2 stellt die System.Tuple-Klasse zum Erstellen von Tupel-Objekten, die strukturierte Daten enthalten.

var primes = Tuple.Create(2, 3, 5, 7, 11, 13, 17, 19);

• MSDN [6]

64-Bit-Betriebssysteme und Prozesse

Man kann mit Environment.Is64BitOperatingSystem und Environment.Is64BitProcess 64Bit Betriebssysteme und Prozesse identifizieren.

IsNullOrWhiteSpace

Die neue String.IsNullOrWhiteSpace-Methode gibt an, ob eine Zeichenfolge null ist, leer ist oder nur aus einem Leerzeichen besteht.

String.Concat<T>

Die String.Concat<T>-Methode kann jedes Element in eine aufzählbaren Auflistung, ohne ein vorheriges Konvertieren der Elemente in Strings, miteinander verketten.

• MSDN [7]

StringBuilder.Clear – Stopwatch.Restart

Zwei neue benutzerfreundliche Methoden stehen zur Verfügung

• MSDN [8]
• MSDN [9]

Enum.HasFlag

Die neue Enum.HasFlag-Methode bestimmt, ob eine oder mehrere Bitfelder oder Flags in einen Enumerationswert festgelegt sind. Enum.TryParse<TEnum>-Methode gibt einen booleschen Wert zurück, der angibt, ob eine Zeichenfolge oder ein ganzer Wert erfolgreich analysiert werden konnte.

• MSDN [10]

System.Environment.SpecialFolder

Die System.Environment.SpecialFolder-Enumeration enthält mehrere neue Ordner.

• MSDN [11]

Stream – CopyTo()

Einen Stream problemlos in einen anderen mit der CopyTo() Methode in Klassen kopieren, die von System.IO.Stream-Klasse erben.

• MSDN [12]

Path.Combine

Mir der neuen Path.Combine Methodenüberladung können Dateipfade kombiniert werde.

• MSDN [13]

System.IObservable<T> System.IObserver<T>

Die neue System.IObservable<T> und System.IObserver<T> Schnittstellen und bieten einen allgemeinen Mechanismus für Push-basierte Benachrichtigungen

• MSDN [14]
• MSDN [15]

System.IntPtr und System.UIntPtr

Die System.IntPtr und System.UIntPtr Klassen unterstützen jetzt die Addition und Subtraktion Operatoren.

• MSDN [16]
• MSDN[17]

System.Lazy<T>

Man kann mit System.Lazy<T> nun für alle benutzerdefinierten Typen eine verzögerte Initialisierung aktivieren.

• MSDN [18]

System.Collections.Generic.SortedSet<T>

Die neue System.Collections.Generic.SortedSet<T>-Klasse stellt eine self-balancing Struktur, die Daten nach Einfügen, Löschen und Suchen in sortierter Reihenfolge verwaltet. Diese Klasse implementiert die neue System.Collections.Generic.ISet<T>-Schnittstelle.

• MSDN [19]

System.IO.Compression.DeflateStream und GZipStream

Die Komprimierungsalgorithmen für die System.IO.Compression.DeflateStream und System.IO.Compression.GZipStream Klassen haben sich verbessert, sodass Daten, die bereits komprimiert sind, sich nicht noch mehr vergrößern. Die 4GB-Größenbeschränkung für das Komprimieren von Streams wurde auch entfernt.

• MSDN [20]
• MSDN [21]

Thread.Yield

Bewirkt das der aufrufende Thread die Ausführung an einen anderen Thread abgibt und auf den aktuellen Prozessor ausgfeührt werden kann.

Ein Thread kann das ihm zugeteilte Recht der Ausführung freiwillig abgeben, um anderen, auf die Ausführung wartenden Threads die Chance einzuräumen, aktiv zu werden. Dies wird mit dem Aufruf der Methode Thread.Yield() erreicht.

• MSDN [22]

System.Guid

Die System.Guid Strukture beinhaltet nun die Methoden TryParse() und TryParseExact().

• MSDN [23]
• MSDN [24]

Registry

Der Registrierungsschlüssel ist nicht mehr auf einer maximalen Länge von 255 Zeichen beschränkt.

Neue Microsoft.Win32.RegistryOptions-Enumeration, beinhaltet Volatile. Dieser bewirkt das der Schlüssel nur im Arbeitsspeicher gehalten wird und nach einem Neustart nicht mehr zur Verfügung steht. Dieses wird als flüchtiger Schlüssel bezeichnet.

• MSDN [25]

Obsolete Types

http://msdn.microsoft.com/en-us/library/ee461503%28VS.100%29.aspx

Obsolete Member

http://msdn.microsoft.com/en-us/library/ee471421%28VS.100%29.aspx

Kompatibilität TFS 2008 – TFS 2010

Was geht und was geht nicht, ist hier genau beschrieben.

Dennoch muss noch folgender Patch auf den Clients installiert werden: Visual Studio Team System 2008 Service Pack 1 Forward Compatibility Update for Team Foundation Server 2010 (Installer)

Im nächsten Artikel schreibe ich über einige Neuerungen in Visual Studio 2010

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 12. März 2010 -- Neuerungen in Visual Studio 2010
• 12. März 2010 -- Parallele Programmierung mit .NET 4.0
• 12. März 2010 -- Named & Optional Arguments, Co- & Contravariance, Dynamic und COM Interop
• 25. Juli 2010 -- Dynamische Klasse mit DynamicObject erstellen
• 12. März 2010 -- Neues in WPF 4

Im folgenden Artikel möchte ich über das Neue in der parallelen Programmierung mit dem .NET 4.0 Framework  schreiben:

Parallel Programming – PLINQ, Task, Concurrency

In der Vergangenheit konnten Anwendungen automatisch von neueren Prozessoren mit höheren Taktfrequenzen profitieren (Jedes Jahr Verdopplung der Taktfrequenz). Diese Gesetzmäßigkeit wird sich in der Zukunft nicht mehr fortsetzen (Wärmeentwicklung etc…). Die Leistungsfähigkeit moderner Prozessoren steigert sich heute in der Regel durch den gleichzeitigen Einsatz mehrerer CPU-Kerne. Da Anwendungsentwickler nicht mehr darauf bauen können, dass eine sequentiell implementierte Anwendung auf einer neueren CPU-Generation schneller ausgeführt wird, müssen die Möglichkeiten der Multicore-Technologie gezielt genutzt werden. Der Schlüssel dazu lautet “Parallel Computing”.

Man unterscheidet hier zwischen lineares Aufteilen von Aufgaben und Daten, sowie zwischen hierarchisches Aufteilen von Aufgaben und Daten.

Task

Der Task Parallel Library (TPL) ist ein Satz von öffentlichen Typen und APIs im System.Threading und System.Threading.Tasks Namespaces in .NET Framework 4.0. Diese Typen verlassen sich auf einen Taskplaner, die in der .NET ThreadPool integriert ist. Die TPL hilft den Entwicklern, Produktivität zu steigern und die Parallelität in den Anwendungen vereinfacht.

Entwickler teilt Algorithmus auf Tasks auf.

• TPL teilt diese Tasks den einzelnen CPUs (Kernen) zu.
• Auslastung vorhandener Ressourcen und Skalierbarkeit

Beispiel Task erzeugen

1
2
3
4

using System.Threading.Tasks;
void DoStuff() { Console.WriteLine("Hello!"); }
  Task t = Task.Factory.StartNew(DoStuff);
  t.Wait();

Lambda Alternative

1
2
3

using System.Threading.Tasks;
Task t = Task.Factory.StartNew(() => Console.WriteLine("Hello!"););
t.Wait();

Task und parallele Schleifen

Beispiele:

1
2

Parallel.ForEach(List<Persons>, (p) => Console.WriteLine(p.Name));
Parallel.For(0, 10, (i) => Console.WriteLine(i.ToString()));

Task mit Rückgabewerte

Beispiele:

1
2
3

Task t = ...
Task.Factory.StartNew<Person>( () => ...);
Person p = t.Result;

Task-Ketten

Beispiele:

1
2

Task<Person> task = Task.Factory.StartNew<Person>(() => DoWithPerson());
Task task2 = task.ContinueWith((t) => AndNowDoAnyWithPerson(t.Result));

Auf Task warten

Beispiele:

1
2
3
4
5

t.Wait();
Task[] tasks = ...
Task.WaitAll(tasks, (finishedTasks) => ...);
Task[] tasks = ...
Task.WaitAny(tasks, (finishedTasks) => ...);

Task abbrechen

Beispiele:

1
2
3
4
5
6
7
8
9
10

var source = new CancellationTokenSource();
CancellationToken token = source.Token;
Task t = Task.Factory.StartNew(() => {
  while (true) {
    if (token.IsCancellationRequested) {
    throw new OperationCanceledException(token);
  }
}
});
source.Cancel();

Task Exceptionhandling

Beispiele:

1
2
3
4
5
6
7
8
9
10
11

try {
  Task t = Task.Factory.StartNew(...);
  source.Cancel();
  t.Wait();
}
catch (AggregateException ae) {
  ae.Handle( (e) => {
  Console.WriteLine(e.Message);
  return true;
 });
}

PLINQ

Parallel LINQ (PLINQ) ist eine parallele Implementierung vom LINQ-Muster. PLINQ-Abfrage in vielerlei Hinsicht ähnelt eine nicht parallelen LINQ to Objects-Abfrage.PLINQ-Abfragen, wie sequenzielle LINQ Abfragen beziehen sich auf alle im Arbeitsspeicher IEnumerable oder IEnumerable Daten Quelldateien und haben verzögerte Ausführung bedeutet, dass Sie nicht beginnen ausgeführt, bis die Abfrage aufgelistet wird.Der Hauptunterschied besteht darin, dass PLINQ versucht, in vollem Umfang alle Prozessoren zu auf dem System nutzen.Dies geschieht, indem Partitionierung der Datenquelle in Segmente und anschließend die Abfrage für jedes Segment auf separate Arbeitsthreads parallel auf mehreren Prozessoren ausführen.Parallele Ausführung bedeutet in vielen Fällen, dass die Abfrage erheblich schneller ausgeführt wird.

Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12

var q = from p in menu.AsParallel()
where p.Price >= 4
select p.Name;
var q = from p in menu
  .AsParallel()
  .AsOrdered()
  .WithCancellation(token)
  .WithDegreeOfParallelism(3)
  .WithExecutionMode(…)
  .WithMergeOptions(…)
  where p.Price >= 4
  select p.Name;

Partitionierung in PLINQ

Beipiel:

(from x in D.AsParallel() where p(x) select x*x*x).Sum();

Quellen:

• Einführung in PLINQ [1]
• Parallelität Schnellansicht [2]
• Cancellation Framework [3]

Webcasts:

• Einführung [4]
• Tasks verketten [5]
• Exception handling [6]
• Empfehlenswerte 6teilige Serie von Bernd Marquardt (Parallelprogrammierung mit der Task Parallel Library) [7]

Weitere Downloads:

• Understanding and Applying Parallel Patterns with the .NET Framework 4 [pdf] download

Concurrency

Concurrency Runtime (C++)

Der Concurrency Runtime Scheduler ist ein “stehlender” Algorithmus zum Verteilen der Arbeit unter den Computerressourcen. Tasks werden auf die Worker Threads verteilt und parallel ausgeführt. Sobald einer der Worker Threads nichts zu tun hat, “stiehlt” er eine laufende Aufgabe eines anderen Worker Threads, was zu einer besseren Auslastung der vorhandenen Prozessorkerne führt.

Architektur

Die Concurrency Runtime ist in vier Komponenten eingeteilt

• Parallel Patterns Library (PPL)
• Asynchronous Agents Library
• Task Scheduler
• Resource Manager

Die Komponenten befinden sich zwischen dem Betriebssystem und der Anwendung. Die folgende Abbildung zeigt, wie die Laufzeitkomponenten zwischen OS und Applikation interagieren:

Quellen:

• Parallel Patterns Library [1]
• Asynchronous Agents Library [2]
• Task Scheduler [3]

Im nächsten Artikel schreibe ich über weitere Neuerungen und Veränderungen im .NET Framework 4.0

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 12. März 2010 -- Neuerungen in Visual Studio 2010
• 12. März 2010 -- Weitere Neuerungen im .NET Framework 4.0
• 12. März 2010 -- Named & Optional Arguments, Co- & Contravariance, Dynamic und COM Interop
• 25. Juli 2010 -- Dynamische Klasse mit DynamicObject erstellen
• 12. März 2010 -- Neues in WPF 4