ASP.NET Webforms SQLDatasource Querystringparameter Text

Obwohl ich Bücher dazu geschrieben habe, mein Hirn ist leer. Ich habe vergessen wie man mit einem SQLDataSource Control einen Select Parameter per Querystring definiert. Alle Samples nehmen immer nur eine ID und den Typ Int32. Also fürs Archiv: wenn der Query Parameter eine Zeichenkette ist (also String) und man per unscharfen SQL Kommando Like selektieren möchte gilt folgende Lösung.

   1:  WHERE        (dbo.SEM_SEMINARE.sActive = 1 and metatags like '%'+@suche+'%')"
   2:        >
   3:        <SelectParameters>      
   4:        <asp:QueryStringParameter Name="suche"  
   5:                   QueryStringField="suche" Type="String" />
   6:    </SelectParameters>

Warum mache ich das?

Altlasten, eine Website basierend auf ASP.NET 2.0 die die nach modernes UI gehoben werden muss. Also Bootstrap, responsive Design und keine Postbacks. Dazu werden eben Status Informationen in die URL gelegt und nicht in den Viewstate.

x:Bind mit UWP und Performance

Mit Windows Universal Platform Apps wird XAML um eine Funktion erweitert, compiled Binding. Dazu muss man wissen, das in WPF Databinding per Reflection erst zur Laufzeit ausgewertet wird. Bekanntermaßen läuft man dabie leicht in Performanceprobleme rein. Da hört es sich doch super gut an, wenn nun mit X.Bind statt Binding alles schneller wird, oder?

Um diese Frage zu klären, wurde erst eine WPF MVVM Referenzimplementierung codiert und diese dann in einer Windows 10 App nachgebaut. Leider ist der Code nicht so kompatibel wie man glauben würde, so das das WPF Sample nochmals verändert wurde mit dem Ziel möglichst identen Code zu nutzen.

Das Testszenario füllt eine Listview mit einer Million Einträgen und misst die Zeit. In der WPF Anwendung dauert das 14 Sekunden.

image

Ich möchte nicht ausschließen, das in Betrachtungen Performance relevante Fakten nicht korrekt berücksichtigt worden sind und damit die Ergebnisse falsch sein können.

Das Viewmodel implementiert eine Counter Eigenschaft, weil UWP kein Liste.count im compiled Binding unterstützt. Außerdem scheint es in UWP Apps nötig zu sein einer Property vom Typ ObservableCollection manuell das PropertyChangedEvent auszulösen.

Public Class appVM
    Implements INotifyPropertyChanged
    Private _liste As ObservableCollection(Of zeichen)
    Public Property liste() As ObservableCollection(Of zeichen)
        Get
            Return _liste
        End Get
        Set(ByVal value As ObservableCollection(Of zeichen))
            _liste = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(NameOf(liste)))
        End Set
    End Property
 
 
    Private _counter As Integer
    Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
 
    Public Property counter() As Integer
        Get
            Return _counter
        End Get
        Set(ByVal value As Integer)
            _counter = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(NameOf(counter)))
        End Set
    End Property
End Class
 
Public Class zeichen
    Implements INotifyPropertyChanged
    Private _zeichen As String
    Public Property zeichen() As String
        Get
            Return _zeichen
        End Get
        Set(ByVal value As String)
            _zeichen = value
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(NameOf(zeichen)))
        End Set
    End Property
 
    Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
End Class

Erstaunlicherweise ist .net zu schnell um das Bindung auch im Interface zu aktualisieren. Das heist erst wenn der folgende Code durchgelaufen ist, wird das UI refreshed.

   1:  Class MainWindow
   2:      Public Property l As New appVM
   3:      Private Sub button_Click(sender As Object, e As RoutedEventArgs) Handles button.Click
   4:          textBlock0.Text = Date.Now.ToLongTimeString
   5:          For i = 1 To 1000000
   6:              l.liste.Add(New zeichen With {.zeichen = Date.Now.ToLongTimeString})
   7:              l.counter = l.liste.Count
   8:          Next
   9:          textBlock1.Text = Date.Now.ToLongTimeString
  10:      End Sub
  11:   
  12:      Private Sub MainWindow_Loaded(sender As Object, e As RoutedEventArgs) Handles Me.Loaded
  13:          l.liste = New ObservableCollection(Of zeichen)
  14:          grid1.DataContext = l
  15:          l.liste.Add(New zeichen With {.zeichen = "test"})
  16:          l.counter = l.liste.Count
  17:      End Sub
  18:   
  19:  End Class

 

Im XAML Code wird lediglich eine Listview Control mit einem Datatemplate eingesetzt. Zu Testzwecken wurde mit dem Mode Oneway experimentiert (standard ist twoway) und Binding liste.count verwendet. Beides brachte keine sichtbare Änderung in der Durchlaufzeit.

   1:   <Grid x:Name="grid1">
   2:          <Button x:Name="button" Content="Button" HorizontalAlignment="Left" 
Margin="321,14,0,0" VerticalAlignment="Top" Width="75"/>
   3:          <TextBlock Text="{Binding counter}" HorizontalAlignment="Left" Width="100"
   4:                     TextWrapping="Wrap" VerticalAlignment="Top" Margin="407,18,0,0"/>
   5:          <ListView 
   6:              IsSynchronizedWithCurrentItem ="True"
   7:              ItemsSource="{Binding liste,Mode=OneWay }" x:Name="listView"
   8:              HorizontalAlignment="Left" Height="299" Margin="36,10,0,0" VerticalAlignment="Top" Width="158">
   9:              <ListView.ItemTemplate>
  10:                  <DataTemplate >
  11:                      <Grid>
  12:                          <TextBlock Text="{Binding zeichen,Mode=OneWay}"></TextBlock>
  13:                      </Grid>
  14:                  </DataTemplate>
  15:              </ListView.ItemTemplate>
  16:          </ListView>

 

Identes Szenario in der Windows 10 UPW App. XAML und VB.NET benötigen nun 48 Sekunden und damit mehr als 3x so lange.

image

Völlig überraschend reduziert sich die Zeit bei   Text="{Binding liste.count}"  statt   Text="{Binding counter}" auf 24 Sekunden. Mutmaßlich wird das Binding für den Counter so nur einmal aufgerufen.

Im nächsten Schritt führen wir compiled Bindung ein. Hier gibt es ein paar weitreichende Änderungen

  • Datacontext spielt keine Rolle mehr- Das Viewmodel wird als Property der Page zugewiesen
  • x : Bind ist per Default OneTime
  • Verschachtelte Bindings müssen per x : Datatype auflösbar sein.

Der XAML Code der WUP APP sieht damit wie folgt aus

   1:     xmlns:model="using:App4"
   2:  ...
   3:  <TextBlock Text="{x:Bind l.counter, Mode=OneWay}" HorizontalAlignment="Left" Margin="452,54,0,0" 
   4:                     TextWrapping="Wrap" VerticalAlignment="Top"/>
   5:    <ListView 
   6:         ItemsSource="{x:Bind l.liste,Mode=OneWay}" x:Name="listView"
   7:         HorizontalAlignment="Left" Height="299" Margin="36,10,0,0" VerticalAlignment="Top" Width="158">
   8:     <ListView.ItemTemplate>
   9:        <DataTemplate x:DataType="model:zeichen">
  10:            <Grid>
  11:              <TextBlock Text="{x:Bind zeichen, Mode=OneWay}"></TextBlock>
  12:            </Grid>
  13:       </DataTemplate>
  14:   </ListView.ItemTemplate>
  15:  </ListView>

 

Die Durchlaufzeit des kompilierten XAML Databinding Beispiels liegt nun bei 23 Sekunden und damit bei rund 50% des normalen Bindings. Allerdings noch immer deutlich über den Werten von WPF (14 Sekunden). Dazu kommt das sich X.Bind mit seinen default Wert überraschend verhält. Auch die Collection, die sich nicht aktualisiert, ist ein unerwartetes Ergebnis und Effekt des Kompilier Vorganges. Alternativ lässt sich mit Bindings.Update eine Aktualisierung erzwingen, was ich aber als seltsam im Kontext von MVVM empfinde. Zusätzlich war es schwierig Programmierfehler zu finden. Normale Binding Fehler werden im Output Window von Visual Studio angezeigt. Für compiled Bindings suche ich noch nach derartiger Hilfe. Was mich zusätzlich verwundert, ist das eigentlich eine UWP App native Code enthalten sollte und damit meines Erachtens nach schneller als eine .net JIT Optimierung sein sollte. Dieser Blog Artikel liefert also mehr Fragen als Antworten.

Nachtrag 1: Aufgrund erster Diskussionen beide Anwendungen direkt ohne Visual Studio gestartet. WPF: 12 Sekunden –70MB Ram im Taskmanager. WUP 10 21 Sekunden – 315 MB.

F12 XAML Debug Developer Tools

Der Betreff ist frei erfunden. Es gibt keine F12 Taste für XAML, nein es ist viel besser. Mit Visual Studio 2015 kann man WPF Anwendungen und den darin enthalten XAML Code zur Laufzeit analysieren. Dabei muss man nicht mal den Quellcode besitzen. Das geht mit jeder beliebigen Anwendung und dem Visual Studio enthalten Tools:  Live Views XAML – Live Visual Tree und Live Property Explorer.

Wenn eine WPF Anwendung läuft, kann sich der Visual Debugger an den laufenden Prozess hängen (Debuggen – an den Prozess anhängen oder STR ALT P). WPF Anwendungen sind leicht zu erkennen, da sie vom Typ managend Code sind.

image

Im Eigenschaftsfenster visuelle Echtzeitstruktur (visual Tree) ist die XAML Struktur zu erkennen. Ganz ähnlich wie im Browser DOM Explorer lässt sich per Pfeil in der WPF Anwendung das UI Element auswählen.

image

Zusätzlich lassen sich live im weiteren Eigenschaftsfenster Echtzeit Eigenschafts Explorer sämtliche Properties der deklarativen UI ändern. Hier wurde die Beschriftung (Caption) ersetzt.

image

Für die neuen Windows Universal Plattform Apps ist die Vorgehensweise etwas anders, aber im Ergebnis gleich überzeugend. Dazu wird in Visual Studio über andere Debug Ziele (other debug tragets)- ein vorhandenes installiertes App-Paket ausgewählt. Die App darf nicht laufen.

image

Da UWP kein managend sondern native Code ausführt, muss die Option systemeigen (native only) gewählt werden. In diesem Beispiel nehmen wir uns die Windows 10 Wetter App vor um zu erforschen wie der XAML Code aufgebaut ist

image

Die App Startet und Visual Studio zeigt den visual XAML Tree. Hier im Bild mit ausgewählter Layout Adorner Funktion (zweite Icon von links).

image

Auf die neuen visuellen WPF Debugging Funktionen bin ich gestoßen im Rahmen der Vorbereitung meiner ADC WPF Session.

besser lesen im Browser Lesemodus

Wir werden älter oder die Buchstaben kleiner. Egal mit welcher Perspektive, Microsoft hat seit drei Jahren für uns eine echte Innovation, den Lesemodus oder auch Reading View genannt. Dabei kann der Benutzer eine Website in einem auf den Text fokussierten lesefreundlichen Modus konsumieren.

Die Leseansicht wurde mit IE11 aus Windows 8, dem METRO Browser eingeführt. Eine eigene Logik erkennt passende Websites und blendet in der Adressleiste ein Buch Icon ein, wenn der Inhalt geeignet erscheint.

image

Danach fokussiert der Browser die Darstellung auf das Wesentliche und blendet kleine Bilder wie Werbung oder Menüs aus.

Der neue Edge Browser und der Windows 8.1 phone Browser unterstützen diese Ansicht ebenfalls. Sogar Mozilla Firefox zieht in der Version 40 nach. Webdesigner sollte ein paar Regeln kennen um davon bestmöglichen Nutzen ziehen zu können.

Grundsätzlich sollen mindestens 700 Zeichen auf der Website sein. Dazu gehören folgende Metatags ohne die z.B. der Windows Phone Browser die Darstellung verwehrt. Die Inhalte werden dann im Lesemodus an definierter Stelle eingeblendet, außer Title.

   1:  <title>Lesemodus</title>
   2:  <meta name="displaydate" content="muss kein Datum sein oben">
   3:  <meta property="og:site_name" content="ppedv AG">
   4:  <meta name="copyright" content="copyright am Ende">

Die Überschrift wird aus dem ersten H1 Element ausgelesen. Erst der darauf folgende Text, idealerweise in ein P Element gepackt, wird dann alternativ formatiert dargestellt. Die Schriftgröße und Art wird vereinheitlicht.

readingview1

readingview2

Bilder müssen  >= 400 px mit einem Verhältnis >= 1/3 und =< 3.0 sein. Andernfalls werden diese nicht angezeigt. Laut Dokumentation sollte man Bilder in  figure Element schachteln und per figcaption beschreiben. Der Edge Browser zeigt dann in meinen Versuch kein Bild mehr an.

Im Standardfall wird das erste Bild als dominantes Image bezeichnet und über den Text dargestellt, was auf dem Smartphone sehr gut aussieht. Im Screenshot zu erkennen ist auch der Autor und Datum aus den Metatags.

lesemodus3

Alle weiteren Bilder im Textfluss, die obige Größenanforderungen erfüllen, werden im Fließtext dargestellt.

image

Im Screenshot ist auch der Copyright Hinweis am Ende zu erkennen.

Der Lesemodus ist kein Standard, Mozilla interpretiert die Inhalte anders. Auch werden in den Test Bilder nicht nachvollziehbar ausgeblendet. Versuche mit existierenden Websites legen den Schluss nahe, das es wesentlich mehr Regeln im Browser gibt nach denen eine Darstellung im Lesemodus erfolgt.

image

Die Kurs Websites der ppedv Schulungen kommen aus dem gleichen Template und werden Datengebunden gefüllt und trotzdem unterschiedlich dargestellt.

image

Ich werde an dem Thema dranbleiben, weil es speziell für mobile Darstellung ein echter Gewinn an Usability ist.

Nachtrag: dieser Blogartikel ist aus unerfindlichen Gründen nicht für den Reading View geeignet.

Der Sysadminday 2015 ist vorbei – ein kurzer Bericht

Am Freitag den 31. Juli 2015 habe ich in Zusammenarbeit mit der Windows Server User Group Berlin und einigen Sponsoren (siehe unten) ein Community-Event anlässlich des alljährlichen Sysadmindays (letzter Freitag im Juli) veranstaltet. Es waren etwas mehr als 40 Personen anwesend, um den 4 Vorträgen (siehe unten) zu lauschen, jede Menge Geschenke mitzunehmen und sich am reichhaltigen Buffet und den Getränken zu verköstigen. Die Veranstaltung war kostenlos und wurde durch die großzügigen Sponsorings der ppedv AG und von Altaro ermöglicht.

Die Vorträge:

  • Azure für SysAdmins – eine Reise in die Cloud (Oliver Michalski)
  • AD Authentication Hardening (Jan-Henrik Damaschke)
  • „Vereinfache das Admin-Leben mit der Hybrid Cloud“ - Azure und Hyper-V – Better together (Benedict Berger)
  • Sicher? Ja, Sicher! Client Absicherung. Kleine Schritte große Wirkung. (Mark Heitbrink)

Die Veranstaltung hat 15:00 Uhr begonnen, erste Gäste waren schon deutlich eher da. Gegen 23:30 haben wir die letzten Gäste “rausgekehrt”. Als ersten Snack gab es Sandwiches, Cookies und Chips von Subway, bereitgestellt von Microsoft Deutschland. Nach dem dritten Vortrag wurde das Buffet eröffnet, dass durch Altaro und die ppedv AG finanziert wurde.

Unsere Gäste konnten reichlich Geschenke mitnehmen, darunter:

  • Fachbücher von Microsoft Press, bereitgestellt durch Microsoft Deutschland
  • Geek-Goodies wie z.B. einen “Any-Key” oder einen Labyrinth-Kuli, bereitgestellt von GetDigital
  • T-Shirts, bereitgestellt von Microsoft Deutschland und der Minerva UG
  • Strohhüte, Umhängetaschen, Fachzeitschriften und mehr, bereitgestellt von der ppedv AG
  • “IT-Administrator” Fachzeitschriften, bereitgestellt vom Heinemann-Verlag

Zusätzlich konnten wir einige Preise verlosen:

  • insgesamt 4x je eine Eintrittskarte zu Fachkonferenzen (SQLDays und Sharepoint-Konferenz), bereitgestellt durch die ppedv AG
  • 5 Jahres-Abos der Visual Studio One, bereitgestellt vom Verlag bzw. der ppedv AG
  • Fachbücher vom PACKT-Verlag, bereitgestellt durch die Windows Server User Group Berlin

Wir hoffen, das Event hat allen Gästen gefallen!

Einige Fotos der Veranstaltung:

Sysadminday_2015_20150731_143216_DSC07252Sysadminday_2015_20150731_151104_WP_20150731_004Sysadminday_2015_20150731_151946_WP_20150731_005Sysadminday_2015_20150731_151955_WP_20150731_006Sysadminday_2015_20150731_153414_DSC07257Sysadminday_2015_20150731_153424_DSC07258Sysadminday_2015_20150731_171935_DSC07267Sysadminday_2015_20150731_174526_DSC07274Sysadminday_2015_20150731_181821_DSC07285Sysadminday_2015_20150731_181922_DSC07296Sysadminday_2015_20150731_182709_WP_20150731_011Sysadminday_2015_20150731_185419_DSC07302Sysadminday_2015_20150731_185427_DSC07303Sysadminday_2015_20150731_190434_WP_20150731_015Sysadminday_2015_20150731_190439_WP_20150731_016Sysadminday_2015_20150731_190920_DSC07308Sysadminday_2015_20150731_190928_DSC07315Sysadminday_2015_20150731_201137_DSC07320Sysadminday_2015_20150731_201838_DSC07334Sysadminday_2015_20150731_201854_DSC07339

Windows Server vNext / 2016 TP2: Wie man Updates installiert

Will man die aktuelle Technical Preview 2 vom Windows Server vNext (2016?) patchen, so schlagen die üblichen Methoden fehl:

Die Systemsteuerung (“Control Panel”) bietet keine Update-Option mehr:

update00

Und auch die wuapp.exe meldet einen “Fehler”:

update0

Als “Workaround” kann man aktuell auf die sconfig.exe zurückgreifen. Dort gibt es entsprechende Optionen:

updates1 updates2updates3 updates4updates5 updates6updates7

CSS Klassen Naming Schema

Durch meine Arbeit mit Material Design Lite bin ich über das opulente CSS Klassen Konzept gestolpert. Es ist ziemlich aufwändig die CSS Klassen zu tippen und Visual Studio Intellisense kann basierend auf diesem Schema nicht wirklich hilfreich sein.

Zwei Beispiele sollen dies erläutern.

   1:  <table class="mdl-data-table mdl-js-data-table mdl-data-table--selectable mdl-shadow--2dp">
   2:   
   3:  th class="mdl-data-table__cell--non-numeric">Material</th>

 

Jedenfalls haben ich in diesem Kontext gelernt, das es ein Namensschema BEM gibt. In HMTL für Block-Element-Modifier.

Da CSS3 keine Namensräume kennt, stellen die MDL Entwickler das Präfix mdl- voran. In Anbetracht der schieren Fülle der Klassennamen tippt man sich einen Ast- hier mdl-textfield bis man überhaupt an der richtigen Stelle steht. Dazu kommt das man in der Regel immer zwei CSS Klassen Minimum benötigt. Eine für Design und eine fürs JavaScript.

image

BEM definiert einen Block, z.B. die HTML Tabelle, ein Menü oder Tab Bereich. Hier als Tabelle data-table genannt.

In der nächsten Hierarchiestufe findet sich das Element, getrennt mit einem doppelten Unterstrich. Beispiel ist data-table__cell oder textfield__input.

Da der Bindestrich schon für zusammengesetzte Worte genutzt wird (data-table), kommt ein doppelter Bindestrich für eine nächste Hierarchiestufe Modifier zum Einsatz. Obig wird die data-table als –selectable definiert oder die Schattentiefe.

Akademisch ist das eine gute Idee. In der Praxis ist der Schreibaufwand erheblich. Darüber hinaus sind die gewählten Namen (textfield, data-table, --floating-label ) selten intuitiv. Im Vergleich zu Bootstrap ergibt sich eine relevant geringere Produktivität.

Windows 10 wird als RTM in MSDN angeboten

Nur als kurze “Randnotiz”: Seit heute kann man die Windows 10 ISOs in der MSDN als RTM-Version herunterladen!

Windows10_in_MSDN

Dabei stehen zur Verfügung:

  • Windows 10 Home 1
  • Windows 10 Pro 1
  • Windows 10 Education 1
  • Windows 10 Enterprise 1
  • Windows 10 Enterprise 2015 LTSB
  • Windows 10 Features on Demand 2
  • Windows 10 Language Interface Packs
  • Windows 10 Symbols
  • Windows 10 Symbols Debug/Checked
  • Windows 10 IoT Core for MinnowBoard MAX (x86)
  • Windows 10 IoT Core for Raspberry Pi 2 (ARM)

Visual Basic 14 Zeichenketten

Wenn ich schon dabei bin, sämtliche Neuerungen zu Visual Basic 14 (in Visual Studio 2015) zu erläutern, dann auch noch schnell die Zeichenketten.

Seit langer Zeit gibt es in VB.NET XML Literals, die wie aus ASP.NET Webforms geklaut aussehen. Neben dem mehrzeiligen XML Code, kann man auch Ausdrücke injizieren.

   1:    Dim a As Integer = 42
   2:    Dim xml = <xml>
   3:                        <node>
   4:                            <%= a %>
   5:                        </node>
   6:                    </xml>
   7:   text1.Text = xml

In Kombination mit LINQ sind da sehr abgefahrene Zeilen Code möglich. C# Programmierer konnten das nicht und platzten vor Neid. Vermutlich deshalb wurde XML auch zusehend ignoriert und durch JSON ersetzt. VB.NET zieht nach und kann nun Strings mehrzeilig und mit Ausdrücken.

   1:    text1.Text = $"Hello
   2:                               world
   3:          {a}"

Das $ Zeichen ist nur nötig, wenn man Ausdrücke per geschweifter Klammer injiziert.

Der Zeilenumbruch wird als vbCRLF in den String eingefügt, genauso wie Leerzeichen.

image

Das war auch schon das Ende der zweiteiligen Reihe “Neue Sprachfeatures in VB.NET 14”

Visual Basic .net 14 nameOf

Mit .net 4.6 ist auch Visual Basic in einer neuen Version angelangt. Gemeinsam mit C#6 ist das neue Sprachfeature nameOf. Was hat es nun damit auf sich und gibt es da nicht schon?

Kurz gesagt liefert NameOf den Namen einer Klasse als String ohne Reflection bemühen zu müssen. Da dies auf Compiler Ebene geschieht, ohne Performance Nachteile.

Der Name einer Eigenschaft wird z.B. in jeder MVVM Property benötigt um die Notification an das User Interface auszulösen. Folgender Code wird jeden View Model Programmierer täglich Brot sein, wenn er die Klasse per Implements INotifyPropertyChanged mit dem Interface versieht.

   1:  Private newPropertyValue As String
   2:      Public Property NewProperty() As String
   3:          Get
   4:              Return newPropertyValue
   5:          End Get
   6:          Set(ByVal value As String)
   7:              newPropertyValue = value
   8:              RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("NewProperty"))
   9:          End Set
  10:  End Property
  11:   
  12:  Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

Das Code Schnippsel wurde mit Visual Studio 2015 im Code Editor per prop + TAB +TAB erstellt. Ich würde schwören das in früheren Versionen ein Unterstrich für die private interne Eigenschaft verwendet wurde.

In der Regel wird man in den VM Klassen eine Abstraktionsfunktion finden ala

   1:   Protected Sub OnPropertyChanged1(propertyName As String)
   2:          RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
   3:   End Sub

So muss nur noch OnPropertyChanged1 mit dem Namen der Eigenschaft als Parameter aufgerufen werden. Logik in Hochkommas ist allerdings schon seit SQL fehleranfällig.

Mit Visual Studio 2012 kommt ein Compiler Attribut, das den Namen eigenständig auflöst: Callermembername

   1:  Protected Sub OnPropertyChanged(<CallerMemberName> Optional propertyName As String = Nothing)
   2:          RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
   3:  End Sub

 

In der Eigenschaft der Klasse reicht dann ein einfaches onPropertyChanged() (statt Zeile 8) und alles ist gut. Einziger Nachteil, das geht nur innerhalb von Funktionsparametern.  Es kann sein, das man im Viewmodel aus einer Zuweisung eines Wertes das PropertyChanged Event eines anderen Propertys auslösen möchte. Jedenfall gibt es nun NameOf, das diese Flexibilität auch wieder durch den Compiler bringt.

   1:  OnPropertyChanged1(NameOf(NewProperty))
Training, Schulung, August Aktion

Month List