SmartUnitTests in Visual Studio 2015 – PEX is back

Schon mit Visual Studio konnte man Pex & Moles als AddOn installieren und verwenden (siehe: http://blog.ppedv.de/post/2011/01/12/Einfache-Stubs-fur-FileSystem-Aufrufe-beim-Unit-Testing-mit-Moles.aspx) Dieses, ursprünglich von MS Research entwickelte, Projekt bestand aus zwei Teilen. Moles ist ein Mocking Framework. Dieses hat unter dem Namen “Fakes-Framework” nun Einzug in Visual Studio 2012 gehalten (http://blog.ppedv.de/post/2012/07/22/Unit-Test-fur-SharePoint-Development-Fakes-Framework.aspx)

Allerdings hat bis vor kurzem der zweite Teil gefehlt. PEX schaffte es nicht ins VS 2012 oder VS 2013. Nun mit der Preview von Visual Studio 2015 kommt nun kehrt das Tool “PEX” unter dem Namen “Smart Unit Tests” wieder zurück.

Smart Unit Tests erstellen von einem bestehenden Code aus die dazu passenden Unit Tests. Es werden Parametrisierte Unit Tests angelegt.  Da der Code schon vorher bestehen muss, eignet sich dieses Tool nicht für Test Driven Development. In der Praxis werden aber die meisten Tests, wenn überhaupt, erst nach dem Code geschrieben. Und bei dieser Vorgangsweise kann das Tool sehr hilfreich sein.

Nehmen wir für einen ersten Test eine ganz simple Funktion die in der Klasse “Berechnungen” implementiert wurde und schreiben für diese einen Unit Test:

1 public decimal Dividieren(int a, int b) 2 { 3 decimal erg = a / b; 4 return erg; 5 }

 

Im Visual Studio kann nun bei jeder Funktion im Kontext Menü der Punkt “Smart Unit Tests” aufgerufen werden.

image

Das Projekt wird kompiliert und Visual Studio sucht nun für die Funktion jene Parameter, die es wert sind getestet zu werden. Die gefundenen Werte werden in einem eigenen Fenster ausgegeben:

image

Gleichzeitig wurde im Projekt eine weitere Klasse angelegt. Diese nennt sich “BerechnungenTest” und enthält keine Testmethoden sondern PexMethoden. Die Methode die für die Tests der Dividieren-Funktion zuständig ist sieht so aus:

1 public partial class BerechnungenTest 2 { 3 [PexMethod] 4 [PexAllowedException(typeof(DivideByZeroException))] 5 public decimal Dividieren( 6 [PexAssumeUnderTest]Berechnungen target, 7 int a, 8 int b 9 ) 10 { 11 decimal result = target.Dividieren(a, b); 12 return result; 13 // TODO: add assertions to method BerechnungenTest.Dividieren(Berechnungen, Int32, Int32) 14 } 15

Diese Methode ist aber noch nicht die TestMethod die von MS Test ausgeführt wird. Die Testmethoden werden zunächst dynamisch erstellt. Im Smart Unit Test Fenster kann die erstellte Methode angesehen werden. Wenn eine Zeile im Fenster ausgewählt wird, erscheinen im rechten Teil die “Details” und hinter diesen sieht man die entsprechende Test-Methode:

image

Diese Methode wurde dynamisch erstellt und ausgeführt. Möchte man diese als Test dauerhaft in das Projekt aufnehmen, muss aus dem Kontext-Menü der Punkt “Save” gewählt werden. Damit wird eine .g.cs Datei erstellt und diese enthält nun die Testmethode:

1 [TestMethod] 2 [PexGeneratedBy(typeof(BerechnungenTest))] 3 public void Dividieren598() 4 { 5 decimal d; 6 Berechnungen s0 = new Berechnungen(); 7 d = this.Dividieren(s0, 0, 1); 8 Assert.AreEqual<decimal>(default(decimal), d); 9 Assert.IsNotNull((object)s0); 10 } 11 } 12 }

Die Einrückung der Klammern stimmt noch nicht ganz, aber das ist ja nur Formsache.

Je komplexer der Code ist der getestet werden soll, umso umfangreicher werden die gefundenen Testfälle. Bei einer “erweiterten” Rechne-Methode werden es schon 7 Fälle.

1 public decimal Rechne(int a, int b, string rechenoperation) 2 { 3 decimal erg = 0; 4 switch (rechenoperation) 5 { 6 case "+": 7 erg = a + b; 8 break; 9 case "-": 10 erg = a - b; 11 break; 12 case "*": 13 erg = a * b; 14 break; 15 case "/": 16 erg = a / b; 17 break; 18 } 19 return erg; 20 }

image

 

Fazit

um bestehenden Code einfach zu testen, ist dieses Tool perfekt. Es ermittelt zuverlässig die “interessanten” Parameter der Funktionen. Allerdings widerspricht das komplett dem Test-First-Ansatz. Aber zumindest sind ein paar Tests besser, als gar keine Tests. Und dieses Tool, erleichtert das Erstellen der Unit Tests ungemein.

XAMARIN Tools in Visual Studio 2013 installieren

Die XAMARIN Developer Tools bieten die Möglichkeit, auf Basis von .NET/C# Mobile Applikationen “Cross-Plattform”, also für verschiedene mobile Plattformen zu erstellen. Im Konkreten können Entwickler, auf Basis von Mono, der Cross-Plattform Implementierung der Common Language Infrastructure (auch bekannt als Microsoft .NET) native Apps für iOS, Android und Windows mit nativem User Interface Komponenten erstellen und dabei die selbe ‘'Shared-Codebasis” auf den unterschiedlichen Plattformen nützen. In seinem Produktsortiment hat das Unternehmen aus San Francisco aktuell die XAMARIN Plattform für Windows und iOS auch eine XAMARIN Test Cloud sowie den .NET Mobility Scanner. Die Test Cloud ermöglicht es, Applikationen online auf physischen Geräten zu testen. Der .NET Mobility Scanner ist ein freies Web-basiertes Tool, auf Basis von Silverlight, der sich insofern als nützlich erweist, um den Entwicklern zu zeigen, wie viel von ihrem Code auf anderen Plattformen, also im Speziellen auf iOS, Android und Windows Phone verwendet werden kann.

XAMARIN Logo

In einem vorigen Blogbeitrag sind wir auf die unterschiedlichen Szenarien in der mobilen Entwicklung eingegangen. In diesem Blogbeitrag zeigen wir Ihnen, wie Sie bequem das Add-on XAMARIN für Visual Studio in die Entwicklungsumgebung Visual Stuido 2013 integrieren können, Zunächst muss auf https://store.xamarin.com/ das entsprechende Angebot ausgewählt werden. Visual Studio Integration, bieten derzeit nur die Lösungen INDIE, ENTERPRISE und die BUSINESS. Natürlich bietet XAMARIN auch einige Rabatt Aktionen: So können Entwickler mit einer gültigen MSDN Lizenz 20% jährlich sparen. Den Link zur MSDN Aktion finden Sie hier: https://xamarin.com/msdn. Für Studenten gibt es derzeit sogar ein Lern-Programm, dass ihnen XAMARIN für iOS und Android weitestgehend gratis zur Verfügung stellt. Studenten können sich hier http://xamarin.com/student mit ihrer offiziellen Uni E-Mail Adresse für eine XAMARIN Indie Lizenz - leider ohne Visual Studio Add-on - bewerben (VS Support für Studenten gibt es aber dann um $99 pro Jahr).

Ist der Registrierungsprozess einmal abgeschlossen, kann man sich im persönlichen Portal auf der Webseite des Herstellers, im Bereich Downloads die aktuellen Versionen von XAMARIN Studio (aktuell 5.5.3) und dem XAMARIN Visual Studio Add-On (aktuell 3.7.248) laden.

image

Das Visual Studio Plugin für Android und iOS Entwicklung kann als .msi Datei bequem mithilfe eines Assistenten zu MS Visual Studio hinzugefügt werden.

Installation XAMARIN Visual Stuido

Anschließend muss, um die Registrierung abzuschließen, im XAMARIN Account auf der Webseite die E-Mail Adresse des Entwicklers registriert werden. Dazu werden unter dem Reiter XAMARIN.Android und XAMARIN.iOS die jeweiligen E-Mail-Adressen als “Seat” zum Account hinzugefügt.

image

In der Entwicklungsumgebung Visual Studio 2013 können nun Anwendungen für die unterschiedlichen Plattformen als neues Projekt angelegt werden.

image

In diesem Beispiel wird eine neue Android Applikation angelegt. Die dann auf dem aktuellen Android Betriebssystem “KitKat” auf einem installierten Emulator oder dem mit dem PC verbundenen Android Smartphone ausgeführt werden kann.

Mithilfe von Visual Studio 2013 und XAMARIN können nun Apps für iOS, Android und Windows Phone auf Basis von C#/.Net erstellt werden. Aktuell gibt es jedoch noch eine Einschränkung bei der Entwicklung von iOS Anwendungen: Es wird für die Erstellung der Installationsdatei für iOS ein MAC Rechner benötigt, da das MAC OS rein rechtlich nur auf Apple Geräten funktionieren darf und auch kann. Das Betriebssystem wird von Apple offiziell nur als Update für MAC Rechner über den ITunes Store ausgeliefert.

Custom Code Activity für SharePoint 2013 Workflow

Der Workflow Manager bringt schon einige Activities mit. Jedoch ist es manchmal wünschenswert eigene Activities mit C# Code zu erstellen und nicht alles nur im Designer “zusammen zu klicken”

Im großen Überblick sind die notwendigen Steps einfach.

1) Die Activity ist eine von “CodeActivity” abgeleitete Klassen. Die Methode “Execute” wird vom Workflow aufgerufen.

2) das Assembly mit der Klasse muss auf der Maschine mit dem Workflowmanager deployed werden.

So schnell der Teil 1 erledigt ist, so mühsam ist Teil 2, weil hierfür kein Template bereitgestellt wird.

Zunächst legen wir ein neues Visual Studio Projekt an. Als Vorlage wird “Activity Library” ausgewählt. Dieses Template ist im Bereich “Workflow” zu finden. Die automatisch angelegte “Activity1.xaml” kann gelöscht werden.

Danach wird mit “Add-Item” eine neue Code-Activity in das Projekt eingefügt. Im Beispiel nenne ich diese “SimpleActivity.cs”

image

Mit dieser Vorlage wird die Klasse “SimlpeActivity” angelegt und die Methode Execute überschrieben.

1 public sealed class SimpleActivity : CodeActivity 2 { 3 4 public InArgument<string> Text { get; set; } 5 public OutArgument<string> Result { get; set; } 6 7 protected override void Execute(CodeActivityContext context) 8 { 9 10 string text = context.GetValue(this.Text); 11 12 Result.Set(context, text.ToUpper()); 13 } 14 }

In den Zeile 4 und 5 werden ein Input und ein Output Parameter für diese Activity angelegt. Innerhalb der Excecute Methode kann über Context.GetValue ein Inputparameter abgerufen werden.

Mit Result.Set kann der Output-Parameter gesetzt werden. In diesem simplen Demo wird der Inputwert in Großbuchstaben in den Output geschrieben. In der Realität wird wohl die Execute-Methode etwas komplexer werden.

Teil 2 – Das Deployment

Das Assembly muss mit einem “strong name” versehen sein, daher muss das Assembly signiert werden. Dafür wird in den Properties des Projektes, die Checkbox “Sign the assembly” gesetzt und somit ein neues Keyfile im Projekt angelegt.

Als nächstes muss eine Datei mit dem Namen “allowedtypes.xml” erstellt werden. In dieser Datei werden die Typen beschrieben, welche vom Workflowmanager geladen werden. Der Dateiinhalt sieht wie folgt aus:

1 <AllowedTypes> 2 <Assembly Name="SimpleActivityDemo"> 3 <Namespace Name="SimpleActivityDemo"> 4 <Type>SimpleActivity</Type> 5 </Namespace> 6 </Assembly> 7 </AllowedTypes>

Nachdem das Projekt kompiliert wurde müssen die erstellte DLL und die Datei “AllowedTypes.xml” in ein Verzeichnis des Workflowmanagers kopiert werden. Das Zielverzeichnis ist: “C:\Program Files\Workflow Manager\1.0\Workflow\Artifacts”

Möchte man die Activity nun in einem Visual Studio Workflow verwenden, muss die Activity in die Toolbox aufgenommen werden. Im Context-Menü der Toolbox kann mit dem Menü Punkt “Choose Items…” die DLL ausgewählt werden und damit die enthaltene Activity in die Toolbox aufgenommen werden.

image

Danach kann die Custom-Activity wie jede andere in Workflow Projekte aufgenommen werden. Die beiden Parameter “Text” und “Result” sind wie gewohnt über das Eigenschaftenfenster im Visual Studio zu setzen.

image

Windows 10 Technical Preview: Die Dritte!

Am 11. November veröffentlichte Microsoft die nächste (und dritte) Technical Preview-Version von Windows 10: Build 9879. Nach den Neuerungen muss man allerdings geduldig suchen!

Neben kleineren Optimierungen und Fehlerkorrekturen, wurden einige Änderungen an den visuellen Effekten bei Animationen von Fenstern (beim Öffnen, Minimieren und Maximieren) und Übergängen zwischen virtuellen Desktops vorgenommen - diese sind jetzt etwas dezenter.

Die “größte” Neuerung ist die Individualisierung von zwei Icons auf der Taskleiste. Mit Windows 10 wurde eine neue Suche und virtuelle Desktops implementiert. Die Icons zu diesen Features sind standardmäßig auf der Taskleiste zu finden.

Windows 10 - 01

Da viele User die Icons als störend empfanden, besteht jetzt die Möglichkeit diese von der Taskleiste zu entfernen. Hierzu muss man einfach einen Rechtsklick auf die Taskleiste vornehmen. In dem dann erscheinenden Kontextmenü findet man dann die passenden Einträge “Show Task View button” und “Show Search button”.

Windows 10 - 02

Entfernt man die Haken vor den Einträgen, verschwinden auf der Taskleiste die entsprechenden Icons.

Windows 10 - 03

ASP.NET Identity

Da Microsoft in den letzten Monaten durchaus den ein oder anderen Blick über den Tellerrand gewagt hat, hat sich doch so einiges getan. Besonders in der Web-Welt von ASP.NET. Alle sprechen nur noch von One ASP.NET, und das alles einfacher und klarer ist und werden soll. Die ersten Schritte sind schon getan, man findet beim erstellen eines neuen Projekts nur noch eine ASP.NET WebApplication Vorlage welche dann die optionale Auswahl der verschiedensten Technologien ermöglicht.
Doch der Fokus dieses Blogbeitrags soll auf das neue IdentityModel abzielen. Bisher war es wohl eher eine Qual mit dem Membership Modell von Microsoft etwas eigenes bzw. angepasstes auf die Beine zu stellen. Doch nun hat das ASP.NET Team erkannt, dass es an der Zeit für etwas frischen Wind ist und so einige Änderungen/Anpassungen vollzogen welche es uns Entwicklern leichter ermöglichen sollen unsere User mit den dazugehörigen Profildaten zu verknüpfen.

Mit ASP.NET WebForms

Zunächst schauen wir uns mal die Projektvorlage an welche wir beim erstellen einer neuen WebApplication erhalten.

Blog_ASP_Identity_27102014

Im App_Start Ordner ist die Identityconfig.cs und im Models ordner, welcher selbst auch neu ist, kam die IdentityModel.cs neu hinzu. Beide zusammen bilden so zu sagen das Grundgerüst für das neue IdentityModel.

IdentityConfig

In der IdentityConfig.cs befinden sich mehrere Klassen, eine davon ist die ApplicationUserManager. Diese ist der Dreh und Angelpunkt der IdentityConfig. Hier werden mehrere Einstellungen und Richtlinien getroffen, hauptsächlich bei der Erzeugung eines neuen Users. Hier wird z. B. die Passwortstärke oder die Anzahl an maximalen fehlversuchen beim Login festgelegt.

Blog_ASP_Identity_27102014_2

IdentityModel

Im IdentityModel befindet sich einerseits das UserModel (ApplicationUser) und der DbContext welcher von der EntityFramework CodeFirst Migration verwendet wird. Falls wir nun unseren Usern weiter Information beim Login aus den Fingern kitzeln wollen fügen wir diese einfach dem Application User als einfaches Property hinzu. In unserem Fall fügen wir mal ein Property Ort vom Typ string hinzu.

   1: public class ApplicationUser : IdentityUser
   2: {
   3:     public string Ort { get; set; }
   4:  
   5:     public ClaimsIdentity GenerateUserIdentity(ApplicationUserManager manager)
   6:     {
   7:         // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
   8:         var userIdentity = manager.CreateIdentity(this, DefaultAuthenticationTypes.ApplicationCookie);
   9:         // Add custom user claims here
  10:         return userIdentity;
  11:     }
  12:  
  13:     public Task<claimsidentity> GenerateUserIdentityAsync(ApplicationUserManager manager)
  14:     {
  15:         return Task.FromResult(GenerateUserIdentity(manager));
  16:     }
  17: }

Im ApplicationUserContext steht nicht großartig viel Code. Den Context verwenden wir eig. nur um mit Hilfe der CodeFirst Migration auf die Datenbank los zu gehen.

Hierzu 2 einfache Befehle:

  1. Enable-Migrations –EnableAutomaticMigration
  2. Update-Database

EnableeAutomaticMigration deshalb, weil wir dann keine Zeit damit verschwenden müssen uns selbst um die Migrationen zu kümmern.
Standardgemäß wird die entsprechende Datenbank als lokaler MDF-File im App_Data Verzeichnis erzeugt, dies kann man natürlich auch ändern wie man es gerne möchte in der Web.config  z. B.

Letzte Schritte

Da wir nun die Config und das Model soweit konfiguriert haben wie wir es gerne möchten und unsere Datenbank geupdated wurde, steht uns nicht mehr viel im Weg bevor wir diese Daten vom User erfassen lassen können.

Blog_ASP_Identity_27102014_3

Der nächste Schritt wäre es, in der Register.aspx eine weitere Zeile mit entsprechendem Input Element hinzu zu fügen welche dem Nutzer die Eingabe ermöglicht.

   1: <div class="form-group">
   2:     <asp:label runat="server" AssociatedControlId="Ort" CssClass="col-md-2 control-label">Email</asp:label>
   3:     <div class="col-md-10">
   4:         <asp:TextBox runat="server" ID="Ort" CssClass="form-control" />
   5:         <asp:RequiredFieldValidator runat="server" ControlToValidate="Ort"
   6:                                     CssClass="text-danger" ErrorMessage="The Ort field is required." />
   7:     </div>
   8: </div>


Nachdem wir das Input-Element hinzugefügt haben müssen wir noch in der CodeBehind beim erzeugen des neuen Users die jeweiligen Daten mit angebenen.

1: var user = new ApplicationUser() { UserName = Email.Text, Email = Email.Text, Ort = Ort.Text };

 


Und das wars schon. Mehr muss man gar nicht machen um die Userdaten zu erweitern. Mit MVC sieht das ganze recht ähnlich aus nur anstelle der Register.aspx hat man im Views/Account/ Verzeichnis eine Register.cshtml und die CodeBehind haben wir dort auch nicht. Anstelle davon ist der AccountController da mit der [HttpPost] Register Action. Ein kleiner zusätlicher Schritt ist noch bei MVC zu machen, und zwar man sollte noch das RegisterViewModel anpassen, dort kann man auch direkt mit Data Annotatinos Arbeiten und weitere ValidierungsLogik hinzufügen.

Fazit

Einfach zu handhaben und gar nicht so kompliziert wie es den meisten im ersten Moment vll. vorkommt.

Viel Spaß Zwinkerndes Smiley

easy Datenbindung MVVM und XAML

Ich erinnere mich noch recht gut an meine ersten Silverlight Schulungen. Das Thema zwei Wege Datenbindung und die Benachrichtigungsevents ans Userinterface, war für den Kursteilnehmer immer etwas mühsam. Nun komme ich aus einem Vortrag auf der #ADCX und hab ganz Beiläufig fody kennen gelernt. Und die Welt ist schöner geworden.

Zur Erinnerung: Um einem Model die Fähigkeit zu geben, eine Änderung der Daten dem User Interface mitzuteilen, muss das Interface INotfiyPropertyChanged implementiert werden. Pro Eigenschaft muss dann das ProperChanged Event, mit dem Namen des Propertys als String Argument, ausgelöst werden. Mal abgesehen von der Tipperei, eine perfekte Fehlerquelle. Mit .net 4.0 wurde dann das CallermemberAttribut eingeführt, das dem Compiler erlaubt, den Wert zuzuweisen. In Silverlight 5 muss man einen Trick verwenden, um das Attribut überhaupt nutzen zu können.

   1:  <AttributeUsageAttribute(AttributeTargets.Parameter, Inherited:=False)>
   2:  Public NotInheritable Class CallerMemberNameAttribute
   3:      Inherits Attribute
   4:  End Class

Ohne obigen Code wird folgender VB.NET Code in einem Silverlight Projekt nicht kompilieren

   1:  Public Class person
   2:      Implements INotifyPropertyChanged
   3:      Property id As Integer
   4:      Private _name As String
   5:      Public Property name() As String
   6:          Get
   7:              Return _name
   8:          End Get
   9:          Set(ByVal value As String)
  10:              _name = value
  11:              OnPropertyChanged()
  12:          End Set
  13:      End Property
  14:   
  15:      Protected Sub OnPropertyChanged(<CallerMemberName> 
Optional propertyName As String = Nothing)
  16:          RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
  17:      End Sub
  18:      Public Event PropertyChanged(sender As Object, 
e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged
  19:  End Class

 

Die Zwei Wege Bindung wird nur für das Property name implementiert. Es muss die Langform mit Getter und Setter verwendet werden um in letzteren das Änderungs Event auszulösen (Zeite 11). Der Compiler ersetzt in Zeile 11 den Wert des Parameters propertyName mit “name”.

Es gib wohl Menschen die sich den Gedanken der Compiler Services noch tiefer zu Gemüte geführt haben. Auf Basis von Fody existiert ein Plugin für NotifyPropertyChanged, das man sich per Nuget in seine Visual Studio Projekt installieren kann.

image

Ab jetzt ist es nur noch geli einfach. Aus je zehn Zeilen Code wird eine. Es reicht eine Klassenattribut einzufügen und die verkürzte Propertysyntax.

   1:  <ImplementPropertyChanged>
   2:  Public Class person
   3:      Property id As Integer
   4:      Property name As String
   5:  End Class
Der Compiler erzeugt daraus im wesentlichen die Langversion des Codes, wie im vorigen Beispiel demonstriert.

PS fast auf den Tag genau vier Jahre sind vergangen seit Bob Muglia beiläufig Silverlight für Tod erklärte. Nur drei Monate später musste Bob der damalige Chef von Server und Tools seinen Stuhl räumen. HTML5 reicht auch heute noch bei weitem nicht an Silverlight heran.

SCCM 2012 R2: Neue Anwendungsanforderungen automatisch melden

Der System Center Configuration Manager (SCCM) 2012 R2 bietet die Möglichkeit, Anwendungen für Benutzer als “verfügbar” bereitzustellen. In dieser Kombination (und nur dort) lässt sich auch eine Genehmigungsanforderung einschalten:

approv1

Der Benutzer hat nun die Möglichkeit, die Software über den Application Catalog (Anwendungskatalog) anzufordern:

approv2

Wurde die Anforderung vom Benutzer ausgelöst, so taucht sie dann in der SCCM-Konsole auf:

approv3

Leider ist es nicht vorgesehen, dass man das Eintreffen einer neuen Anforderung per E-Mail o.ä. meldet und in der Regel sitzt kein Admin den ganzen Tag vor der GUI und wartet auf neue Anforderungen. Also muss man eine andere Lösung schaffen, dies weitgehend zu automatisieren.

Eine Variante wäre, bei Eintreffen eben eine E-Mail zu versenden. Dazu muss man das Eintreffen einer Anforderung automatisiert feststellen können. Und dazu ist die PowerShell sehr gut geeignet:

approv4

Der Aufruf dazu lautet:

Get-CMApprovalRequest | Where-Object {$_.CurrentState -eq 1}

(CurrentState ist der Zustand der Anfroderung; “1” bedeutet, sie ist neu und unbearbeitet, “4” bedeutet z.B., sie ist bereits genehmigt)

Mittels Format-Table o.ä. könnte man die Ausgabe noch aufbereiten:

approv5

Nun lässt sich diese Ausgabe z.B. in eine E-Mail verpacken. Ein komplettes Skript könnte dann so aussehen:

approv6

Zum Kopieren:

$FromAdr = admin@abc.de
$ToAdr = receiver@abc.de
$SMTPSrv = send.abc.de
$MailSubject = "New SCCM Application Approval Request"

If((Get-CMApprovalRequest | Where-Object {$_.CurrentState -eq 1} | Measure-Object).Count -gt 0)
{
    $Mailtext = Get-CMApprovalRequest | Where-Object {$_.CurrentState -eq 1} | ft Application,User,Comments -Auto
    Send-MailMessage -from $FromAdr -to $ToAdr -subject $MailSubject -body $Mailtext -smtpServer $SMTPSrv
}

 

Sie möchten mehr zum System Center Configuration Manager erfahren und weitere Tips und Tricks erhalten? Dann sind Sie bei unserer SCCM-Schulung genau richtig!

 

Expression Blend UX Guides

Es ist wahnsinnig einfach schlechtes Design zu entwerfen. Aber es ist auch relativ einfach gute User Interfaces zu bauen, wenn man die Grundregeln kennt. Um ein klares Layout (Clean Layout) zu erstellen braucht das UI ein Schema. Mit einem typografischen Grid Layout kann man die UI Elemente wie Text und Bilder strukturieren und ausrichten.

(Quelle Wikipedia)

Visual Studio 2013 erlaubt es ein Raster einzublenden und neu erzeugte Controls an den unzähligen Führungslinien auszurichten.

image

Expression Blend für Visual Studio 2013 kann da schon einiges mehr. Wenn man im Designer vom Lineal per Maus Drag und Drop auf das UI zieht entstehen blaue Führungslinien. Diese werden Rulers und Guides genannt.

image

Dieses UI Schema kann man sogar speichern um es später in anderen XAML Seiten wieder zu verwenden. Im Menü View – Manage Guides auswählen.

 image

Besonders praktisch, Blend bietet auch eine Reihe von vordefinieren Guidelines  zur Auswahl. Für eine Windows Store App (vormals METRO) sind das

  • BasicPage
  • FileOpenPicker
  • GroupDetailPage
  • GroupedItemsPage
  • HubPage
  • ItemsPage
  • SearchResultsPage
  • SettingsFlyout
  • ShareTargetPage
  • SplitPage

Die GroupItemsPage Vorlage

image

Expression Blend für Visual Studio 2013 ist der Nachfolger von Blend 4.0. Damit lassen sich WPF, Silverlight und WIndows 8.1 Apps (HTML und XAML) Designen. Expression Studio 4 wurde komplett eingestellt. Der Nachfolger ist direkt in Visual Studio integriert und benötigt keine separate Lizenz. Mehr zu UX Design gibt es auf der GUI&DESIGN Konferenz in Berlin. Der Autor gibt auch 2-tägige Blend Schulungen.

Weitere Services und Preisanpassungen bei Microsoft Azure

 

Microsoft hat angekündigt den Dienst für instanzabhängige öffentliche IP-Adressen öffentlich verfügbar zu machen. Somit können virtuelle Maschinen und Web- oder Workerrollen direkt mit einer öffentlichen IP verbunden werden, ohne dass man diese weiter über einen Endpunkt mappen muss. Damit kann man Szenarien wie Ftp-Server und das Monitoring von virtuellen Maschinen in Azure direkt über die IP-Adressen durchführen. Nach dem Bereitstellen der allgemeinen Verfügbarkeit ist auch die Beschränkung von zwei IP-Adressen pro Abonnement weggefallen. Die Preise für die allgemeine Verfügbarkeit werden ab dem 1. Dezember 2014 in Rechnung gestellt. Mehr Informationen erhalten Sie unter http://msdn.microsoft.com/library/azure/dn690118.aspx.

 

Auch die Azure Site Recovery steht nun als allgemein verfügbarer Dienst zur Verfügung. Somit können Hyper-V virtuelle Maschinen die in Azure Rechenzentren laufen im Katastrophenfall repliziert und in einem Azure Rechenzentrum auch wiederhergestellt werden. Mehr Informationen erhalten Sie unter http://azure.microsoft.com/en-us/services/site-recovery/.

 

Die ursprünglichen Preissenkungen für Service Bus Queues und Service Bus Topics treten erst ab dem 1. November 2014 und nicht wie ursprünglich angekündigt zum 1. Oktober 2014 in Kraft. Eine detaillierte Preisübersicht finden Sie unter http://azure.microsoft.com/en-us/pricing/details/service-bus/.

 

Für SQL Datenbanken ist Elastic Scale in der Vorschau verfügbar. Damit kann der Prozess zum Skalieren der Datenschicht einer Azureapplikation wesentlich vereinfacht werden. Mit Elastic Scale wird mittels .NET Bibliotheken und Azure Servicevorlagen die Funktionalität zur Verfügung gestellt, dass die Applikation auf wenige oder aber auch auf tausende Datenbanken zugreift. Die Preview ist ohne weitere Kosten ab sofort verfügbar, die für diesen Dienst erstellten Datenbanken werden selbstverständlich wie bisher abgerechnet. Kunden die bisher SQL Database Federations verwendet haben können diesen Dienst bis September 2015 weiter nutzen. Sie werden aber mit Migrationspfaden versorgt um die nötigen kleinen Anpassungen an der Applikation durchzuführen und den neuen Dienst nutzen zu können. Mehr Informationen erhalten Sie unter http://azure.microsoft.com/en-us/documentation/articles/sql-database-elastic-scale-get-started/.

 

Layoutrounding mit Expression Blend

Pixel sind niemals rund. Wenn man es genau nimmt sind die realen Pixel quadratisch. Es gibt eine Reihe von Fällen indem die Umrechnung der virtuellen Pixel in die physikalisch vorhandenen erhebliche Probleme aufwirft. Man kann keinen halben Pixel füllen. Windows versucht alles erdenkliche solche Effekte zu minimieren. Dazu kommt das mit dem High DPI Displays zumindest dieses Problem, für das ungeübte Auge nicht zu erkennen ist. Die Funktion nennt sich Layoutounding. Damit wird ein mathematisch halb zu füllendes Pixel ganz gefüllt.

In XAML bestimmt das Container Element wie die Inhalte gerendert werden. Silverlight macht dies automatisch, in WPF ist diese Funktion deaktiviert. Folgendes WPF Beispiel zeigt di Problematik in Expression Blend für Visual Studio 2013.

   1:  <Canvas x:Name="LayoutRoot" Background="White"  UseLayoutRounding="True">
   2:  <Ellipse Fill="#FFF4F4F5" HorizontalAlignment="Left" Height="10" 
   3:  Stroke="Black" VerticalAlignment="Top" Width="10" 
StrokeThickness="0.2" Canvas.Left="245" Canvas.Top="174"/>
   4:  <Ellipse Fill="#FF1717F1" HorizontalAlignment="Left" Height="8" 
   5:  StrokeThickness="0.2" VerticalAlignment="Top" Width="8" 
Canvas.Left="246" Canvas.Top="175"/>
   6:  </Canvas>

Es gibt einen Aussenkreis mit nur 1 Pixel Abstand, der mit einer 0,2px Linie umrandet ist. Nimmt man Silverlight als Projektype sieht das Ergebnis im Visuellen Designer wie erwartet aus. Hier im Bild auf 6000% gezoomt.

layoutrounding2

Alles wie es sein soll. Wenn man den gleichen XAML Code in ein WPF Projekt kopiert und das Attribut UseLayoutRounding  nicht oder auf false gesetzt hat sieht das Ergebnis wie folgt aus

layoutrounding1

Dies mag auf den ersten Blick ein sehr konstruiertes Beispiel sein, soll aber verdeutlichen, das auch bei WPF Pixelgenaues Layout besonderer Aufmerksamkeit bedarf.

Themen wie diese, können Sie auf der GUI&DESIGN Konferenz mit den Experten diskutieren.

Training, Schulung, JavaScript, HTML, CSS, Dot Net, Asp Net

Month List