Wenn weiterhin 3DS Max + alles andere gleichzeitig laufen können soll, dann ja.

Ich habe den Kurs bei SGD gemacht (2008) und war damit im Wesentlichen ganz zufrieden. Es ist halt ein reiner Einstieg, das richtige Lernen ging erst danach los. Aber es werden einem alle Kenntnisse vermittelt, die man für den weiteren Aufbau benötigt.

Wertschätzung habe ich eigentlich relativ wenig dadurch erfahren. Es ist halt ein Kurs und damit hatte es sich schon. Wertschätzung habe ich nur für die Arbeit erhalten, die ich darauf aufbauend dann geleistet habe. Im Nachhinein hätte ich mir diese Kenntnisse aber tatsächlich auch mit einem guten Buch für 50-60 Euro aneignen können. Aber ja, auch ich bin öfters mal gern faul und brauche einen gewissen Druck dahinter, weshalb ich dennoch den Kurs gewählt habe. Auch die Möglichkeit mit den Einsendeaufgaben konkretes Feedback zu meinen Schwachstellen zu erhalten, war dabei ausschlaggebend.

Ah ok, ich würde mich also von einem ersten Zeichen ausgehend weiter durchtasten und das erste Zeichen verwerfen (+Matching von vorne), wenn es nicht passen sollte? Das sollte eigentlich machbar sein. Danke für den Anstoß 😉

Also, der Teil, den ich aus der OCR erhalte ist Teil eines Formulars. In diesem Formular ist ein Datum gedruckt im Format TTMMYY. Dazu ist aber auch noch alles mögliche andere aufgedruckt oder reingekritzelt. Daher soll das Datum irgendwie rausgehoolt werden aus diesem Zeichengewirr. Es gibt natürlich auch den Fall, dass etwas über das Datum gedruckt wurde, aber das sind jene Fälle, die ich ignorieren kann und muss. Allerdings habe ich auch in Ausnahmefällen schon gesehen, dass das Datum auch mit TT.MM.YY aufgedruckt sein kann. Diesen Spezialfall abzudecken wäre aber erst in der 2. Stufe interessant, da er wohl recht selten auftritt...

Daher dachte ich mir, dass ich diesen Regex ja von mir aus schon möglichst einschränken kann. Und zwar so:

1. Stelle: 0-3
2. Stelle: 0-9
3. Stelle: 0-1
4. Stelle: 0-9
5. Stelle: 1-2
6. Stelle: 0-9

Damit kann ich Datumsangaben bis 2029 abdecken, was die Laufzeit der Software wohl überschreiten würde. Evtl. kann ich aus 1-2 noch 1-3 machen an der 5. Stelle, dann wäre 2039 als Enddatum angesagt.

Wie gesagt, der Teil, den ich aus der OCR erhalte ist fix und daran kann ich am Code auch leider nichts ändern. Ebenfalls der Bildausschnitt, da der von dem Programm um die OCR herum festgelegt wird (sonst hätte ich versucht, diesen exakter um das Datumsfeld zu platzieren - aber da die Bedruckung nicht immer 100%ig platziert ist, wäre auch das erst mal problematisch).

In meinem Beispiel würde mit meinem Pattern allerdings die Zeichenkombination [lItl/x1i][1Itl/x][9oO030][0oO0][1Itl/x2][1Itl/x] gefunden. Nach Extraktion der jeweils ersten Zahl aus jeder Gruppe würde hier allerdings 119011 als Datum herauskommen. Die führende 1 kommt von erwähntem Gekritzel und unsauberem Bedrucken, die OCR kann das in bestimmten Fällen nicht unterscheiden.

Das Parsen schlägt logischerweise fehlt und ich habe kein Datum als Ergebnis. Es wird jetzt allerdings von der Regex-Klasse alles ignoriert, was bei einem vorherigen Match schonmal betroffen war. Die gesamte Gruppe vom ersten (falschen) Datum fliegt raus und aus dem Rest ergibt sich kein weiterer Match. Besser fände ich, wenn ALLE möglichen Matches aus dem gesamten Eingabestring gefunden werden würden - also [lItl/x1i][1Itl/x][9oO030][0oO0][1Itl/x2][1Itl/x] und [1Itl/x][9oO030][0oO0][1Itl/x2][1Itl/x][53S]. Bei letzterem würde das Parsen des Datums funktionieren und die Plausiprüfung (darf nicht in der Zukunft liegen) wäre erfolgreich. Ich hätte mein Datum.

Falls sich da von Seiten der Regex-Klasse nichts anbietet, werde ich halt den umständlichen Weg gehen und meinen Eingabestring so lange um je eine Zeichengruppe verkürzen, bis ich ein passendes Ergebnis habe (bis hin zu "Es gibt kein Ergebnis"). Möglich wäre zwar auch (in diesem Beispiel) den Regex von rechts nach links laufen zu lassen. Da finde ich zwar dieses Datum, allerdings kann mir dasselbe Problem natürlich auch hier in die Quere kommen.

Wie gesagt, war eher als Frage gemeint, ob ich da einfach was übersehen habe, was mir die Arbeit erheblich erleichtern könnte. Man lernt ja immer gerne mal was dazu. Aber im Zweifelsfall gehe ich halt den etwas holprigeren Weg und komme damit ebenfalls an mein Ziel 😉

Edit: Ja, Regex Studio ist bei mir immer in Gebrauch, da einfach bequemer. Vor ein paar Jahren noch habe ich mich gefragt, wozu man so ein Tool brauchen könnte, aber inzwischen will ich nicht mehr ohne 😉

Hi zusammen,

ich habe aus einer OCR eine Ausgabe erhalten, die wie folgt aussehen kann:

[cre][lItl/x1i][1Itl/x][9oO030][0oO0][1Itl/x2][1Itl/x][53S][HMNRBER][0oO0][HMNRBE2][HMNRBEK][0oO0][tItl/xi(][HMNRBEhbL]

Dieser Teil des Programms ist fix, ich kann da keinen Einfluss auf die Ausgabe nehmen. Nun habe ich aus diesem Kram (zwischen den Eckigen Klammern sind alle Möglichkeiten, die ein Zeichen laut OCR haben kann) mittels Regex ein Datum extrahiert. Der Regex sieht bisher so aus:

[[\w()/]{0,7}[0-3]{1}[\w()/]{0,7}][[\w()/]{0,7}[0-9]{1}[\w()/]{0,7}][[\w()/]{0,7}[0-1]{1}[\w()/]{0,7}][[\w()/]{0,7}[0-9]{1}[\w()/]{0,7}][[\w()/]{0,7}[1-2]{1}[\w()/]{0,7}][[\w()/]{0,7}[0-9]{1}[\w()/]{0,7}]

Funktioniert bei einem Großteil der Daten auch ganz gut. Allerdings in diesem Beispiel hier nicht, da dieser Regex auch ein "Zeichen" vorher matcht. Herauskommen würde dann 119011, was natürlich für ein Datum eher ungünstig ist. Einen weiteren Match gibt es allerdings nicht, da die gematchten Teile bei der weiteren Untersuchung nicht mehr berücksichtigt werden. Nun ja, klar könnte ich jetzt an dieser Stelle eine Datumsprüfung machen und anhang des Index des Matches dann einen neuen Eingabe-String bauen, auf den dann wiederrum geprüft wird usw. Aber ich frage mich halt, ob das nicht auch einfacher geht. Kann man dem Regex nicht irgendwie sagen, dass er auch bereits gematchte Teile für weitere Matches berücksichtigen soll?

Gruß

Ich sehe das ähnlich wie Abt, wer mit Programmieren seine Brötchen verdienen will oder auch etwas mehr hobbymäßig machen möchte, der muss der englischen Sprache mächtig sein. Für den einfachen Einstieg gibt es hunderte deutschsprachige Bücher und für etwas ambitioniertere Projekte muss man sich halt sprachlich weiterentwickeln. Zumal ich das Meiste als eher einfaches Englisch einstufe - die Beiträge sind selten in Prosa- oder Gedichtform oder auf Altenglisch verfasst, das kann man gut lesen, auch wenn man kein Muttersprachler ist.

Auch mich nicht falsch verstehen, ich bin oft dankbar für deutschsprachige Ressourcen zu einem bestimmten Thema. Aber gerade wenn es so richtig ans Eingemachte geht, dann gibt es eben nicht anderes als Englisch. Damit muss man sich einfach abfinden.

Wir haben inzwischen Obfuscatoren wieder abgeschafft und sind dazu übergegangen, uns ein paar Blackbox-Dlls in nativem C++ zu schreiben, die von C# angesprochen werden. Darin befindet sich essentielle Logik und an die kommt man dann nicht mehr ganz so einfach.

Für Obfuscation ist C# bzw. .NET einfach die falsche Adresse, das lässt sich in den meisten Fällen problemlos wieder in lesbaren Code umwandeln. Variablen umbenennen ist für einen geübten Entwickler pillepalle. Und wer dann gar noch mit IL-Code umgehen kann, dem ist die Verschleierung eh relativ egal.

Warum willst du es schwer machen, den Code zu verändern? Hat das einen bestimmten Zweck? Falls du Zugriff auf das Hauptprogramm und damit die Laderoutine hast, kannst du dir was überlegen mit Hashes den Code zu prüfen, ob er noch dem entspricht, was du geschrieben hast. Aber auch das dürfte nicht unglaublich schwer zu knacken sein. Ist halt so.

Bisher kein Weiterkommen über diesen Weg. Ich werde mir mal die Lösung anschauen, über eine Zwischen-DLL in C++/CLI zu gehen. Trotzdem danke schonmal.

Ich hab das vor einiger Zeit mal mit einer kleinen Struktur gelöst, als "Geht das überhaupt?"-Projekt. Vielleicht kannst du daraus was lesen, was dir weiterhilft.

static class Program
    {
        [DllImport("Unmanagedtest.dll", CallingConvention = CallingConvention.Cdecl)]
        unsafe public static extern int Modify(IntPtr taest);

        [DllImport("Unmanagedtest.dll", CallingConvention = CallingConvention.Cdecl)]
        public static extern int Multiply(int i, int j);

        unsafe static void Main(string[] args)
        {
            testgedings tast = new testgedings();
            tast.iArgh = 5;
            tast.iBrgh = 10;
            tast.strBla = "Sers";

            arr[] ah = new arr[2];
            ah[0] = new arr();
            ah[1] = new arr();
            ah[0].haha = 1;
            ah[0].strInner = "Ich bin 1";
            ah[1].haha = 2;
            ah[1].strInner = "Ich bin 2";
            tast.harr = ah;

            int size = Marshal.SizeOf(typeof(testgedings));
            for (int i = 0; i < tast.harr.Length; i++)
            {
                size += Marshal.SizeOf(tast.harr[i]);
            }
            IntPtr unmanagedAddr = Marshal.AllocHGlobal(size);

            Marshal.StructureToPtr(tast, unmanagedAddr, true);

            Modify(unmanagedAddr);

            Marshal.PtrToStructure(unmanagedAddr, tast);

            Marshal.FreeHGlobal(unmanagedAddr);
            unmanagedAddr = IntPtr.Zero;
        }
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class testgedings
    {
        public int iArgh;
        public int iBrgh;
        [MarshalAs(UnmanagedType.BStr, SizeConst = 100)]
        public string strBla;
        [MarshalAs(UnmanagedType.ByValArray)]
        public arr[] harr;
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class arr
    {
        public int haha;
        [MarshalAs(UnmanagedType.BStr, SizeConst = 100)]
        public string strInner;
    }

Die C++ Methode sah bei mir so aus:

int __declspec(dllexport) Modify(teststruct * tst){

std::wstring sr (L"Harlow!");
tst->iArgh = 299;
tst->iBrgh = 999;
tst->strBla = SysAllocString(sr.c_str());
arraydings ha;
ha.hirgl = 9999;
std::wstring si(L"Ich bin innen");
ha.strInner = SysAllocString(si.c_str());
tst->arr = ha;	

arraydings aha;
SafeArrayGetElement(tst->sfarr, 0, &aha);
std::wstring si1(L"Ich bin 1 NEU");
aha.strInner = SysAllocString(si1.c_str());
	
return 1;
};

Ich weiß, das ist furchtbar lesbar mit meinen Bezeichnern, aber ist jetzt halt rein aus unserem POC-Projekt rauskopiert.

String-Arrays aus C# haben wir auf C++ Seite immer als SAFEARRAY behandelt. Darin liegen BSTR-Objekte, mit denen man arbeiten kann.

Hallo zusammen,

mal wieder das leidige Thema COM-Interop/Schwarze Magie. Ganz grob zu meinem System: Wir haben eine große Warenwirtschaft, die in C++ mit der MFC geschrieben wurde. Aufgrund der teils nervtötenden Umwege, die man für viele Dinge gehen muss (die man aus .NET gewohnt ist), haben wir uns entschieden, diverse Sachen in .NET-Dlls auszulagern, also eigentlich in COM-Komponenten. Das funktioniert bei zwei Komponenten bisher ganz gut, da diese nichts weiter tun, als Daten aufzubereiten und darzustellen. So weit so gut.

Bei der jetzt geplanten Komponente sollen allerdings die Daten nicht direkt in der Komponente als Endstation abgelegt werden, sondern in der Warenwirtschaft weiter verwendet werden. Dazu sollen Strukturen hin und her geschubst werden (also C++-WaWi <-> .Net-Dll). Wenn ich jetzt auf der .NET Seite meine Klassen soweit fertig geschrieben habe, diese mit

[StructLayout(LayoutKind.Sequential)]
[ComVisible(true)]

versehen habe und ansonsten auch alles, wie bei den anderen Komponenten gemacht habe, dann wird mir ja von VS die Type Library ausgegeben und die Dll registriert. Einen Pointer bekomme ich auch wunderbar zurück und auch simple Anfragen und Rückgaben funktionieren. Also bool, integer und auch string-Arrays (BSTR-Arrays) sind problemlos möglich.

Das Problem kommt auf, wenn ich eine eigene Klasse als Rückgabetyp verwenden möchte. Das sieht dann so aus:

public KeyListe HoleKeyListe()
{		
	KeyListe keys = MethodeUmKeyListeZuErstellen();
	return keys;		
}

[StructLayout(LayoutKind.Sequential)]
[ComVisible(true)]
public class KeyListe
{
	[MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
	public string[] key_paulist;
	[MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_BSTR)]
	public string[] key_veblist;
	
	public KeyListe()
	{
		
	}
}

In der .tlh, die mir von der nativen Anwendung aus der TypeLibrary erstellt wird, sehe ich auch die ganzen Schnittstellen beschrieben.

Darin sieht die Klasse KeyListe dann so aus:

struct __declspec(uuid("f8e88956-1b18-3ccf-b290-b4620faf59dd"))
com_KeyListe
{
    SAFEARRAY * key_paulist;
    SAFEARRAY * key_veblist;
};

Methods:
struct KeyListe * HoleKeyListe ();

Mein Gedanke war jetzt, dass es dann doch gehen sollte, diesen com-Typ, der erstellt wurde, in C++ zu nutzen und darin das Ergebnis von HoleKeyListe abzulegen. Das wird mir auch alles brav kompiliert:

KeyListe * keys = s_ptr->HoleKeyListe();

Beim return selbst bekomme ich aber einen TypeMismatch-Fehler. Ich gehe daher einfach mal davon aus, dass es halt doch nicht ganz so einfach zu lösen ist. Jetzt stehe ich allerdings etwas auf dem Schlauch, wie ich jetzt weitermachen soll. Ich habe auch schon ausprobiert, eine Struktur in C++ zu bauen, die derjenigen in C# entspricht und dann einen Pointer auf ein Objekt der Struktur an eine etwas modifizierte C#-Methode weiterzureichen und den Inhalt dann nach einem MarshalPtrToStructure zu bearbeiten. Allerdings mit demselben Ergebnis.

Wie immer will ich nicht unbedingt fertige Lösungen, dazu fuchst mich das Problem zu sehr, als dass ich es nicht verstehen möchte. Ich wäre allerdings für Ansätze dankbar, wie ich z.B. anschauen kann, WAS von der Methode zurückkommt, noch bevor es versucht wird, meinem Pointer auf der C++ Seite zuzuweisen (was ja offenbar erst an dieser Stelle den Type-Mismatch verursacht), so dass ich mir das genauer anschauen kann. Vielleicht finde ich so ja eine Lösung, wie ich das Ergebnis umwandeln muss, um es auf der C++-Seite weiterzuverwenden. Oder ob das überhaupt so möglich ist und ob ich nicht doch ganz was anderes machen muss (was natürlich schon etwas ärgerlich wäre, vor allem, weil es eben so aussieht, als würde nur noch ein winzigkleines Stückchen fehlen für das richtige Ergebnis).

Danke schonmal fürs Lesen und evtl. weitere Zeit, die ihr für mich erübrigt.

Gruß

Kapier ich nicht.

Ich fürchte auch... und sei es nur "früher war alles besser" 😉

Nun, ich bin schlichtweg begeistert 😉

Damit wurde einigen Kollegen die Argumentationsgrundlage gegen .NET entzogen.

Stimmt, aber der Code ist da, sprich, du kannst das Komprimieren ggf. auch selbst implementieren. Oder eben das SDK mal anschauen, ob du da was brauchbares drin findest.

Es ist auf jeden Fall eine Lösung. Wenn die für dich in Ordnung ist, ist es auch schon die Lösung.

Besser geht natürlich immer. 7Zip hat z.B. ein SDK mit C#-Samples, mit dem man selbst basteln kann. Auch gibt es mit SharpCompress einen Wrapper.

Da es sich wohl um eine CSV-Datei handelt, kannst du dir daraus auch ein DataTable bauen und dieses dann editieren. Im Anschluss zurück in eine CSV schreiben und fertig.

Dann überspring doch das erneute hinzufügen zum Dictionary, wenn die Nummer schon vorhanden ist. Try-Catch könnte da schon helfen. Da kannst du die ArgumentException von Dictionary.Add abfangen und den Datensatz dann halt entsprechend nicht hinzufügen.

Besser ist es aber, die Mustersätze wohl schon vorher auszumachen und gar nicht erst hinzuzufügen. Dass diese kein einheitliches Erkennungsmuster haben, halte ich für unwahrscheinlich oder wenigstens aber unglücklich.

Dieser Artikel behandelt das Thema Regex wunderbar und hat mir dabei geholfen, mich darin einzuarbeiten: Regex Tutorial

Aber vom kurz überfliegen des Problems hätte ich gesagt, geht das völlig problemlos.

Schick. Ich hoffe, ich habe mal Zeit den auszuprobieren.

War auch meine Erfahrung, dass die OneDrive-App nach dem Update auf Windows 8.1 nicht mehr so ging wie vorher. Nicht davon betroffen ist die Desktop-Anwendung. War trotzdem nervig und schade.

Letztlich wird das Ganze wohl auch nur eine UI für WIX sein. Ich würde mir halt wünschen, dass ich bei Bedarf auch an das XML ran kann, wenn ich es denn benötigen würde. Muss ich mir aber erst mal anschauen, bevor ich weitermecker 😉

Die Schererei habe ich mir mit meinem alten HP Gerät mal angetan - und ich würde es nicht wieder tun. Das Display selbst hat knapp 170 Euro gekostet. Nicht berücksichtigt habe ich die Steuerplatine und das entsprechende Netzteil, denn für das höher auflösende Display war mein Notebook halt nicht ausgelegt. Das hat dann nochmal etwa 100 Euro gekostet. Es folgten etwa 20 Stunden Basteln und Löten, bis das Display überhaupt im Notebook-Deckel untergebracht war und nochmal so viel, bis ich das Netzteil und die Steuerplatine im restlichen Notebook untergebracht hatte. Folge waren zunächst thermische Probleme im Notebook-Inneren, weil die Steuerplatine Teile eines Abluft-Kanals verdeckt hatte. Nochmal das ganze raus und anders wieder rein. Es funktionierte zwar so einigermaßen, aber fast 300 € und geschätzte 50 Stunden Arbeit war es einfach nicht wert. Ohne umfangreiche Elektronikkenntnisse würde ich sowieso nicht rangehen (das Netzteil musste ich mir selber bauen) und angesichts dessen, was brauchbare Notebooks so kosten, ist ein Verkauf des alten und Neukauf sinnvoller - fast immer.

Ausnahme sind nur solche Displays, die vom Hersteller selbst für genau dieses Gerät angeboten werden und entsprechend "einfach" getauscht werden können. Alles andere ist bescheuert. (Im Nachhinein habe ich das ganze als Bastelprojekt deklariert, sonst wäre der Eindruck entstanden, ich hätte nicht mehr alle am Tablett 😉 )

Nettes Spielchen für Zwischendurch mal 😉 Danke dafür

Was mir noch fehlt ist ein Hinweis darauf, dass man es richtig gelöst hat. Die drei Versuche von mir waren alle zwar richtig, aber das stellte ich erst fest, nachdem ich die Randbereiche durchgesehen hatte. Oder gibt es zumindest eine Meldung auf eine falsche Lösung?

@Abt

Durch das BizSpark-Programm kann man auch als kleine Firma durchaus eine Ultimate-Lizenz legal besitzen. Ob das sinnvoll ist und auch wirklich effektiv genutzt wird, sei mal dahingestellt.

Danke für den Tipp, bin gerade selbst dabei, mich in die Thematik einzuarbeiten und habe so etwas auch noch irgendwo auf meiner Todo-Liste 😉

Oracle VM Server for x86 kostet keine Lizenzgebühren...

Ich weiß, es steht Oracle drauf, was schon abschreckend sein kann. 😉

Klingt für mich eher nach einem Type1-Hypervisor. Schau dir mal Oracle VM Server for x86 an, das läuft direkt auf der Hardware und bootet die VMs dann.

In Reallife sieht das so aus, dass so wenig wie möglich hin und her gewechselt wird und schon gar nicht Designer und Code gleichzeitig angezeigt wird. Würd ich auch bei meinen 2 Bildschirmen nicht machen, da nach dem groben Positionieren von den Elementen der Designer erst mal überflüssig ist. Hat man alles ordentlich benannt, kann ich mit dem Designdokument, das normal neben mir liegt, weiterarbeiten.

Hier wird z.B. das Nutzen einer ListBox erläutert. Da du die Collection ja schon hast, sollte der Rest schnell umgesetzt sein:

MSDN

Du solltest doch eigentlich irgendwo eine Collection mit deinen bereits platzierten Objekten haben? Diese an eine Listbox zu binden ist jetzt doch nicht soo schwer, oder? 😉

Bei einzeiligen if-Blöcken haben wir aus gutem Grund inzwischen die Klammerpflicht eingeführt. Gab da so einen Kollegen, der seine if-Block-Erweiterung einfach druntergehängt hat, ohne dann die Klammer zu setzen. Das Ergebnis war dementsprechend toll und die Fehlersuche war recht anstrengend, weil an so was nun wirklich keiner dachte. Weniger Codezeilen gut und schön, aber solche Fehlersuchen sind die paar Klammerzeilen wirklich nicht wert.

Ich schätze eher, man sieht die Probleme und den kommenden Knall zwar, will aber bis dahin noch möglichst viel Kapital draus schlagen. Sprich, auf den Zug aufspringen, aber rechtzeitig wieder abspringen. Das beschleunigt ab einem bestimmten Punkt den Prozess aber nur zusätzlich. Und nachher heult wieder jeder rum, weil Geld "weg" ist, das man eh nie hatte. Ich verstehe es nicht und fahre eigentlich ganz gut damit 😉

Ich selbst nutze Win8 eigentlich schon seit der Developer Preview produktiv. Einfach nur, weil ich gerne neue Sachen ausprobiere. Diverse Kritikpunkte von Zeitschriften/Foren konnte ich da nachvollziehen, andere jedoch nicht. Mit Windows 8.1 hat MS aber eine ordentliche Schippe nachgelegt und fast alle meiner Kritikpunkte beseitigt. Daher setze ich es auch weiterhin produktiv und mit viel Freude dabei ein.

Größter Vorteil für mich ist die Geschwindigkeit. Das mag subjektiv sein, aber es fühlt sich einfach noch schneller und runder an als Win7. Aber das war meckern auf hohem Niveau. Weitere schöne Sachen, die mit 8.1 kamen, sind für mich:

• Endlich ein eigenes Hintergrundbild im Startmenü, so dass der optische Bruch beim Wechsel zwischen Desktop und ModernUI quasi nicht mehr vorhanden ist.
• Gefühlt bessere Autokonfig (man muss eigentlich kaum was nachträglich einstellen)
• Nahezu alle Einstellungen im Startmenü (bei Tablets wichtig)

Ein paar nicht so tolle Dinge habe ich aber auch weiterhin. Bei Outlook 2013 z.B., klar, es ist ein Desktop-Programm und eigentlich kann ich da auch nicht mehr erwarten. Aber ich hätte mir z.B. einen Software-Link auf ein Live-Tile im Startmenü gewünscht, so dass ich darauf wie bei Windows Mail eine Vorschau auf neue Mails bzw. deren Anzahl habe, Outlook selbst aber so bleibt, wie es ist (eine Desktop-Applikation). Gleiches gilt für andere Programme, so dass ich diese nicht unbedingt öffnen muss, um Neues zu sehen. Vor allem bei aktivem Sperrbildschirm könnte man so die Anzahl Mails, Newsfeeds usw. sehen, obwohl man eben nicht die ModernUI-Apps nutzt.

Weiter:

• Gelegentlich will ich eine "App" öffnen (Store). Mir wird dann der Ladebildschirm angezeigt und kurze Zeit später beendet sich die App kommentarlos. Erst ein weiteres Öffnen bringt dann die tatsächliche Anwendung zum Vorschein. Ein Bug halt.
• Das Anordnen der Kacheln ist mir noch etwas zu statisch. Das vorgegebene Raster ist nicht immer optimal.
• Ich hätte gerne den Runterfahren-Button direkt auf dem Startmenü, dass ich da erst noch das Charm öffnen oder mit einer Tastenkombi rumhampeln muss, ist nicht besonders gut. Eine eigene Kachel mit shutdown sieht blöd aus.

Aber im Großen und Ganzen hält sich das Negative bei Win8 doch sehr in Grenzen. Vielfaches Gejammer über das fehlende Startmenü verstehe ich einfach nicht und die "Hässlich"-Nörgler müssen ja das neue Startmenü seit 8.1 kaum mehr sehen. Ich bin jedenfalls sehr zufrieden.

Habe selbst mit 2100€ angefangen und nach einem Jahr auf 2600€ erhöht bekommen (Baden-Württemberg).

Eine Klasse erstellen für die Vokabeln, diese durch Serialisieren und Deserialisieren speichern/lesen. Die Liste an das DataGridView binden oder ggf. Events davon abonnieren und entsprechend darauf reagieren.

Ja, denn der Schnittpunkt mit der Y-Achse lässt sich ermitteln, indem man X=0 setzt. Dadurch wird m*x = 0 und es bleibt nur t übrig.

Erzeug die Oberfläche dynamisch und speicher dir die Daten dazu in einem selbst gewählten Format ab.

Sehr schön 😉 Etwas rustikal in der Optik, aber eigentlich mag ich das sehr. Beim Layout muss man aber dringend nochmal drüber ^^

Aber wie gesagt, gefällt mir ganz gut und schau ich mir gerne etwas näher an.

Vom TFS gibts auch eine lokale und kostenlose Express-Variante, die etwas eingeschränkt ist (nur SQL Server Express, keine SharePoint- oder Reportintegration, nur 5 Benutzer...). Nutze ich bisher, werde aber in Kürze auf die größere Version umsteigen. Allerdings habe ich das beschriebene Problem nicht mit binären Dateien - und ich verstehe es auch nicht so recht. Irgendwo müssen diese binären Dateien ja generiert werden, und zwar aus lesbaren Dateien. Und nur diese gehören in die Versionsverwaltung.

Mein erstes Projekt war ein Textadventure in QBASIC. Ganz viele Zeilen, zuletzt ein absoluter Alptraum, was die Wartung und Erweiterung anging, weshalb ich es irgendwann "fertig" genannt hatte (zum Schluss halt eben recht schludrig und hopplahopp, was die Story angeht). 😉

Das kommt drauf an, wo du danach tätig sein willst. Deutschland ist ein Papierland. In vielen Fällen ist es schonmal ganz toll, wenn du ein Papier hast, auf dem offiziell beglaubigt ist, dass du auch was kannst. Da tuts auch schon eine Ausbildung und sei es nur als Fallback-Strategie, wenn das eigene Gewerbe mal vor die Wand fährt.

Studium und Techniker brauchen halt ggf. enorm viel Zeit, wenn man das ganze mit einer gewissen Ernsthaftigkeit angehen will (immer auch davon abhängig, was man schon drauf hat). Studium konnte ich mir genau deshalb nicht leisten.

Der einzige vielleicht nicht, aber einer von wenigen hätte ich mal vermutet 😉 Nichts für ungut.

Du kannst unter VS2012 deine Solution für .NET4 in den Projekteinstellungen festlegen. Vielleicht schafft das schon Abhilfe.

Du rufst nie UpdateProgressBar() auf und setzt die Variable nie auf false. Generell ist mir der Sinn dieser Lock-Variable nicht ganz schlüssig. Kannst du da noch ein paar Sätze mehr dazu sagen?

Bau dir eine eigene Progressbar mit zwei Panels, von denen du das innere in der Größe änderst und die Farbe entsprechend anders gestaltest. Alternativ kannst du per API, die "Animation" abstellen:

Disable WinForms ProgressBar animation

Indem du das Klick-Event abfängst, deine Einstellung speicherst, und beim Neustart wieder ausliest und setzt.

Für den Einstieg (Einstieg in was? IDE oder Programmiersprache?) sind beide gleich gut geeignet, da die neuen und größeren Features für Einsteiger eh noch uninteressant sind. "Probleme" gibt es vermutlich in jeder IDE, die Frage ist, welche Probleme genau es sind und inwieweit sie einen betreffen. Ohne genauere Infos, welche Probleme du meinst, kann man dazu also nichts weiter sagen.

Das Verhalten kenne ich auch. Ich stell das immer ab, indem ich MinSize und MaxSize auf die aktuelle Size einstelle.

Dann würde ich dir auf jeden Fall von der Preview abraten, da die nicht für Produktivsysteme gedacht ist. Ich hab sie zwar auf meinem Notebook auch drauf, aber nicht ohne vorher ein Image von der Platte gemacht zu haben, mit dem ich ganz schnell wieder zum vorherigen Zustand zurück komme. Aber wie gesagt, es ist eine Preview, die noch Fehler enthalten kann. Solche Fehler können eine komplette Neuinstallation auch notwendig machen. Insofern würde ich das einfach sein lassen, wenn genau die Neuinstallation keinesfalls infrage kommt.