hallo zero_x,
ich möchte das Projekt mit silverlight umsetzen.
stimmt, das soll (unter anderem) mein "silverlight lernen" projekt werden und wenn schon, dann auch gleich etwas nützliches dabei rauskommen.
ich werd mal damit beginnen und schaun, wie weit ich komme.
fg
hannes

Danke für eure Rückmeldungen!
Werd mir diese zu Hause dann genauer durschschaun + auch die Tutorial Videos. Bin ja noch Anfänger mit Silverlight.
Emulator vs. echtes Gerät: Da ist mir auch schon aufgefallen, dass es beim Testen so ist, dass manche XNA Sachen im Emulator mit z.B. 50 fps laufen, auf dem echten Gerät jedoch nur mit z.B. 21fps. D.h. testen müsste ich das natürlich sowieso auf einem echten Gerät.
Ich bin mir nicht sicher, glaube aber eher nicht dass XNA, das ja eher für Gameloop mit 3D Modellen usw. gedacht ist das Richtige ist.
Mein Programm ist ja doch eher so, dass es z.B. Auf/Untergangsdaten von Objekten und ebenen eine Sternenkarte anzeigen soll.

Die Überlegung mit der Writable Bitmap Klasse kommt daher, dass es eben kein statisches Bild ist, welches ich anzeigen möchte, sondern eher ein "von innen" betrachteter Globus des Sternenhimmels. 😉
Ich hoffe, das ist halbwegs verständlich.
Natürlich ist es letztendlich ein Bild (?), jedoch muss dieses beim Scrollen/Zoomen immer neu erstellt werden, da man bei einem höheren Zoom Level z.B. schwächere Sterne sehen möchte usw.

thx
hannes

hallo,
da ich bisher noch nichts aufwänidgeres mit silverlight geamcht habe, wollte ich mal fragen, ob ich da zumindest am richtigen wege bin. Mir ist klar, dass ich dabei noch viel lernen muss, aber ich dachte mir, ich frage mal nach, ob die angedachte Vorgangsweise zumindest korrekt ist.

Was ich möchte: Eine Sternenkarte in Silverlight zeichnen, laufend auf Windows Phone 7. Die Karte ist dynamisch, d.h. man kann auswählen, was eingezeichnet werden soll (Sterne bis zu welcher Sichtbarkeit, Koordinatengitter, Linien zwischen den Konstellationen u.a.). Das ganze soll so performant als möglich passieren, damit es auf pan/zoom flüssig reagiert - dazu würde ich die "WritableBitmap" klasse verwenden.
Für das pan/zoom verhalten würde ich mich daran orientieren: http://dotnetbyexample.blogspot.com/2010/08/windows-phone-7-multi-touch-panzoom.html

Meine Frage ist daher einfach, ob das erfolgversprechend ist (ausgehend davon dass ich es hinbekomme 😉 oder ob es schon vom ansatz her nicht funktionieren kann bzw. es bessere lösungen gibt?

thx
hannes

Hallo und vielen Dank für deine umfangreiche Antwort!
muss mir zu Hause mal deine Links durchschaun und mich genauer einlesen, um sinnvolle Fragen stellen zu können 😉 - vorab schon mal vielen Dank für deine angebotene Hilfestellung!

ABER: Rektaszension und Deklination sind vermutlich gar nicht die Koordinaten, die Du haben willst, denn ich denke Du willst einem Beobachter auf der Erde eher azimutale Koordinaten (also Azimut=Horizontwinkel und Altitude=Höhenwinkel (über dem Horizont) anbieten(*).

Genau das möchte ich.

Ich hab mich schon etwas mit ephemeridenberechnung beschäftigt, was mir vorerst aber mal egal sein kann - vorab möchte ich einfach mal versuchen, sterne korrekt darzustellen. Ich habe mir gedacht, ich werde es so angehen:

1. Info's von dir "aufarbeiten" 😉
2. Sternenkatalog besorgen in dem Positionen enthalten sind (später dann auch mag. usw. auswerten)
3. Versuchen, diese Einträge darzustellen

Der Screenshot ist von deinem Programm?
Wow - schaut verdammt gut aus!

thx
hannes

hallo,

ich würde gerne ein planetariumsprogramm in silverlight entwickeln.
straonoimsche formeln zur berechnung der positionen von planeten, sternen usw. habe ich mir schon zusammengesucht.
Was ich bisher nicht gefunden habe: Wie kann ich diese positionen grafisch darstellen?
Es sollte ja eine Projektion sein - der Beobachter steht auf der Erde und kann in alle Richtungen blicken können - also so, wie es "in echt" ist. 😉
D.h. ich muss die Position eines Objektes von Rektaszension (=Höhe) und Deklination (=Winkel) auf eine Kugel projezieren und der Betrachter befindet sich im Inneren dieser Kugel. Da ich noch nichts passendes gefunden habe, möchte ich gerne fragen, ob jemand von euch ein paar Informationsquellen im Netz dazu kennt?
Etwas, das ein wenig in diese Richtung geht, habe ich (für Flash) auf dieser Seite gefunden: http://astrotips.com/index.php?module=PostWrap&page=/static_html/flash_planetarium.html

thx
hannes

hallo,

wenn es eine Klasse ist, die von anderen wiederverwendet wird, würde ich das nicht machen (eigentlich auch nicht, wenn nur ich sie verwende) - wenn dir Intellisense als Rückgabeparameter List<T> anzeigt, ist jedem Programmierer klar, was das ist - wenn er hingegen als Rückgabeparameter "MeineKlasseCollection" sieht imho. nicht so. Außerdem würde ich als Rückgabeparameter - wenn möglich IEnumerable<T> verwenden.

Is aber persönliche Meinung.

fg
hannes

Danke für eure Antworten,

ich habe es inzwischen so abgeändert: Design Patterns: Teil 2 – Dependency Injection mit Castle Windsor

Das ist möglich, weil ich bei den "Datenbank Integrationtests" beim Starten eine Methode "DatabaseTest.For" aufgerufen wird, wo ich den DI-Container initialisieren kann + funktionieren.

Fürs Testen verwende ich nUnit + ja es sind Integrationtests, möchte daher kein Fake-Objekt injecten, wo diese "mit den DB Tests zu tun haben".
Dort wo diese aus dem Container kommen + für den Test nicht relevant sind, verwende ich Fake Objekte.

thx
hannes

hallo,

ich möchte euch gerne zu eurer Vorgangsweise bzw. was ihr mir zu folgendem Problem empfehlen würdet fragen:

Um nHibernate Mappings zu testen + dass es für jede Entität möglich ist, CRUD Operationen auszuführen, gibt es Integrationtets.
Diese haben folgenden Aufbau:

• nHibernate Session erstellen
• Save, Get, Delete ausführen
  ...also recht einfach 😉

Innerhalb der Session Klasse (welche die nHibernate Session kapselt) wird eine weitere Klasse erstellt - der Zugriff auf einen Volltextindexserver.
Bisher war dies direkt via "new IndexingServer();"

Das habe ich nun geändert - die Abhängigkeit wird vom DI container (Castle Windsor) geladen: Registry.Container.Get<IIndexServer>();

Dadurch ergibt sich nun das Problem, dass vor ALLEN Tests, welche die Session Klasse verwenden, der DI Container entsprechend aufgesetzt werden müsste d.h. einen Implementierung für "IIndexServer" registriert werden müsste.

Hier könnte ich nun z.B. Alle Testklassen für die "Datenbank Integrationtests" von einer gemeinsamen Base ableiten und dort im [TestFixtureSetUp] die benötigte(n) Implementierung registrieren.

Ist das aber die empfohlene Vorgangsweise?
Zuvor hatten viele Klassen die benötigten Komponenten teilweise im .ctor übergeben bekommen bzw. selbst via "new" erzeugt.
Das "selbst erzeugen" möchte ich natürlich vermeiden - hier sollen die Instanzen vom DI Container kommen, nur verursacht das leider gewisse Voraussetzungen bei der Ausführung der Integrationtests.

Bei den Unittests habe ich es so geändert, dass für die benötigten Komponenten Mocks im DI Container registriert werden + das funktioniert wie erwartet. 👍
Nun würde ich es auch bei den Integratointests entsprechend ändern, möchte DAVOR jedoch fragen, ob das überhaupt die empfohlene bzw. auch von euch angewandte Vorgangsweise ist?

Vielen Dank (fürs lesen des langen Postings 😉 + für eure Unterstützung vorab,
Hannes

Nachtrag: Derzeit habe ich es mal gem. dieser Vorgangsweise "umgebaut": Design Patterns: Teil 2 – Dependency Injection mit Castle Windsor

Das geht, weil jeder "Datenbank Integrationtest" beim Einstieg eine Methode "DatabaseTest.For" aufruft, wo ich den DI-Container initialisieren kann.
Ob diese Vorgangsweise "best practice" ist, weiß ich nicht.

fg
hannes

hallo,

ich möchte gerne fragen, ob jemand von euch ein freies application lifecycle management produkt kennt bzw. im Einsatz hat? In der Fa. haben wir dzt. SVN für Versionsverwaltung, nUnit für Unittests, Cruise Control als Build Server und FlySpray als BugTracking Tool in Verwendung.

Was dzt. noch völlig fehlt, ist ein Tool zum erfassen von Anforderungen (System Requirements) - d.h. dzt. werden diese einfach in Word geschrieben.
Später gibt es zu diesen dann ein weiteres Word - das Designdokument.
Weiters gibt es eine Excel Liste, wo einzelne Punkten, die zu impl. sind, angeführt sind, mit Zuordnung zum Entwickler und Spalte für MT-Schätzung usw.

Was ich/wir gerne hätten:
Ein Tool, das "alles kann" - ich bzw. ein Consultant erstellt eine Anforderung - daraus wird (u.U. + später) eine Aufgabe für einen Entwickler. Mit einem Klick kommt man zum dazugehörigen Designdokument. Zuständiger Entwickler od. das Team sind dazu eingetragen mit MT-Schätzung. Später kann zu diesem Punkt mal ein Bug erfasst werden, also Bugtracking. Alle Besprechungsprotokolle zu diesen Thema sind evenfalls über einen Klick erreichbar, sodass man nicht alles, was dazugehört mühsam "zusammensuchen" muss.

Gibt es hierzu kostenlose Alternativen zum Team Foundation Server von MS bzw. würde sich dieser dafür überhaupt eignen?

fg
hannes

hallo,

ohne da jetzt die "ultimative wahrheit" sagen zu können 😉, schreibe ich halt mal, was ich dazu denke:

ad 1) Würde ich machen

ad 2) Die Testprojekte heißen bei uns wie das zu testende Assembly + "Tests"

ad 3) Mach ich auch so, jedoch <ClassName> + "Tests".

ad 4) <FunktionsName><Bedingung><Erwartetes Ergebnis>
z.B. "GetPerson_WithPersonName_ReturnsPerson"

ad 5) DRY lässt sich bei Unittests imho. nicht komplett vermeiden.

ad 6) Hier wird empfohlen, sich an die "AAA" (arrante, act, assert) syntax zu halten. Das ist bei deinen Tests der Fall. Ev. könnte man noch Variablennamen "expected" und "actual" verwenden, dann kann man im Assert angeben: Assert.That(actual, EqualsTo(expected));

fg
hannes

hallo,

danke für das Tutorial, ich möchte jedoch noch darauf hinweisen, dass es ein Problem bei der Lokalisierung gibt, sobald man für sein CF-Programm ein CAB Setup erstellt.

Das "tückische" ist, dass alles supa funktioniert, solange man im Debugger testet - wenn man jedoch deployd, funktioniert es dann nicht mehr.

Beschreibung des Bugs:
http://www.codeproject.com/KB/windows/celocalization.aspx
http://blogs.compactframework.de/Peter.Nowak/Trackback.aspx?guid=c1173b7e-3dd6-4734-86eb-596f2abb3762

fg
hannes

hallo,

ich finde, das beispiel demonstriert auch eine mögliche (sinnvolle?) Vorgangsweise.
Natürlich kann ich nur die Fälle in automatischen Tests abbilden, die mir "einfallen" + ev. übersehe ich dabei manche Fälle.

Hier gibt es nun die Möglichkeit:

1. Sobald ein weiterer Fall auftritt, diesen durch einen weiteren Test abdecken.
   Ich finde, das ist "normales Vorgehen" - wenn Software entsteht, ist ja legitim, dass eine Klasse um eine Methode erweitert wird. Für diese ist dann natürlich ein Test zu schreiben, oder eben für einen Fall, den ich in meinen Tests bisher nicht berücksichtigt habe. Natürlich soll der Fehler/das Verhalten im Code behandelt werden, Test ist ja kein Ersatz für Fehlerbehandlung (wo sinnvoll) im Code.

2. Tools für automatisches Whiteobox Testing verwenden.
   Mit diesen habe ich mich bisher auch nur theoretisch beschäftigt - was haltet ihr davon? Wenn, dann würde ich mich mal mit PEX beschäftigen: http://research.microsoft.com/en-us/projects/pex/

Die Idee dahinter ist halt, dass eine Methode automatisch mit allen möglichen Input Parametern getestet wird (einfach gesagt). D.h. Wenn die Methode int als Input parameter hat, wird ein Test erstellt, der die Methode mit 0, x, int.MaxValue aufruft. Wie gesagt - kenne das bisher nur von der Theorie und habs noch nicht in konkreten Projekten verwendet.

Dies wäre jedoch ev. eine Möglichkeit, den beschriebenen Fall abzudecken.
=> Ev. könnte man die Umfrage noch erweitern: "Ich verwende auch Tools für automatishes Whitebox testing". 😉

fg
hannes

hallo,

man sollte wohl auch "einrechnen": Wie schnell kann ich Änderungen (die es immer gibt) oder Erweiterungen durch neue Anforderungen implementieren und sicher sein, bestehende Funktionalität nicht zu gefährden/brechen.

Beispiel: Erweiterung x dauert 5 MT.
Danach müsste ich genaugenommen das gesamte Programm nochmal testen, Aufwand z.B. 10MT
Durch automatische Tests reduziert sich der manuelle Testaufwand auf z.B. 5 MT.

D.h. beim Implementieren der Erweiterung x konnte ich durch automatische Test 5 MT einsparen. Nun ist noch die Frage, wie viele Erweiterungen/Änderungen es an meiner Software so geben wird.

hallo,

natürlich ist das jetzt keine Studie oder ein wissenschaftlicher Beweis - aus bisheriger Erfahrung kann ich jedoch sagen:

• In einem Vorgängerprojekt, in dem es wenige und vor allem "weniger gute" automatische Tests gibt, habe ich ein ungutes Gefühl, wenn ich etwas ändern muss.
• Das Testen nach Änderungen, ob noch alles funktioniert, ist weit aufwändiger.
• Die Architektur ist generell schwer zu testen d.h. nachträglich Tests zu schreiben ist nicht so einfach.

Zum letzten Punkt muss man ergänzen: Natürlich lernt man dazu und macht vieles beim "2. Versuch" besser. Der persönliche Nutzen ist jedenfalls, dass ich im aktuellen Projekt, wo es mehr automatische Tests gibt, es einfacher/sicherer finde, wenn etwas geändert werden muss.
Das reicht mir als Argumentation für automatische Tests + ich denke, jeder der das selbst erlebt hat, dem geht es ebenso. Soll heißen: Man macht sich als Entwickler das eigene Leben leichter. 😉

Das heißt jetzt natürlich nicht, dass es nicht trotzdem Bugs gibt - wenn das jedoch der Fall ist, wird dieser behoben + gleich ein Test dafür geschrieben, der beweist, dass der Bug behoben ist. So sieht man es auch z.B. bei nHibernate, wo es neben den allgemeinen Tests noch Tests für "Fixtures" gibt, diese haben die selbe Nummer wie im Bugtracking System und so gibt es dann einen Zusammenhang zwischen Bug + Test, der dessen Fix beweist.

hallo,

ein Grund gegen Unittests ist ev.: Das Programm hat insgesamt < 50 Zeilen Code. 😉

Wichtig ist wohl noch "korrekte" Unittests zu schreiben (da bin ich auch noch am lernen) und zu unterscheiden zwischen Unittests und Integrationtests. Der größte Vorteil für mich ist, dass ich mir "traue", Refactorings zu machen, wenn ich für den betroffenen Code (besser: den gesamten Code) automatische Tests habe.

fg
hannes

Hallo,

Ich möchte euch gerne zu euren Erfahrungen zum o.g. Thema fragen.
Ev. habt ihr etwas in der Art bereits implementiert und bei Projekten erfolgreich im Einsatz.

Szenario ist, dass große Datenmengen, ev. auch große Einzeldateien von einer Arbeitsstation (Client) zu einem Server übertragen werden müssen.
Technologie ist .net 3.5 unter Verwendung von WCF.
Am Server werden diese Dateien geprüft und ev. "importiert" d.h. deren Inhalt in einer Datenbank abgelegt.
Da Sql Server und Oracle unterstützt werden müssen und nHibernate zum Einsatz kommt, wird das FileStream Feature des Sql Servers nicht verwendet.
Wenn Einzeldateien sehr groß sind, werden diese in einer selbst implementierten "Blob" Storage am Dateisystem des Servers abgelegt.

Konkreter Anwendugnsfall: User legt auf seinem PC eine DVD mit zu prüfenden/importierenden Daten ein und startet einen Prozess.
Auf der CD können sich Einzeldateien befinden, welche bis zu 500MB groß sind - große Einzeldateien dürfen also kein Problem sein.
Die Daten sollen - wie geschrieben - zum Server übertragen und verarbeitet werden.
Später möchte der User die importierten Daten wieder bearbeiten - dazu muss er diese auf seine zu seinem lokalen PC übertragen und am Dateisystem ablegen. ("CheckOut" Mechanismus - Dateien müssen am Client abgelegt werden werden, da sich innerhalb diese Links befinden (ähnlich zu HTML) und ein Viewer eine Datei benötigt.)

Daraus ergeben sich imho. 2 Anwendungsfälle:

• Import der Daten (Übertragung vom Client => Server)
• Abfrage der Daten (Übertragung vom Server => Client)

Aus meiner Sicht gibt es 2 offensichtliche Vorgangswseisen:

1. Arbeiten mit einem "Shared Directory", einem Verzeichnis, auf welches Server und Client Zugriff haben.
   Dieses wird zum Datenaustausch verwendet.
2. Streaming der Daten via WCF Service.

ad 1.)
Ist vermutlich einfacher umzusetzen (Dateien kopieren), jedoch wird ein "shared Directory" benötigt.
Das kann zu Problemen mit Webapplikationen führen, welche derzeit jedoch nicht unterstützt werden müssen.

ad 2.)
Ist das eine empfohlene Vorgangsweise?
Hiermit habe ich keine Erfahrung, kann das also nicht beurteilen, denke aber, dass es hier einfacher ist, einen Web Client anzubinden.

Was sind eure Erfahrungen/Empfehlungen dazu bzw. habt ihr schon einmal eine Lösung in diesem Umfeld implementiert?

thx
hannes

hallo,

ev. hilft folgendes: http://www.pocketpc.ch/programmieren/42760-standby-verhindern.html

Ich habe selbst eine Anwendung impl., die genau das macht + im Hintergrund läuft,
damit die Beleuchtung nicht abgeschaltet wird während man z.B. EMails liest.
Das Problem mit dem Wechseln zum Homescreen kenne ich jedoch überhaupt nicht - auf welchem Gerät testest du dein Programm?

fg
hannes

hallo,

ja, jetzt ist mir verständlich, was du meinst.

Wir verwenden es dzt. (produktiv + erfolgreich) in der Form, dass es einen eigenen "Server" gibt, welcher Webservice Anfragen entgegennimmt. Dieser verwendet intern Lucene.net, um einen Index am Dateisystem abzulegen.

Die Komponente, welche Volltextsuchen durchführt, weiß nichts von Lucene.net - für diese ist es ein Webservice Aufruf.

fg
hannes

hallo,

der von mir angesprochene Vorteil (Volltextindizierung der DB verwenden), kommt aber nur zum tragen, wenn man die Volltextfunktion der DB verwendet!
Dann bist du aber nicht mehr DB unabhängig.

Wenn du Lucene.net verwendest, kannst du Volltextabfragen nicht mit SQL Statements kombinieren, auch nicht, wenn der Index in der DB liegt - zumindest nicht, wenn es ein Überbau ist, der anstelle eines Dateisystems die DB als Ablage verwendet.

Lucene.net weiß ja nichts von SQL Abfragen und die DB nichts von einem Volltext in Lucene - eine Kombination innerhalb eines einzigen Select Statements in der Form "Select * from ... where Fulltext("abc")" ist daher so nicht möglich.

So kann man die Indexierungsroutine jederzeit ändern und doch das DB-Schema beibehalten.

Weiß nicht, was du damit meinst.
Auch wenn du den Index am Dateisystem hast, ist er unabhängig von einem DB Schema.

fg
hannes

Leider nein.
Ich möchte den erstellten Index auf einer Datenbank speichern. Das was du meinst scheint eine Indizierung einer DB zu sein. Oder habe ich das jetzt falsch verstanden?

Nein, hab damit eh die Indizierung der DB gemeint.
Warum möchtest du den Index in einer DB speichern bzw. was ist das Problem, wenn der Index wie bei Lucene am Dateisystem liegt?

Achja und zum Thema SQL Server:
Leider muss das System so weit wie möglich unabhängig vom konkreten DB-System sein.

Das war auch der Grund, warum ich Lucene.net einsetze.
Hat halt alles Vor- und Nachteile. Lucene.net ist einfach verwendbar, schnell + bietet Möglichkeiten, die eine DB integrierte Volltextsuche (meines Wissens nach) dzt. nicht kann z.B. Direkten Zugriff auf den VolltextIndexkatalog.
Großer Vorteil des Volltextindexes in der DB ist imho., dass man Abfragen auf diesen dann in ein SQL Statement gemeinsam mit anderen Kriterien kombinieren kann. (Select ... from ... where Fulltext(...) and ...)

fg
hannes

hallo,

Indexspeicherung auf einer Datenbank

Die meisten DBMS unterstützen die Indizierung von DB Spalten, in welchen Text gespeichert ist - ist das eine Lösung für dich?

es sollten möglichst viele Dateitypen unterstützt werden

Das hat nichts mit der Indizierung an sich zu tun. Um aus einer Datei mit einem bestimmten Typ (z.B. .doc) einen Klartext extrahieren zu können, musst du über die "IFilter" Schnittstelle gehen (z.B. http://www.codeproject.com/KB/cs/IFilter.aspx) und den Text extrahieren - dieser kann dann durch die Indizierung weiterverarbeitet werden?

es wäre cool, wenn das System die Dokumente nach erstmaliger Indexierung "überwacht" siehe: FileSystemWatcher-Klasse

es sollte Dokumente in deutscher Sprache aufbereiten können Für Lucene.net und auch z.,B. Sql Server (sicher auch andere, aber von denen weiß ich es), gibt es Tokenizer, die das können.

fg
hannes

Danke für eure interessanten Beiträge,

ich stimmte auch zu fast allen Teilen mit eurer Meinung überein, möchte jedoch ergänzen: Ich finde es sehr gut, dass es Foren wie dieses gibt, wo man sich austauschen kann und von der Erfahrung anderer profitieren. Deshalb wohl der Leitsatz "gemeinsam mehr erreichen" 🙂

Natürlich ist es aber schon was andres, wenn man hier über Codeschnipsel diskutiert, oder die Architektur eines gesammten Projektes mit > 10000 Klassen betrachtet - da sind dann halt plötzlich Sachen wichtig, die in einem "Codeschnipsel" (um beim Wort zu bleiben) wohl nicht so wichtig sind.
Beispiel: Für ein Programm mit gesamt 200 Zeilen werde ich mir eher nicht überlegen, ob ich einen DI-Container einsetzen soll, für ein Enterprise Projekt ev. schon.

Ein Autor von "Inside sharp develop" hat mir mal zurückgeschrieben, dass das team viel gelernt hat, nachdem sie sich mit design patterns beschäftigt haben. Ich denke daher wiederum, dass man ev. viel lernen kann, wenn man sich den Source eines Projektes wie "sharp develop" anschaut.

fg
hannes

hallo,

oft wird geschrieben: man kann viel lernen, indem man Code aus anderen Open Source Projekten liest. Was mein ihr dazu?
Was, wenn das Projekt z.B. eine Java Portierung ist (nHibernate, nUnite, ...) und spezifische Funktionen von C# nicht nutzt - lernt man dann ev. Sachen, die man in der Praxis anders lösen kann + sollte?
Habt ihr schon mal durch fremden Code gesteppt und gedacht: das ist elegant implementiert, das mache ich nächstes mal auch so?
Habt ihr Empfehlungen für Projekte, aus welchen man etwas lernen kann?

fg
hannes

Hallo herbivore,

danke für deinen hinweis!
ich habe es nun so abgeändert, dass es Möglichkeit 1 entspricht.

fg
hannes

Danke für eure Antworten,

ich habe es (nach Unterhaltung und als Vorschlag eines Arbeitskollegen) nun folgendermaßen implementiert (Code nachbearbeitet):

internal class Importer<T>
{
  private ComponentWithEvent Component_A { get; set; }
  
  public event EventHandler<MyEventArgs> MainClassEvent
  {
      add
      {
          Component_A.SubEvent += value;
      }
      remove
      {
          Component_A.SubEvent -= value;
      }
  }

Die Klasse "Importer", welche von einem Importprozess verwendet wird, stellt also das Event bereit, beim Zugriff auf dieses wird jedoch direkt an das Event der Komponente gebunden. Ist also eine Abwandlung von Möglichkeit 1, mit dem Vorteil, dass das Event nicht doppelt definiert werden muss.

@DFDotNet: Wie löst du das Problem, dass diese zentrale Instanz dann ALLE Events bekommt? Wenn es z.B. mehrere Instanzen des "Importers" gibt, schicken diese alle ihre Events an die zentrale Instanz. Beim Loggen dieser Meldungen bekommt man dann ev. mehr Meldungen, als man sich wünscht. 😉
Lösung wäre, dass man den Instanzen eine Id gibt, daimt man wieder unterscheiden kann, was jedoch auch ein Aufwand ist, da diese Id u.a. an die Subkomponenten weitergegeben werden müsste usw.

thx
hannes

hallo und danke für deine Antwort,

Eine Publiceigenschaft mit dem Typ des Events in jeder Schicht einbauen , sodass das Eventobject bis ganz nach oben durchgereicht werden kann. (Ungetestet)

Das müsste dann gar nicht public sein, intern würde reichen, nur die oberste Schicht muss es als public bereitstellen - das wäre "Lösung 1", welche imho. ja auch nicht ganz optimal ist.

Oder einfach in jeder Schicht das Event implementieren

Der Importprozess soll die Komponente A, B, ... nicht kennen d.h. von diesen ein Event direkt abonieren, Komponenten A, B, x, ... werden intern vom "Import" verwendet - hier soll keine interne Logik nach außen gegeben werden.

fg
hannes

Hallo,

wir haben soeben innerhalb unsere Entwicklerteams darüber diskutiert,
sind derzeit noch zu keinem finalen Ergebnis gekommen, weshalb ich euch gerne um eure Meinung fragen möchte.

Szenario:
Es gibt einen Importprozess, welcher ein Protokoll schreibt.
Der Importprozess verwendet eine Instanz der Klasse "ClientImporter".
Der "ClientImporter" wiederum verwendet intern (private) weitere Komponenten, nennen wir sie Komponente A und B.
Komponente "A" löst nun eine Event aus (z.B. Datei nicht gefunden), welches ins Protokoll geschrieben werden soll.

Importprozess (schreibt Protokoll) => Importer => Komponente A, B (lösen Event aus),... ev. weitere Komponenten/Sub-Komponenten

Wie kann man nun elegant dieses Event "nach oben" geben, an den Importprozess, sodass dieser es ins Protokoll schreiben kann?

1. Möglichkeit: Bubbling von Events
   Komponente A bietet Eventhandler für "File not found" - der übergeordnete Importer registiert sich an diesem Event.
   Der Importer seinerseits bietet ebenfalls ein Event "File not found" - der Import-Prozess registriert sich an diesem Event.
   Nachteil: Doppelte Events, Events müssen "weitergegeben" werden

2. Möglichkeit: Domain Event Pattern oder Mediator Pattern verwenden.
   Es gibt eine zentrale Stelle, an welche Events (Messages) geschickt werden.
   Andere Komponenten z.B. der Importprozess können sich an dieser Stelle registrieren, um die Meldungen zu bekommen.
   Komponenten schicken Meldungen an diese "zentrale Stelle".
   Nachteil: "Mediator" muss static sein und bekommt u.U. Events von mehreren Importprozessen gleichzeitig.

Zum Hintergrund: Die Applikation wird als WCF Service gehostet und es werden mehrere Instanzen erzeugt.
Diese Instanzen würden sich einen statischen Mediator "teilen" - wenn 10 Importprozesse laufen, würde dieser alle Meldungen bekommen.
Abgesehen davon, dass das wohl nicht so gut ist, kann eine Meldungen dann nicht mehr ohne weiters einem spezifischen Importprozess zugeordnet werden.

3. Möglichkeit: Wie 2., jedoch erzeugt der Importprozess eine Mediatorinstanz, dieses ist daher nicht static.
   Der Mediator würde dann Meldungen von einem Importprozess bekommen, ABER: Diese Mediatorinstanz müsste man weitergeben an die untergeordneten Komponenten,
   welche ja ebenfalls an diese Messages "posten" müssen.
   Der "Importer" und die Komponenten A und B müssen also den Mediator kennen...was wohl nicht Sinn der Sache ist, weil diese imho. nichts damit zu tun haben sollten (single responsible principle).

Ev. wird später mal WF verwendet und k.A., wie es sich da dann verhält, wenn man statische Instanzen (Möglichkeit 2) verwendet -
wenn möglich möchte ich statische Instanzen aus bekannten Gründen (z.B. Skalierung) eher generell vermeiden.

Derzeit tentiere ich zu Möglichkeit 1.
Gefallen tut mir die Lösung allerding nicht, weil ich hier Events mehrfach ausführen muss und die übergeordnete Klasse die Events ihrer Komponente(n) weitergeben muss.

Wie würdet ihr hier vorgehen?

thx
Hannes

Danke für deine Erklärungen!
"Leider" ist das ja so, dass man sich - sobald man ein selbst entwickeltes Programm anbieten möchte - sich auch mit rechtlichen Dingen beschäftigen muss. Mir geht's einfach darum, dass ich da keine unerwarteten/teuren Probleme bekomme, wenn ich mal etwas zum freien DL oder auch kommerziell anbieten möchte.

thx
Hannes

hallo + danke für deine antwort,

Zitat:
Was bedeutet "Lizenz beilegen", wenn ich die Applikation zum Download anbiete (frei oder auch nicht)?
Das wurde doch weiter oben schon besprochen.

dann hab ich es leider nicht verstanden.
lt.: http://www.gnu.org/licenses/gpl.html
The “source code” for a work means the preferred form of the work for making modifications to it. “Object code” means any non-source form of a work.

D.h. also Code in form einer kompilierten assembly.
=> Ich MUSS (?) bei "meiner" Lizenzerklärung also angeben, dass das Programm Libraries verwendet, welche unter der Microsoft Public License lizenziert sind?

fg
hannes

hallo,

sorry wg. der ev. "blöden Frage", aber mit rechtlichen Sachen habe ich mich bisher noch überhaupt nicht auseinandergesetzt, da ich nicht selbstständig SW verkaufe.

Was bedeutet das nun genau, wenn ich selbst eine Software entwickle + verkaufen möchte, welche eine Library unter der "Microsoft Public License" verwendet?
Ist das erlaubt, OHEN dass ich meine SW auch wieder unter der "Microsoft Public license" freigebe? (nach meinem Verständis - im Gegensatz zur z.B. GNU general public Lizenz - JA)
Was bedeutet "Lizenz beilegen", wenn ich die Applikation zum Download anbiete (frei oder auch nicht)?

thx
Hannes

hallo,

Das ist jetzt keine direkte Antwort auf deine Fragen zu "WidgetManager § , aber ev. ist die "Offline Funktionalität" von Silverlight 3 für dich interessant?
Imho. sollte im Programmcode kein "if (inBrowser)" stehen.
Man sollte eher versuchen, Logik, DAL, ... in eigene Layer zu kapseln und den GUI Layer austauschbar zu machen.

fg
hannes

hallo,

oje, das hab ich wohl bissl falsch verstanden - das "Copy to Output Directory" geht natürlich nur mit Dateien "unterhalb" eines Projektes, is auch logisch, dort kann man angeben, dass diese ins Output Directory eben dieses Projektes kopiert werden.

Wenn die Dateien in einem Solution Ordner liegen, muss man das wohl via "Pre/Post Build" Commands machen, also dort einen copy Befehl eintragen.

fg
hannes

hi,

beim Properties Dialog kann man unter "Copy to Output Directory" genau das einstellen.

fg
hannes

hi,

interessanter thread. 😉
Mein 1. Programm war in "gwbasic" - interpreter wurde von einer 5 1/4" Diskette im Dos mode gestartet (DR Dos) - war 86k "groß". (der Interpreter)
Hat das Alter abgefrafgt und je nach Eingabe etwas anderes geantwortet d.h. 1 If-Verzeigung. In der Schule (HTL für EDV) habe ich mit Turbo Pascal begonnen, später C und Assembler.
Beruflich am Anfang C++: MS Visual C++ (3.0? weiß ich nimma genau).
Seit C#/.net 1.0 mit diesem. 😉

fg
Hannes

hallo,

habs mir gerade DL, weil der Screenshot nett ausgesehen hat. 😉
so als Empfehlung: Du solltest unbedingt versuchen, GUI und Logik zu trennen - ev. hast du das eh noch vor.
Dann wäre der spätere Schritt zur Verwendung von z.B. WPF als GUI viel einfacher. 🙂
Auch die Methoden zum Laden/Speichern haben natürlich nix in der Form Klasse verloren.

...das soll jetzt kein "obergscheites dahergerde" sein, sondern eine anmerkung, weil es ja offensichtlich ein "übungsprojekt" ist. 👍

fg
hannes

hi,

sowas i.d. Art?
http://www.christec.co.nz/blog/archives/174
Wenn ich das machen wollte, würde ich auch WPF für Windows Mobile verwenden - weiß aber net, welche Einschränkungen das hat (findet man aber sicher), weil ich noch nix damit gemacht habe. 😉

fg
hannes

alle bücher, die verfilmt wurden und die ich gelesen habe, waren um welten besser als ihre video-konkurenz.

stimmt.
Wobei ich sagen muss, dass ich von der Verfilmung von "Das Parfum" (sehr gutes Buch) positiv überrascht war.

fg
hannes

hi,

Jetzt, wo Du das anspricht fällt es mir auch auf... Wenn er die von Microsoft meint, hab ich doch eigentlich nichts davon, da Microsoft die Fehlerdaten erhält - oder irre ich mich da?!

Das sollte die meisten Fragen klären: http://www.microsoft.com/whdc/winlogo/maintain/StartWER.mspx

Aber - ist wohl nur für größere Projekte interessant, nicht zum "herumprobieren" weil ja auch so ein Verisign Zertifikat nicht kostenlos ist.

fg
hannes

hi,

ein schönes Übungsbeispiel.
Ich würde dabei grob mal so vorgehen:

1. Klassenmodel:
   Die Klassen "Addition", "Subtraktion", ... erben von der Klasse "Rechnungsart".
   Jede dieser Klassen kann "ihre" Rechnungsart erstellen.
   Rechnungsart besteht immer aus Operand1, Operand2, Operator (diese sind i.d. Basisklasse).

=> Das kann man dann einfach erweitern, sodass z.B. die "Division" nur ganzzhalige Divisionen erstellt, keine Division durch 0, Rechnungen in bestimmten Zahlenraum usw.

ToString() so überschreiben, dass es dir Rechnung ausgibt: "1 + 4 = ".
Intern kenn die Klasse natürlich das Rechenergebnis - die Eingabe aus dem Textfeld kannst du dann Parsen (int.TryParse(...)) und mit dem Ergebnis vergleichen. (aber erst später, vorerst ist GUI egal)

Dann gibt es einen Klasse für die Spiellogik, welche die Zeit stoppt, und die Klasse für die Rechnungsart x mal aufruf. (Der sog. "Controller")

Wichtig: Das alles hat noch garnix mit GUI zu tun - dieses würde ich am Schluss machen.

Achja und wie kann ich den String der Aufgabe und das Ergebnis(int, damit das Ergebnis in der Form Datei mit der eingegeben Zahl verglichen werden kann) als Rückgabewert der Klasse bekommen? Man darf ja nur einen Rükgabewert haben.

Bin mir nicht sicher ob ich verstehe, was du meinst.
Du möchtest die Eingabe mit dem korrekten Ergebnis vergleichen?
String in Zahl wandeln: int.Parse()

Fang halt mal an und frage ggf. nochmal bzw. häng das vorläufige Ergebnis hier an. 😉

viel Spaß beim programmiefen + fG
Hannes

hallo,

na das freut mich aber, wenn ich dir da die Unsicherheit nehmen konnte. 😉
btw. wegen eines falschen Ansatzes neu zu beginnen ist nicht schlimm - vor allem, wenn es kein Produktiv-Projekt ist, sondern zur Übung dient - das nennt man dann "Refactoring". 😁
Auch in anderen Sourcen zu stöbern, ist eine gute Möglichkeit, sich Wissen anzueignen, würde das nicht als "klauen" bezeichnen.

Zwecks Referenz auf das Datenobjekt, wie meinst du das hier genau?

Damit meine ich eigentlich nur, dass es nicht so sein sollte, dass dein GUI Objekt eine Referenz auf eine Klasse (=Implementierung) deines "Daten-Objektes" haben soll, sondern auf ein Interface (=Contract) deines "Daten Objektes". Das soll jetzt aber nicht heißen, dass man es so machen MUSS.

Generell sollte man aber versuchen, wenn ein Objekt eine Referenz auf ein anderes Objekt hat, dies über ein Interface abzubilden => "program against an interface/contract, not an implementation". Dadurch wird die Kopplung zwischen den konkreten Objekten aufgehoben. D.h. du kannst die dahinterliegende Implementierung austauschen.

Weiters ermöglicht dir dieser Ansatz später die einfachere Verwendung von Mocking (für Unittests) oder von Dependency Injection.

fg
hannes

hallo,

Das mit dem Drucken etc klingt einleuchtend.

ja, betrachte die eigentlichen Daten (welche du speichern/drucken/sonstwas kannst), immer unabhängig von deren Repräsentation.

Angenommen, ich habe in meiner zukünftigen Anwendung einen Button "Klassenvorlage erzeugen". Dann entstehen bei jedem Klick zwei zusammengehörende Objekte: das Grafikobjekt der Gui-Klasse (evtl. Usercontrol) und das Datenhalterobjekt für die ins Grafikobjekt eingegebenen Klassendaten.

ja. Wobei diese Logik nicht in das Klick-Event des Buttons programmiert werden soll, siehe z.B. MVP Pattern.

Da sich die Objekte nicht kennen (sollte wohl auch so sein um flexibel zu bleiben), weiß ich nun nicht, wie ich diese verwalten soll. Schließlich kommt ja mit jedem Klick ein weiteres Objektpaar hinzu und es kann auch sein das mal eines gelöscht werden muss oder editiert werden soll.

Nein, ich danke, dass das GUI Objekt das Daten-Objekt sehr wohl kennen "darf", jedoch nicht umgekehrt d.h. das Daten Objekt weiß nichts davon, dass es z.B. auf einem Winform angezeigt wird.
Die GUI Objekte kann man einfach in einer Liste speichern. Jedes GUI Objekt hat eine Referenz auf sein "Daten Objekt". Auf diese Weise würde ich die Objektparre verwalten. Im Idealfall ist die Referenz noch auf ein Interface des Daten Objektes.

Du kannst dir auch anschaun, wie z.B. #Develop das gelöst hat - die haben ja auch einen GUI Designer, der das selbe "Problem" hat. Ich denke jedoch, dass es hier (ohne es selbst gesehen zu haben) recht komplext wird, das das Projekt einfach einen enormen Umfang hat.

Für den Anfang würde ich wie beschrieben beginnen:

• 2 Objekte (Datenhalter bzw. "Domain Objekt")
• GUI Objekt, welches eine Referenze auf ein Daten Objekt hat

fg
hannes

hallo,

mal paar Anmerkungen dazu meinseits bzw. wie ich das angehen würde:

Das Grafikobjekt "Klassenrechteck", welches die Klasse darstellen soll, soll es auch die Informationen zur Klasse (Methoden-, Feldnamen usw.) Speichern? Dann wären jedoch Gui und Daten vermischt.
Oder sollte es umgekehrt gemacht werden, so dass das Datenobjekt ein Grafikobjekt von sich selbst erzeugt? Dann gibt es ja wieder keine Trennung von Gui und Daten, oder?

Auf jeden Fall die Objete trennen - die grafische Darstellung hat nichts mit dem Objekt an sich zu tun. Sieh es einfach so: Du möchtest, dass deine Objekte mit Winforms und WPF darstellbar sind...oder am Drucker ausgebbar. Wenn du da die Anzeigelogik ins Objekt programmierst, geht das nicht.
Es gibt also eine "Datenhalterklasse", welche Properties wie Methodennamen, Feldnamen usw. hat.

Dann eine eigene GUI Klasse, welche weiß wie man z.B. eine solches Objekt in Winforms grafisch darstellt. Hier kannst du ein Usercontrol als Basis verwenden.

MVC oder MVVM sind schon gute Ansätze, würde ich jedoch in der 1. Ausbaustufe weglassen - immer 1 Schritt nach dem anderen. 😉

fg
hannes

        int[,,] fu1()
        {
            var val1 = new int[1,2,3];
            return val1;
        }

?
...hab ich aber noch nie gebraucht, sowas. 😉

fg
hannes

hallo,

ich betrachte Persitierung eher als "solved problem" und würde immer wieder auf die Verwendung eines O/R Mappers setzen. Habe beides gemacht, d.h. mit DataSet + Stored Procedures gearbeitet + mit O/R Mapper und für Business Applikationen welche gem. DDD entwickelt werden ist es imho. "best practice" ein O/R Mapper zu verwenden.
Ich möchte da jetzt aber bitte KEINEN Glaubenskrieg auslösen, ist ja überhaupt nicht Thema des Threads.

Das Active Record Pattern sah ich bisher so, dass es ein 1:1 Mappings zwischen 1 Datenbanktabelle und 1 Klasse darstellt. Änderungen an Property werden in DB geschrieben usw. ohne Berücksichtigung von Validierung - werde mich da noch genauer informieren.

CSLA.Net kenne ich noch nicht, was ich sogleich ändern werde. 😉

thx
hannes

hallo,

danke für deine antwort!

Validierung ist ein sehr komplexes Thema

Dem muss ich leider 😉 zustimmen.

Das ich es außerhalb der Domain Objekte regeln möchte, bin ich mir schon sicher. Alles andere, wie einfache "Name != null" Prüfung würde da ja keinen Sinn machen und selbst das ist fraglich. Mich interessiert eure Meinung, weil ich dazu bisher zwar verschiedene Ansätze gefunden habe, aber noch keine sog. "Best Practice" - im Zusammenhang/Zusammenspiel mit DDD.

Das wundert mich, weil es ja kein utopisches Thema ist, sondern etwas, das jeden, der umfangreichere Applikationen entwickelt betrifft.

fg
hannes

hallo,

ich würde mir auch Unterstützung für AOP wünschen. 😉
Verwende es derzeit noch nicht, überlege aber, dafür PostSharp zu verwenden - beruflich.

fg
hannes

hallo,

ich möchte euch gerne fragen, wie ihr bei der Validierung von Domain Objekten und auch UI Objekten vorgeht.
Habe dazu schon einiges gelesen, z.B.: http://www.lostechies.com/blogs/jimmy_bogard/archive/2009/02/15/validation-in-a-ddd-world.aspx
und die Antworten, die dazu diskutiert werden.

Dem Ansatz, welchen z.B. der "Application Validation Block" hier geht, finde ich nicht gut - Domain Model Objekte werden mit Attributen versehen. Validierung ist imho. aber immer Contextbezogen d.h. ich möchte ev. ganz unterschiedliche Dinge validieren, je nachdem ob ich ein Domain Objekt speichern möchte oder es löschen will.

Beim Speichern jetzt aber eine Validierung aufzurufen ist imho. auch nicht korrekt. Ev. sollte man ein Domain Objekt ja immer speichern/zwischenspeichern können - nur wenn gewisse Operationen ausgeführt werden, muss das Objekte bestimmte Bedingungen erfüllen - erst dann ist also zu validieren.

Im Idealfall sollte die Validierung natürlich nicht beim Domain Objekt selbst sein - vielmehr sollte man diese "von außen" steuern, verändern und erweitern können. Validierung ist nicht Aufgabe des Domain Objekte - eine andere Klasse sollte das Objekte daher validieren.

So ist meine Sicht der Dinge.
Wie sehr ihr das?

Grundsätzlich gefällt mir das nCommon Projekt (http://code.google.com/p/ncommon/) sehr gut und ich verwende diese Ansätze auch für Validierung usw. Derzeit müsste man die Validierung aber manuell aufrufen z.B. vor dem Speichern.

  var dmObject = new DMObject {CoCode = "123"};
  var dmObjectValidator = new DMObjectValidator();
  var result = dmObjectValidator.Validate(dmObject);

  Assert.AreEqual(2, result.Errors.Count());

Das ist natürlich nicht so gut, weil man die Validierung explizit aufrufen muss und man das "vergessen" könnte (als aufrufender Client).
Andrerseits ist es wie gesagt fraglich, ob ich diese fix mit dem "Speichern" verbinden soll - d.h. dass man beim Aufruf von "Save()" die Validierung automatisch aufruft - das würde dann ein "Zwichenspeichern" verhinden.
Außerdem gefällt es mir nicht, in einer "Save()" Methode eine Validierung aufzurufen - die Methode tut imho. dann "zu viel".

Wie macht ihr Validierung von Domain Objekten?
Soll man den Validate() Aufruf dem Client überlassen + damit Verantwortung abgeben, oder Validate() selbst aufrufen und damit die Einschränkung treffen, dass Objekte nicht immer gespeichert werden können, sondern diese "valid for save" sein müssen...was aber auch wieder contextabhängig ist.

Die Validierung von GUI Objekten ist dann ja noch eine "eigene Sache" - sollen diese die Validierung der Domain Objekte verwenden?
Soll man hier eine eigene Valdierung implementieren? (Imho. ja, da man hier dann Validation Results zurückgeben kann + an Error-Provider binden).

Hab da schon einiges gelsen, bin aber noch zu keiner finalen Überzeugung gekommen, wie man es wohl am sinnvollsten machen sollte, daher die Frage: Wie macht ihr das in euren Projekten?

thx
hannes

hi,

DAL ist imho. die Schicht, welche die Daten gem. Repository Pattern bereitstellt. D.h. die Datenbank sieht dann so aus wie eine Liste, der man Einträge entnehmen, hinzufügen, suchen, ... kann. Sie abstrahiert den DB Zugriff. Ich kann den DAL austasuchen gegen z.B. Objekte im Speicher (was Mocks auch machen), ohne dass der Rest der BL was davon merkt.

Das Model im MVVM ist eine Klasse, welche Daten enthält.
Das könnte z.B. die Klasse aus deinem Domain Model sein. Es könnte aber auch eine eigene GUI Klasse sein. Dann benötigst du allerdings DTO's, welche die Daten zwischen GUI Klasse und Repository abgleichen.

So ist meine - derzeitige - Sicht der Dinge. 😉

Blog kenn ich dazu keines, aber ich kann dir das Buch "Applying Domain Driven Design and Patterns With Examples in C-Sharp" empfehlen. Ist nicht direkt über MVVM aber über DAL + Domain Objekte.

MVVM ist ein Pattern, um Logik vom GUI zu trennen, so hab ich das gemeint, dass es nichts mit DAL zu tun hat.

fg
hannes

hallo,

die übliche Vorgangsweise bei größeren Projekten ist gem. "Domain Driven Design", du hast deine Domain Objekte, welche die Aufgabenstellung in Klassen abbilden. Der DAL ist üblicherweise mit einem O/R Mapper realisiert z.B. nHibernate. Je nachdem, wie dann deine Anforderungen sind, kann es noch DTO Objekte oder GUI Objekte (welche z.B. "Notify Property Changes" impl.) geben.

So eine generell richtige Vorgehensweise gibt es da imho. nicht. Hängt wesentlich von Projektumfang ab.

ABER: Das ganze hat nicht unbedingt mit MVVM zu tun. MVVM ist ein Pattern, welches die Vorteile aus MVP mit den Möglichkeiten das Databindings zu kombinieren versucht.

fg
hannes

hallo,

@winSharp93: Danke für den Hinweis, das kannte ich auch nicht!

Ist auch unter Windows XP verfügbar, ist eine .net 3.0 Assembly: "...\Framework\v3.0\System.Speech.dll"

fg
hannes