.
Anmeldung | Registrieren | Hilfe

.NET-Blogs Archiv Mai 2014

Schon gewusst? Visual Studio 2013 IDE Features für C++ Entwickler

27.05.2014 18:30:33 | Christian Binder

Nach einigen interessanten Meetings mit C++ Teams möchte ich hier einige VS2013 IDE Features ansprechen, die das Leben als C++ Entwickler einfacher machen können und oft nicht bekannt sind.

Starten möchte ich mit Native Multi-Targeting, welches es schon seit VS 2010 gibt und erlaubt, mit der aktuellen IDE auch ältere Platform Toolsets zu verwenden. So kann man z.B. mit VS2013 ein Projekt mit dem VS 2010 Toolset bauen. In diesem Post gibt es mehr Informationen. Ergänzen möchte ich noch, dass man im Platform Toolset Setting des Projektes die gewünschten Toolsets V90, V100, V120 usw. nur findet, wenn VS 2008, VS 2010 und VS 2013 side-by-side installiert sind.

Nun zu einigen hilfreichen IDE Features.

NavigateTo – Shortcut CTRL + ,

Ein absolut einfacher Weg, Files und Symbols zu finden. Hier suche ich nach “Faceb” und bekomme die Klassen und Files, die Bestandteil der Facebook Implementierung sind, aufgelistet. Eine Suche nach “book face” würde das gleiche Ergebnis bringen. Also auch wenn ich das exakte Symbol oder den exakten Filenamen nicht mehr kenne - einfach mal testen.

image

Switch Header to Cpp – Shortcut CTRL +K+O

ist eine schnelle Möglichkeit zwischen Header und Cpp zu wechseln. In diesem Fall war ich im Facebook.cpp, dadurch wird der Header in dem blauen “Temporären Tab” angezeigt. Möchte ich den Header persistieren, kann ich das via “Keep Open” im “Temporären Tab” und er wandert auf die linke Seite. Der “Temporäre Tab” ist auch beim Debuggen außerordentlich hilfreich, da so am Ende der Session nicht gefühlte 100 Tabs offen sind und man selektiv die Tabs persistieren kann.

image

Quick Launch – Shortcut CTRL + Q

Wo konnte ich nochmal die Farben in VS umstellen oder wie kann ich die Scrollbar anpassen?  Quick Launch hilft die Optionen schnell zu finden. Einfach “Theme” eingeben und ich finde die Einstellung, die es mir erlaubt zwischen Blau, Dunkel oder Hell zu wählen.

image

Scrollbar / Map Mode

Dem Einen oder Anderen ist vielleicht die neue Scrollbar in den Screenshots aufgefallen. Einfach mal im Quick Launch “Scrollbar” eingeben und die Optionen anschauen. Es gibt nun für die neue Scrollbar einen  Map mode, der auch ein Source Preview ermöglicht.

image 

Die  Scrollbar zeigt nun das ganze Dokument und den Bereich, in dem ich mich gerade befinde, hell hinterlegt. Die Idee dahinter ist, dass Entwickler typischerweise eine Art Karte des Codes im Kopf haben, also quasi ungefähr wissen, wo sich was befindet. Die Scrollbar im Map mode soll unter anderem eine schnelle Navigation in großen Files noch einfacher machen.

image

Bewege ich mich nun auf der Scrollbar in einem Bereich, der gerade nicht im Editor angezeigt wird, erhalte ich eine Preview des Codes. Die Größe des Preview ist konfigurierbar.

image

Zudem zeigt die Scrollbar Fehler, Breakpoints, Bookmarks und Ergebnisse der Suche an.

image

Durch das Auskommentieren des Facebook Headers habe ich einiges kaputt gemacht Smile. Alle Stellen mit Fehlern werden rot markiert und die Änderungen gelb. Vor allem beim Refactoring ist diese Ansicht sehr hilfreich.

image

GoToDefinition Shortcut - F12 ist bekannt. Peak Definition Shortcut  - ALT + F12 vielleicht aber noch nicht.

Mit Peak Definition kann man die Definition inline im aktuellen Editor öffnen. Dabei handelt es sich um ein voll funktionales Editorfenster, welches auch weitere Peak Definitions, quasi als Stack anzeigen kann.

image

Organize Code – Shortcut - ALT + Arrow Up or Arrow Down

Codezeile oder Block markieren und mit ALT und den Pfeiltasten verschieben. In folgendem Screenshot habe ich die Usings umstrukturiert. Nicht das wichtigste Feature, aber vielleicht doch in der einen oder anderen Situation nützlich.

image

Format Code – Shortcut CTRL + K + F 

In gewachsenen Projekten sieht die Formatierung des Codes meist sehr unterschiedlich aus. In VS stehen jetzt eine Reihe von Formatierungen zur Verfügung, die automatisch beim Schreiben oder mit dem Shortcut auf bestehenden Code angewendet werden. Was genau wie formatiert wird, legt man in den Optionen fest:

image

Hier ein Beispiel von Code – nicht schön:

image

Code markieren und CTRL + K + F   - Besser

image

Tipp: Einstellungen im Team festlegen – Exportieren und Importieren.

Rename Refactoring – Shortcut F2

Wer an C++ und Refactoring denkt, dem fällt wohl Visual Assist ein, eines der besten Refactoring Tools für C++. Dennoch werden Basis Refactorings auch direkt in Visual Studio verfügbar sein. Ein Beispiel ist das Rename Refactoring, welches via C++ Rename Refactoring zur Verfügung steht.

image

C++ Unit Testing

C++ Unit Tests sind direkt in C++ verfügbar und können transparent mit dem TestExplorer oder Build ausgeführt werden. Mehr Informationen zum C++ Unit Testing gibt es unter C++ Unit testing.

image

Zum Abschluss möchte ich noch Funktionen zur Codevisualisierung vorstellen.

Include Dependencies

Include Abhängigkeiten können via Architecture > Generate Dependency Graph >For Include file visualisiert werden. Diese DGML basierenden Graphen können exportiert und im Team zur Diskussion und Analyse genutzt werden.

image

Code Map Debugging – Shortcut CRTL + Shift + ö

Code Maps sind eine graphische Repräsentation der Code Artefakte und haben das Ziel, die Komplexität der Abhängigkeiten zu visualisieren. Code Maps selbst können statisch erzeugt werden. Viel Interessanter ist aber die Möglichkeit, eine Code Map über den Callstack z.B. beim Debuggen zu erstellen. Im Debugging wird dazu Show Call Stack on Code Map aktiviert:

image

Während des Debugging wird eine Code Map aufgebaut. Der Pfeil auf der Map zeigt an, in welchem Code wir uns gerade befinden. Die Code Map gibt zum einen eine gute Übersicht, welche Codebereiche während des Debugging ausgeführt wurden und zum anderen kann die Map mit Kommentaren versehen später mit dem Team besprochen werden.

image

Viel Spass
Chris

NDepend im Einsatz

26.05.2014 21:55:11 | Hendrik Loesch

Seit einigen Wochen nutze ich NDepend als logische Erweiterung zum Resharper und Style Cop. Während der Resharper dafür sorgt, dass sich alle Entwickler an die gleichen Regeln halten. Kann ich mit NDepend zum einen prüfen ob sich auch wirklich an die Regeln gehalten wird, vor allem aber ob die Ideen hinter den Regeln auch korrekt […]

LINQ und Reflection, das Traumpaar im.NET Framework

24.05.2014 17:03:00 | Klaus Bock

LINQ und Reflection

… oder; nie war das Laden und Instanziieren von Typen zur Laufzeit einfacher.

Wer kennt nicht die Thematik, bestimmte Typen anhand vorgegebener Kriterien zur Laufzeit zu Laden? Z.B.: einzelne Filter in einem Filtersatz vereinen, oder verschiedene Regeln eines Parser zur jeweiligen Analyse zu laden. Diese Liste könnte man noch beliebig weiter fortsetzen.
Das Ziel ist immer das Gleiche: Verschiedene Objekte mit definierten Gemeinsamkeiten zu einem bestimmten Zeitpunkt zu Laden und Instanziieren, wobei die Gemeinsamkeiten und der Ladezeitpunkt variabel bleiben sollen, da die Parameter für die Auswahl der benötigten Objekte erst zur Laufzeit bekannt sind.

Seit der Version 2.0 des .NET-Frameworks lässt sich das Instanziieren von einzelnen Objekten zur Laufzeit sehr einfach mittels der Klasse Activator bewerkstelligen. Das Auffinden der zu ladenden Typen in Schleifen oder in einer LINQ-Abfrage ist auch keine Raketenwissenschaft. Warum also nicht beides, LINQ und Activator, in einer Klasse zusammenführen und generisch gestalten?

Das logische Ergebnis währe eine Klasse Activator<T>. Als Typparameter müsste die Klasse Strukturen, Klassen und Schnittstellen akzeptieren. Weitere Filter, wie etwa die Assembly aus der geladen werden soll, oder der Namensraum auf den die Auswahl begrenzt wird, sind ebenfalls denkbar. Erstellt werden die zu ladenden Instanzen mittels einer Methode CreateInstances, die ein IEnumerable<T> zurückgibt. Die Verwendung so einer Klasse könnte etwa so aussehen:

var results = (new Activator<IFooBar>()
               {
                   ReferenceAssembly = typeof(FooBar).Assembly,
                   NamespaceName = "Me.Foo.Bar"
               })
               .CreateInstances();

Befinden sich die zu ladenden Typen in der selben Assembly wie der als Typparameter angegebenen Typ, muss die Eigenschaft ReferenceAssembly nicht angegeben werden. Sollen alle in der Assembly verwendeten Namensräume durchsucht werden, muss auch der Eigenschaft NamespaceName kein Wert zugewiesen werden. Die Verwendung währe dann einfach:

var results = (new Activator<IFooBar>()).CreateInstances();

Da auch unbedingt Schnittstellen als Typparameter verarbeitet werden sollen, muss zunächst geprüft werden ob es sich bei dem angegebenen Typparameter um eine Schnittstelle handelt. Wenn ja, muss die Erkenntnis in einer Weiche genutzt werden, da sich die Vorgehensweise beim Auswählen eines Typs auf Basis einer implementierten Schnittstelle von einem einfachen Typvergleich stark unterscheidet.  
Im Konstruktor wird zunächst geprüft ob der angegebene Typparameter eine Schnittstelle ist. Wenn ja, wird der voll qualifizierte Name der Schnittstelle im privaten Feld interfaceName, sowie das Ergebnis der Überprüfung im privaten Feld isInterface gespeichert.

private readonly string interfaceName;
private readonly bool isInterface;
private Assembly internalReferenceAssembly;
public Activator()
{
    if (typeof(T).IsInterface)
    {
        this.interfaceName = typeof(T).FullName;
        this.isInterface = true;
     }
     this.internalReferenceAssembly = typeof(T).Assembly;
}

Je nach Status, Schnittstelle oder nicht, wird bei einer Abfrage in den entsprechenden Ausdruck verzweigt. Ist der angegebene Typparameter eine Schnittstelle, wird in der from-Klausel mit der Methode GetInterface geprüft, ob der gerade verarbeitete Typ die angegebene Schnittstelle implementiert. Gibt die Methode eine Objekt zurück, also keine null-Referenz, wird ein Cast des aktuell verarbeiteten Typs in den Typ des Typparameter durchgeführt und selektiert.
Ist der Typparameter keine Schnittstelle, wird ein einfacher Typvergleich durchgeführt und entsprechend selektiert.

private IEnumerable<T> InternalCreateInstances()
{
    return this.isInterface
            ? from type in this.internalReferenceAssembly.GetTypes()
              where type.GetInterface(this.interfaceName) != null
              select (T)Activator.CreateInstance(type)
            : from type in this.internalReferenceAssembly.GetTypes()
              where type == typeof(T)
              select (T)Activator.CreateInstance(type);
}

Die Typumwandlung in den Typ des Typparameters wird immer durchgeführt, um beim Aufruf der Methode CreateInstances einen Enumerator vom Typ des Typparameters zu erhalten, da die Methode CreateInstance der Activator-Klasse immer eine Instanz vom Type Object zurückgibt.

Falls die Erstellung der gewünschten Typen auf einen bestimmten Namensraum begrenzt werden soll. wird lediglich eine Überladung obiger Methode mit der Angabe des Namensraums als Zeichenfolge benötigt. In dieser Methode wird die where-Klausel um die Verarbeitung des Namensraums erweitert.

private IEnumerable<T> InternalCreateInstances(string namespaceName)
{
    return this.isInterface
            ? from type in this.internalReferenceAssembly.GetTypes()
              where type.FullName.StartsWith(namespaceName, StringComparison.InvariantCulture)
                  && type.GetInterface(this.interfaceName) != null
              select (T)Activator.CreateInstance(type)
            : from type in this.internalReferenceAssembly.GetTypes()
              where type.FullName.StartsWith(namespaceName, StringComparison.InvariantCulture)
                   && type == typeof(T)
              select (T)Activator.CreateInstance(type);
}

In der öffentlichen Methode CreateInstances der Klasse, wird geprüft ob der Eigenschaft NamespaceName ein Wert zugewiesen wurde und entsprechend verzweigt.

public IEnumerable<T> CreateInstances()
{
    return !string.IsNullOrEmpty(this.internalNamespaceName)
            ? this.InternalCreateInstances(this.internalNamespaceName)
            : this.InternalCreateInstances();
}

Soviel zum internen Ablauf.
Aber was ist bisher passiert, wenn die Methode CreateInstances innerhalb einer Ladeklasse aufgerufen wird? Eigentlich noch Garnichts. Bisher wird nur ein typisierter Enumerator erstellt, der seine Auswahl anhand der Gegebenheiten trifft. Erst wenn der Enumerator verwendet wird, wird die Enumeration durchlaufen und die Typinstanzen werden erstellt.

var query = (new Activator<IFooBar>()).CreateInstances();
// Hier weiterer Code ...
// Erst jetzt werden die IFooBar-Instanzen erstellt
Dictionary<string, IFoobar> instances = query.ToDictionary(k => k.Name);

Im vorangegangenen Beispiel wird erst der Enumerator erstellt. Dann kann noch beliebiger weiterer Code folgen. Erst wenn die generische Dictionary erstellt wird, werden die IFooBar-Instanzen erzeugt.

Fazit:

Der oben vorgestellte Ansatz ist mit Sicherheit nicht der Weisheit letzter Schluss. Statt Überladungen der privaten Methode InternalCreateInstances, könnte man eine Methode verwenden die eine Ausdrucksbaumstruktur (Expression Tree) entsprechen der Bedingungen erzeugt.
Für meine aktuellen Anforderungen ist der vorgestellte Ansatz vollkommen ausreichend. Mir ging es in erster Linie darum, redundanten Code zu vermeiden und die eigentliche Erzeugung der verschiedenen Typinstanzen in die jeweilige Ladeklasse zu verlegen.

Technorati-Tags: | | |

Raspberry Pi Tweety

18.05.2014 15:05:00 | Martin Hey

Der Raspberry Pi rockt. Damit kann man ziemlich coole Sachen machen. Allerdings ist es besonders für Entwickler, die bisher eher auf der .NET-Plattform unterwegs sind eine kleine Überwindung - ist es doch nur eine Platine und es läuft kein Windows drauf.

Mit ein bisschen Einarbeitung alles kein Problem. Ich möchte kurz zeigen, dass man mit den richtigen Werkzeugen ziemlich nah an der gewohnten Umgebung und damit dann alles ganz einfach ist. Mein Raspberry soll seine aktuelle CPU-Temperatur per Tweet versenden - ok, zugegeben etwas nerdig ist das schon, aber was solls.

Inbetriebnahme
Im Grunde braucht es erst einmal nur einen Raspberry, eine SD-Karte und ein Netzwerkkabel. Das Installationspaket findet man auf der Raspberry-Website. Ich hab mich für Raspbian entschieden. Für die Installation des Betriebssystem-Images hat sich der Win32DiskImager bewährt. Im Anschluss daran einfach die SD-Karte in den Raspberry reinstecken und das Strom- und das Netzwerkkabel anschließen - schon bootet er. 

Die restliche Konfiguration findet auf dem Gerät selber statt. Dazu findet man zunächst die IP-Adresse heraus, die der Router dem neuen Familienmitglied gegeben hat und verbindet sich dann mittels Putty. Mit den Credentials pi/raspberry kann man sich dann verbinden.

Als allererstes sollte man sich hier der Konfiguration und Installation benötigter Komponenten widmen. Folgende Commands empfehlen sich daher:
sudo raspi-config
sudo apt-get update
sudo apt-get upgrade
Mit Hilfe des erstem Commands vergrößert man die Partition auf die Größe der SD-Karte und gibt seinem Nutzer ein neues Kennwort. Mit den anderen beiden Commands aktualisiert man die Pakete auf das aktuelle Patchlevel.

Vorbereitung für die Ausführung von .NET-Programmen
Debian ist Linux, und mit Hilfe von Mono können wir hier .NET Programme laufen lassen. Das hat den großen Vorteil, dass die Entwicklung ganz gut im Visual Studio stattfinden kann und die Assembly dann mit Hilfe der Mono-Runtime auf dem Pi ausgeführt wird. Die meisten Stichpunkte sind schon gefallen... wir brauchen ein paar Pakete:
 
sudo apt-get install mono-runtime
sudo apt-get install libmono-system-core4.0-cil
Damit wird die Mono-Runtime und System.Core und damit die LINQ-Unterstützung installiert.

Teil 1: Erstellen einer .NET Konsolen-Anwendung
Ja genau, das ist alles! Wir erstellen eine .NET Konsolenanwendung im Visual Studio. 
using System;

namespace UniqueSoftware.Raspberry.StatusTweeter
{
    class Program
    {
        static void Main(string[] args)
        {
            new Worker().Run();
        }
    }


    public class Worker
    {
        public void Run()
        {
            Console.WriteLine("Hello World");
            
        }

    }
}
Diese Anwendung können wir jetzt Kompilieren und auf unseren Pi kopieren. Wichtig dabei sind die exe-Datei und die config-Datei. Als Tool zum Kopieren verwende ich WinSCP.

Unser Programm kann jetzt schon im Putty ausgeführt werden. Dafür einfach
mono ./UniqueSoftware.StatusTweeter.exe
eingeben. Ganz klar steht nach Mono der Pfad zur hochgeladenen Assembly - also den ggf. anpassen.

Teil 2: Auslesen der Temperatur
Die CPU-Temperatur kann mit Hilfe des Commands
vcgencmd measure_temp
oder auch
cat sys/class/thermal/thermalzone*/temp
ausgelesen werden. Die zweite Lösung hat den Charme, dass hier einfach eine unformatierte Zahl geliefert wird, womit das Wegschneiden der Maßeinheit wegfällt, allerdings sind es Tausendstel-Grad-Celsius.

Was macht dieses Command? Es öffnet alle Dateien die den Namen temp haben und in den Ordnern thermal/thermalzone* liegen, wobei * ein Platzhalter ist. Um das Auflösen des Platzhalters kümmert sich die Shell. Aus diesem Grund können wir das so nicht verwenden - aber ist auch kein Problem - wir können ja mit Hilfe des .NET Frameworks alle Unterordner in thermal ermitteln und dann das gleiche tun.
public IList<float> DetermineCpuTemperatures()
{
    var folder = new DirectoryInfo("/sys/class/thermal/");
    var subFolders = folder.GetDirectories("thermal_zone*");
    var fileResults = subFolders.Select(subFolder => Path.Combine(subFolder.FullName, "temp"))
        .Select(File.ReadAllText)
        .ToList();

    var result = new List<float>();
    foreach (var fileResult in fileResults)
    {
        int temperature;
        if (!int.TryParse(fileResult, out temperature))
        {
            continue;
        }

        var temperatureInDegree = ((float)temperature) / 1000;
        result.Add(temperatureInDegree);
    }

    return result;
}

Teil 3: Tweet versenden
Zunächst wird eine Twitter-App benötigt, weil ein API-Key und ein Secret benötigt wird. Dazu meldet man ich im Twitter Developer Portal mit seinem Twitter-Account an und legt eine neue App an. Wichtig ist, dass man der App Lese- und Schreibberechtigungen gibt. Auf der API-Key Seite dort sind 4 Keys relevant: API-Key und -Secret sowie der Access-Token mit dem zugehörigen Secret.

Mit Hilfe von NuGet wird nun TweetSharp hinzugefügt. Es fehlen nun in unserem Programm noch 2 Funktionen - eine die den Text des Tweets erzeugt und eine die den Tweet absetzt.
public string BuildTweet(IList<float> temperatures)
{
    if (temperatures.Count == 1)
    {
        return string.Format("Hier ist der Pi und meine CPU-Temperatur ist {0:f2} °C.",
            temperatures[0]);
    }

    return string.Format("Hier ist der Pi und meine CPU-Temperaturen sind {0}.",
        temperatures.Select(x => string.Format("{0:f2} °C", x)));
}

public void SendTweet(string message)
{
    const string API_KEY = "ri8VPJluqJTFiOKqNg5lTZ0AA";
    const string API_SECRET = "EQrg5XeatwSzmMlnB296ukSPJUlWNwLXsaPDhVPjaRuoBG5px1";
    const string ACCESS_TOKEN = "2312268955-Y2wOLzCy2Iw5ctK20N4SqdSHK9Zs6VvlInZUmEm";
    const string ACCESS_TOKEN_SECRET = "2LTmy2JRkGmFqLxggthASmvwpi7SKxwiJoq772BaHY7TL";

    var twitterApp = new TwitterService(API_KEY, API_SECRET);
    twitterApp.AuthenticateWith(ACCESS_TOKEN, ACCESS_TOKEN_SECRET);

    var tweet = new SendTweetOptions();
    tweet.Status = message;

    var result = twitterApp.SendTweet(tweet);
    if (twitterApp.Response.InnerException != null)
    {
        throw twitterApp.Response.InnerException;
    }
}
Die Hauptmethode des Programms ändert sich damit dann wie folgt:
public void Run()
{
    try
    {
        var temperatures = DetermineCpuTemperatures();
        var tweetText = BuildTweet(temperatures);
        SendTweet(tweetText);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex);
    }
}
Das war's auch schon fast. Im Windows läuft das Programm schon. Im Mono läuft es im Standard erst einmal nicht, weil noch keine vertrauenswürdigen Zertifikate vorhanden sind. Das ändert man, indem man auf dem Pi  die Zertifikate von Mozilla importiert.
sudo mozroots --import --ask-remove
Sollte das nicht ausreichend sein, so kann man das komplette Mono Development Paket installieren und im Anschluss dem Zertifikatsmanager die Twitter-Seite hinzufügen.
sudo apt-get install mono-devel
sudo certmgr -ssl https://api.twitter.com
Ab sofort werden bei jedem Programmstart die CPU-Temperaturen an eure Follower geschickt. 

REST-Services mit SOAPUI testen

18.05.2014 09:05:00 | Martin Hey

Schon in Zeiten von SOAP-Webservices war SOAPUI ein gutes Tool für funktionale Tests der Schnittstelle. Besonders im .NET-Framework, das es dem Entwickler so einfach wie möglich macht, indem Proxies angelegt werden und gleich die große Deserialisierungsmaschinerie anspringt, ist es durchaus an einigen Stellen sinnvoll, überprüfen zu können was genau an Markup über die Leitung geschickt wird und wenn Kommunikation oder Deserialisierung fehlschlagen.

Auch bei rest-basierten Services kann das an vielen Stellen sinnvoll sein. In meinem aktuellen Beispiel verwende ich einen REST-Service eines Drittanbieters von einem Android-Phone aus. Leider ist der Service des Anbieters noch in der Entwicklung und die Schnittstelle ändert sich gelegentlich. In meinem Fall gab es ein Serialisierungsproblem auf Anbieterseite - so wurden Objekte an einem Endpunkt, der eine Liste zurückgeben sollte nicht immer als Objektliste serialisiert, was dann natürlich bei der Deserialisierung zu argen Problemen führt. Dafür habe ich mir mit SOAPUI einen Test geschrieben.

Gehen wir von folgendem Szenario aus: Es gibt einen Endpunkt, der JSON zurückgibt. Laut Schnittstellen-Definition handelt es sich dabei um eine Liste von Personendaten. Leider ist es bei der Implementierung zu einem Fehler gekommen so dass nicht immer eine Liste zurückgegeben wird. Ein entsprechendes fehlerhaftes Beispiel ist in .NET schnell erstellt.
public class SampleController : Controller
{
    public JsonResult GetAll()
    {
        var persons = new PersonRepository().GetAll();
        if (persons.Count == 1)
        {
            return this.Json(persons[0], JsonRequestBehavior.AllowGet);
        }

        return this.Json(persons, JsonRequestBehavior.AllowGet);
    }
}

Nun zum eigentlichen Punkt - der Test. Ein Projekt in SOAPUI ist schnell erstellt.

Basierend auf diesem Request kann nun mit Hilfe des entsprechenden Kontextmenü-Eintrags ein neuer Test erzeugt werden.


Nun müssen nur noch Assertations festgelegt werden. Das kann im entsprechenden Tab erledigt werden.
Meine erste Assertation ist, dass Statuscode 200 zurückkommt.

Basierend auf den Eingabeparametern (die es in meinem Beispiel nicht gibt) könnte man auch auf andere Statuscodes prüfen - z.B. 401 (Unauthorized) oder 409 (Conflict) usw.

Prüfung 2 ist, ob wir eine Liste zurückbekommen, die den Anforderungen entspricht. Das macht man am besten scriptgesteuert. SOAPUI greift dazu auf Groovy-Scripte zurück:

Ein Script könnte so aussehen:
import groovy.json.JsonSlurper 

def response = messageExchange.response.responseContent
def slurper = new JsonSlurper()
def json = slurper.parseText response

List persons = (List) json;
assert !(persons.isEmpty())
persons.each{
	assert it.LastName != null
	assert it.FirstName != null
}
So kann man nun feststellen, ob das Ergebnis stimmt oder eben nicht. Bekomme ich statt der erwarteten Liste nur ein Objekt zurück, schlägt hier der Cast fehl.

Diese Tests kann man nun einzeln oder im Kommandozeilen-Testrunner ausführen und so automatisiert feststellen, ob das Backend tut was es tun soll.

Der WortWecker ist fertig

17.05.2014 10:28:00 | Daniel Springwald

Nachdem das Projekt nun ein paar Monate in der Schublage lag (siehe Teil 2 und Teil 1) ist die Uhr nun endlich einsatzbereit.

Ein erster Funktionstest vor dem endgültigen Zusammenbau:

Die Taster zur Einstellung der Alarmzeit und der Lautsprecher müssen noch angebracht werden:

Noch ein letzter Blick in das Innenleben:

Ein abschließender Test aller LEDs:

Die Uhr an ihrem Bestimmungsort :-)

Wird es dunkel, dimmt das Licht der LEDs (gesteuert durch den verbauten Helligkeitssensor) entsprechend ab:

Dotnet Day Franken 2014 – Fümpf Joa echd woa

12.05.2014 22:33:03 | Hendrik Loesch

Am vergangenen Wochenende war ich das erste Mal beim Dotnet Day Franken in Nürnberg und muss nun sagen, dass ich absolut begeistert bin. Da ich als Sprecher, sowie durch die Saxonia Systems AG als Sponsor, vor und hinter die Kulissen schauen konnte, habe ich natürlich tiefere Einblicke gewonnen als der übliche Teilnehmer und so speist […]

Microsoft Engineering Stories – Scaling Agile across the Enterprise

12.05.2014 16:27:30 | Christian Binder

Unter folgendem Link ist eine neue Videoserie zur Motivation, den Hintergründen oder einfach Geschichten rund um die agile Transformation der Microsoft Developer Division entstanden. Hierbei werden die verschiedensten Aspekte angesprochen, absolut empfehlenswert für Alle, die sich Agilität in grösseren Organisationen nicht vorstellen können. Wer wenig Zeit hat, sollte sich als Shortcut das Takeaways Video am Ende anschauen.

Viel Spass
Chris

DNUG Braunschweig Treffen–Richtig Async!

12.05.2014 13:43:00 | Lars Keller

Die DNUG Braunschweig trifft sich am 20.05.2014 um 19:00 im Restaurant Zucker (Tagungsraum). Dieses Mal kommt uns der Microsoft MVP Klaus Löffelmann mit dem Thema “Richtig, Async!” besuchen.

Async/Await sind Spracherweiterungen, die Microsoft in Visual Basic und CSharp mit Visual Studio 2012 eingeführt hat, um mit Spaghetti-Code und umständlichen Callbacks für asynchrone Methodenaufrufen Schluss zu machen und den Programmfluss wie in der synchronen Programmierung intuitiv gestalten zu können. Leider birgt die Anwendung dieser Techniken auch, in einige böse Fallen zu laufen, die Programme u.U. sehr instabil werden lassen können. Klaus Löffelmann, Visual Basic MVP, zeigt in seinem Talk den Unterschied zwischen Asynchronität und Parallelisierung, erklärt die korrekte Anwendung von Async und Await, und wie sich Fehler und Racing-Conditions bei asynchronen Methodenaufrufen und der Parallelisierung von Programmen vermeiden lassen, und Sie so trittsicher sowohl ältere Win-Forms Anwendungen wie moderne Store-Apps gleichermaßen im „Fast and Fluent“-Stil entwickeln.

Vita
Klaus Löffelmann ist Microsoft MVP, Fachbuchautor rund um das Thema .NET- und Windows-8-Entwicklung und selbstständiger Softwareentwickler in der Microsoft-Welt mit über fünfundzwanzig Jahren Berufserfahrung. Mit seiner Firma ActiveDevelop hat er sich auf das Thema „Migration von Software zu neuen Entwicklungstechniken und Plattformen“ und insbesondere auf die für Firmen risikoarme Vorgehensweise der „Weichen Migration“ spezialisiert. Zu seinen Kunden zählen viele namhafte Firmen des Mittelstandes, Konzerne, Banken und Versicherungen sowie Softwareentwicklungsabteilungen von Kommunen, Behörden und der Länder.

https://twitter.com/loeffelmann
https://www.facebook.com/klaus.loeffelmann

Wie immer ist die Veranstaltung kostenlos!
Weitere Informationen zur DNUG Braunschweig können hier gefunden werden: http://www.dotnet-braunschweig.de

Rückblick auf das MobileCamp 2014 - der Sonntag

12.05.2014 11:05:00 | Martin Hey

Tag 2
Auch der zweiten Tag begann mit einer Keynote und diese war besonders interessant und kurzweilig. Zwei Google Glass zum selber ausprobieren und ein Xiaomi zum ausprobieren der chinesischen Konkurrenz für westliche Mobiltelefonhersteller waren der perfekte Auftakt für den Tag. Und ganz besonders spannend: Den ganzen Tag lang konnten Interessierte die Hardware ausprobieren.

Im Anschluss daran widmete ich mich einer Session betitelt mit "Meetings verbessern" und es war interessant herauszufinden wie andere mit Fokussierungsproblemen in Meetings umgehen, denn wer kennt sie nicht ergebnislose Meetings oder Marathonmeetings.

Und nun: ein Mittagessen zugeschnitten auf Entwickler: Pizza und Mate. Der schiefe Turm von Pizza(schachteln) hat es übrigens nach dem Foto nicht mehr lange ausgehalten.

Nach dem Mittag wieder ganz spannend für mich das Thema Open Source Compliance. Wie verhindere ich Copyleft-Effekte im Business Umfeld, welche Lizenzen sind verwendbar, wenn man Business-Anwendungen schreibt, die nicht OpenSource sein dürfen. Es gab viele Tipps, wie man gut durch den Lizenzdschungel kommt und mit vielen praktischen Tipps aus dem juritischen Alltag.

Die letzte themenbezogene Session war für mich Crowdfunding für mobile Apps und hat für mich etwas Licht ins Dickicht gebracht. Dachte ich bisher immer an Crowdinvesting und was es dabei alles zu beachten gibt, so bietet Crowdfunding eine ganz andere Perspektive. Und ganz wichtig dabei auch das Herangehen an so einen Funding-Prozess aus Unternehmenssicht. Es war gut, dass so viele dabei waren, die direkt aus der Praxis mitreden konnten, weil sie den Prozess bei Unternehmen schon begleitet haben und wussten was genau relevante Punkte sind.

Für alle, die sich etwas näher mit einem der Themen an denen ich teilgenommen hab oder auch an anderen beschäftigen wollen: unter http://lanyrd.com/cxdcb findet sich ein Großteil der Präsentationen und Unterlagen, die Grundlage für die Sessions waren.

Zu vielen Zeitpunkten wäre ich gern in mehreren Sessions parallel gewesen, einfach weil es so interessante Themen gab.

Ich kann diese Konferenz einfach nur jedem empfehlen, der auch nur im entferntesten etwas mit Mobile zu tun hat.

Noch einmal vielen Dank und im nächsten Jahr bin ich gern wieder mit dabei.

Rückblick auf das MobileCamp 2014 - der Samstag

12.05.2014 09:05:00 | Martin Hey

Ein spannendes Wochenende geht vorbei und nach einiger Abstinenz vom Bloggen möchte ich genau das zum Anlass für einen Blogpost nehmen. Auch wenn im Vorfeld viele Teilnehmer unterschiedliche Angaben dazu gemacht haben - ja, es ist inzwischen schon das 6. MobileCamp, wie man dann unschwer am Tshirt erkennen konnte. Und mit einem Besucherrekord von knapp 300 Teilnehmern von denen überraschenderweise noch immer die Mehrzahl direkt aus Dresden und Ostsachsen kam, konnten Maßstäbe gesetzt werden. 

Thematisch richtet sich dieses Barcamp sowohl an Entwickler als auch an Designer, Grafiker, Rechtsexperten, Projektmanager, Vertriebler - eben alle, die sich mit der Thematik Mobile auseinandersetzen. Trotzdem war der Anteil an Nicht-Entwicklern relativ gering.

Für mich war es das dritte Mal, dass ich beim MobileCamp dabei war und was soll ich sagen: es hat sich gelohnt. An dieser Stelle vielen Dank an die Veranstalter und die anderen Sponsoren die die Veranstaltung, die das Barcamp erst möglich machen. Und wer sich wegen der Formulierung fragt: Ja,dieses Jahr waren wir mit unter den Sponsoren.

Nun aber zum spannenden Teil....

Tag 1
Der Tag beginnt mit einer großen Vorstellungsrunde (wer bin ich, was mache ich und warum bin ich hier), was bei der Anzahl der Teilnehmer schon mal eine ganze Weile in Anspruch nimmt. Im Anschluss daran - wie bei jedem Barcamp - Sessionfindung und Raumplanung. Ganz interessant - dieses Jahr gab es sowohl am ersten als auch am zweiten Tag eine Keynote, was eigentlich barcampunüblich ist. 

Die Keynote am ersten Tag drehte sich rund um das Thema Firefox OS. Und viele Aspekte waren doch sehr bekannt von anderen Plattformen, denn alles ist eine App. Sehr beruhigend ist, dass die Mozilla-Entwicklergemeinde wohl aus den Fehlern anderer Hersteller gelernt haben und an "Features" wie Markieren und Copy&Paste schon in der ersten Version denken.

In der zweiten Session des Tages drehte es sich für mich rund um das Thema Gamification und es war für mich sehr spannend einen Einblick in die wissenschaftlichen Hintergründe zu bekommen und das auf einem gut verständlichen und High-Level Weg. 

Nach der Mittagspause in der es (typisch ostdeutsch) Soljanka aus der Gulaschkanone gab

Im Anschluss daran stand ich das erste Mal vor der Qual der Wahl: Unity und Game Erstellung oder App Marketing. Als jemand mit BWL-Herz, landete ich in der App-Marketing Session die anhand eines aktuellen Beispiels und damit natürlich auch mit etwas Eigenmarketing der Session-Ownerin sehr interessante Aspekte aufzeigte.

Im Anschluss daran schaffte es Torsten mit einer Session zum Thema Psychologie die Hälfte der Teilnehmer in seinen Bann zu ziehen. Da ich vom  letzten den Developer Open Space aber schon einen Eindruck gewinnen konnte was er da erzählen wird, zog es mich eher zu einer Session die sich thematisch mit rechtlichen Neuerungen im eCommerce beschäftigt. Auch wenn ich aktuell noch keinen Onlineshop betreue und es mich deswegen nur am Rande betrifft, war es doch sehr spannend, zu diskutieren, was da ab Mitte Juni ansteht und wie Shopbetreiber damit umgehen müssen.

Die vorletzte Session des Tages war für mich zwar interessant, aber ohne direkte Anwendungsmöglichkeit: Haitech - wie steuere ich die Fernbedienung eines Spielzeugs fern, um schlechtes UX des Spieleherstellers zu umgehen. Es war spannend, was man mit ein paar Transistoren und Widerständen und ein klein wenig Programmierung erreichen kann, aber ich habe gemerkt dass ich bisher doch zu selten einen Lötkolben in der Hand hatte als dass ich das direkt machen würde. Glücklicherweise sind genug Ingenieure in meinem Bekanntenkreis.

17 Uhr - die letzte Session des Tages beginnt. Für mich Gamification Teil 2 - dieses mal ein Deep Dive in die wissenschaftlichen Ansätze - sehr sehr spannend, jedoch in Anbetracht der Uhrzeit hatte ich doch gelegentlich Schwierigkeiten, dem Ganzen mit "hier ist noch eine Grafik, die zeigt folgendes" und "ich hab hier eine Tabelle in der wird dargestellt, dass ... " zu folgen.

Den krönenden Abschluss des Tages gab es wie jedes Jahr im Citybeach Dresden und auch wie jedes Jahr bei Regen - Traditionen soll man beibehalten.

Second try using the Entity Framework

09.05.2014 04:56:00 | Jürgen Gutsch

Ist schon witzig, da muss man mit dem Chef zusammen einen Workshop zum Thema ASP.NET MVC und Entity Framework halten um zu sehen, dass sich das Entity Framework seit der Version 4 um einiges gebessert hat.

BTW: Das war Arbeitsteilung, ich habe ASP.NET MVC geschult und Laurin auf eine sehr mitreißende Art das Entity Framework. Erheiternd für alle Beteiligten war, dass sich dabei meine Meinung zum EF dabei leicht verbesset hatte. ;)

Als ich das EF zuletzt (mit der Version 4) verwendet hatte, war NHibernate der OR-Mapper meiner Wahl und das EF kam bei weitem nicht an den Komfort und die Performance heran. In allen Fällen, in denen ich das EF damals eingesetzt hatte, gab es immer an Stellen Probleme, die aus meiner Sicht absolut nebensächlich waren. Fast immer war es direkt oder indirekt das Change-Tracking des EF das für mich absolut nicht wichtig war. Entweder war es die Performance die an der Stelle Probleme machte oder aber das störende attachen und detachen von Objekten. Das Change-Tracking kann man ausschalten. Richtig…. sollte man aber nicht, wenn man nicht umständlich prüfen will, ob man ein Update oder ein Insert machen möchte.

Mit EF 6 sind tatsächlich einige Dinge hinzugekommen, die einem das Leben mit dem Tool leichter machen und die alten Krankheiten wenigstens etwas erträglicher. Zum Beispiel finde ich das Mapping über die DataAnnotations eine gelungene Sache. Umständliche Mapping-Konfigurationen fallen somit weg. Die DataAnnotations sind nicht kritisch, im .NET Verfügbar und keine EF Abhängigkeit. Ich kann sie also getrost in meinen Projekten nutzen.

Mit etwas gemischten Gefühlen sehe ich, dass EF einfach so funktioniert… Ja genau…  Selbst dann, wenn es keine Konfiguration und keinen ConnectionString gibt, außer den DbContext. Gut ist dass es einfach geht. schlecht ist, dass es irgendwas macht und ohne Konfiguration nicht ersichtlich ist, was genau das passiert. Wo wird die Datenbank hingelegt? Welche SQL Server Instanz wird genutzt?

Das attachen und detachten – mein Hauptkritikpunkt – ist einfacher geworden. Man muss nicht mehr explizit attachen, allerdings muss man explizit den Status setzen und dem EF sagen, was mit dem Entity passieren soll:

public void Add(T entity)
{
    using (var ctx = _contextFactory.CreatDbContext())
    {
        ctx.Entry(entity).State = EntityState.Added;
        ctx.SaveChanges();
    }
}

public void Update(T entity)
{
    using (var ctx = _contextFactory.CreatDbContext())
    {
        ctx.Entry(entity).State = EntityState.Modified;
        ctx.SaveChanges();
    }
}

public void Delete(T entity)
{
    using (var ctx = _contextFactory.CreatDbContext())
    {
        ctx.Entry(entity).State = EntityState.Deleted;
        ctx.SaveChanges();
    }
}

Ein Upsert (Insert or Update) ist so nur mit ein paar Zeilen mehr machbar.

Wenn man es nicht anders kennt, ist das ok, immerhin sind das hier einfache und kleine Methoden. Im Vergleich zum NHibernate ist das aber ein erhöhter aufwand. Ich möchte mich eigentlich nicht darum kümmern, wie sich das EF intern verhält. Eigentlich gehe ich davon aus, dass ein OR-Mapper weiß, was mit dem Objekt passieren soll. An dieser Stelle bleibt meine Kritik am EF bestehen. Allerdings – und das muss man hervorheben – ist das wie im Code oben gezeigt, einfacher geworden und es funktioniert nun scheinbar auch tatsächlich richtig.

Ein weiterer Punkt der verbessert worden ist, ist die Testbarkeit. Aber sehr gute Testbarkeit ist noch ein Stück weg. Schließlich möchte ich nicht das EF testen, das hat Microsoft sicher bereits getan, sondern ich möchte meinen Code ohne EF testen können. Da der DbContext keine abstrakte Klasse ist, wird es schwierig (je nach Mocking-Tool) das DbSet richtig zu simulieren. Aus dem Grund ist es nötig, dass der DbContext nochmal gewrappt wird, dass für den Wrapper ein Interface zur Verfügung steht. Erst dann kann der Code richtig vom EF abgekapselt werden:

var data = Builder<Season>.CreateListOfSize(50).Build().AsQueryable();

var set = new Mock<DbSet<Season>>();
set.As<IQueryable<Season>>().Setup(m => m.Provider).Returns(data.Provider);
set.As<IQueryable<Season>>().Setup(m => m.Expression).Returns(data.Expression);
set.As<IQueryable<Season>>().Setup(m => m.ElementType).Returns(data.ElementType);
set.As<IQueryable<Season>>().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());

var context = new Mock<IDbContextWrapper>();
context.As<IDbContext>().Setup(x => x.Set<Season>()).Returns(() => set.Object);
       
var contextFactory = new Mock<IDbContextFactory>();
contextFactory.Setup(x => x.CreatDbContext()).Returns(context.Object);
var repo = new GenericRepository<Season>(contextFactory.Object);

Fazit

In einem aktuellen Projekt, ist das EF das erste mal eingesetzt, ohne dass ich auf große Probleme gestoßen bin. Das ist doch ein gutes Zeichen. Es ist auch sehr gutes Beispiel dafür, dass es eine gute Entscheidung von Microsoft war, das EF als Open Source öffentlichen zu machen und öffentliche Contributions zu ermöglichen. Wenn die Community rund um ein Open Source Projekt groß genug ist, kann das Projekt nur besser werden und Probleme aus der Praxis werden schneller behoben.

Open Source Rocks :)

Jetzt muss nur das lästige Change-Tracking zu einer internen Magic werden, um die ich mich nicht kümmern muss und der DbContext sollte besser simulierbar sein. Das wichtigste: Das ganze Designer- und Klicki-Bunti-Zeugs sollte noch entfernt werden, damit keiner auf die blöde Idee kommt das zu nutzen…

Aber im Großen und Ganzen ist das EF inzwischen benutzbar und ein richtig gutes Werkzeug geworden, vorausgesetzt man nutzt Code-First.

BTW: Ich sehe gerade Laurins Gesicht vor mir, wie er sich freut, dass er mich dazu gebracht hat das EF ein bisschen toll zu finden. ;)

Ich bin Microsoft MVP des Monats

09.05.2014 03:05:00 | Lars Keller

I am featured as MVP Spotlight! Yeah! – Darüber habe ich mir sehr gefreut!

Das gesamte Interview könnt Ihr hier nachlesen: http://mvp.microsoft.com/de-de/spotlight/Lars%20Keller-20140425002333

Das coole ist, dass das Interview in 11 Sprachen übersetzt wurde. Nun benötige ich nur mal einen chinesischen Browser. ;-)

Konferenzen: dotnet Cologne 2014 & .NET Day Franken

09.05.2014 02:42:00 | Lars Keller

Ich freue mich sehr bei den beiden Community Konferenzen dotnet cologne und .NET Day Franken mit einem Vortrag dabei zu sein.

Zusammen mit Peter Nowak werde ich über das Thema Beyond Mobile Device Management sprechen. Wir zeigen auf, was nach einer MDM Einführung passieren sollte. Apps entwickeln ist nur eine Sache davon.

see you there!

Offener Brief von Microsoft und fast 150 anderen Firmen: Netzneutralität muss erhalten bleiben

08.05.2014 20:43:28 | Mathias Gronau

Angeblich hat der Vorsitzende der Federal Communications Commission (FCC), Tom Wheeler, Pläne, die bevorzugte Behandlung von Teilen des Internet-Traffics zu ermöglichen. Dagegen wenden sich in einem offenen Brief die meisten der großen US-Technikfirmen. Dazu gehören neben Microsoft auch die Branchengrößen Amazon, eBay, Facebook, Twitter und Yahoo. In dem Schreiben fordern sie Wheeler auf, an der Netzneutralität festzuhalten. Die vollständige Liste der Unternehmen finden Sie hier als PDF-Datei. In dem Schreiben fordern sie, an einem freien und offenen Internet festzuhalten, sowie an Regeln, durch die Nutzer und Anbieter geschützt werden. Die entscheidenden Zeilen übersetzt ZDNET in einem Artikel wie folgt: “Medienberichten zufolge will die Kommission Regeln vorschlagen, die es Telefon- und Kabelnetzanbietern erlauben würden, Internetfirmen technisch und finanziell unterschiedlich zu behandeln und neue Gebühren von ihnen zu verlangen”, schreiben die Unterzeichner in dem am Mittwoch veröffentlichten Brief. “Sollten diese Berichte der Wahrheit entsprechen, dann ist das eine große Bedrohung für das Internet … Statt eine individuelle Bevorzugung zu erlauben, sollten die Regeln der FCC die Nutzer und Internetfirmen vor Blockaden, Benachteiligung und einer Bevorzugung gegen Bezahlung schützen, und den Markt für Internetdienste transparenter machen”, heißt es weiter in dem Brief. “Solche Regeln sind entscheidend für die Zukunft des Internets.” Auf den ersten Blick klingt das ja wirklich gut. Allerdings bin ich mir derzeit nicht wirklich sicher, was ich davon halten soll. Schließlich wird das Internet für so viele unterschiedliche Aufgaben genutzt, dass eine gnadenlose Gleichmacherei zu schwer absehbaren Konsequenzen führen kann. Sie stutzen und glauben mir nicht? Lassen Sie mich zur Verdeutlichung einige Beispiele bringen, ich beginne mit dem Worst Case. Ich habe schon mehrfach von Plänen gelesen, schwierige und seltene Operationen von Robotern vornehmen zu lassen, die von Spezialisten gesteuert werden, die sich irgendwo auf der Welt befinden. Die Übertragung der Signale soll über das Internet erfolgen. Jetzt stellen Sie sich einmal vor, die Signale kommen während der Operation teilweise verzögert an, und sei es nur eine zehntel Sekunde. Möchten Sie dann der Patient mit dem offenen Herzen sein? Ich nicht. Das war jetzt zu weit hergeholt und eh’ Zukunftsmusik? Na gut, nehmen wir ein anderes Beispiel, nicht so drastisch und extrem, dafür aus der Gegenwart. Immer mehr Menschen empfangen ihre Fernsehprogramme über das Internet. Jetzt stellen Sie sich einmal vor, Sie wollen am Sonntagabend Ihren geliebten Tatort sehen (die Sendung und den Sendezeitpunkt dürfen Sie gerne austauschen), und immer wieder sehen Sie nur Klötzchengrafik oder die Sendung stockt sogar ganz. Auch wenn diese Effekte nur kurzzeitig auftreten, sind sie doch sehr störend. Würden Sie sich in dieser Situation nicht auch wünschen, dass der Anbieter etwas Geld dafür zahlen würde, dass seine Daten etwas schneller übertragen werden? Der Preis dafür? Eine von Ihnen aufgerufene Webseite wird eventuell eine zehntel Sekunde später aufgebaut. Das merken Sie doch nun wirklich nicht. Und wenn eine Mail etwas später kommt, geht die Welt dadurch auch nicht unter. Der etliche Megabyte große Download des neuen Servicepacks für Windows geschieht eh’ im Hintergrund, so dass Sie eine Verlangsamung vermutlich nicht merken werden. Irgendwie scheint es mir […]

.NET-Stammtisch mit neuer Website

07.05.2014 12:30:00 | Jürgen Gutsch

Eigentlich ist das nichts neues, den seit einiger Zeit ist der .NET-Stammtisch mit einer neuen Website online, die vom Umfang her etwas geschrumpft ist.

Was aber nun endlich funktioniert ist der Terminkalender, der auch im Archiv die neuesten Einträge am Anfang zeigt und – GANZ WICHTIG – den aktuellen Termin am Tag des Termins nicht ins Archiv verschiebt, sondern erst, wenn der Termin vorbei ist. Wahnsinn… ;)

Nicht wirklich…

Aber so wie es sich für eine .NET-Community Website gehört, wird nun auch hier die neueste ASP.NET MVC Version eingesetzt und die Website selber wird auf Microsoft Azure gehostet. Neu ist die Möglichkeit, sich in den Verteiler einzutragen um sich an Termine erinnern zu lassen oder über neue Termine benachrichtigen zu lassen.

Vielen Dank geht hier an Microsoft, die uns (im Rahmen des Technical Community Supports) vor ein paar Jahren ein gewisses freies monatliches Kontingent zur Verfügung gestellt hat.

Sowohl die Website, als auch das Azure Konto ist immer auch die Spielwiese für den .NET-Stammtisch, um Dinge zu testen oder vorzuführen. So wird die Website immer wieder für Demos (sei es Web API, MVC, LESS, oder auch Git) herangezogen.

So bleibt die Website immer in Bearbeitung und entwickelt sich stetig weiter :)

http://www.dotnetkk.de/

dotnet Cologne 2014

05.05.2014 15:34:00 | Jürgen Gutsch

Am Freitag ist es soweit. Die dotnet Cologne 2014 findet am 9. Mai statt und ich habe es auch mal wieder geschafft dabei zu sein. Diesmal allerdings nicht nur als Teilnehmer, sondern darf als Sprecher in einem Show-Case Vortrag ein Projekt vorstellen, das wir mit aktueller Technologie und aktuellen Techniken und Microsoft Azure für ein weltweit bekanntes Unternehmen in der Schweiz umsetzen durften.

Ich werde vorstellen wie sich ein relativ umfangreiches Mobile Game mit Windows Azure implementieren lässt und werde aus dem Nähkästchen plaudern auf welche Probleme wir wir gestoßen sind und welche Überraschungen wir mit Microsoft Azure erlebt hatten.

Am meisten freut es mich aber, die vielen bekannten Gesichter der .NET Community wieder zu sehen und viele weitere .NET-Begeisterte Gesichter kennenzulernen oder auch endlich mal persönlich zu treffen.

Animatronischer Minion - erster Test mit Zufallsbewegungen

01.05.2014 00:24:00 | Daniel Springwald

Wer möchte nicht ein lebenden Minion haben? Geht leider nicht - aber vielleicht bringt ja auch ein mechanischer Minion ausreichend Freude :-)

Zuerst muss ein Spielzeug-Minion her:

Das Spielzeug öffnen und die manuellen Mechanik entfernen (durch Druck auf das G-Symbol öffnet schloss der Minion vorher Auge und Mund):

Die beiden Augenlieder werden mit Hilfe von Servos steuerbar gemacht:

Zwei Servos für die Arme:

Und alles zusammen setzen:

Für die Steuerung der Servos wird noch etwas Elektronik benötigt:

Das Innenleben des Minions wird verkabelt:

Erste Tests mit (noch) unkontrollierten Zufallsbewegungen:

Regeln | Impressum