Wenn ich nun aber die Möglichkeit hätte bei verlassen der Methode einen call zu bekommen,

Da bietet sich in diesem Zusammenhang TearDown an.

Siehe auch Is there a simple “virtual file” class for .NET (c# if source is available)?.
Dort wird auch noch auf ein kommerzielles Produkt hingewiesen, dass stabiler arbeiten zu scheint.

Hallo rollerfreak2,

suchst du evtl. etwas in Richtung aspektorientierter Programmierung (AOP)?
Dann wäre PostSharp etwas für dich.

Dieses Online Ebook hatte ich auch erstmals in Betracht gezogen gehabt, aber ich dachte eher dass dies nur eine zusammenfassende Lektüre für C# wäre in der nur erklärt wird was möglich ist.

Ja - aber es entspricht genau der Printversion (die du ja offensichtlich hast).

Und wenn du mit dem Buch nicht zurecht kommst, ist deine Entscheidung ja quasi schon gefallen, oder? 😉

Später kannst du es ja immer noch lesen.

Hallo CloudAc,

herzlich willkommen hier auf myCSharp.de!

Ich habe im moment Einstieg in Visual C Sharp 2010 von dem Galileo Verlag und ViscualC#2008 in 21Tagen.

Auch wenn Buchpräferenzen häufig sehr subjektiv sind, würde ich dir doch eher zu ersterem Buch raten:
Zum einen ist es aktueller (C# 4.0 vs. C# 3.5), was zwar nicht per se besser ist, aber IMHO durchaus ein Anhaltspunkt sein kann.
Zum anderen sind bei mir Bücher mit Titeln wie "... in 21 Tagen" schon mal gleich unten durch 😉

Aber lies doch einfach ein wenig online (vollkommen legal!) in Visual C# 2010 rein und schaue, wie du damit zurecht kommst.
Für C#-Anfänger ist das Buch IMHO ganz gut geeignet; für Einsteiger in die Programmierung ist es m.E. fast ein wenig zu ausführlich bzw. gewichtet nicht genügend.

Siehe auch generell [FAQ] Wie finde ich den Einstieg in C#?

sehe ich, dass die Zeile fetchSettings(id) darüber grau hinterlegt ist, also offenbar gerade ausgeführt wird. Allerdings ist sie wie gesagt nicht im aktuellen StackTrace enthalten.

Dann schaue einmal in die anderen Threads, wenn das auftritt (Doppelklick auf den entsprechenden Thread im Fenster "Threads").

Damit bist du eigentlich schon fast fertig.

(Da mich das Thema auch interessiert:) Ist der Windows-Server also standardmäßig schon "sicher" konfiguriert?
Also sprich: Ist es leichtsinnig, eine "cleane" Server-Installation einfach so am Netz hängen zu lassen?

Hallo Toxo,

du kannst die Expressions, die du den Query-Methoden übergibst, auch dynamisch zusammenbauen. (siehe Experession Klasse).
Ansonsten kannst du dir auch die ExecuteStoreQuery<T> Methode anschauen.

Ich würde aber mal Ausschau halten, ob nicht jemand so etwas schon gebaut hat - so exotisch ist die Anforderung, benutzerdefinierte Ansichten zu erzeugen, ja auch nicht.

Leider ist die Anlage des TaIndex nicht ausreichend, zeitweise wird das DataTemplate direkt angesprungen

Da kannst du mit der Focusable-Property arbeiten (einfach mal mit entsprechenden Tools den logischen Baum unter die Lupe nehmen und schauen, wo du sie anpassen musst).

Beim Öffnen eines PopUps springt der Focus nicht automatisch in die erste TextBox

Da würde ich ein Behavior dafür schreiben.

Siehe z.B.:
WPF: Oberfläche mit ContentPresenter wechseln?
MVVM und Navigation
MVVM - Navigation

Aber ich möchte kein TabControl haben, sondern eigentlich ein simples "Panel". Gibt es eine Alternative zu der TabControl-Lösung?

Klar - du kannst allgemein ein ItemsControl mit beliebigen ItemsTemplate und ItemsPanel verwenden.

dass es im framework evtl. doch eine möglichkeit gibt, das ende eines tages gesondert zu interpretieren.

Genau die gibt es ja (23:59:59:...)!

Deine Frage ist viel mehr: "Gibt es im Framework die Möglichkeiten, auch ungültige DateTimes zu erstellen?"
Und die Antwort dazu lautet: Nein, gibt es nicht.

Siehe auch Wikipedia: Frequenz - diese ist definiert als 1/T (wobei T die Periodendauer ist) 😉

@CoLo: Der Code hat einen kleinen Schönheitsfehler:
Verwende besser double als Typ, damit du auch nicht-ganzzahlige Frequenzen darstellen kannst.

Zudem müsste es IMHO eher "1000.0 / value" im Setter heißen 🙂

Wenn die IDisposable-Ressource der geschachtelten inneren using-Anweisung die Ressource der äußeren using-Anweisung enthält, gibt die Dispose-Methode der geschachtelten Ressource die enthaltene Ressource frei.

Vielleicht ein etwas verständlicheres Beispiel:

Statt:

using (var stream = File.Open("Foo.txt"))
using (var reader = new StreamReader(stream))
{
   //Zugriff auf Reader
} //hier wird stream zweimal dispost: Einmal von reader.Dispose() und einmal explizit

Besser:

using (var reader = new StreamReader(File.Open("Foo.txt")))
{
   //Zugriff auf Reader
} //hier wird stream nur einmal dispost (aufgrund von reader.Dispose)

Hintergrund ist, dass häufig nicht definiert ist, wie sich Objekte bei mehrfachen Aufrufen von Dispose verhalten.

IMHO hätte man besser spezifizieren sollen, dass man Dispose problemlos mehrfach für die selbe Resource aufrufen darf. Das hat man aber nicht und so muss man damit leben 😉

Ist die Schriftart auch tatsächlich auf dem System installiert?

Darum ja eben die Frage, ob das COmmand den Presenter verwenden soll, oder das Model direkt!

Meiens Erachtens eher das Modell, sonst müsstest du ja lauter Methoden im Presenter hinzufügen, die nur die Model-Methoden aufrufen:

//Presenter:
public void AddItem()
{
   model.Items.Add(new Item());
}

//Command:
public void Execute()
{
   presenter.AddItem();
}

(Oder was meinst du mit: "Da kann man den Code des Commands IMHO auch gleich in den Presenter packen.") --> kannst du das kurz demonstrieren?

Statt des Codes oben kann man das Command dann IMHO auch gleich weglassen:

//Presenter:
//Wird vom View aufgerufen
public void AddItem()
{
   model.Items.Add(new Item());
}

Sonst müsste jeders Control immer Presenter.Methode() aufrufen.

Wie gesagt: Da reicht ein Delegate und eine Methodensignatur in deinem CommandManager:

void Bind(Action action, Button button);
//Aufruf:
CommandManager.Bind(() => presenter.AddItem(), myButton);

Evtl. wäre aber fast schon ein Interface für einen Filter geeigneter als ein Delegat.

in meinem Code steht ca soetwas:

Ja - ich würde eher schreiben:

CommandManager.Bind(myPresenter.InsertCommand, insertToolStripMenuItem);
CommandManager.Bind(myPresenter.InsertCommand, btnInsert);
//bzw. ohne Command (Insert ist eine Methode)
CommandManager.Bind(myPresenter.Insert, insertToolStripMenuItem);

Letztlich ist ein Command bei dir - so wie ich das sehe - eh auf einen Presenter festgelegt.
Insofern sehe ich keinen Sinn, Command und Presenter nochmal auseinanderzureißen.
Das führt letztlich lediglich dazu, dass dein Presenter deutlich mehr Funktionalität öffentlich zugänglich machen muss, um vom Command verwendet werden zu können.

Da kann man den Code des Commands IMHO auch gleich in den Presenter packen.

BTW: Pass' bei deinem CommandManager auf, dass du dir kein Memory-Leak einfängst (falls er statisch ist).

Der TreeView erlaubt es jedenfalls, ein nicht-sichtbares Item zu selektieren, und reagiert entsprechend darauf

...aber mit einer (verspäteten) Exception sagtest du, oder hab' ich das jetzt falsch verstanden?
Ansonsten kann man das evtl. auch irgendwie per Behaviour lösen, dass automatisch aufklappt.

Ich dachte bei "nested" eher an ein Java angelehntes Prinzip, nämlich das die Ordnerstruktur den Namespace wiederspiegelt

Ja - innerhalb des Projektes ist es üblich, dass man Codedateien auch auf Unterordner verteilt (und sich dabei an den Namespaces orientiert).

Im Gegensatz zu Java hat man in VS-Projektdateien aber die Projekteigenschaft "Default Namespace", der standardmäßig als Präfix für alle Namespaces im Projekt verwendet wird.
Für diesen erstellt man dann im Normalfall keine Unterordner (d.h. nicht wie bei Java-Projekten, dass man den Code z.B. erst unter "...\de\mycsharp\myapplication&quot; findet).

Das Problem dabei ist nämlich, daß das ViewModel nicht weiß, ob ein Knoten aufgeklappt ist oder nicht.

Dann muss es das wissen - es mahct ja auch keinen Sinn, einen Knoten zu selektieren, den der Nutzer gar nicht sehen kann 😉

Siehe hierzu Gelöst: TreeViewItem expanden (da hat es auch ohne das BasedOn funktioniert).

Meiner persönlichen Meinung nach bevorzugst du dann aber eher die "nested" Methode, oder nicht?

Ich hatte die nested Methode so verstanden, dass man da quasi Solutions erstellt, die dann Projekte enthalten, welche evtl. mehrere Ebenen tiefer im Dateisystem liegen.
Und das gefällt mir überhaupt nicht.

Aber gewissermaßen hast du recht: Ich neste die flate Variante 😉

Dann werden allerdings die Styles aus dem Theme nicht mehr angewendet.

Sollte eigentlich nicht passieren.

wenn du also ein framework aufsetzen würdest, dann hättest du auch pro logischer gruppierung wie zb. system, ui usw. eine eigene solution in einem verzeichnis und darunter dann die projekte?

Das kommt auch mit darauf an, um wie viele Projekte es sich handelt: Viel mehr als 20 in einer Solution macht IMHO keinen Sinn (also 10 Projekte + jeweils ein Testprojekt).

Wenn die Teile des Frameworks unabhängig sind bzw. Teile optional sind, würde ich das auch durch Aufteilung in verschiedene Unterordner klarmachen.

Für da UI-Framework würde ich also eine eigene Solution in einem eigenen Ordner anlegen, dann aber unter diesem Ordner nur noch jeweils ein Ordner für jedes Projekt anlegen - und nicht nochmal tiefer schachteln, z.B. (die Aufteilung auf die Projekte sei mal dahingestellt):

X:\MyFramework\UI\UI.sln
X:\MyFramework\UI\Controls.Basics\Controls.Basics.csproj
X:\MyFramework\UI\Controls.Text\Controls.Text.csproj
X:\MyFramework\UI\Controls.DateTime\Controls.DateTime.csproj

Wenn das Framework noch komplexer wäre (und der UI-Teil z.B. auch aus Animationen besteht, wobei sich der Bereich Animationen auch wieder aus mehreren Assemblies zusammensetzt), spricht IMHO auch nichts gegen einen weitere Unterordner unterhalb von "UI" (aber dann wieder mit eigener Solution) - UI.sln sollte es dann nicht mehr geben.

Um es einmal in Best Practices zu formulieren, die ich verwende:*Nicht zu viele Projekte pro Solution (aber auch nicht zu wenige): So zwischen 2 und 8 sind IMHO im Schnitt ganz ok *Ein Projekt ist immer nur Teil einer Solution (spezielle Solutions für Autobuilds, andere Konfigurationen etc. mal ausgenommen) *Jede Solution hat ihren eigenen Ordner *Jedes Projekt hat seinen eigenn Ordner *In einem Ordner befindet sich nur eine Solutiondatei *Für jedes Projekt in einer Solutiondatei existiert ein Unterordner unmittelbar unter dem Ordner, in dem die Solutiondatei liegt *Unterhalb eines Ordners, in dem sich eine Solutiondatei befindet, liegt keine weitere Solutiondatei *Alle Projekte builden in ein gemeinsames Verzeichnis (abhängig von der Konfiguration "bin" oder "debug"), das sich neben dem Verzeichnis befindet, in dem der Quellcode liegt *Assemblies werden dabei anhand ihres Pfades benannt (z.B. MyFramework.UI.Controls.DateTime.dll für "x:\MyFramework\UI\Controls.DateTime\Controls.DateTime.csproj")

Was also IMHO z.B. zu vermeiden ist (vorletzter Punkt nicht beachtet):

X:\MyFramework\UI\UI.sln
X:\MyFramework\UI\Controls\Basics\Basics.csproj
X:\MyFramework\UI\Controls\Text\Text.csproj
X:\MyFramework\UI\Controls\DateTime\DateTime.csproj

Hallo MrSparkle,

verwende besser den ItemContainerStyle (und lasse die Angabe von BasedOn weg):

<TreeView ...>
    <TreeView.ItemContainerStyle>
        <Style TargetType="{x:Type TreeViewItem}">
            <Setter Property="IsSelected" Value="{Binding Path=IsSelected, Mode=TwoWay}" />
        </Style>
    </TreeView.ItemContainerStyle>
</TreeView>

eine Property als DependencyProperty zu definieren macht genau dann nur Sinn, wenn ich weiß, dass von meiner Klasse geerbt werden könnte - und eine Änderung an den Werten der Propertys dann in den Subklassen behandelt werden muss?

Nein, dafür ruft man im Setter einer herkömmlichen Property einfach eine virtuelle Methode auf, die dann überschreieben werden kann bzw. feuert ein Event.

Die MSDN fasst IMHO ganz gut zusammen, wofür man eine Dependency Property braucht:

Represents a property that can be set through methods such as, styling, data binding, animation, and inheritance.

Eine Dependency Property bietet also Unterstützung für Animationen und Styles - somit hat sie u.U. mehrere Werte "gleichzeitig":
Ohne DependencyProperty könntest du Styles nicht dynamisch ändern, Animationen nicht beenden, usw.

Generell gilt aber:
Dependency Properties nur zu DependencyObjects hinzufügen - und nur von DependencyObject erben, wenn die Klasse später Teil des visuellen oder logischen Baums der WPF sein soll (also im Prinzip nur bei Controls).

Hallo ingemar,

ich mache es, wie in dem verlinkten Thread als "Flat" bezeichnet; teilweise jedoch auch eine leichte Mischung aus beiden Varianten:

In ein Laufwerk "X:" (Partition oder gemappt mit subst) wird für jedes (eigenständige) Projekt ein Ordner angelegt.
Wenn es sich um ein Projekt mit mehreren, nicht direkt voneinander abhängigen Teilen handelt (z.B. Client + Server, usw.) und diese jeweils ihre eigene Solutiondatei (*.sln) haben, lege ich einen weiteren Unterordner an, sodass immer alle Projekte in einer Solution auch in einem Ordner liegen.

Darin befinden sich dann die .csproj-Projektdateien und die Quellcodedateien (diese evtl. nochmals in Unterordnern, welche die Namespacestruktur abbilden).

Gebuildet wird dann alles nach "X:\Build[Projektname]", um möglichst doppelte Builds zu Vermeiden.

Beispielsweise sieht das ganze dann so aus (*.sln + *.csproj-Dateien):

X:\MyApplication\Common\Common.sln
X:\MyApplication\Common\Helpers\Helpers.csproj

X:\MyApplication\WebServer\Server.sln
X:\MyApplication\WebServer\Server\Server.csproj
X:\MyApplication\WebServer\DataAccess\DataAccess.csproj
X:\MyApplication\WebServer\Validation\Validation.csproj

X:\MyApplication\Client\Client.sln
X:\MyApplication\Client\ViewModels.Persons\ViewModels.Persons.csproj
X:\MyApplication\Client\ViewModels.Orders\ViewModels.Orders.csproj
X:\MyApplication\Client\Views\Views.csproj
X:\MyApplication\Client\Application\Application.csproj

und ergibt dann folgende Ausgabe (je nach Situation alle Dateien mit Prefix "[Firmenname].[Produktname]."):

X:\Build\MyApplication\Common.Helpers.dll
X:\Build\MyApplication\WebServer.Server.dll
X:\Build\MyApplication\WebServer.DataAccess.dll
X:\Build\MyApplication\WebServer.Validation.dll
X:\Build\MyApplication\Client.ViewModels.Persons.dll
X:\Build\MyApplication\Client.ViewModels.Orders.dll
X:\Build\MyApplication\Client.Views.dll
X:\Build\MyApplication\Client.Application.dll

Nun hängt aber mein Hauptprozess, er lädt die erste Datei runter und es gibt auch keine Fortschrittsanzeige mehr (das wohl weil der Hauptprozess hängt).

Das ist auch kein Wunder - siehe die Falle in [FAQ] Warum blockiert mein GUI?

Soweit ich das verstanden hab also doch oder?!

Das es teilweise funktioniert, mag stimmen - aber konzipiert sind embedded Datenbanken quasi nie für "echten" Mehrbenutzerbetrieb.
Wenn so etwas historisch "gewachsen" ist, kann man es noch "entschudligen", aber bei einer Neuimplementierung sollte man IMHO nicht gleich mit angezogener Handbremse losfahren 😉

Siehe auch SQL Server CE in a multi user scenario - is this really, really stupid?.

Sehr herzlichen Dank, sieht mir stark nachdem aus was ich suche.

Ist aber nicht mehrbenutzerfähig.

aber wenn jetzt der erste User drauf geht oder auch bei Usern wo die ConnectionPools schon wieder freigegeben wurden, dann müsste der dann drei ConnectionPools befüllen und nicht einen.

Ich verstehe immer noch nicht genau, wo dein Problem ist.

ADO.NET ist relativ gut optimiert - ich glaube nicht, dass du durch das Deaktivieren einer Optimierungsmaßnahme wirklich signifikanten Performancegewinn erwarten kannst...

Hallo DeadRabbid,

herzlich willkommen hier auf myCSharp.de!

auf ihren Rechner kopieren und damit weiterarbeiten können. Dafür wird bisher Microsoft Access verwendet.

Access taugt generell nicht wirklich für Mehrbenutzersysteme - und das physische Kopieren von Datenbanken, um Offline-Zugriff zu ermöglichen, ist auch keine gute Idee (mitunter, weil dann relativ schnell Änderungen im Offline-Modus verloren gehen, wenn man nicht spezielle und extrem fehleranfällige Synchronisationslogik implementiert und zudem sehr leicht Inkonsistenzen entstehen können).

Wahlweise nehme ich auch Vorschläge in der Form entgegen die es sehr einfach machen einen SQL Server auf einem Netzwerk einzurichten und diese Datenbank dann auch Offline zu verwenden.

Das ist die bessere Variante:
Schaue dir mal SQL Server-Replikation an - das sollte das sein, was du suchst.
Alternativ bietet sich zur Not auch das Microsoft Sync Framework an (das ist dann aber IMHO mit mehr Aufwand in der Implementierung verbunden).

Wie sollte ich das mit dem Interface für, zum Beispiel, die Kinect machen?

Ich finde, da klingt dein Ansatz:

Oder ich mache für jedes Eingabegerät ein Interface, welches die Aufgaben implementieren können, also IKinectSteuerbar, IMouseSteuerbar usw.

am besten: Deine Aufgabe implementiert es und die entsprechenden Methoden (beispielsweise MovementDetected usw.) werden dann von dir aufgerufen.

Im einfachsten Fall kannst du den Aufgaben natürlich auch einfach eine Klasse aus dem Kinnect-API übergeben,

Allerdings soll nach zwei Minuten Inaktivität wieder die Startseite angezeigt werden.

Also so eine Art Kioskmodus?
Evtl. findest du etwas bei Google, wenn du nach "Kiosk mode" suchst.

Ansonsten kannst du ein Webbrowser in eine WinForms Anwendung einbetten und das entsprechend realisieren.
Alternativ wird's sicherlich auch mit einem Plugin funktionieren.

Dafür verwendet man doch ViewModels oder bin ich damit auf dem Holzweg?

Genau; das ist ein Einsatzgebiet von ViewModels.

Bzw. wo in meinem Projekt (Client oder Webteil) erstelle ich diese ViewModels?

ViewModels gehören in den Client, d.h. in die Silverlight-Anwendung (nicht in den Server!).

Was genau meinst du mit danach werden lokal die ViewModels erzeugt?

Das war die Erklärung, warum Varianten eins und zwei funktionieren 😉
Mit Variante 3 verlangst du quasi (sehr schwammig ausgedrückt), dass das Framework Code erzeugt, um per SQL die ViewModels auf dem Server zu erstellen (wenn der Code aus dem Grund nicht funktioniert, den ich in meiner Antwort annehme - da müsstest du aber schon die Exception posten 😉 ).
Und das klappt natürlich nicht.

Durch das ToArray (bzw. ToList) schließt du jedoch sozusagen den Code ab, der nach SQL umgesetzt werden soll; somit gibt es keine Probleme mehr beim Mapping.

Aber das ist bestimmt nicht der Weisheit letzter Schluß

Definitiv nicht!

Ich kann mich chavez anschließen:
Wirf mal einen Blick auf das Entity Framework oder NHibernate - die sollten beide sowohl MSSQL als auch MySQL unterstützen.

Generell kannst du dir das Fassade bzw. das Strategy-Pattern (in Kombination mit dem Factory-Pattern) anschauen bzw. etwas konkreter das Repository-Pattern in Verbindung mit DI.

Du sagst, das der Presenter die Commands erzeugen sollte? MAcht er diese dann durch Properties öffentlich verfügbar?l

Wie gesagt: So pauschal kann man das nicht sagen, da es zig verschiedene Szenarien gibt, in denen man das Command-Pattern in diesem Zusammenhang einsetzen kann 😉

Commands sind hier hauptsächlich da, um immer wiederkehrende Aktionen zu kapseln. [...] Ich erstelle das COmmand im View und übergebe den Presenter.

Was steht dann in diesem Beispiel konkret in deinem View?

Bitte imer Fehlermeldungen angeben!

Meiner Vermutung nach wäre aber gerade dieser Rückgabe Typ der richtige für neue, selbst erstellte Abfragemethoden wie hier der autom. generierte:
[...]
Oder?!

Jein - in deinem Fall wäre ein Array oder eine Liste der richtige Typ.

Salopp gesagt wird alles, was du auf ein IQueryable<T> anwendest, nach SQL übersetzt und dann vom DB-Server durchgeführt.
Selektierst du gleich die ViewModels, schlägt das allerdings vermutlich fehl, da die ViewModels keine Kontext-Typen sind und die Klasse dem Mapper somit unbekannt ist.

ToArray und ToList erzwingen hingegen die Ausführung des Queries und danach werden lokal die ViewModels erzeugt.

Allerdings ist es m.E. nicht unbedingt optimal, die ViewModels im Repository erzeugen zu lassen; dieses sollte IMHO erstmal nur Entity-Klassen zurückgeben.
Und dann ist IQueryable<> tatsächlich der passende Rückgabetyp, da dann auch z.B. so etwas möglich ist:

public IQueryable<Person> GetActivePersons()
{
   return this._context.Persons.Where(p => p.IsActive);
}

//...
repository.GetActivePersons().Where(p => p.Age > 20);

Generiert sinngemäß folgendes SQL:

SELECT * FROM [Persons] WHERE IsActive AND Age > 20

Würdest du hier statt IQueryable<Person> ein Person[] übergeben (und somit ToArray innerhalb der Methode aufrufen), würde der Server:

SELECT * FROM [Persons] WHERE IsActive

ausführen und die Prüfung auf das Alter hinterher lokal ablaufen.

Damit das klappt, muss das Framework natürlich wissen, wie die ganzen Aufrufe in SQL umgesetzt werden müssen - und beim Selektieren von benutzerdefinierten Typen ist dies nicht der Fall.

So jedenfalls die Kurzform 😉

Command arbeitet auf Model und nicht auf Presenter?

Ich würde es so formulieren: Das Command ist Teil des Presenter bzw. auf einer Ebene mit diesem.

Ob es Zugriff auf den Presenter hat, hängt vom Anwendungsfall ab (ein "Auswahl aufheben"-Command bräuchte evtl. tatsächlich Zugriff, da die Auswahl evtl. rein UI-technisch realisiert ist).

Wie genau setzt du denn das Command-Pattern ein bzw. welchen Zweck erfolgt sein Einsatz?
Reiner Event-Ersatz zur besseren Entkopplung?
Undo-/Redo?
Commands (ähnlich wir RoutedCommands in der WPF), um gleiche Menüeinträge je nach Kontext andere Aktionen ausführen zu lassen?

In ersterem Fall würde ich dann einfach Commands mittels Delegaten im Presenter erzeugen á la:

this.AddOrderCommand = new DelegateCommand(this.CanAddOrder, this.AddOrder); //CanAddOrder und AddOrder sind (private) Methoden im Presenter

IMHO macht in diesem Szenario ein Command ohne zugehörigen Presenter keinen Sinn; letztlich ist ein Command ja nur ein Weg, eine Methode des Presenters aufzurufen (wobei sich dann natürlich die Frage stellt, wozu man das Command überhaupt braucht - ein Attribut und / oder Spezifikation der Methode wäre ja auch möglich - ähnlich wie in Caliburn für WPF)

Im letzteren Fall würde ich die Registrierung auch im Presenter abwicklen - dieser könnte dann ja auch Ziel für die Commands auftreten und würde entsprechend die richtige Aktion auswählen.

die Aufgaben sollen in sich abgeschlossene Projekte sein. Sie liefern sowohl ihr Aussehen, also die Gui, also auch die Logik.

Dann sehe ich zwei Möglichkeiten:

Entweder überlässt du den "Aufgaben" ihre Darstellung komplett selbst (inkl. Inputhandling) und lädst dann quasi von jeder Aufgabe ein UserControl.
Um dann Kinnectsteuerung etc. zu vereinfachen, kannst du tatsächlich auf deine Interfaces zurückkommen, welche dann von den COntrols implementiert werden.

Oder du stellst quasi eine Art Framework mit speziellen "Controls" zur Verfügung (z.B. Selection, MultipleChoice, Text, Drawing, Map, Audio, ...), die dann von den Aufgaben genutzt werden können (und du dich aber um das Inputhandling davon kümmerst).

Insgesamt sieht es mir etwas zu "billig" aus.

Tja - ich fürchte, dieses Schicksal teilt dein Entwurf mit den Entwürfen vieler Programmierer 😉
Entwickler sind halt in den wenigsten Fällen professionelle Designer.

Siehe hierzu auch: Wie Grafik und Design lernen? sowie Suche Buch/Tutorial zum Thema GUI Design
Dort sind einige Links verlinkt, die zumindest mal Ansätze und "Richtlinien" für gutes UI-Design liefern.
Zudem gibt's auch einige Bücher zu der Thematik.

Aber mein Context kennt anschließend diese Funktion nicht!

Was für ein Context und was für eine Funktion?

Die Methode "GetPerson" musst du natürlich auf die Klasse aufrufen, die sie bereitstellt.
Außerdem solltest du Properties statt Felder verwenden.

Ich will den Background nicht für beide als Resource in Window.Resources anlegen.

Warum nicht?
Das einfachste und sauberste wäre, einen Style in den Resourcen anzulegen und dann diesen dem Button zuzuweisen.

Hallo Thunder,

herzlich willkommen hier im Forum!

Siehe [Hinweis] Syntaxfehler selbst lösen (Compilerfehlermeldungen) :

Vergleiche in C# werden mit == formuliert; bei = handelt es sich um eine Zuweisung.

Das setzten wir jedoch als Grundlagen voraus, daher ==> geschlossen

Siehe How do I calculate someone's age in C#?.

Ganz so trivial (im Sinne von [Hinweis] Wie poste ich richtig? ), wie man anfangs meint, ist die Rechnung also IMHO doch nicht (den Thread per Google zu finden, ist jedoch ganz einfach) 😉

Hallo akunz,

IMHO kann man Eingabegeräte nicht derart pauschal behandeln, wie du das vor hast.
Die Eingabeart unterscheidet sich IMHO einfach doch sehr: Mit der Muas klickt man, mit Multitouch wird getapt oder gewischt, mit der Tastatur "nach links", "Leertaste", "Enter" (usw.) gedrückt.

Was du eher brauchst, ist das Command-Pattern (wobei deine Commands im einfachsten Fall auch Actions sein könnten).

Dann kannst du dir pseudocodemäßig z.B. so etwas zusammenstricken (würde mir jetzt spontan einfallen und ist sicherlich nicht der Weißheit letzter Schluss):

var mouse = //...;
var multitouch = //...;
var keyboard = //...;
//...
var nextPageCommand = //...;
//...
mouse.Click.Do(nextPageCommand );

keyboard.OnKey(Keys.Left).Do(nextPageCommand);
keyboard.OnKey(Keys.Enter).Do(nextPageCommand);
keyboard.OnKey(Keys.Space).Do(nextPageCommand);

multitouch.OnGesture(swipeLeft).Do(nextPageCommand);

Hier mal die gesamte TouchlessMgr Klasse:

Warum willst du die unbedingt verwenden?
Bzw. warum verwendest du nicht direkt diesen TouchlessMgr (also dessen Properties)?

Google generell mal nach "Webcam C#" - ich bezweifle, dass du da nichts findest.

Tja - da hilft ein Blick in die :rtfm: Doku weiter (auch wenn das allgemein wohl eine unübliche Vorgehensweise zu sein scheint...):
[QUOTE3=MSDN: Activator.CreateInstance(Type, object[]),http://msdn.microsoft.com/de-de/library/wcxyzt4d.aspx]MissingMethodException: No matching public constructor was found.
[...]
The constructor to be invoked must be accessible and must provide the most specific match with the specified argument list.[/quote3]

Insofern musst du wohl über ConstructorInfo gehen bzw. eine andere Klasse instanzieren.