Ich bin ein wenig verwundert wie wenig über das Thema Credentials lokal und sicher speichern geschrieben wird. Immerhin wird so gut wie jede Windows 8 Store APP auf eine Service zugreifen und die meisten werden das auch per Autorisierung absichern. WinRT bietet eine API um auf den Betriebssystem eigenen Passwort Tresor zuzugreifen. Dort werden auch unter anderem die Usernamen/Passwort Kombinationen aus dem Internet Explorer abgelegt. Für .NET hat Microsoft eine Klasse Passwortvault, die die WinRT API nutzt spendiert. (war auch ne Prüfungsfrage beim MCP) Dim vault As Windows.Security.Credentials.PasswordVault = New Windows.Security.Credentials.PasswordVault()
Dim pc = New PasswordCredential("aaaaaaa", Me.DataContext.username, Me.DataContext.Passwort)
vault.Add(pc)
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Die Daten sollen dann sicher abgelegt sein und können nur aus der ursprünglichen Anwendung ausgelesen werden. Der Zugriff erfolgt über den Resource Key. Meist ist das eine URL, hier einfach aaaaaaa. Da es mehr als eine Anmeldung pro URI geben kann, kommt da ne Liste. Wenn man die Zeile mit RetrievePasswort weglässt, ist in cred der Username gesetzt, aber das Password mit einem Leerstring besetzt.
Dim vault As Windows.Security.Credentials.PasswordVault = New Windows.Security.Credentials.PasswordVault()
Dim x = New internalSettings
Try
Dim cred = vault.FindAllByResource("aaaaaaa").FirstOrDefault
cred.RetrievePassword()
x.Passwort = cred.Password
x.UserName = cred.UserName
catch
End Try
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Der managed Wrapper scheint etwas unfertig. Es ist nicht möglich auf die Existenz eines Resource Keys zu prüfen. Hier muss man über eine Exception gehen. Außerdem gibt es eine Properties Collection zu der man per Add etwas hinzufügen kann. Zur Laufzeit krachts dann aber.
Dim pc = New PasswordCredential("aaaaaaa", Me.DataContext.username, Me.DataContext.Passwort)
pc.Properties.Add("ServiceUri", Me.DataContext.ServiceUri)
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Ich habe bereits vor einiger Zeit einen kritischen Blog Beitrag verfasst, wie man nach den Windows 8 Store APP Richtlinien Einstellungen in Anwendungen realisiert. Tim Heuer hat vor einiger Zeit ein kleines Projekt gestartet (Callisto), das es leichter machen soll u.a. auch einen Setting samt Flyout zu realisieren. Die Grundidee gleicht dem Silverlight Toolkit. Der Sourcecode ist auf Github zu haben. Da ich eigentlich weniger Arbeit haben will und nicht mehr, nehme ich das Paket von Nuget. Das ist zwar nicht ganz aktuell, aber ich habe nicht vor Bugfixes an Open Source vorzunehmen. Um der WinRT App mitzuteilen, das der Benutzer das Setting Charme geöffnet hat, muss ein Event abonniert werden. Ein guter Ort dafür ist die App.xaml.vb (Für C# Developer weniger gut ) und dort am Ende des OnLaunched Events. AddHandler SettingsPane.GetForCurrentView().CommandsRequested, AddressOf OnSettingsRequest
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Im SettingsRequest wird dann ein Menüpunkt eingefügt.
Protected Sub OnSettingsRequest(sender As SettingsPane, args As SettingsPaneCommandsRequestedEventArgs)
Dim h As New SettingsCommand("SpListe", "Config", New UICommandInvokedHandler(AddressOf SettingsFunktion))
args.Request.ApplicationCommands.Add(h)
End Sub
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Erst wenn der Benutzer diesen auswählt wird dann das Settingspane geöffnet und der neue Punkt Config eingefügt.
Erst ab hier kommt die Callisto Bibliothek zum Einsatz.
Private Sub SettingsFunktion()
Dim s = New SettingsFlyout()
s.Content = New settings1
s.HeaderBrush = New SolidColorBrush(Colors.DarkBlue)
s.Background = New SolidColorBrush(Colors.White)
s.HeaderText = "Config …."
s.IsOpen = True
End Sub
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Der Eigentliche Dialog ist ein XAML Usercontrol mit dem Namen settings1.xaml.
Ich weis noch immer nicht, wie die Windows METRO Anwendungen nun heißen. Kein gutes Zeichen fürs Marketing. In Visual Studio heißt das Template Windows Store, was nicht ganz richtig ist, weil man wohl auch Desktop Anwendungen … lassen wir das. Im Rahmen einer Machbarkeitsstudie werden Interfaces von SharePoint evaluiert um sie in WinRT zu verwenden. Aktuell wird auf die SharePoint REST Services programmiert. Weil ich faul bin über einen Proxy in Visual Studio 2012. Entsprechend der Odata Query Language wartet dort ein WCF Service, der sich an den ADO.NET Dataservices anlehnt. URL ist https://server/_vti_bin/ListData.svc/ In meinem Fall musste ich drei mal meine Domain Account eingeben um die Referenz erstellt zu bekommen. Mit Hilfe des Proxy lässt sich dann der Data Service instanziieren. Der Name IntranetDataContext ergibt sich in diesem Fall aus dem verwendeten SharePoint. Dim dc As IntranetDataContext = New IntranetDataContext(New Uri("https://server/_vti_bin/ListData.svc"))
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Wenn die Namen unklar sind einfach im Class View von Visual Studio nach DataContext suchen.
Als nächstes geht es um die Authentifizierung am Sharepoint
Dim cr = New System.Net.NetworkCredential("usr", "pwd", "domain")
dc.Credentials = cr
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Dann wird der Service aufgerufen. Weil dieser den ASYNC Pattern aus .NET 4.5 nicht implementiert auf die gute alte Beginexecute und Endexcute Methode um asynchron zu bleiben. Die Liste heist Mitarbeiter und kann auch direkt im Browser per https://server/_vti_bin/ListData.svc/Mitarbeiter so abgerufen werden.
dc.BeginExecute(Of MitarbeiterItem)(New Uri("Mitarbeiter", UriKind.Relative), AddressOf fertig, dc)
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Am Schluss dann noch die Rückrufmethode die den Aufruf abschließt und die Daten erhält aber dummerweise in einem anderen Thread aufgerufen wird. Also muss man noch den Dispatcher bemühen.
Public Async Function fertig(ByVal result As IAsyncResult) As Task
Dim data = dc.EndExecute(Of ServiceReference1.MitarbeiterItem)(result).ToList
Await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, Sub()
listbox1.ItemsSource = data
End Sub)
End Function
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Die WCF Dataservices sind aktuell in der Version 5.0 angekommen und damit auch kompatibel zu Entity Framework mit dem seit 4.1 neuen Typ dbcontext. Das bedeuted in Visual Studio 2012 und einem webprojekt kann ein EF Model direkt als Quelle für den WCF Dataservice verwendet werden. Der VB.NET Code für den minimal Service sieht wie folgt aus. Public Class WcfDataService1
' TODO: replace [[class name]] with your data class name
Inherits DataService(Of NorthwindEntities)
' This method is called only once to initialize service-wide policies.
Public Shared Sub InitializeService(ByVal config As DataServiceConfiguration)
' TODO: set rules to indicate which entity sets and service operations are visible, updatable, etc.
' Examples:
config.SetEntitySetAccessRule("*", EntitySetRights.AllRead)
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All)
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3
End Sub
End Class
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }Damit lässt sich die Customers Tabelle in der Datenbank lesen und aktualisieren. Anders als beim RIA Service ist der Aufruf in der URL per REST direkt mit Customers (Case sensitiv) durchzuführen.
Die Proxy Generierung im Windows 8 Projekt ist dann sogar per Discover im Add Service Reference Dialog möglich.
Der VB.NET Code im Windows 8 WinRT ist nahezu ident zu RIA Services Nutzung.
Dim svc As New ServiceReference2.NorthwindEntities(New Uri("http://localhost.fiddler:19668/wcfdataservice1.svc"))
Private Sub Button_Click_1(sender As Object, e As RoutedEventArgs)
listview1.DisplayMemberPath = "Company_Name"
svc.BeginExecute(Of ServiceReference2.Customers) _
(New Uri("Customers", UriKind.Relative), AddressOf fertig, svc)
End Sub
Public Async Sub fertig(ByVal result As IAsyncResult)
Await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, Sub()
listview1.ItemsSource = svc.EndExecute(Of ServiceReference2.Customers)(result).ToList
End Sub)
End Sub
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Windows 8 APPs (METRO) werden in der Regel HTTPRequests ausführen. Diese kann man hervorragend mit Fiddler 2 analysieren. Für das Entwickeln eines Services wird man diese häufig auf dem lokalen Computer betreiben müssen. Genau dies unterbindet Windows 8. In Fiddler wird in der Win8 Config ein Zusatzprogramm gestartet. Mit dem kann pro Windows 8 Store App einen Ausnahme festgelegt werden. Ich drücke da immer Exempt All. Ein weiteres Hindernis ist, das der Web Server IIS Express aus Visual Studio 2012 nur HTTP Requests auf localhost akzeptiert. Ein entsprechender .NET Code Aufruf aus einer WinRT Anwendung läuft allerdings an Fiddler vorbei. Das war auch bei Silverlight schon so. Wenn man einen Punkt in die Domain “mogelt” wird der Request an den Proxy und damit Fiddler umgeleitet. In Silverlight war das ipv4.fiddler. Das klappt heute nicht mehr. Wenn man z.B. im Browser versucht einen WCF RIA Service auf 127.0.0.1 aufzureuifen erhält man eine Fehlermeldung HTTP Error 400. The request hostname is invalid. Um also mit einer Windows 8 Anwendung einen lokalen Web Service zu tracen und damit Fehler im Übertragungsprotokoll wie SOAP, ATOM oder ODATA zu finden muss man jetzt .fiddler an den Server Namen anhängen http://localhost.fiddler:19668/wcfdataservice1.svc/ Folgender Trace zeigt die Identen Daten zuerst mit RIA Services und dann mit WCF Dataservices 5.0 übertragen und mit einem automatisch generierten Proxy in Windows 8 konsumiert.
Es gibt aktuell zu viele Varianten Daten zu einer Windows 8 Store App (METRO) zu bringen. Dafür fehlt nach wie vor der direkte Zugriff auf einen SQL Datenbank. In diesem Blog habe ich untersucht wie man einen RIA Service, bekannt aus Silverlight, mit Windows 8 verbindet. Es kommt Visual Studio 2012 zum Einsatz. Zunächst habe ich ein Web Projekt angelegt. Bei Verwendung des MVC Templates scheint es Probleme zu geben, denen ich später auf den Grund gehe. Im ASP.NET Web wurde die Datenbank Nortwhind.sdf in das Verzeichnis APP_DATA kopiert. Als nächstes erzeugt man ein Datenmodell mit Entity Framework. Man clickt sich durch die Dialoge (immer nur bestätigen) bis man beim auswählen der Tabellen ist. Für das folgende Beispiel kommt die Customers zum Einsatz. Im Entity Framework hat sich seit der Version 4.1 eine Änderung ergeben (Stichwort dbcontext ) die nicht kompatibel zu RIA Services ist. Deswegen muss man im Modell die Code Generation Eigenschaft ändern auf Default und die beiden .tt Dateien löschen. Der Dialog wird nur angezeigt, wenn keine Tabelle im Model ausgewählt ist. Die .tt Dateien sieht man im Visual Studio Solution Explorer nur wenn “Show All Files” ausgewählt. Das Icon findet sich in der oberen Leiste des Visual Studio Explorer ca in der Mitte, leicht rechts. Weiter geht's mit der Erstellung des RIA Services. Das Template dazu ist “Domain Service Class”. Ganz wichtig ist den Odata Endpoint zu aktivieren, weil nur dann die Proxy Generierung im Windows 8 Projekt Erfolg haben wird. Zum Test kann der RIA Service direkt im Webbrowser aufgerufen werden. Die URL setzt sich zusammen aus Projektname- Domainserviceklasse .SVC. Der Pfadteil “Services” ist willkürlich, da ein HTTP Module den Request filtert. http://localhost:19668/services/WebApplication1-domainservice1.svc/odata/ Mit Zusatz $metadata sieht man das Schema. Nun kann man das Windows 8 Store Projekt zur Solution hinzufügen und dann per Add Service Reference den RIA Service hinzufügen. Nun die Frage, wie programmiert man so was an. Doku habe ich keine gefunden die RIA Services und Winrt zusammen zeigt. Allerdings scheint der Proxy recht ähnlich zu funktionieren wie bei WCF Dataservices (noch ein Service Layer). Zur Anzeige wird ein XAML Listview Control verwendet. Die Zeile mit DisplayMemberpath wird man normalerweise per XAML Deklaration erledigen. Der erste VB.NET Code Block wird entweder bei Pageload oder auf Button Click ausgeführt. Eine Eigenart von RIA Services ist, der SET Anhang an den Tabellennamen. So ruft man auch die URL direkt auf. Dim svc As ServiceReference1.DomainService1 = New ServiceReference1.DomainService1(New Uri(http://localhost:19668/services/WebApplication1-domainservice1.svc/odata/))
Private Sub Button_Click_1(sender As Object, e As RoutedEventArgs)
listview1.DisplayMemberPath = "Company_Name"
svc.BeginExecute(Of ServiceReference1.Customers) _
(New Uri("CustomersSet", UriKind.Relative), AddressOf fertig, svc)
End Sub
Public Async Sub fertig(ByVal result As IAsyncResult)
Await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, Sub()
listview1.ItemsSource = svc.EndExecute(Of ServiceReference1.Customers)(result).ToList
End Sub)
End Sub
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Ich würde diese Weg wählen wenn, entweder eine RIA Service Schicht vorhanden ist, oder man auch Silverlight Clients bedienen möchte. Schließlich wird die Welt noch länger brauchen bis jeder ein Windows 8 Device hat.
Die Verwendung von Styles ist in Windows 8 kaum anders als in Silverlight und vermutlich WPF. Mit Hilfe des Style Attributes kann der XAML Code in einer Page reduziert werden. Das wesentlich schlagkräftigere Argument wird aber die Wiederverwendung einer Style Vorlage sein. So kann man zb ein UIElement einmalig Designen und dann immer wieder verwenden. In der Datei StandardStyles.xaml befinden sich Z.B. die runden Buttons die man in der AppBar oft verwendet. Einem Textblock Steuerelement kann so per Deklaration mit dem Schlüsselword StaticResource eine Vorlage (auch Theme) zugewiesen werden. Die Definition der Vorlage kann in der XAML Page direkt, der APP.XAML oder meist in einem Ressource Dictionary vorgenommen werden. Dort werden ein Style für ein UIElement definiert und die Eigenschaften per Setter direkt gesetzt. Wichtig ist der Zieltyp. Ein weiterer Style kann mittels BasedOn von einem anderen Style die Setter sozusagen erben. <ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:App1">
<Style x:Key="demo1" TargetType="TextBlock">
<Setter Property="FontSize" Value="16"></Setter>
</Style>
<Style x:Key="demo2" TargetType="TextBlock" BasedOn="{StaticResource demo1}">
<Setter Property="FontFamily" Value="Impact"></Setter>
</Style>
</ResourceDictionary>
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Dann muss das Dictionary in der app.xaml der Anwendung hinzugefügt werden.
<Application
x:Class="App1.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:App1"
xmlns:localData="using:App1.Data">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Common/StandardStyles.xaml"/>
<ResourceDictionary Source="Dictionary1.xaml"/>
</ResourceDictionary.MergedDictionaries>
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
Themes gibt es übrigens in Windows 8 styled Apps (METRO) wirklich. Sie heißen dark und light und sind in per Windows 8 System in C:\Program Files (x86)\Windows Kits\8.0\Include\winrt\xaml\design\ definiert.
Die Zuweisung erfolgt im ersten Element der app.xaml per RequestedTheme="Light".
Die Microsoft Mühlen malen langsam. Der Name der Beta Prüfung 71-485 enthält noch immer METRO. Die Prüfung ist die letzte von drei nötigen für den neuen MCSD. Abwohl Fortgeschritten im Namen, deckt sie sich in weiten Teilen mit der 70-484 und ist dabei sogar meist einfacher außer es kommen wieder Fragen zu Dingen die man noch nicht gemacht hat wie Remote Debugging.. Das Schema rund 30 Fragen und 2 Fallstudien mit ca je 10 Fragen. Zur Vorbereitung empfehle ich die Website. Was waren Prüfungsfragen: Animationen auch per Code, Minifrage nach Unittests Lokalisierung, Ressourcen, XAML, Code per Resourceloader. Services WNS, Oauth ein paar Zusatzfragen die schon im ersten Teil vorkamen zu Kamera und Devices. Da hab ich meist geraten. Advanced empfand ich z.B. , Drucken, Tasks, Background (download/upload), Encryption, Cryptographicbuffer, ganz unbekanntes zum Store und Lizenzierung, Messung von Usern und Anwendungsverhalten, wiederverwendung per WINMD Der aktuelle volle Titel der Zertifizierungsprüfung Advanced Metro style App Development using C#
Auf dem Weg zum MCSD Windows 8, habe ich nun heute die BETA Prüfung 71-484 geschrieben. Vorbereitendes Material gibt es nur wenig. Microsoft schreibt auf seiner MCP Seite zu den Grundlagen der Windows METRO Anwendungsentwicklungein paar Stichpunkte. Die Prüfung umfasste 2 Fallstudien mit je ca 10 Fragen und nochmal 30 Fragen meist im gewohnten Multiple Choice verfahren. Einige Fragen erfordern Code snippets per Drag und Drop zu platzieren. Die Fallstudien sind recht mühsam, da man Anforderungen und Code lesen muss und dann dazu Fragen bekommt. Fand ich schwer. Selbst wenn ich Braindumps zur Prüfungsvorbereitung gehabt hätte, sie hätten nichts geholfen. Wichtig sind die Quickstarts, davon habe ich einiges in den Prüfungen vorgefunden. Wie offensichtlich generell gibt's den Test nur für C# und JavaScript. Inhaltlich ging es viel um Tiles, Toasts und Notifcations. Selbst das XML Format sollte einem geläufig sein. Dann natürlich um den Life Cycle, Status Sichern, große Daten wie Bilder, lokal, temporär, Roaming. Daten auf der lokalen Maschine und wie man diese sharen kann, welche Rechte wo auch removable Storage. Ein wenig um Datenbindung Listen Observablecollection und Converter. Etwas exotischer war auch eine Grouping Frage dabei. Einige Fragen gingen sehr präzise in Richtung MVVM, welche Logikteile wo anzusiedeln sind. Ein Teil ging um Bildschirmdarstellung, VisualStatemanager oder Manifest. Auch was zum drehen des Bildschirmes. Dann noch um die Contracts, Share, Search, Sharetarget Events, SettingsPane. Ich glaube mich auch zu erinnern, wie man eine Hilfe per Settings Charme realisiert. Die Lösungen waren irgendwas mit Invoke was ich so nicht kannte und raten musste. Dann ein Part um Services, REST und die Analogien zu den HTTP Commands. Nicht ganz geläufig war mir die WebAuthentication auch mit Oauth. Fragen die zum Store und submission Prozess gingen musste ich raten. Auch bei Navigation war was zum Caching was ich nicht gemacht hatte. Originalname der Prüfung: Essentials of Developing Windows Metro style Apps using C#
Einen Wahr Falsch Konverter würde ich manchmal jemanden wünschen. Hier geht es aber um die Anzeige von Daten, bzw. einer Liste die aus komplexen Objekten mit einer boolschen Eigenschaft besteht. Typischerweise bindet man eine Wert vom Typ Bool an einen Eigenschaft die Typ Text oder was anderes hat. Einige Converter sind in WinRt Visual Studio 2012 Projekt Template schon vorbelegt. Ich baue mir den ToX converter um flexibel zu sein. Ich hab mir kurzfristig überlegt ob ich die Switchwerte als StaticResource im XAML deklariere, mich aber dann für gemeine Propertys entschieden. Imports System
Imports Windows.UI
Public Class booleanToXConverter
Implements IValueConverter
Private _wahr As String
Public Property wahr() As String
Get
Return _wahr
End Get
Set(ByVal value As String)
_wahr = value
End Set
End Property
Private _falsch As String
Public Property falsch() As String
Get
Return _falsch
End Get
Set(ByVal value As String)
_falsch = value
End Set
End Property
Public Function Convert(value As Object, targetType As Type, parameter As Object, language As String) As Object Implements IValueConverter.Convert
If value Then
Return wahr
Else
Return falsch
End If
End Function
Public Function ConvertBack(value As Object, targetType As Type, parameter As Object, language As String) As Object Implements IValueConverter.ConvertBack
End Function
End Class
Man könnte auch die Parameter im Binding verwenden, muss diese dann aber x-fach im XAML Code tippen.
Zunächst die deklarative Instanz mit seinen beiden Attributen
<Page.Resources>
<local:booleanToXConverter x:Key="booleanToXConverter" falsch="Gesendet" wahr="Empfangen"/>
Das Binden per XAML im Windows 8 METRO Style App per Converter
<TextBlock Text="{Binding key,Converter={StaticResource booleanToXConverter}}" Margin="0"
FontSize="21"