Die Meldung des Compilers sollte aussagekräftig genug sein 😉

Falls nicht: Deine Methode DaysAmount erwartet drei Parameter. Und wieviele gibst du tatsächlich mit beim Aufruf ?

Hallo Freunde,

ich hatte keine Gelegenheit bis gestern, da wieder bei zu gehen. Ich brauchte echt mal Abstand von C#-Code 😁

Durch den letzten Post von @MarsStein kam ich auf eine andere Idee: Das Path-Element hat einen MouseOver-, MouseEnter- und MouseLeave-Event, alle darunterliegenden (Geometry etc) haben das nicht. Anstatt also nur einen allumfassenden Path zu zeichnen, zeichne ich für jedes Element, das ein MouseOver-Event benötigt, einen eigenen Path.

Ergo schrumpft der Algorithmus auf dies hier zusammen:

private void DrawElement(float[][][] data, string KreisName = "")
        {
            //Und los gehts mit Zeichnen

            for (int areaCount = 0; areaCount < data.Length; areaCount++)
            {
                PathGeometry pg = new();
                //Startpunkt ermitteln
                Point startPoint = ScaleCoordToPoint(data[areaCount][0][0], data[areaCount][0][1]);
                PointsDrawn++;

                //PathGeometry zeichnen
                PathFigure path = new();
                path.StartPoint = startPoint;

                for (int coordCount = 1; coordCount < data[areaCount].Length; coordCount++)
                {
                    Point pt = ScaleCoordToPoint(data[areaCount][coordCount][0], data[areaCount][coordCount][1]);
                    PointsDrawn++;
                    path.Segments.Add(new LineSegment(pt, true));
                }
                pg.Figures.Add(path);

                System.Windows.Shapes.Path p = new();
                p.Stroke = Brushes.Black;
                p.StrokeThickness = 1;
                p.Data = pg;
                p.Tag = KreisName;

                //Events hier anklemmen
                p.MouseEnter += AreaEnter;
                p.MouseLeave += AreaLeave;
                TheCanvas.Children.Add(p);
            }
        }

Ich gebe einen string im Tag-Property mit, damit ich im Eventhandler erkennen kann, welches der Elemente das Event gefeuert hat.

Das fühlt sich für mich viel eher nach "Windows Forms-Style" an denn WPF, aber für dieses kleine Programm hier mag das gehen. Viel größer wird es eh nicht. So oder so, es funktioniert und ich danke für den Schubser in eine zielführende Richtung.

Äußerst interessant für mich wäre, wie man das "in reiner Lehre" in WPF wohl machen würde. Ich denke, das da konzeptionell schon anders herangegangen werden muss, ich habe aber keine blasse Idee, wie...

Hallo Freunde,

ich habe hier eine Fragestellung, die auch durch Google und StackOverflow unbeantwortet geblieben ist - womöglich habe ich aber auch falsch gefragt.

Ich habe hier eine WPF-Anwendung, die eine Landkarte zeichnet. Das ganze sieht wie folgt aus:

private void DrawElement(float[][][] data)
        {
            //Und los gehts mit Zeichnen
            List<PathFigure> li = new();

            for (int areaCount = 0; areaCount < data.Length; areaCount++)
            {
                //Startpunkt ermitteln
                Point startPoint = ScaleCoordToPoint(data[areaCount][0][0], data[areaCount][0][1]);
                PointsDrawn++;

                //PathGeometry zeichnen
                PathFigure path = new ();
                path.StartPoint = startPoint;

                for (int coordCount = 1; coordCount < data[areaCount].Length; coordCount++)
                {
                    Point pt = ScaleCoordToPoint(data[areaCount][coordCount][0], data[areaCount][coordCount][1]);
                    PointsDrawn++;
                    path.Segments.Add(new LineSegment(pt, true));
                }
                li.Add(path);
            }

            PathGeometry pg = new();

            for (int i = 0; i < li.Count; i++)
                pg.Figures.Add(li[i]);

            li.Clear();

            System.Windows.Shapes.Path p = new();
            p.Stroke = Brushes.Black;
            p.StrokeThickness = 1;
            p.Data = pg;
            TheCanvas.Children.Add(p);
        }

So weit, so gut, so funktionierts. Wenn jemand eine performantere Idee hat, bin ich aufgeschlossen - ist aber nicht die Frage.

Ich möchte nun einen OnMouseOver-Trigger (oder MouseEnter/MouseLeave) an jeden der einzelnen PathGeometry anhängen. Alle Beispiele, die ich bisher gesehen habe - inklusive hier im Forum - befassen sich mit dem Trigger innerhalb des XAML. Das ist okay, wenn man das Objekt im XAML erstellt, aber das ist hier nicht der Fall.

Doch wie mache ich das per Code-Behind ?

Bin für jeden Schubser dankbar.

...und wenn du dann schon am Anfang hängst, weil dir keiner erzählt hat, das man das große Problem in kleine Probleme aufteilen soll (und/oder du das einfach nicht kannst), dann sieht das so aus, als würde nach "gib mir mal Code, schnell" gefragt.

Nichtsdestotrotz: Je konkreter gefragt, desto besser die Hilfestellung 😉

Kirsche auf dem Sahnehäubchen wäre es gewesen, das Quadrat vom Rechteck abzuleiten. Dann hättest nur noch den Konstruktor überschrieben - alle anderen Methoden bräuchten dann kein override 😉

  
  
for (int i = 0; i < 8; i++) //Erstelle zum Testen 9 Kämpfer  
  
  

sind 8 Durchläufe, also nur 8 Kämpfer.

das ist in dem später folgenden

k++;

begründet. Dieser (leider untaugliche, aber der TE ist ja Anfänger) Winkelzug hat die Überschreitung der Arraygrenzen, auf die der TE bei seinen ersten Tests garantiert gestoßen ist, erstmal behoben. Blöd nur, das Kämpfer 9 niemals als fighter1 zum Zuge kommen wird dadurch.

Besser wäre gewesen:

do
    k = GetRandomNumber(0,8); 
while (k != startpos);

Kommandzeilen-Parameter sind dein Freund 😉

Die ungarische Notation sieht vor, das man Variablennamen mit einem Kürzel versieht, das den Typ der Variablen erkennbar macht. So sieht man schon am Namen, ob das ein Integer (iAlter z.B.), ein String (strFilename) oder ein Double (dEinkommen) ist. Diese Idee stammt aus einer Zeit, als die Code-Editoren noch keine Farbkennung für die verschiedenen syntaktischen Elemente der Programmiersprache beherrschten.

Heutzutage ist Farbcodierung Standard und für alle Sprachen verfügbar. Dadurch ist die ungarische Notation unnötig und - nicht nur für uns alte, eingefleischte C#-Hasen - sogar abzulehnen, da es den Codeguidelines für C# widerspricht.

Wow, das nenne ich mal einen wirklich lehrreichen Schubser 👍 👍

Zunächst muss ich zu meiner Verteidigung sagen, das ich all diese Tutorials - auch das von @Abt vorgeschlagene von Microsoft - sehr wohl gelesen habe. Ich mache das mit dem Programmieren ja nun auch schon den einen oder anderen Tag, habe das alles verstanden und war daher tatsächlich so übermütig zu glauben, das ich das Zeug vom RKI mal eben schnell zusammenhäkeln könnte. Klassen in JSON zu verwandeln und wieder zurück ist ja nun auch kein Hexenwerk (das mit Rockstar war mir auch nicht bekannt 🙂 ), wenn man die Tutorials durch hat.

Allen diesen Tutorials, auch denen bei Youtube und wo auch immer - die fast ausnahmslos Newtonsoft verwenden, daher dachte ich, nimmste mal das - ist allerdings eines gemein: Sie fertigen eine Klasse mit mehr oder weniger Komplexitätsgrad - meist mit weniger bis keinem. Dann zeigen sie dir, wie man daraus JSON macht und dann, wie man das wieder in Klassen verwandelt. So weit, so gut, so einfach.

Kein einziges, das ich fand, befasst sich mit dem Thema: Hier ist JSON, mach mal. Genau das habe ich aber versucht. Das JSON in den Simpel-Tuts ist natürlich auch entsprechend simpel, konnte also auch nicht wirklich als Vergleich dienen: "Aha, so sieht das in JSON aus, das machen die im RKI auch so, also muss meine Klasse so und so aussehen". Wenn ich sehe, was @Abt da für einen Haufen Klassen generiert hat, frage ich mich: Welchen Schuss hab ich nicht gehört, das ich anhand des MSDN-Tutorials nicht auf Anhieb so eine Klassenstruktur erzeugen konnte ? 😉

Übrigens habe ich gestern abend nach Eingabe von "C# JSON in Klassen umwandeln" bei Google den Trick mit Edit -> Paste Special gesehen. Ich habe ernsthaft nach diesem Menüpunkt oder etwas vergleichbarem gesucht, aber erst heute morgen mit einem frischen Hirn entdeckt, das es da "Inhalte einfügen -> JSON als Klassen" gibt. My bad, das ich so blind war und nicht drauf komme, das "Paste special" nach "Inhalte einfügen" übersetzt wurde. Hätte ich das früher gesehen, hätte ich euch gar nicht behelligt, dann wären die Klassen ja schon fertig gewesen und das Zeug hätte womöglich dann schon funktioniert 🙂 🙂

Auf jeden Fall habe ich viel gelernt durch den kurzen Abschnitt, den @Abt dort geschrieben hat. Newtonsoft fliegt raus, Bordmittel sind eigentlich immer die bessere Wahl (als alter Delphi-Coder lernt man das schnell). Ich werde das ganze mit dem System.Text.JSon umsetzen - eine Fehlermeldung ist ohnehin am Anfang besser als ein Null. Und ich habe gelernt, das man gar nicht JSON-Profi sein muss, um aus JSON nun Klassen zu machen, das vereinfacht das ganze. Ach ja: Der HttpClient wird nur einmal erzeugt, das ist ne Kommandozeilen-Anwendung, die nur einmal durchläuft. Wird das ganze mal komplexer und mit WPF-GUI, dann komt da natürlich n using drumherum bzw. die Instanz wird nur einmal erzeugt und bis zum Programmende beibehalten.

Nochmals vielen Dank !

[Edit]
Nachdem ich die Klassen selbst generiert habe und diese Klassenstruktur da sehe, stimme ich @Abt zu. Das war wohl ein Werkstudent, der das erzeugt hat.
[/Edit]

Hallo Freunde,

ich bin wieder mal zu doof. Ich versuche, die REST-Daten des RKI mal selbst abzufragen und auszuwerten. Doch bereits beim Parsen des JSON scheitert das ganze. Vielleicht kann mich jemand in die passende Richtung schubsen ?

Folgende URL wird abgefragt: https://services7.arcgis.com/mOBPykOjAyBO2ZKk/arcgis/rest/services/RKI_COVID19/FeatureServer/0/query?where=1%3D1&outFields=*&outSR=4326&f=json

Das ganze mache ich mit folgenden paar Zeilen:

        async static void Search()
        {
            HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Add("ContentType", "application/json");

            string uri = "https://services7.arcgis.com/mOBPykOjAyBO2ZKk/arcgis/rest/services/RKI_COVID19/FeatureServer/0/query?where=1%3D1&outFields=*&outSR=4326&f=json";
            HttpResponseMessage responseMessage = await client.GetAsync(uri);
            string contentString = await responseMessage.Content.ReadAsStringAsync();
            dynamic jsonText = JsonConvert.DeserializeObject(contentString); //Das hier funktioniert
            var data = JsonConvert.DeserializeObject<attributes>(contentString); //Hier kommt nix

            Console.WriteLine(jsonText);
        }

Ich habe herausgefunden, das man die passenden Klassen selbst erst bauen muss (ich dachte, das ginge auch irgendwie "von selbst"), was ich in dieser Form gemacht habe:

    class attributes
    {
        public int IdBundesland { get; set; }
        public string Bundesland { get; set; }
        public string Landkreis { get; set; }
        public string Altersgruppe { get; set; }
        public string Geschlecht { get; set; }
        public int AnzahlFall { get; set; }
        public int AnzahlTodesfall { get; set; }
        public int ObjectId { get; set; }
        public DateTime Meldedatum { get; set; }
        public string IdLandkreis { get; set; }
        public string Datenstand { get; set; }
        public int NeuerFall { get; set; }
        public int NeuerTodesfall { get; set; }
        public DateTime Refadtum { get; set; }
        public int NeuGenesen { get; set; }
        public int AnzahlGenesen { get; set; }
        public int IstErkrankungsbeginn { get; set; }
        public string Altersgruppe2 { get; set; }
    }

    class features
    {
        public int ObjectId { get; set; }
        public attributes[] attributes { get; set; }
    }

wobei ich auf die features-Klasse erst kam, als mir klar wurde, das das ein Array aus attributes ist... Oder sowas. Ich habe da überhaupt keinen Durchblick und bisherige Googelei ergibt zwar tonneweise Code, wie man es macht - aber nur mit händischem JSON-String und einer Klasse mit zwei Membern... Also nicht sehr informativ.

Was mache ich da falsch ?

Passt zwar nicht ganz hier hinein, aber einen neuer Thread hierfür...

Wo gibt es die Option "alle Foren als gelesen markieren ?" An den üblichen Orten habe ich nichts gefunden.

Ich finde das alles ziemlich spannend. Der gesamte Code ist uninteressant, glaubt mir. Wer selbst an solchen großen und lange laufenden Projekten gearbeitet hat, weiß das. Teile und Ideen bzw. Patterns zu veröffentlichen, ist der optimale Weg, so das auch die Community davon profitiert.

Besonders spannend finde ich das Thema Datensammlung und hier das darauf geachtet wird, die Sammelwut so weit wie möglich einzudämmen. Andere Websites sind da gieriger 😄

Ich mache gerade eine völlig überflüssige Fortbildung in Java (brauch das Zertifikat...)

Ist noch immer so, keine Stub-Exe oder ähnliches. Zumindest wurde uns bisher nichts anderes gezeigt.

Zumindest im Microsoft SQL-Server gibt es die CONVERT-Funktion, mit der man Datumsangaben konvertieren kann. Der Funktion gibt man einen Paramter mit, der das Format beschreibt, in der das Datum angegeben ist - das macht es systemunabhängig.

Es komplett mit Python zu machen. C# ist nicht geeignet für das, was du da vorhast.

Den Code einfach durch einen C-Compiler jagen. VS hat so einen drin, der C++-Builder von Idera kann ANSI-C, ja sogar ein GCC unter Linux wird da helfen. Der Code muss ja nicht laufen, nur compilieren.

Und vielleicht gibt es zu dem Crosscompiler einen Kommandozeilenschalter, der "verbose" oder so lautet - manchmal spuckt der dann auch was brauchbares aus.

Das ist doch total simpel 😁

Dein Code müsste, würde er den checked-operator konsequent nutzen, so aussehen:

short value20 = checked(Convert.ToInt16(Console.ReadLine()));
byte value21 = checked((byte)value20);

Wenn das jetzt nicht nur 2 Zeilen sind, sondern 132 Zeilen mit solchem Code, wird es echt mühsam, immer wieder checked() einzutippen. Also machen wir n Block draus:

checked
{
     short value20 = Convert.ToInt16(Console.ReadLine());
     byte value21 = (byte)value20;
}

Alle checked-operatoren sind nun weg, nur der eine um den Block herum ist noch da. Aber der umfasst eben ALLE Zeilen im Block. That simple 😁

Die fehlende Variable im Buch ist ein Fehler des Lektorats. Lektoren können toll Rechtschreibung und Grammatik, aber nicht programmieren. Die wissen nicht, das shtVar auch mit shortValue ersetzt werden muss, wie es der Autor vorher getan hat 😉

Ich hatte vor noch gar nicht allzu langer Zeit ein ähnliches Problem.

Ich habe hier eine Software übernommen, an der so in etwa 30 Entwickler die letzten 20 Jahre mehr oder weniger (meist leider sehr viel weniger) gut gearbeitet haben. Ich stand plötzlich ganz allein davor, keine Ahnung von nix und viele Millionen Zeilen eher schlechter Code.

Gegen die ungeheure Masse an Infos, die dann plötzlich über dich hinwegrollen wie ein Tsunami bist du schlicht chancenlos. So, wie durch ein Wasserrohr nur eine maximale Menge an Wasser durchpasst (will man mehr, dann platzt es), geht auch nur eine bestimmte Menge an Wissen pro Tag / Woche / Monat in deine Birne rein.

Ich bin jetzt zweieinhalb Jahre hier, und habe noch immer nicht alles gesehen und verstanden - derart komplex ist das System hier. Aber alle wissen das und sind nachsichtig mit mir 😉

Wenn du den Kollegen dann vermittelst, das du leider nicht in der Lage bist, diese ~60 Mannjahre in drei Monaten aufzuholen, klappt das auch. Gib dir selbst ne Chance, alles auf einmal ist ein deutlich zu großer Happen.

Ich glaube, der Fernlehrer hat mit "Talent" eigentlich die zwei schon genannten Dinge gemeint: Logisches und Abstraktes Denken.

Beides braucht es, wenn man den ganzen Quatsch wirklich raffen will - ich machte das seit... Äh... ohje, fast 35 Jahren und glaube, das ich das zumindest ein ganz klein wenig beherrsche.

So wie dein Code aussieht, ist das klar Anfänger-Code und was den Anspruch angeht ist das gezeigte jetzt auch nicht so Mega. Aber spielt das ne Rolle ? - Nö, tut es nicht. Wesentlich ist, das du eine Aufgabe gefunden hast, die du umsetzen wolltest, und genau das hast du getan, sogar mit Erfolg. Das ist das Entscheidende.

Der Rest ist dann Erfahrung, die aber erst mit der Zeit kommt. Ich würde also empfehlen, erstmal dabei zu bleiben - du hast noch gar nicht richtig angefangen zu programmieren, da warten noch etliche spannende und faszinierende Dinge auf dich.

Ich bin ein Verfechter von @Abt's Methodik: Zeig ihm, wie es besser gemacht wird. Aber schubs ihn nur, durch die Tür gehen muß er schon selbst.

Warum ? Weil ich hier jeden Tag sehe, welch ungeheure Mengen an Schrott-Code so produziert wird. Ich überarbeite hier ein sehr großes Projekt mit jeder Menge Programmcode, über 30 Jahre gewachsen und von deutlich mehr als einem dutzend "Programmierern" vermurkst.

Wenn wir nun @ck87 zeigen, wie er sein Problem mit Arrays löst (unerheblich wie komplex das letztlich wird) und er seine Routine am laufen hat - was wird dann passieren ? ck87 ist stolz auf seine Lösung und wird es fortan nach Möglichkeit immer so machen.

Das ist kein Schwachsinn, sondern Praxis, wie ich es hier jeden Tag sehe, wenn ich eine neue Delphi-Unit öffne.

Darum ist es IMHO gar keine schlechte Idee, solchen Fragestellern gleich einen besseren Weg aufzuzeigen. Das hilft, die Denkmurmel anzuregen "oh, das geht auch anders ? Das ist ja cool". Schlechten Code gibt es schon genug und in der heutigen Zeit, wo man nur noch Bilbiotheken zusammenschmeißt, muß eben dieser Bibliothekscode nach aktuellem Stand "ordentlich" sein, um es mal salopp zu formulieren.

Das dieser Code in 5 Jahren vllt. nicht mehr "ordentlich" ist, ist der Lauf der Dinge. Aber: Alles in Arrays zu lösen war schon vor 25 Jahren nicht der Weisheit letzter Schluß, als ich das erste mal jemandem das Programmieren beibrachte.

Oder indem man schlicht und ergreifend

EinzelnesElement

von

BasisKlasse

ableitet...

Vielleicht hilft ja auch ein simples Umladen in eine Variable.

int j=colours.Count;
if (j > 0)
{
   for (i=0; i<= j; i++)

Wir können die Frage auch anders formulieren:

Du willst nun deinen Personen-Klasse in was größeres integrieren. Also machst du eine neue WinForms-Anwendung und willst dort deine Objekte weiter benutzen. Was ja auch völlig okay ist.

Doch plötzlich: In WinForms gibt es keine Console...

Das ist wohl richtig. Aber wir haben es hier mit einem ultrablutigen Anfänger zu tun.

Da ist es besser für das Verstehen, wenn man sowas Schritt für Schritt und auch etwas umständlicher formuliert. Die Effizienz kommt dann später 😉

Das mit der defensiven Programmierung ist zwar richtig, aber ich sehe das nicht ganz so streng. Da kann man imho ruhig mal die 'rule of thumb' anwenden.

Dann machst du da einen der Fehler, die ich mir in den letzten 30 Jahren als Programmierer abgewöhnt habe:

Das brauche ich jetzt nicht so sorgfältig machen, passiert sowieso nie was anderes.

Fällt gleich mit in die Kategorie Brauche ich nicht kommentieren, MSDWGI.

Wenn man sich sowas nicht gleich angewöhnt, wird es schwierig. Sich selbst zu ändern (und seine Gewohnheiten !) gehört zu den schwierigsten Aufgaben, die man sich stellen kann.

Es ist auch nicht wirklich abwegig, solche Eventhandler aus anderen Methoden aufzurufen. So wäre es nicht verwerflich, aus einem Timer-Event diesen Eventhandler aufzurufen.

Doch was gibt man dann mit als "Sender"-Parameter ? Gebe ich den Timer mit (der Sender aus meinem Timer-Eventhandler), dann kracht es. Gebe ich null mit, kracht es auch.

Die Prüfung auf null ist somit ganz sicher keine Verschwendung. Wie schon erwähnt: Defensiv programmieren und immer das Unerwartete erwarten.

Besseres Beispiel:

Eine Methode mit Rückgabewert ist wie die Freundin, die man anbrüllt. Die brüllt was zurück.

Eine void-Methode ist die Katze: Die kann man zwar auch anbrüllen, aber die Katze schaut nur gelangweilt bis verwirrt. Zurück kommt aber akustisch nix.

Üblicherweise ändern sich die Filter während eines (!) Filtervorganges nicht. Ergo schreit das regelrecht nach einer Prepare-Methode für deine Filter, der du die Filterkriterien mitgibst und die z.B. eine List<delegate> zurückgibt.

In dieser List<> sind dann nur noch die Filtermethoden drin, die du tatsächlich benutzen mußt für diesen Filtervorgang. So entscheidet sich genau einmal pro Filterung, welche Filter zu nehmen sind - und nicht im Extremfall 30.000x.

Die einzelnen Filterroutinen auch noch nach Geschwindigkeit zu sortieren und/oder nach Wahrscheinlichkeit eines Treffers (wodurch der Rest nicht mehr abgearbeitet werden muß) ist dann das Sahnehäubchen oben drauf.

Vergiss eine UnPrepare-Methode nicht 😉

Mir wäre jetzt noch Delphi eingefallen (Object Pascal ist die verwendete Sprache), das eine monolithische und dadurch ziemlich große EXE-Datei erstellt und von keiner Form von Framework abhängig ist (WinAPI lassen wir mal außen vor...) .

Aber beim ReportViewer ist hier auch Schluß, das geht nicht ohne DLLs, die nun mal zu installieren sind.

IMHO ist deine Anforderung heuer nicht mehr erfüllbar.

"Zu alt" ist man nie. Seit 1984 bin ich Programmierer, habe vor 4 Jahren C# als neue Sprache dazu gelernt, mich dann selbständig gemacht, ein paar Jahre gutes Geld verdient und bin nun wieder auf dem Weg zurück ins normale Berufsleben.

Dies soll zwei Dinge drastisch klar machen: Man ist tatsächlich nie zu alt und du wirst niemals aufhören zu lernen, wenn du diesen Weg gehst. In keinem Beruf ist das permanente Lernen "bis zum letzten Atemzug" so zutreffend und unabdingbar wie hier.

Wesentliche Grundlagen, um beim Programmieren überhaupt ne Chance zu haben, sind IMHO ein ausgeprägtes logisches Denkvermögen, ein analytischer Verstand und, last but definitely not least, ordentliche Englischkenntnisse. Ohne die wird es echt schwer. Falls es aufgefallen ist: Mathematik spielt nur am Rande eine Rolle, das war einmal.

Ein weiterer Gesichtspunkt, gerade bei Einsteigern, ist die Wahl der Sprache. C++ halte ich aufgrund seiner kryptischen, schwafeligen und streckenweise unlogischen Syntax für völlig ungeeignet, C# dagegen ist schon fast ideal, auch VB.NET ist ein prima Einstieg, solange man OPTION STRICT aktiviert.

Entgegen meinem Vorposter bin ich dafür, Windows-Programme (erstmal in Windows Forms) zu machen. Denn entscheidend bei den ersten Gehversuchen ist das "Eye-Candy" - und das hat man bei Konsolen-Anwendungen wenig bis gar nicht 😉

Anschließend braucht es nur noch ein paar Ideen "was will ich machen" - Adressverwaltungen, MP3-Sammlungen, die eigene XXX-Video-Sammlung verwalten etcpp... Da gibt es einiges, auch hier sind einige Vorschläge dazu zu finden, auch wenn das Niveau IMHO manchmal drei oder vier Stufen zu hoch angesetzt wurde 😉

Wenn dann noch die Geduld "ich will das jetzt aber herausfinden" vorhanden ist und man vom anschließenden "Aha, so geht das, cool" fasziniert ist, wird auch ein Vollblut-Programmierer aus dir 😃

Ich würde eine Reparaturinstallation von VS2015 machen. Das zwingt zur Paketüberprüfung und Neuladen desselben. Dann sollte die Deinstallation auch klappen.

Ließe sich die Entscheidung, ob Neu oder Editieren, nicht durch die Poperties leicht festlegen ?

Letztlich muß man ja die Angaben des Benutzers irgendwie aus dem Form wieder heraus bekommen. Üblicherweise nimmt man dafür ja Properties. Wenn man denen einen Setter verpaßt und dann von "außen" sozusagen die Poperties befüllt, steht doch automatisch fest, das ein Editieren vorliegt und man kann bereits im Setter seine Flags entsprechend setzen...

Meine Idee war ursprünglich, ob es nicht eine Möglichkeit in der Config gibt, den Pfad zu dem Assembly anzugeben, habe aber nichts gefunden.

Unterstreichung durch mich. Sollte es erklären 😉

Ich habe lange überlegt, ob ich mich hier beteiligen sollte, oder nicht. Die Feindseligkeit gegenüber anders arbeitenden ist schon bedrückend. Aber lassen wir das, führt zu nix.

Ich arbeite seit kurzem in einem Unternehmen, das man getrost als "von vorgestern" bezeichnen könnte. Der Compiler ist von 1999, der Code - vorsichtig ausgedrückt - unstrukturiert, weitgehend undokumentiert und das (immerhin) verwendete SourceSafe mit seinem Ein-/Auscheck-Zwang ist immer wieder nervtötend.

Ich würde gern losziehen und hier als erstes ein nach heutigen Maßstäben vernünftiges VCS einführen. Git wäre da meine erste Wahl, doch wenn man so gar keine Ahnung davon hat, ist man auch nach mehrstündiger Recherche nicht ernsthaft schlauer. Ich weiß das aus Erfahrung, denn ich habe schon dreimal versucht, mich da einzufuchsen. Das Problem dabei ist: Es gibt massenhaft Tutorials (auch hier), die mir zeigen, wie ich was wo installieren muß und wie ich ein Repo anlege.

Doch wenn das Repo auf einem Server liegt, damit auch mein Kollege damit arbeitet ? Kein einziges der Tutorials kam bis zu diesem Punkt und ein lokales Repo ist nur was für Einzelkämpfer, nicht für Team-Development.

Zu DevOps sieht das nicht wirklich besser aus, doch zähle ich hier auf die Community, die offenbar was davon versteht. Mir ist da z.B. völlig schleierhaft, welchen Vorteil ich aus einem über Nacht erzeugten Kompilat haben soll. Ist es tatsächlich inzwischen üblich, das man am Code Änderungen vornimmt und diese einfach nur eincheckt, ohne das ganze wenigstens einmal durch den Compiler zu schubsen ? Wenn ja, bleibe ich Oldschool...

Auch sehe ich keinen ernsthaften Nutzen aus einem Release-System. Unser Kundenkreis ist überschaubar (vielleicht ein dutzend Kunden), wir entwickeln ausschließlich Desktop-Anwendungen, der Anteil an Webentwicklung ist Null, der Anteil an Mobile Apps ist Null. Es existiert auch gar kein Bedarf in unserem Bereich für so etwas. Wozu also Releases, ergo wozu ein Release-System ?

Aufgrund des überschaubaren Kundenkreises gibt es auch gar keine Testsysteme hier. Aber womöglich ist damit etwas ganz anderes gemeint, als ich im Moment denke.

Gibt es ein paar wirklich brauchbare Artikel, die einem den Nutzen eines DevOps-Systems aufzeigen kann ? Welchen Aufwand müßte ich betreiben, um auch eine "exotische" Sprache wie Delphi oder Assembler mit in den Prozess zu integrieren ? Macht sowas überhaupt Sinn, wenn man mit Web oder Mobile nichts, aber auch rein gar nichts am Hut hat ?

Fragen über Fragen.

[Narrenkappe]
Verdammt... Ich benutze immer TAB zum Einrücken, lasse das aber in den Einstellungen der IDEs immer durch Leerzeichen ersetzen. Werde ich jetzt gefeuert ?
[/Narrenkappe]

Man muß sich wundern, wie stark dieses Phänomen inzwischen um sich gegriffen hat. Bestes Beispiel: Wahlausgang Brexit, Wahlausgang Präsidentenwahl USA und auch die Wahlergebnisse der SPD, die so gar nicht den Analysen entsprachen...

So einen Zampano hatte ich nicht am Hals. Eine DUNS-Nummer und die Gewerbeanmeldung waren ausreichend. Kann aber sein, das das ominöse OV so eine F2F-Geschichte nötig macht.

Ich habe gerade heute mein Code Signing-Zertifikat bekommen. Ich habe dies über K Software geordert, die - wie schon gesagt - nur ein Reseller für Comodo sind. Nachdem dann Comodo auch kapiert hat, das ich als Einzelunternehmer trotzdem ein Unternehmen habe, ging das reibungslos.

Habe für ein Jahr USD84,00 bezahlt, also knapp 81€. Probleme mit dem Timestamping hatte ich nicht, das Zertifikat wird auch problemlos von VS2015 angenommen und die resultierende EXE ist dann signiert.

Eigentlich ganz einfach.

Man nehme Punkt[0]. Nun berechne Er alle Entfernungen der Punkte[1..n]. Der, der am dichtesten dran ist, wird dann Punkt[1].

Man nehme Punkt[1]. Nun berechne Er alle Entfernungen der Punkte[2..n]. Der, der am dichtesten dran ist, ist Punkt[2].

Und so weiter.

Entfernungen nur einmal berechnet, Ergebnis-Liste gleich sortiert.

IMHO sieht das nach einer Zweiteilung aus. Teil 1 ist eine simple Konsolenanwendung, die einfach per geplantem Task angestoßen wird und die Dateien bearbeitet. Ich bin mir ziemlich sicher, das da schon ein SQL-Server existiert - an den kannst du dich bestimmt "dranhängen" und dort deine usgewerteten Daten hineinschreiben. Teil 2 wäre dann eine GUI-Anwendung, die einfach aus den Daten aus dem SQL-Server die gewünschten Infos extrahiert und zur Anzeige bringt.

Webserver halte ich da für eher ungeeignet.

Anders formuliert: Dre TE stammt aus einer Zeit, wo man 5 Zeilen aus einem Buch abtippte und das Ergebnis war auf dem Bildschirm. Kenn ich auch noch, sowas.

Diese Zeiten sind schon lange vorbei.

Es braucht nun ein wenig Einarbeitung, bis man begriffen hat, das es keinen Grafikmodus mehr gibt (weil man durch das Betriebssystem schon längst im Grafikmodus ist) und bis man verstanden hat, wie man nun einen Pixel irgendwo hin setzt.

Die Konvertierung ist wohl möglich.

Abt verlangt von dir nur, das eindimensionale Array in das zweidimensionale Array umzuwandeln, von dem er dir nicht verrät, wie es aussieht.

Denn genau das verlangst du vom SQL-Server bzw. deinem Programm auch, weshalb das ganze mit einer unwillig wirkenden Fehlermeldung antwortet.

Aber mich verwundert es, dass das Thema noch fortgeführt wird.
Hier ist eigentlich nicht der richtige Ort um Netzwerkthemen, die nichts spezifisches mit Programmierung sondern mit Netzwerkgrundlagen/Einrichtungen zu tun haben, behandelt werden.

Warum denn auch nicht - ist ja der Offtopic-Bereich hier. Was mir die Gelegenheit gibt, den Finger mahnend zu erheben und darauf hinzuweisen, das der Versuch einer (D)DOS-Attacke bereits eine strafbare Handlung darstellt. Auch wenn es nur experimentell oder aus Jux ist. Solange man das ganze auf einen Server losläßt, der nicht von einem selbst kontrolliert wird, ist das Computersabotage.

Aber zum Glück machen wir solchen Kleinkinder-Blödsinn nicht 😉

Viele der Neuerungen, die angedacht sind, finde ich super. Speziell die out-Geschichten, die immer etwas hakelig waren und der Stunt mit den Tuples.

Defnitives No-Go sind aber IMHO die lokalen Prozeduren. Ich kenne dieses Konstrukt aus Delphi, das ich über Jahrzehnte verwendet habe, bis ich in die C#-Schiene gewechselt habe. Und glaubt mir: Die Dinger taugen zu rein gar nichts. Sie machen den Code erheblich unlesbarer und sehr viel schwerer zu durchschauen.

Das mag zum Teil daran liegen, das ich sehr viel mit "altem" Code zu tun habe. Prozeduren mit > 10k LOC sind da wahrlich keine Ausnahme, sondern die Regel. Dann noch 22 lokale Prozeduren dazu und du siehst wirklich gar nichts mehr. Ich entnehme dann in aller Regel diese lokalen Prozeduren und mache Unit-interne Prozeduren daraus, was den Code solcher Monster-Funktionen fast immer erheblich einfacher zu durchschauen macht.

Glaubt einem mit 20 Jahren Erfahrung mit diesem Zeugs 😉 Dies ist einer der Syntax-Zucker-Elemente, die auf gar keinen Fall in meinen C#-Code gelangen.

Wenn es nicht zuviele Forms werden und der Satz an Kommandos von der SIO (Serial I/O) ist bekannt, wäre dies vielleicht ein praktikabler Weg:

Erstelle alle Forms, die zu den SIO-Kommandos passen. Erzeuge ein Dictionary, in das du die Forms hineinpackst und dazu passend den Kommandostring von der SIO.

Wenn nun ein Kommando von der SIO kommt, kannst du im Dictionary nach diesem String suchen und die dazugehörige Form einfach anzeigen.

Aufräumen bei Programmende nicht vergessen 😉

Ím wesentlichen kann man hier problemlos einen normalen String verwenden.

Problematisch wird es nur, wenn diese Struktur in eine Datei geschrieben wurde und wieder ausgelesen werden soll. Dann muß man tatsächlich bei einem String*20 auch exakt 20 Zeichen auslesen - dies hat sonst der Compiler von VB6 für einen erledigt.

VS2013 macht das auch. Ich habe mich daran gewöhnt, einfach weiterzutippen. Ich habe festgestellt, das dies der schnellere Weg für mich ist - ansonsten müßte ich ja erst umständlich weg vom Buchstabenfeld zum Cursorblock, dort ENDE drücken und wieder zurück. Dauert länger als ") zu tippen.

Der PC reagiert da gar nicht auf das Gewackel an irgendeinem Pin...

Tatsächlich gab es damals™ Einsteckkarten für serielle und parallel Schnittstellen. Auf diesen war ein 40-Pin-Chip drauf, ein UART8250 oder (moderner) 16450 oder (noch moderner) 16550. DIESER reagiert auf das Gewackel an den Pins und wirft am Ende einen Interrupt am ISA-/PCI-/PCIe-Bus raus.

Auf diesen Interrupt reagiert der PC und holt das empfangene Byte aus dem UART heraus.

Ganz ehrlich: Das ganze ist wesentlich komplexer, als du ahnst 😁 Ohne ein gerüttelt Maß an Elektronikkenntnissen wird das schwer zu kapieren sein 🙂 Ich würde mich erstmal auf die Programmierung überhaupt konzentrieren, für die Details ist später noch Zeit.

Mit VS2013 Community und gegen .NET4.5 muß man eine Kleinigkeit beachten. Denn: Der Namespace "System.Configuration.Install" scheint gar nicht mehr zu existieren 8o Die MSDN-Hilfe von Microsoft führt auf eine völlig falsche Fährte (man ist geneigt zu glauben, das sei .NET3.5 und älter).

Tatsächlich muß man zunächst einen Verweis auf "System.Configuration.Install" hinzufügen, dann hat man auch einen ".Install"-Namespace und auch eine Klasse "Installer".

Am besten sieht man den Unterschied, wenn man den Inhalt des Arrays umdreht:

int[] meinArray = new int [] { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

Läßt du dieses Array durch die beiden Originalschleifen laufen, siehst du deutlich, was anders läuft.

Ich glaube, hier hat der TE den Unterschied zwischen Bytes und Zeichenketten noch nicht verstanden.

Empfängt man die Bytes "02 AE" und schreibt diese in eine Textdatei, dann zeigt Notepad nun mal nicht automatisch "44546" an, sonden zwei kryptische Zeichen.