Danke für dein Feedback

Das mit den Namespaces ist tatsächlich noch eine sehr alte und eigenwillige Angewohnheit, bei der es auch mal an der Zeit wird, sie an den Nagel zu hängen. Die Grundregel ist eigentlich ganz einfach, Ordner mit _ vorne dran zählen nicht als eigener Namespace.
Mal gucken, vielleicht ändere ich das direkt mal in der nächsten Zeit. Ist ja grundsätzlich nicht so wild.

Beim Thema SourceGenerators bin ich ganz bei dir.
Ich verfolge das Thema auch seit diesem Post im .Net Blog und finde es sehr spannend. Ich sehe dafür auch einige Anwendungsfälle, ganz unabhängig von der Serialisierung.

Bei der Library MessageCommunicator ging es mir zunächst darum, den Code so zu schreiben, damit möglichst wenig allokiert und möglichst selten mit locks gearbeitet wird. Das Thema Cross-Plattform Testtool (mit GUI) kam dann eher so nebenbei rein. Insbesondere deswegen, weil ich von Avalonia sehr positiv überrascht war und weil ich tatsächlich so ein Tool immer wieder mal brauche. Es steckt aber viel Spielerei drin, was gar nicht so dringend notwendig ist. Zum Beispiel verschiedene Themes, automatischer Wechsel zwischen Hell und Dunkel auf Windows, überall Eingabevalidierung, integrierte Markdown-Dokumentation, etc.
Für mich war das in Summe schon sehr spannend, da ich in den letzten 13 Jahren primär auf Windows unterwegs war.

GitHub
github.com/RolandKoenig/MessageCommunicator

Das Projekt
Dieses Projekt ist aus der Idee entstanden, ein Set an Klassen für einen einfachen TCP/IP basierten Nachrichtenaustausch mit den neusten Mitteln aus .Net Core zu machen. An sich nichts Weltbewegendes, es war von Anfang an mehr als Übung gedacht. Mit der Zeit ist das Projekt aber schon etwas gewachsen und eine Cross-Plattform fähige GUI drum herum entstanden. Für den einen oder anderen ist es dadurch sicher ein gutes Testwerkzeug.
Die Konkrete Funktion: In meinem Umfeld habe ich oft damit zu tun, dass mittels einfacher Nachrichten über TCP/IP kommuniziert wird. Die Erkennung von Nachrichten im TCP/IP Datenstrom erfolgt dabei mit Regeln wie „Endekennzeichen“, „Feste Länge“ oder „Längenangabe in der Nachricht“. Der Message Communicator macht genau das, man kann eine oder mehrere Verbindungen definieren und je Verbindung das Nachrichtenformat festlegen. Anschließend kann man bei erfolgreichem Verbindungsaufbau mit der Gegenstelle „chatten“. In Summe ist es als Testprogramm gedacht. Bei den Verbindungen wird folgende Funktionalität unterstützt:*Unterstützung Passiv/Aktiv: Warten auf Verbindungsanfrage von außen auf bestimmten Port / Aufbau einer Verbindung zu einer fremden IP-Adresse und Port *Unterstützung TCP oder UDP: Modus kann einfach in der Konfiguration umgestellt werden. *Einzelne Verbindung: Trifft eine neue Verbindungsanfrage an einem Port ein, so wird die vorherige als ungültig erklärt (gilt für passiven Modus) *Timeouts: Trifft über eine gewisse Zeitspanne keine Nachricht von der Gegenseite ein, so wird die Verbindung automatisch abgebaut und ein neuer Verbindungsaufbau versucht *Flexible Nachrichtenerkennung: Die Logik zur Erkennung einer Nachricht kann flexibel konfiguriert werden. Z. B. Erkennung einer Nachricht auf Basis eines Ende-Kennzeichens oder einer festen Länge. *Automatischer Reconnect: Sobald ein Verbindungsprofil gestartet wurde, kümmert es sich automatisch um den Verbindungsaufbau und um ggf. notwendige reconnects.

Neben der GUI steht die Funktionalität dahinter aber auch in einer Library per Nuget zur Verfügung. In der Readme auf Github sind entsprechend zwei kurze Beispiele.

Technologie
Unabhängig von der reinen Funktion ist das Projekt sicher auch von der Technologie her interessant. Die GUI basiert auf Avalonia und läuft damit auf Windows, Linux und macOS.Wer es nicht kennt: Avalonia ist ein OpenSource-Framework und ähnelt sehr stark WPF. Während der Arbeit an diesem Projekt war ich von der Stabilität und dem Reifegrad des Frameworks sehr überrascht – abgesehen von einigen kleinen Ecken und Kanten natürlich. Als Runtime verwende ich aktuell .Net Core 5.

Download
Das Programm kann man sich direkt von GitHub bei Releases runterladen oder auch über den Windows Store installieren (?? App „Message Communicator“).

Nächste Schritte
Ich selbst habe momentan das meiste eingebaut, was ich brauche. Gerne könnt ihr euch das Projekt bei Interesse anschauen und Rückmeldung geben.

Da du auch mobile Plattformen im Blick hast, würde ich hier an deiner Stelle auch eher Web bzw. genauer ASP.Net Core Blazor anschauen (auch die anderen ASP.Net Core Technicken sind sicher interessant für dich, z. B. Razor Pages)

Rein von Desktop-Seite her könnte hier hier ggf. noch Avalonia mit reinbringen. Hierbei handelt es sich um ein OpenSource UI-Framework, was sehr stark an WPF erinnert und Crossplatform fähig ist. Ich arbeite derzeit sehr gerne damit, hat gefühlt einen hohen Stabilitätsgrad und läuft auf Windows, Linux und Mac.

Grundsätzlich verhält es sich so, wie Abt schon schreibt. WPF und RealTime-Rendering ist eine ganz eigene Geschichte.

Wenn du es trotzdem probieren willst:

• WriteableBitmap ist dein Freund
• Je höher die Auflösung, desto eher bekommst du FrameDrops rein

Besser als mit WriteableBitmap ist es mit Direct3D Interop - aber auch deutlich komplizierter. Und auch hier kommst du früher oder später an die von Abt beschriebenen grenzen.

Hallo trex0113,

schau dir am besten Libraries wie *Html Agility Pack - https://htmlagilitypack.codeplex.com *AngleSharp - https://github.com/AngleSharp/AngleSharp

an.

Da wäre ich beinhart, wenn er sich beschwert soll er dir den Fehler vorlesen. Wenn kein Fehler mehr da ist, warten wir bis zum nächsten mal.

Und wie oft lest du Fehlermeldungen, ohne sie vorher wegzuklicken? 😉

Ganz im Ernst: Nach meiner Erfahrung ist es eher ein Standardverhalten, Fehlermeldungen wegzuklicken. Das beobachte ich an mir selbst und meinen Kollegen auch immer wieder. Wie soll man es dann vom Benutzer erwarten?

Das Problem löse ich folgendermaßen:

• Unabehandelte Ausnahmen werden sowieso immer weggeloggt.
• Da das Logging selten gelesen wird oder man über Fehlermeldungen auch nicht immer informiert wird, ist eine automatische Benachrichtigung zu empfehlen (zumindest falls möglich). Bei Entwicklungen für interne Kunden sollte das z. B. meist möglich sein, dass man sich bei einer unbehandelte Ausnahme automatisch direkt eine EMail mit Stacktrace und allen relevanten Informationen zuschickt. Sowas in C# zu bauen ist kein wirklicher Aufwand, der Nutzen aber immens.

Hi
ich habe auch ein Modell mit 8 GB Speicher und i7.
Meine Hobby-Projekte kann ich super mit VS 2015 drauf entwickeln. Die größeren Projekte aus der Arbeit würden aber nicht so leicht gehen - hängt denke ich daher von der Projekt-Größe ab. Hier stecken aber auch viel mehr Projekten in der Solution und die Quellcodezeilen gehen in den oberen sechsstelligen Bereich.

Viele Grüße
Roland

Hi,

schau dir mal diese Methode hier an:
Rectangle.Intersect

Gruß

Ich würde sagen, du lest dir die Dokumentation zu object, dynamic und var durch. Dazu noch ein paar Testprogrämmchen und du verstehst recht schnell, wo die unterschiede sind. Das Thema dynamic kannst du wie Abt schon geschrieben hat eher mit Low-Prio behandeln. Selbst var ist eigentlich nicht so wichtig, kommt aber bei je nach Stil des jeweiligen Entwicklers mal öfters, mal weniger vor.

Hi,
hab auch ein Fernstudium gemacht und meine Bachelor-Arbeit war kurz gesagt ein Softwarevergleich. Dazu gehörte dann Aufnahme von Anforderungen, Marktanalyse, Aufstellung von Bewertungskriterien, was macht die Konkurrenz? etc.
Hierzu gibt es auch jede Menge Literatur, welche man als Quellen verwenden kann.

Vom wissenschaftlichen Charakter her hatte ich dabei mit dem Prof nie ein Problem.

Viele Grüße
Roland

Die Kernfunktion ist klar das 3D-Rendering.
Über ein Aufsplitten des Projekts habe ich auch schon ein paar mal nachgedacht. Der Hintergedanke bei mir ist/war aber ein anderer. Und zwar stört mich etwas, wie viel andere Abhängigkeiten man bei einem breit aufgestellten Projekt mitzieht. Bin da immer wieder am überlegen, wo sinnvolle Grenzen sind. Der Kern-Sachen, also Direct3D und Direct2D, gehören aber schon direkt rein. Vor allem Direct2D ist hier sehr interessant, da man damit direkt ohne großartige Zeitverluste den Inhalt von Texturen umzeichnen kann.

Sollte ich aber eine Win2D Integration bauen, wäre das für mich schon eher in einer eigenen Assembly drin. Was ich auch schon länger am überlegen bin, ist ein Renderer für Html-Inhalte direkt in Seeing# zu machen. Hintergrund ist, kleine Benutzeroberflächen auf Texturen zu klatschen - was man damit dann relativ einfach hinbekommen würde. Auch hier wäre es eine eigene Assembly.

Thema Win2D: Einen Hinweis darauf hab ich schon ein paar mal bekommen, habe mich selber aber noch nicht viel damit beschäftigt. Es müsste sich eigentlich sehr einfach integrieren lassen, allerdings nicht für den Desktop-Build, da Win2D ja meines wissens nur für Store Apps ist.

Eine berechtigte Frage, bei der ich auch etwas weiter ausholen muss.

Zunächst, warum ich Seeing# entwickle:
Beruflich mache ich überwiegend (3D-)Simulationssoftware, privat bastle ich viel im Gaming Bereich rum. Mit Seeing# hatte ich im Ursprung nie das Ziel, es als Library zu veröffentlichen, es war mehr eine Art Experimentier-Projekt. Anfangs für Direct3D 10, danach für Direct3D 11. Step by Step habe ich es dann auch für eigene kleine Spiele-Projekt verwendet, wobei diese mehr den Fokus hatten, bestimmte Sachen für meine beruflichen Tätigkeiten auszuprobieren. Die Features, die ich einbaue und an denen ich arbeite, entstehen aber mehr aus den Bedürfnissen aus dem beruflichen raus. Das merkt man auch sehr schnell, denn wer braucht im Gaming z. B. einen Softwarerenderer oder Unterstützung für WPF. So typische Gaming-Sachen wie der XBox Controller sind eher die Ausnahme... ^^

Thema Zielgruppe
Mittlerweilse ist aus dem granzen Projekt schon eher was geworden, was man gut Library nennen kann, daher auch die Veröffentlichung hier. Die Zielgruppe ist für mich weniger das Gaming - wenn, dann eher wie bei mir zum Experimentieren. Die Zielgruppe sind eher professionelle Anwendungen, die die gebotenen Techniken benötigen. Ein Blick auf die Features offenbart das auch:

Klar, du kannst Direct2D oder die anderen Punkte auch anderweitig mit anderen Libraries haben. Aber schau mal zum Beispiel auf das Feature, dass du beliebig viele Views über beliebig viele Grafikkarten verteilen kannst. Hintergrund davon ist, dass du z. B. einen Visualisierungs-Rechner hast, der > 4 Monitore mit verschiedenen Views der 3D-Welt versorgt.

Ein anderer Punkt ist die Unterstützung des Software-Renderers. Das sorgt dafür, dass alles, was Seeing# bietet, auch ohne Probleme auf virtualisierten Umgebungen läuft. In der Vergangenheit (vor zig Jahren) hab ich da z. B. mit WPF3D bzw. dem HelixToolkit rumgespielt, und genau hier hatte ich damit Probleme.

Das Thema MediaFoundation hat z. B. das Ziel, die Frames aus einer beliebigen View direkt in eine Video-Datei (z. B. mp4) mitzuschreiben.

Und nicht zu unterschätzen ist das Thema Multithreading. Spätestens wenn du große 3D-Szenen hast, ist das extrem wichtig. Alles, was du mit Seeing# machst, läuft in Hintergrund-Threads. Und das auch auf jeder unterstützten Platform.
Wer schon einmal versucht hat, Direct3D Inhalte in WPF einzubinden, weiß, dass das nicht so trivial ist.

Mein Ziel mit Seeing#
Nun wieder zurück, was ich damit eigentlich will. Das Thema OpenSource habe ich deswegen gemacht, um evtl. den Einen oder Anderen zu finden, der daran ebenfalls Interesse hat und das Projekt auch ein Stückchen mit treibt. Weiterhin kann der Quellcode auch Inspiration für andere sein, die an der einen oder anderen Stelle ähnliche Probleme haben, wie ich sie hatte.

edit:
Noch eine ganz wichtige Unterscheidung zu anderen Engines ist, dass Seeing# von Anfang an dafür gedacht war, sich in die Oberflächen-Frameworks einzubinden. Egal ob ich jetzt in Win.Forms, WPF oder im Windows Store unterwegs bin. Ich zieh 1 bis X RenderPanels rein, und die 3D-Engine rendert da rein. Alles andere an UI Logik wird über die normalen Steuerelemente gemacht. Weiterhin gibt es verschiedene Mechanismen, um die Logik innerhalb des Renderings/der 3D-Welt mit der Logik der UI zu synchronisieren.
Gaming Engines dagegen sind nach meiner Erfahrung häufiger primär darauf ausgelegt, dass du eine große View hast, in der gerendert wird und bauen darin ein eigenes UI-Framework nach.

Irgendwo kann man den Ansatz von Seeing# auch mit dem HelixToolkit vergleichen. Zwar ist die Integration mit Xaml/WPF lange nicht so stark, aber auch das HelixToolkit zielt eher auf professionellen Einsatz als auf Games.

Hallo zusammen,

ich möchte hier ein OpenSource Projekt vorstellen, an dem ich jetzt seit mehreren Jahren nebenbei arbeite und in vielen meiner Apps verwende. Es nennt sich Seeing# und ist im Kern eine Multimedia-API mit starken Fokus auf 3D-Rendering. Hier direkt ein paar Features:

• Integration in Windows.Forms, WPF und Windows Store Apps (bzw. Universal Apps)
• Support für Windows 7 (mit Platform Update)
• Support ansonsten ab Windows 8 und Windows Phone 8.1
• Komplett Multithreaded (alle Berechnungen und Rendering in Background-Threads)
• Ansteuerung mehrerer Grafikkarten gleichzeitig
  (pro View kann unterschieden werden, welche Grafikkarte diese rendern soll)
• Beliebig viele Views parallel
• Ein paar Postprocessing Effekte
• 3D-Rendering basiert auf Direct3D 11
• Volle Unterstützung für den Software-Renderer (WARP)
• Integration von Direct2D
• Integration der Media Foundation (Videos lesen / erzeugen)
• Dann noch so Sachen wie XBox-Controller, Audio-Unterstützung usw.

Der Quellcode liegt auf GitHub und ist unter LGPL (kann also auch kommerziell verwendet werden, ABER: Änderungen am Quellcode müssen ebenfalls unter gleicher Lizenz veröffentlicht werden):
https://github.com/RolandKoenig/SeeingSharp

Projekte und Beispiel-Apps findet ihr auf meiner Homepage (www.rolandk.de/wp). Zusätzlich hab ich mittlerweile auch eine Beispiel-App im Store von Windows 10 (Link zum Windows Store)

Ich veröffentliche das Projekt hier, um den ein oder anderen Interessentan an dem Projekt zu finden. Auch für Ideen, in welche Richtungen man so etwas weiterentwickeln kann, bin ich immer offen.
Aktuell stehen zum Beispiel folgende Sachen auf meiner TODO-Liste:

• Import von 3D-Modellen aus verschiedenen Formaten
• Skelett-Animationen

Viele Grüße
Roland

Naja..
Datei und Ordner kannst du ja nennen, wie du möchtest. Muss ja nicht zwingend irgendwas mit deinem Programm-Namen zu tun haben.
Und der Dateiinhalt kann ja auch verschlüsselt sein (per GZip-Stream oder sowas).

Und C:\ProgramData ist auch ein versteckter Ordner.
Die meisten (normalen) User finden den somit sowieso nicht.

Edit:
Was aus meiner Sicht viel interessanter ist, ist die Frage, wie man mit dem Ändern der Rechner-Uhr umgeht. Denn das probieren die meisten und schafft auch Otto-Normal-User.
Also eigentlich zwei Frage (1. wie erkennt man das und 2. wie reagiert man).

Hallo C4RL0,

wie wäre es mit C:\ProgramData?
In dem Ordner kannst du mit jedem Benutzer schreiben und ist eben für Anwendungspezifische Daten da.

Den Pfad bekommst du mit:

Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)

Die Konsolenausgabe in der WPF wird in Visual Studio unter Ausgabe ausgegeben.

Das wird es wohl sein.
Mir ist auch schon einmal aufgefallen, dass diese Umleitung in die Visual Studio Ausgabe eher bremst. Bei einigen Zeilen kein Problem, aber bei 26T sicher etwas anderes..

Wenn du die Exe unabhängig von VS startest, gibt es diese Umleitung entsprechend auch nicht und somit läufts dann genauso schnell

Hi Tubifex,

wenn ich mir deinen Text so ansehe, hast du dich schon etwas mit 3D beschäftigt.
Von den Standard-Funktionen von WPF kann ich dir wie Abt und MrSparkle abraten, da stößt du relativ schnell an Grenzen. Helix ist definitiv ein gutes Projekt, mit dem du einstigen kannst. Dort sind auch einige Algorithmen für Triangulation usw. drin, könnte mir vorstellen, dass es da auch schon Standards für Verformungen o. Ä. gibt. Ich persönlich habe mit Helix aber bis jetzt weniger gemacht.

Wenn du voll auf DirectX gehen willst (aufgrund Performance etc.), kann ich dir auch mein OpenSource-Projekt Seeing# vorschlagen (schau einfach auf meine HP). Allerdings sind genau die Features, die du suchst, dort aktuell nicht umgesetzt.

Viele Grüße

super, danke direkt für die Tipps 😃

Ich schau mir die Sachen direkt mal an. Generell habe ich kein Problem damit, ein paar Euros (.. im Monat/Jahr) dafür auszugeben, wenn es dadurch an der Stelle "sauber" wird - die Homepage z. B. kostet ja auch was.

Noch ein kleiner Nachtrag:

• Habe wie oben von Abt beschrieben ein Open Source Zertifikat angelegt - Kostenlos und einfache Validierung
• Über Visual Studio 2013 Projekteinstellungen -> Signierung eingespielt
• Ergebnis: Noch nicht viel anders wie ganz oben, einzig das Herausgeberfeld ist damit korrekt gefüllt.

Per Pluralsight bin ich dann auf folgenden Link gestoßen:
https://robindotnet.wordpress.com/2013/02/24/windows-8-and-clickonce-the-definitive-answer-2/

Das Zertifikat oben wird nach wie vor benötigt. Was über den Visual Studio Weg aber noch fehlt, ist die Signierung der Exe selbst. Nachdem ich die Schritte wie in obigen Artikel beschrieben gemacht habe, war die Meldung bei der Installation weg.

PS.: Der Name der Technik hinter der ursprünglichen Fehlermeldung (siehe ganz oben, erster Post) ist "SmartScreen Filter". Dies ist ein Feature von Windows 8/8.1. Wenn man danach in Google sucht, findet man genau die Informationen, die man braucht.

Hallo zusammen,

ich habe heute begonnen, bei meinem OpenSource-Projekt FrozenSky die Beispiel-Programme zu überarbeiten und entsprechend als Download auf meiner Homepage bereitzustellen. Bei letzterem bin ich jetzt den Weg per ClickOnce gegangen, da es an sich eher unkompliziert funktioniert und eine Auto-Update Funtion bietet.

Mein Problem oder die Unschönheit bei dem Ganzen ist das Thema "Unbekannter Herausgeber". Wegen dieser kleinen Sicherheitshürde muss der Benutzer bei Windows 8 1-2 Mal bestätigen. Und die Bestätigung blöderweise so, dass man diese auch erst auf den zweiten oder dritten Blick sieht. Im Anhang ein Screenshot von dem Dialog, den ich hier meine.

.. wenn man die Farben bei Windows so eingestellt hat, wie ich, ist es wie man sieht sogar doppelt Blöd, da man den ersten Link "Weitere Information" nicht einmal richtig sieht.

Jetzt habe ich deswegen mal ein bisschen gegoogelt und bin entsprechend auf Zertifikats-Anbieter gestoßen, wie diesen hier. Nun kostet der Spaß so 170€ im Jahr... jetzt zwar nicht unbezahlbar, man frägt sich aber, ob es nicht noch andere Varianten gäbe? Welche Erfahrungen habt ihr bei diesem Thema?

Viele Grüße
Roland

Hi,

war ZXing keine Alternative?
=> https://zxingnet.codeplex.com

Hätte ich zwar noch nicht oft verwendet, aber bisher keine Probleme damit gehabt. Und läuft natürlich auch Offline.

Hallo zusammen,

das Thema hat sich erledigt.*Die Beispiele der MediaFoundation kann man mit dem Windows 7 SDK installieren und laufen auch super auf Windows 8.1

• Mein Fehler: Die Farbwerte vom Video wurden korrekt ausgelesen, Problem war nur, dass Media Foundation die Alpha-Werte nicht überschreibt und damit so lässt, wie sie vorher waren (=> Bei einem neuen Buffer 0). Beim Debuggen habe ich leider nur auf den ersten Wert geschaut und somit ist mir das nicht aufgefallen. Wenn ich nun den Speicherblock in ein Bitmap konvertiert habe, war jeder einzelne Pixel vollkommen Transparent.

edit: Gerade die aktuelle Version auf Github hochgeladen, mit meinem Beispiel Wmv-File läuft der Test jetzt sauber durch.

Gruß und Danke
Roland

Hallo zusammen,

seit einigen Tagen versuche ich jetzt, per Media Foundation (über SharpDX) Frames aus einem Video (erst mal wmv-Format) in den Hauptspeicher zu lesen. Das aktuelle Coding dazu könnt ihr euch hier auf GitHub anschauen: MediaFoundationVideoReader. Mein Quellcode basiert dabei großteils auf diesem Beispiel von MS: Using the Source Reader to process media data

Eigentlich würde es ja gut aussehen.. der SourceReader ließt jeden Frame, ich bekomme einen Buffer, Auflösung passt, Anzahl der Frames passt usw.. ABER: In jedem gelesenen Frame ist im Speicherblock (->MediaBuffer) jeder Byte auf 0.

Wer es ausprobieren möchte:
Im Projekt FrozenSky.Tests.Rendering ist ein Test per XUnit kodiert (Methode ReadSimple_WmvVideo), welcher eine Beispiel WMV-Datei lädt und das 10. Frame einfach auf den Desktop schreibt. Später soll das dann mit einem Referenz-Bild verglichen werden, aber zum Testen schreibe ich das erst einmal auf den Desktop.

Was ich schon probiert habe und wo ihr mir evtl. helfen könnt:*Relativ viel mit den Parametern rumgespielt und auch versucht, einige Hinweise aus dem Internet anzuwenden (siehe Kommentare im Code) *Tja, Google suche.. seltsamerweise hätte ich aber genau ein solches Problem nirgends gefunden *Es gäbe eigentlich noch ein Beispiel im Windows SDK (VideoThumbnail), welches genau das macht, was ich möchte. Einen Download oder ähnliches kann ich aber leider nirgends mehr finden. Der Downloadlink unten auf der Seite geht (zumindest heute früh) bei mir auch nicht. Weiß jemand, wohin Microsoft die Beispiele verschoben hat?

Viele Grüße
Roland

Hi,

cool sind die Teile schon.
Allerdings würde ich den Begriff "Wearables" nicht nur auf die Uhren beziehen, sondern zum Beispiel auch auf Smart Glasses wie die M100 / BT-200 oder sowas.

Privat nutze ich die Sachen nicht wirklich, vor allem auch, weil ich mir fürs Laufen schon länger eine spezielle Uhr dafür gekauft habe. Aus Business-Sicht sind die Sachen aber aktuell schon sehr interessant, da sie eine direkte Interaktion mit dem User ermöglichen. Programmieren ist an sich auch einfach, da die meisten auf Android-Systeme ohne großartige Spezialitäten setzen.

Bin aber gespannt, was sich aus diesem noch jungen Bereich alles so entwickelt.

Viele Grüße
Roland

Hi MrSparkle,

reichen würds schon..
Das wäre dann wohl eine weitere Variante, einfach per Blend einige Übergangs-Animationen bauen.

Die Sachen mit den Shadern schauen halt z. T. schon geil aus und lassen sich so mit WPF- oder WinRT-Standardmitteln nicht direkt machen (zumindest nach meinem Wissenstand). Bei den Shader-Beispielen sind so Sachen drin, wie*Bild löst sicht langsam auf (nicht linear) *Bild läuft wie eine Flüssigkeit langsam nach unten *Bild verpixelt langsam *...

Das Channel9-Video oben zeigt es eigentlich nicht so schön, wie das Quellcode-Beispiel, welches man mit dem Codeplex-Projekt runterladen kann. Ma gucken, evtl. komm ich die Woche dazu, und mach am Arbeits-Laptop mal ein kleines Video und lade es hier hoch.

So dumm wies klingt, im Moment bin ich schon am überlegen, wie viel Aufwand es mir macht, die Sachen in meine 3D-Engine als Postprocessing-Effekte einzubauen. An anderen Stellen kann man diese ja auch gut verwenden. Vorteil: Dann wäre es grundsätzlich egal, ob ich auf Win.Forms, WPF oder WinRT aufsetze.

Edit:
Eine weitere Idee wären natürlich noch die in Direct2D integrierten Effekte (Siehe Msdn). Da scheinen ne ganze Menge sinnvolle enthalten zu sein und der Aufwand, diese zu integrieren, ist eigentlich auch relativ gering. Und natürlich (Windows-)Plattformneutral.

Gruß
Roland

Hallo zusammen,

aktuell bin ich darüber am Grübeln, wie ich in eine Multimedia-Anwendung einige hübsche Übergangseffekte einbauen kann. Im Prinzip habe ich eine Liste an Bildern, welche animiert von Bild zu Bild schalten soll und evtl. auch ein paar Text-Elemente oder ähnliches mit drin hat. Nichts besonderes also.. oder mit anderen Worten: Sowas, was man mit Power-Point und den enthaltenen Übergangseffekten auch recht schnell basteln kann.

Richtig cool finde ich die Sachen, die hier aufbauend auf WPF / PixelShadern gebaut wurden:
https://wpffx.codeplex.com/
http://channel9.msdn.com/shows/Continuum/WPFFXDemo/

Jetzt sehe ich mehrere Möglichkeiten, diese Sache umzusetzen:*Auf Basis der WPFFX Library
Dieser Weg erscheint mir erst einmal sehr einfach. Die Library funktioniert mit .Net 4.5 auch noch, scheint mir leicht anzuwenden zu sein und integriert sich einwandfrei in den Xaml-Stack. Was ich hier noch testen müsste, ist, ob das ganze auch sauber ohne Hardware-Beschleunigung funktioniert (da Verwendung von Shadern). Ein weiteres Problem.. oder naja.. wenn man es Problem nennen will.. ist die Fixierung auf WPF. Eigentlich wäre es cool, diese Sachen auch in WinRT machen zu können, da dann verteilbar über den Windows Store.

*Auf Basis der Transitions von WinRT
WinRT hat diesen Mechanismus ja sowieso von Haus aus drin, allerdings bekommt man damit solche Effekte wie im Video oben nicht direkt hin. Ich vermute, die Technik in WinRT baut auf DirectComposition auf? (berichtigt mich, wenn ich falsch liege). Ich stelle es mir schwer vor, hier mit einem C#-Programm korrekt anzuknüpfen und damit eigene Transition-Effekte zu machen.

*Shader-Effekte in WinRT
Wirklichen Support dafür gibt es ja nicht, aber Jeremi Ahmorrill scheint einen halbwechs sinnvollen Weg gefunden zu haben (https://xamlfx.codeplex.com/). Hier auch der Blog-Post dazu: https://jeremiahmorrill.wordpress.com/2013/11/22/pixel-shaders-for-xaml-windows-runtime/ *Über meine eigene 3D-Engine
Als letzten Weg könnte ich die Sachen auch in meine eigene Engine (FrozenSky) einbauen, allerdings stelle ich mir das fast als aufwändigsten Weg vor. Vorteil wäre dann natürlich, dass das auf jeder Plattform und auch im Software-Renderer sicher laufen würde. *Ganz einfach über Videos
Natürlich gibt es da noch den Ansatz, aus den Sachen gleich vorab ein Video zu machen (Powerpoint aufnehmen) und dann abspielen zu lassen.. ^^ Dynmik ist dann halt weg.

An euch wollte ich an dieser Stelle die Frage stellen, ob ihr noch andere Ideen hättet, um an eine solche Sache ran zu gehen.

Viele Grüße
Roland

hm.. keine leichte Fragestellung.

Ich könnte mir jetzt schon einige automatisierte Tests vorstellen, um deine Logik abzusichern (ich spreche aber explizit nicht von UnitTests). Du hast doch sicherlich verschiedene KI stärken? Sprich: Leichte KI findet schlechtere Lösung als eine Schwere KI. In einem automatisierten Tests könntest du virtuell KI gegen KI antreten lassen und davon ausgehen, dass KI mit geringerer Schwierigkeitsstufe immer gegen eine KI höherer Schwierigkeitsstufe verlieren müsste.. alles andere sollte ja rein theoretisch nicht möglich sein, zumindest, wenn die Bewertungs-Logik sauber ist.

Eine Prüfung in der Testautomatisierung kann auch sein, dass bei einem solchen automatischen Lauf eine utopische Anzahl X an Zügen nicht überschritten werden darf.
.. oder ähnliche andere Prüfungen, welche man per Code ausdrücken kann.

Alles solche Sachen, welche ärgerlich wären, diese auf manuellem Weg zu finden.

Wie aber auch die vorredner schon schreiben... ob eine schwere KI wirklich schwer ist, lässt sich auch in meinen Augen deutlich schwieriger verifizieren. Es ist ja auch irgendwo subjektiv, denn der Schwierigkeitsgrad hängt ja immer von der Erfahrung des Spielers ab. Da würde ich jetzt eher wieder empfehlen, ab einem gewissen Stand viel mit anderen möglichen Spielern zu testen.

Hoffe, das hilft etwas weiter..

Viele Grüße
Roland

Hallo FZelle,

ich denke auch, dass du bei den Herstellern da wenig Probleme haben wirst. Wir haben bei uns öfters Testgeräte verschiedenster Hersteller und Produktkategorien rumliegen.

Viele Grüße
Roland

Hi,

schau dir SharpDX an:
http://sharpdx.org/

Da ist sicher was dabei und SDX steht auch unter MIT-Lizenz.

Gruß
Roland

Hallo BlackMatrix,

mit OpenCV haben wir von der Funktion her gute Erfahrungen gemacht, die Einarbeitungskurve ist aber leider sehr hoch. Es existiert zwar ein umfassender C#-Wrapper, man kommt aber leider nicht drum rum, sich tiefer mit dem Handling von nativen Ressourcen (Pointer, etc.) auseinanderzusetzen.

Viele Grüße
Roland

Hi,

für die Erzeugung des MSI-Paketes habe ich in VS2013 meiner Projektmappe ein "Visual Studio Installer - Setup Wizard"-Projekt hinzugefügt

Bin fast etwas überrascht.. dachte eigentlich, das Standard VisualStudio Setup geht mit VS2013 gar nicht mehr..

Ich persönlich verwende WIX. Dein anliegen kann ich verstehen, bei kleinen Projekten ist es häufig so, dass man eine durchgängige Versionsnummer haben will und diese nicht händisch an verschiedenen Stellen pflegen muss. Einen solchen Automatismus gibt es aber nach meinem Kenntnisstand auch nicht. Gründe hat oben schon Abt geschrieben.

In den letzten Jahren haben wir es so gehandhabt, dass wir bei jedem Release die Dateien händisch aktualisiert haben. Wichtig: Beschäftige dich neben den Versionsnummern auch mit Produkt- und Upgrade-Guids. Diese Sachen müssen korrekt aktualisiert werden, um auch das richtige Verhalten bei Upgrades oder Neuinstallationen zu haben.

Mittlerweile haben wir die Prozesse bei uns selber am Build-Server automatisiert. Per WIX tut man sich hierbei relativ einfach, weil die Datengrundlage leserliches XML ist. Wichtig ist aber auch hier genau zu definieren, was wann wo wie aktualisiert werden soll.

Viele Grüße
Roland

Moin,

das Gerät steht bei mir definitiv auf der Beobachtungsliste.
Habe mich schon das ganze letzte Jahr gefragt, wie wohl Microsofts Antwort auf Google Glass, Vuzix M100 und Konsorten sein wird. Das die was machen, haben mir schon verschiedene Quellen genannt.

Von mir also klar Daumen nach oben.

Letzten Endes möchte ich aber auch nicht zu viel Loben. Die anderen Datenbrillen aus den letzten zwei Jahren (Glass, M100, BT-200, etc.) hatten technisch noch klare Grenzen, ob Microsoft das besser hinkriegt, muss sich zeigen.

Viele Grüße
Roland

Hier muss ich nochmals einhacken:
Bei dem Beispiel-Coding von mir läuft er definitiv in das ex.Dump() und zeigt dort auch die Exception aus der GetString Methode an... Genau so kenne ich das Verhalten auch von anderen Programmen her.

Anbei noch ein Screenshot, bei dem man genau das sieht.

Hallo BlackMatrix,

eigentlich muss die Exception bei GetString durch das await abgefangen werden. Ich habe es jetzt in LinqPad ausgefährt (Nur MyObject und MyException ersetzt) und es funktioniert eigentlich ganz gut.

public async Task<object> GetObject()
{
    var obj = new object();
    string s = string.Empty;

    while (true)
    {
        try
        {
            s = await Task.Run(() => GetString());
            break;
        }
        catch (Exception ex)
        {
			ex.Dump();
			return null;
            // Versuche andere Einstellungen
        }
    }

    return obj;
} 

Die Exception im zweiten Teil wird sauber abgefangen und weggeschrieben. Passt.

Evtl. passt bei dir der Exception-Typ nicht?

Gruß
Roland

Hallo zusammen,

für so etwas einfaches würde ich jetzt auch nicht gleich auf DirectX zurückgreifen. Das ist fast wie mit Kanonen auf Spatzen schießen.. Vor allem, wenn man von DX noch keine Ahnung hat, kann das schnell ein sehr aufwändiger Weg werden.

Nutze doch den Performance-Profiler in Visual Studio, um deine Engpässe zu finden.

Spontan würde ich folgendes Untersuchen:*Wie schnell bekommst du die Bilder überhaupt aus der Quelle (=> ist die überhaupt schnell genug) *Wie effizient ist deine Konvertierung in ein Bitmap? *Wie schnell ist dein Draw? (auch hier kannst du optimieren)

Viele Grüße
Roland

Hallo zusammen,

einen Linux-Support würde ich auch ganz interessant finden. Wir haben auch schon vor ein paar Jahren überlegt, einen Teil unserer Software auf Linux/Unix-Systeme zu portieren. Damals war eine (neu-)Entwicklung in Java oder Mono im Gespräch. Das Thema hat sich aber damals in Luft aufgelöst..

Das interessante wäre, für welche Plattformen auf Linux/Unix offiziell Support gegeben wird.

Microsoft verkauft von Suse die Enterprise Lizenzen 😃

hm.. bei den Kunden, bei denen bei uns Linux-Support im Gespräch war, war Red-Hat oder HP-Unix im Einsatz.. 😉

Letzten Endes bin ich aber froh, das das aktuell (noch) gar nicht geht. Mehr Systeme bedeutet immer auch einen höheren Testaufwand. Und wenn ich mir die Vielzahl an Linux-Distros so anschaue, ist das sicherlich nicht zu unterschätzen.

Davon abgesehen finde ich die aktuelle Marschrichtung von .Net sehr gut. Den OpenSource-Compiler Roslyn verwenden wir beispielsweise heute schon in unserer Scripting-Umgebung und sind sehr begeistert davon.

Viele Grüße
Roland

Hallo zusammen,

ich habe das Thema auch schon mal relativ einfach gelöst: Einfach zum Programmstart ne Fake-Datei schreiben und direkt wieder löschen. Wenn das Klappt, hat man Schreibrechte.

Das Problem damals war eben das, dass bei fehlenden Schreibrechten das Programm zwar lief (=> Dateien vom Netzwerk lesen kann), spätestens wenn der Benutzer auf Speichern klickt aber das böse Erwachen kommt.

Wenn Du auf einen Netzwerkordner keine Rechte hast, dann siehst Du ihn in einem gut konfigurierten Netzwerk überhaupt nicht

Ein kurioser Fall, den ich da mal hatte: Wir konnten die Fake-Datei einmal schreiben, aber nicht wieder löschen. Letzten Endes hatten wir nur Schreib-Rechter aber z. B. keine Leserechte. Das zum Thema.. Admins wissen häufig auch nicht so genau, was sie da einstellen.

Viele Grüße
Roland