Auf den Spuren von .NET

Dienstag, 26. April 2011 19:42

Die vom .NET-Stammtisch Konstanz-Kreuzlingen (DE / CH) veranstaltete .NET Community Konferenz mit dem Namen See# Party geht in die zweite Runde. 

Die Rückmeldungen und Stimmen aus der ganzen .NET Community von Deutschland und der Schweiz von der ersten Veranstaltung im letzten Jahr waren so positiv, das die Usergroup gestützt durch einen Schweizer-Verein (Usergroup), eine zweite Konferenz geplant hat, die dieses Jahr am 20. August stattfindet.

- Rückblick in Form von Bildern und Blogpost-Feedback zur See# Party 2010 um einen Eindruck zu bekommen

Für ganz frühe Frühbucher gehts hier lang!

Die Agenda mitsamt ihren Sprechern und Themen sollte für jeden von euch etwas beinhalten. (Der Inhalt kann sich noch ändern, dies ist eine Kopie. (Hier gehts zum Original).
Ich habe die aus meiner Sicht herausstechenden Themen hervorgehoben.

Zeit	Track 1 Web	Track 2 Mobile	Track 3 Desktop	Track 4 Cloud
08:30	Einlass
09:00	Begrüßung: (Jürgen Gutsch, Tilo Schinke, Golo Roden)
09:15	Keynote: Eine Branche im Wandel? (Laurin Stoll)
10:00	Pause
10:15	Sponsor Session ASP.NET MVC 3 (Microsoft Schweiz)	Phone 7 - Did they save us from our phones? (David Tielke)	XAML Deep Dive (Mathias Raacke)	Cloud, On-Premise & Co – was für wen? (Golo Roden)
11:15	Pause
11:45	SharePoint (Thorsten Hans)	Sponsor Session Caché (InterSystems)	WCF 4.0 - Die Neuerungen (David Tielke)	Die Microsoft Cloud - wolkig mit Sonnenschein (Robert Eichenseer)
12:45	Mittagspause
13:45	Agil 2.0 - Das Agile Developement Framework (Golo Roden)	The Pragmatic Entrepreneur (Laurin Stoll)	Accessibility - Digitale Barrieren und wen wir damit aussperren (Jürgen Gutsch)	SOS: Optimizing the Wire (Hannes Preishuber)
14:45	Pause
15:15	User Interface Patterns in Silverlight (Roland Weigelt)	WP7 Jumpstart - von 0 auf App! (Karsten Samaschke)	Sponsor Session PostSharp (SharpCrafters)	Wer bin ich? - Von Active Directory zu einer Windows Azure Application (Robert Eichenseer)
16:15	Pause
16:45	ASP.NET Dynamic Data (Mathias Raacke)	Windows Phone 7 - Developer Tools & Toolkits (Patrick Getzmann)	Workflow Foundation 4 - Getting Started (Boas Enkler)	Sponsor Session List&Label (combit GmbH)
17:45	Pause
18:00	Große Verlosung und Abschlussveranstaltung (Jürgen Gutsch, Tilo Schinke, Golo Roden)

Weitere, nähere Infos gibt es unter dem Blogpost von Jürgen Gutsch zur See# Party 2011 oder auf der offiziellen Seite.

Wir sehen uns dort, zur vorzeitigen Anmeldung mit Frühbucherrabatt gehts hier lang.

Tags: Community, Events, See# Party, Stammtisch

Dienstag, 11. Januar 2011 09:37

Golo Roden und meine Wenigkeit haben sich seit langem wieder eine Auszeit aus der stressigen Realität gegönnt.

Dabei kam die Idee auf, eine schon etwas ältere Idee neu anzupacken, zu verfeinern, sodass etwas richtig gutes, brauchbares hinten rauskommt.
Der Name bleibt gleich wie er schon bei der älteren Idee war "XmlRepository". Nur hat sich basierend auf der älteren Idee und deren Eigenheiten "schlank, einfach, praktisch" etwas viel praktischeres und brauchbareres gegeben, als es der frühere Prototyp war.

XmlRepository - das es auf http://www.xmlrepository.ch/ zum Download gibt, ist wie folgt auf der Seite selber kurz umschrieben:

Folgend ein bisschen Beispielcode, damit jeder sich ein ungefähres Bild der Anwendung machen kann:

        XmlRepository.DefaultQueryProperty = "Id";
        XmlRepository.DataProvider = new XmlFileProvider("~/App_Data/");

        using(var repository = XmlRepository.GetInstance<Foo>) {
            var foos = repository.LoadAllBy(f => f.Id > 42);
            repository.SaveOnSubmit(new Foo { Id = 27, ... });
            repository.DeleteOnSubmit(f => f.Id == 23);
        }

XmlRepository ist aus unserer Sicht entwickelt und sehr geeignet für:

• Schnell Prototypen mit simplen Datenstrukturen entwerfen
• Einfache und schnelle Einbindung einer Datenquelle für Datenstrukturen von einfacher bis mittlerer Komplexität
• Sehr für Projekte (Web / Client) geeignet, die nicht einen sehr grossen Datenbestand, sowie wenig Schreibende Zugriffe zu verzeichnen hat
  
• Sehr effiziente, typsichere und bequeme Alternative für manuelle XML-Anbindung

Auch wenn bei dir, werter Leser, kein Anwendungfall zutreffen mag, kann man von jedem Code lernen. Ob es jetzt sei, wie man etwas nicht macht - oder wie man es auch noch - oder besser - machen könnte.

Tags:

Sonntag, 5. Dezember 2010 14:47

LightCore gibt es schon seit längerer Zeit, andere DI-Container noch länger.
In dieser Blogpostreihe geht es aber nicht primär um LightCore, auch nicht um die anderen DI-Container.

Ich möchte mit diesem Blogpost versuchen zu erkären, wie denn die ganze Geschichte funktioniert.

Vom Ursprung bis zu einer implementierten Komponente.

Das Feedback zur LightCore-Webseite und LightCore selber hat auf alle Richtungen ausgeschlagen.

Von: Wow, cool. Brauche ich!, zu: Was ist das denn?, bis zu: Braucht man sowas?, über: Sowas braucht man nicht!, bis zu: Mache ich von Hand oder in 10 Zeilen!.

An dieser Stelle sei gesagt: Ich würde die Fragen nach dem "brauchen" in jedem Fall mit "Ja" beantworten, je nach Kontext wo denn etwas eingesetzt werden soll.

Die Grundprobleme:

1. Abhängigkeit zu konkreten Typen
2. Redundanz bei der Konstruktion von Typen jeglicher Art
3. Keine einfache Möglichkeit der Austauschbarkeit von Typen
4. Keine einfache Möglichkeit der Erweiterbarkeit über Typen

Wieso überhaupt "Abhängigkeit lösen"?

Um die Probleme 2, 3 bis 4 zu lösen. Das heisst, die möglichen Redundanzen - also bspw. doppelten Instanziierungen von Klassen - zu vermeiden. Durch das Lösen der Abhänigigkeit von einem konkreten zu einem abstrakten Typen können die Typen ausgetauscht werden und eine Erweiterung ist mit weniger Aufwand möglich.

Die Abhängigkeit wird nicht "verbannt", sondern gelöst. Lösen heisst in diesem Fall, dass die Abhängigkeit nicht mehr auf _einen_  _konkreten_ Typen besteht, sondern auf _eine_ Abstraktion, die _mehrere_ unterschiedliche Implementationen beinhalten kann.

Anstelle dass nur "World" genutzt werden kann, kann dann mithilfe der Abstraktion "WorldBase", "SecondWorld", "IrgendwasWorld", etc... benutzt werden.

Diese Grundprobleme können auf verschiedene Arten gelöst werden. Vorerst die einfachsten Möglichkeiten.

Eine einfache Abhängigkeit zu konkreten Typen kann folgendermassen aussehen:

World world = new World();
world.SayHello();

 

In diesem Beispiel ist die Methode "SayHello" von der konkreten Klasse "World" abhängig.

Wollen wir diese Abhängigkeit lockern / lösen, brauchen wir eine Abstraktion irgend einer Art.
Das kann ein Interface sein, eine Abstrakte Klasse oder auch eine einfache konkrete Oberklasse.

Am Beispiel einer abstrakten Klasse:

WorldBase world = new World();
world.SayHello();

 

Ja, das war erst der erste Schritt. Das Problem besteht immer noch, es liegt in "new World();". Wir referenzieren den Konstruktur der konkreten Klasse.
Die einfachste Lösung hierfür ist eine Fabrikmethode (Factory Method), womit die Konstruktion der Instanz ausgelagert wird.

Dies könnte so aussehen:

public static WorldBase ConstructMyWorld()
{
                return new World();
}

WorldBase world = ConstructMyWorld();
world.SayHello();

 

So ist das Problem auf einfachste Art gelöst.

Zusammenfassung:
Das Problem war die Abhängigkeit auf die konkrete Klasse "World".
Wenn wir anstelle von der Klasse "World", "SecondWorld" benutzen wollen, brauchen wir das jetzt nur noch an der Stelle "return new World" zu ändern, in "return new SecondWorld();"

Wie häufig wir die Fabrikmethode "ConstructMyWorld" benutzen, bleibt uns überlassen.
Die Stelle bleibt, ein Ort der Änderung.

Das wird möglich indem wir eine Abstraktion benutzen, in unserem Falle "WorldBase".
Die konkreten Klassen "World", "SecondWorld" müssen von aussen gleich aussehen (Implementieren die gleiche Abstraktion), können allerdings anders implementiert sein.

Die Angabe des Typs "WorldBase" braucht bei der Zuweisung am Ort des Benutzens angegeben werden, sowie auch als Rückgabetyp der Fabrikmethode.

Das war die einfachste Möglichkeit der Umkehrung per Fabrikmethode.

Die Frage bleibt evt. noch: Wieso Umkehrung?

Am Anfang hatte die Zuweisung am Ort des Benutzens die Kontrolle über den konkreten Typen, sie gab also an, was sie möchte.

Jetzt liegt die Kontrolle _in_ der Fabrikmethode. Der Ort des Benutzens weiss nur, das da ein Typ zurückkommt, der aussieht wie "WorldBase", nicht mehr und nicht weniger.

Am Schluss noch der vollständige (vermutlich nicht sofort lauffähige = Pseudo) Code:

public class ConsoleApplication
{
                public static void Main()
                {
                                WorldBase world = ConstructMyWorld();
                                world.SayHello();
                }

                public static WorldBase ConstructMyWorld()
                {
                                return new World();
                }
}

public abstract class WorldBase
{
                public abstract void SayHello();
}

public class World : WorldBase
{
                public void SayHello()
                {
                               Console.WriteLine("Hello World");
                }
}

public class SecondWorld : WorldBase
{
                public void SayHello()
                {
                               Console.WriteLine("Hello SecondWorld");
                }
}

Tags:

Donnerstag, 19. August 2010 17:07

Jürgen Gutsch und ich haben bekanntlich ja den grenzübergreifenden (CH / DE) .NET Stammtisch Konstanz-Kreuzlingen gegründet.
Ich bin leider nicht mehr dort lokalisiert aber natürlich immer noch sehr daran interessiert, das es gut läuft.

Das neue Team rund um Jürgen Gutsch und Tilo Schinke hat eine riesen Arbeit geleistet und stellte in kurzer Zeit eine Konferenz in Kreuzlingen (CH) auf die Beine.
Dabei sind sehr viele bekannte Sprecher, wie beispielsweise Stefan Lieser, Albert Weinert, Ken Cascada uvm, die sehr interessante Vorträge halten werden.

Offizielle Ankündigung:

Es würde mich freuen, euch dort zu sehen! :-)

Tags: Ankündigungen, Community, dotnetkk.de, See# Party, ssp2010