Laden...
Avatar #avatar-4122.png
LaTino myCSharp.de - Experte
Softwareentwickler Thüringen Dabei seit 03.04.2006 3.003 Beiträge
Benutzerbeschreibung

Forenbeiträge von LaTino Ingesamt 3.003 Beiträge

10.03.2017 - 07:54 Uhr

Ich meinte schon die "repair"-Option im Setup. Wenn man die VS2008-CD noch griffbereit hat 😉. Funktioniert bestens - zum Glück, sonst wäre das ein K.O.-Kriterium für VS2017 gewesen[1].

LaTino
[1] wir haben noch aktive und hunderttausendfach im Einsatz befindliche CE-Software 😦

10.03.2017 - 07:50 Uhr

Das sind so Fragen, bei denen es sich lohnt, richtig tief in den Urschleim einzutauchen. Wenn du die Zeit noch hast, schau dir an, wie Arrays in C (nicht C#, nicht C++) funktionieren. Im Grund hat T-Virus schon grob erklärt, was da vor sich geht - zum besseren Verständnis lohnt eine Beschäftigung mit C. (Expert C Programming: Deep C Secrets gibt's auch als Kindle-Edition und ist ganz nebenbei auch noch richtig unterhaltsam.)

LaTino

10.03.2017 - 07:41 Uhr

Hat hier jemand schon einen ähnlichen Werdegang hingelegt?

Jeder ist anders. Und 33 ist nicht alt (okay, ich würde es für zu alt halten, wenn jemand in dem Alter seine erste Ausbildung beginnt, aber auch da: besser spät als nie 😉 ). Ich habe als Softwareentwickler angefangen, mich mit Ende 20 selbstständig gemacht und bin dann jahrelang als Consultant durch die Gegend getingelt. Bis ich gemerkt hab', dass mir was fehlt. Und dann bin ich nach 8 Jahren zurück in ein gutes altmodisches Angestelltenverhältnis als Softwarearchitekt/-entwickler an richtig großen Projekten - und habe die Entscheidung keine Sekunde bereut. Langer Rede kurzer Sinn: wenn es das ist, was dich zufrieden macht - dann tu' es.

Zum Buch: ich halte "Schrödinger programmiert" sowohl inhaltlich als auch didaktisch für eine 100%ige Katastrophe. Und die verhältnismäßig vielen Posts hier im Forum, bei denen es Verständnisprobleme mit eben diesem Buch gibt, geben mir da Recht. Angesichts vieler besserer (teils kostenloser) Alternativen sollte sich das wirklich niemand antun müssen.

LaTino

09.03.2017 - 13:55 Uhr

Erste Nebenwirkung nach der Installation war, dass ich mit Visual Studio 2008 nicht mehr debuggen konnte.

Vielen, vielen Dank für den Hinweis, das hat einiges an Aufwand verhindert!

LaTino
(Repair der VS2008-Installation reicht aus, nur wissen muss man's)

08.03.2017 - 16:48 Uhr

Was Coffeebean höflich mit "mehr Steine in den Weg legen" umschreibt, würde ich schlicht und ergreifend als irreführend bis völlig falsch bezeichnen. Ich würde mich zu der Aussage versteigen, dass außerhalb eures Klassenraums kein Mensch existiert, der in der Lage ist, ein Tutorial mit dieser Terminologie zu verfassen, so schräg ist das Ganze. Nun gut, vielleicht muss man schon dankbar sein, dass überhaupt in einer Schule programmiert wird.

Nun hilft dir mein Geschimpfe nur bedingt weiter, daher ein paar Tipps:

  • arbeite die Literatur durch, die du hier genannt bekommen hast
  • spiel mit Visual Studio herum und probier mal ein paar andere Projektarten als "Windows Forms". Versuch beispielsweise, ein Programm, dass du für WinForms geschrieben hast, für eine Konsolenanwendung umzuschreiben.
  • du wirst nicht darum herumkommen, auf Englisch als Weiterbildungssprache zurückzugreifen
  • wenn es Video sein soll: LiveCoding mag ich persönlich ganz gerne.

Oberste Priorität hat aber, dass du die OOP-Grundlagen durcharbeitest, damit du besser verstehst, was passiert, und damit du überhaupt erstmal ein Vokabular bekommst, mit dem du mit anderen Programmierern reden kannst. Tech Speak funktioniert nur, wenn alle dieselben Vokabeln nutzen.

("verlinken" bzw "linking" zB ist für einen Softwareentwickler das hier, während das, was du so nennst, eher "referenzieren" oder "koppeln" genannt wird. Und so weiter. Ohen gemeinsame Sprache kommt man nicht weit.)

LaTino

08.03.2017 - 14:05 Uhr

Das meinte ich mit "ziemlich speziell". Deine Sätze ab "Simples Beispiel" zB sind - so nehme ich an - für einen Klassenkameraden von dir gut verständlich. Für uns hier (es sei denn, ich stelle mich gerade besonders dämlich an) ist kaum nachvollziehbar, von was du redest. Entsprechend wirst du kaum Guides finden, die in diesem Jargon gehalten sind und dazu auch noch der Vorgehensweise folgen, die ihr beigebracht bekommt. [1]

Ich habe gerade unseren Azubi gefragt, wie seine ersten Schritt bei der Implementierung eines neuen Projekts aussehen. Nachdem er sich überzeugt hatte, dass ich ihm keine Frangfrage stelle, kam: "äähm...Unittest-Projekt erstellen?" Und da hat er aus meiner Sicht völlig Recht. Dieser Schritt kommt bei dir dagegen gar nicht vor - so unterschiedlich sind die Herangehensweisen.

Soweit nur zur Veranschaulichung, wieso ich davon ausgehe, dass du nichts finden wirst, dass exakt euern Unterricht abbildet. Es gibt DIE Herangehensweise nicht, und wenn das bei euch noch so ist wie bei uns damals in der Schule, dann fährt man (bei vielen Lehrern) am besten, wenn man alles so macht, wie sie es selbst machen. Deine beste Chance sind also die Unterrichtsmaterialien.

LaTino

[1] weil dir das evtl nicht klar ist, mal eine Auflistung aller Begriffe in deinen Sätzen, die ich eher ungewöhnlich finde bzw bei denen ich nicht direkt weiß, was gemeint ist:

  • Zusatz-Klasse / Operatoren (keine Ahnung, was du meinst, ehrlich gesagt.)
  • verlinken einer Klasse in eine andere
  • Nebenklasse/Hauptklasse
  • "offene" Methoden
    In dem Unterricht würde ich ja gern Mäuschen spielen 😄.
08.03.2017 - 13:35 Uhr

Schau dir vielleicht einfach erst mal das Openbook zur Objektorientierung an: http://openbook.rheinwerk-verlag.de/oop/. Die Vorgehensweise, die du beschreibst, finde ich ziemlich speziell - soll heissen, die Anforderungen, die da an euch bestehen, sind sehr stark geprägt von demjenigen, der euch das ganze beibringt. Insofern - ich kann mich täuschen - zweifle ich sehr stark daran, dass es etwas im Netz gibt, dass EXAKT dem entspricht, was von euch erwartet wird.

(Das geht zB damit los, dass ich die Begriffe "Hauptklasse" und "Nebenklasse" gerade zum ersten Mal gelesen habe, obwohl ich schon ein paar Jährchen Erfahrung auf dem Buckel habe.)

Dir wird nicht viel anderes übrig bleiben, als von dem Material aus dem Unterricht so viel wie möglich zu verinnerlichen und zu üben, üben, üben.

LaTino
PS: Video? Ernsthaft? Geschriebenes >>> Video, meiner Erfahrung nach. Schon allein, wenn man nochmal was nachschlagen muss.

07.03.2017 - 07:54 Uhr

Wenn du noch am Anfang bist und dein Lehrer es noch nicht geschafft hat, dich mit dem prozeduralen Ansatz (== "wir verschachteln so lange Schleifen, bis keiner mehr durchblickt, und wenn unser Programm einmal läuft, lassen wir um Himmels Willen die Finger davon, sonst läuft es auf einmal nicht mehr, und keiner weiß, wieso") völlig zu versauen, dann könnte dir ein wenig Linq vielleicht sogar etwas Erleichterung verschaffen.


//Initialisierung der 70 Labels wie gehabt, die Initialisierung der BackColor kannst du sogar weglassen.
//Achtung: alles eine Zeile, wegen der Kommentare teil ich es in mehrere auf
Enumerable.Range(1, 70).ToList() //einfach: nimm alle Zahlen von 1 bis 70.
    .ForEach(index => //für alle diese Zahlen, wobei wir bei jedem Durchlauf die Zahl "index" nennen
        myLabels.Where((label, labelIndex) => labelIndex % index == 0) //nimm von den Labels diejenigen, deren Nummer im Array bei Teilung durch den aktuellen Index den Rest 0 haben - index 1: alle, index 2: jedes zweite, index 3: jedes dritte...usw.
        .ToList().ForEach(SwitchColor)); //für diese Labels führe die Methode SwitchColor durch.

//noch diese Methode: wenn der Hintergrund schon grün ist, wird er rot, wenn er irgendwas außer grün ist, wird er grün (daher kann man die Initialisierung weglassen)
private static void SwitchColor(Label label) => label.BackColor = label.BackColor == Color.Green ? Color.Red : Color.Green;

Durch die Enumeration von 1 (nicht zwei) bis 70 spart man sich den ersten Durchgang, wo man alle auf Grün setzt.

LaTino
(Disclaimer: die beiden Zeilen hat einer unserer Azubis geschrieben. Bevor einer sagt "linq kapiert doch keiner". Das ist zwar richtig, aber nur, weil es nicht von Anfang an gelehrt wird. Linq ist EINFACHER als verschachtelte Schleifen.)

28.02.2017 - 09:10 Uhr

Tu dir einen Gefallen und schau dir async/await an. Du machst dir das Leben so dermaßen unnötig schwer...

LaTino

28.02.2017 - 07:40 Uhr

S.a. XAttribute.


var parsedItem = XElement.Parse(@"<item pos=""1"" itemType=""LENS"" sideStr=""R"">foo</item>");

Debug.Assert(parsedItem.Value == "foo");
Debug.Assert(parsedItem.HasAttributes);
new List<string> {"pos", "itemType", "sideStr"}.ForEach(p => Debug.Assert(parsedItem.Attribute(p) != null));

LaTino

27.02.2017 - 11:13 Uhr

Außerdem:

Codezeile eins besteht aus Deklaration ("es gibt eine Variable port vom Typ SerialPort") und Instanziierung ("erstelle eine neue Instanz der Klasse Serialport").

Codezeile zwei besteht nur aus der Deklaration, dh die deklarierte Variable ist noch null.

Zudem könnte es sich bei Codezeile eins um eine lokale Variable (deklariert, instanziiert und verfügbar nur innerhalb einer Methode) oder um eine Instanzvariable (deklariert, instanziiert und verfügbar innerhalb einer Instanz einer Klasse) handeln, das wird nicht komplett klar.

Wenn "Private" in Codezeile 2 richtig geschrieben wäre (nämlich klein), würde es sich definitiv um eine Instanzvariable handeln. Der Begriff "statíc" modifiziert diese Instanzvariable so, dass sie zu einer statischen Variable wird, auf die man über den Klassennamen zugreifen kann, ohne eine Instanz zu haben (und die, wie DaMoe80 schreibt, unabhängig von irgendwelchen erzeugten Instanzen immer denselben Inhalt hat.

LaTino

27.02.2017 - 07:49 Uhr

ASP.NET Core 2.0 kommt wohl im April und bekommt auch ein paar neue Features.

Die offizielle Roadmap sagt was anderes. (Q3/17) Was stimmt nun?

LaTino

(Mini-Rant, und völlig OT: net core wird - abseits von sehr kleinen Web-Neuentwicklungen auf der grünen Wiese - so lange ignoriert, wie es keinen Oracle EF Core Provider gibt [1]. Schade drum, einige Konzepte sind wirklich gut, sogar so gut, dass man das grottenschlechte Tooling darüber vergessen könnte.
[1] ist mir klar, dass das nicht die Schuld vom net core-Team ist. Aber so ist die Situation.)

23.02.2017 - 10:10 Uhr

Das ist zwar eine Antwort, sie passt nur leider nicht zur Frage 😉

Es existieren BeginInvoke() und Invoke(), und die Frage war, wieso du Ersteres nutzt. Davon abgesehen würde man einfach so etwas hier machen:


if (InvokeRequired)
    BeginInvoke(new MethodInvoker(() => myTextBox.Text = e.ActionString));
else
    myTextBox.Text = e.ActionString;

LaTino
EDIT: Das Locking ist unnötig. Invoke ist threadsafe.
EDIT2: zur Lektüre (ist wirklich nur ganz kurz) empfohlen: How to: Make Thread-Safe Calls to Windows Forms Controls

23.02.2017 - 09:52 Uhr

Kannst du erläutern, wieso du glaubst, BeginInvoke nutzen zu müssen?

LaTino

23.02.2017 - 09:46 Uhr

Ergänzend zu dem, was p!lle schrieb:

  • Event wird zum ersten Mal ausgelöst
  • in der Eventbehandlung wird die Instanzvariable "actionString" gefüllt und eine asynchron ablaufende Methode gestartet, die wiederum (offenbar) auf die Instanzvariable zugreift
  • während diese Methode läuft, wird das Event zum zweiten Mal ausgelöst
  • die Instanzvariable wird mit dem Wert der zweiten Auslösung überschrieben und die asynchrone Methode ein zweites Mal gestartet
  • jetzt läuft die asynchrone Methode also zweimal, während die Instanzvariable den Wert der zweiten Eventauslösung hat
  • peng

Entweder du überlegst dir eine bessere Weise, die Argumente der Ereignisse zu speichern, als immer wieder eine Instanzvariable zu überschreiben (da gibt es fertige Lösungen), oder du übergibst der asynchronen Methode direkt das Argument, wie p!lle vorgeschlagen hat. Kommt drauf an, was du vor hast.

LaTino

21.02.2017 - 12:51 Uhr

Ist ein Klassiker in C (fehlende SP -> undefined behavior). Ich hab' offenbar ein Brett vor dem Kopf - wo ist der coding horror? (Falls es die Tatsachge ist, dass die Reihenfolge der Abarbeitung in C eben nicht spezifiziert ist - naja, ist halt C, ne?)

Empfehle dazu Peter v.d. Linden: Expert C Programming - Deep C Secrets, er breitet da genüßlich noch weitere C-Seltsamkeiten aus.

LaTino

21.02.2017 - 07:30 Uhr

One note about extensions and Visual Studio: when we use behavior extensions, VS will usually issue a warning about a schema violation, and tag the extension with a squiggly line (see below). The warning states that it is not a valid child for the <behavior> element: “The element ‘behavior’ has invalid child element ‘myLogger’. List of possible elements expected: ‘clientVia, callbackDebug, callbackTimeouts, clear, clientCredentials, transactedBatching, dataContractSerializer, dispatcherSynchronization, remove, synchronousReceive, enableWebScript, webHttp, endpointDiscovery, soapProcessing’.” This is just a nuisance, as this error can be safely ignored and won’t cause any problems during runtime. But if you’re someone who gets bugged by warnings (or has a setting in the project to treat all warnings as errors, you can update the configuration schema in Visual Studio at \Program Files\Microsoft Visual Studio 10.0\Xml\Schemas\DotNetSchema.xsd (replace Program Files with Program Files (x86) for 64-bit OS, and replace 10.0 with the appropriate VS version) and update the schema to allow for this new element as well.

Im Prinzip könnte es also trotz der Schemawarnung funktionieren. In deinem Fall kommt mir die Referenzierung der Extension seltsam vor. Versuch's mal nur mit Angabe der Klasse und dll.


<add name="newtonsoftJsonBehavior" type="Newtonsoft.Json.Extensions.NewtonsoftJsonBehaviorExtension, NewtonsoftJsonExtensions" />

Wobei mir jetzt keine der Klassen irgendwas sagt und ich nur hoffen kann, dass die korrekt implementiert sind 😉.

LaTino

20.02.2017 - 16:58 Uhr

Irgendjemand ne Idee, warum er mir nicht alle "//" entfernt?

Ja, weil du gleichzeitig eine Liste enumerierst UND Elemente aus ihr entfernst. Sowas geht nie gut.

inflames2ks Ansatz ist da doch ein Stückchen eleganter. Man muss auch nicht die ganze Datei im Speicher halten, sondern kann sie gleich zeilenweise lesen:


private IEnumerable<string> GetNonCommentLines(string filePath)
{
    using (var reader = new StreamReader(filePath))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
            if (!line.Trim().StartsWith("//")) 
                yield return line;
    }
}

var result = GetNonCommentLines(language).ToArray();

LaTino

EDIT: Überschneidung mit inflames edit. Egal, ich lass es mal stehen 😉

20.02.2017 - 13:49 Uhr

Mach eine List<LambdaExpression> aus deiner myList.

Dass das dann funktioniert, erkaufst du dir allerdings damit, dass du bei der An/Auswertung des Filters die Signatur der Filtermethode wissen musst (damit du casten kannst).

LaTino

20.02.2017 - 11:24 Uhr

Wie gesagt, mit ein bisschen mehr Aufwand kannst du das sauberer lösen, indem du die Infrastruktur nutzt, die WCF dir dafür bietet, statt die Serialisierung von Hand zu beeinflussen (was wir gerade machen. Funktioniert erst mal, gehört aber eher in die Kategorie quick&dirty.)

Stichworte dazu:

  • IDispatchMessageFormatter
  • IDispatchMessageInspector
  • IServiceBehavior

Mit mittelgroßem Aufwand (~250 Zeilen) kann man ziemlich sauber eine WCF-Servicekonfiguration implmentieren, bei der man per .config einen Endpunkt definiert, der REST/JSON spricht und für die Serialisierung und Deserialisierung JSON.net benutzt. Und dann kann man wieder zurück zur eigentlichen Arbeit gehen, und wenn man einen JSON/REST-Endpunkt braucht, konfiguriert man ihn sich eben schnell, während der Service läuft.

LaTino

20.02.2017 - 11:10 Uhr

Lies dir mal die Beschreibung von ISerializable auf der MSDN in Ruhe durch, das sollte die Fragen beantworten und dir auch gleich sagen, wie dein Deserialisierungsproblem zu lösen ist (Hint: c'tor).

Die Frage, wieso ein override von Dictionary<TKey,TValue> nicht das tut, was er soll...kann ich aus dem Hut nicht sagen. Ich vermute, dass das Dictionary irgendwas anders/zusätzlich macht, an das man nicht ohne weiteres denkt. Dafür müsste man mal mit der Referenzsource debuggen, wenn einen das wirklich interessiert. (Ich gebs offen zu: meine Neugier ist da begrenzt 😉 ).

LaTino

20.02.2017 - 08:41 Uhr

Du könntest natürlich auch einfach einen Wrapper für ein Dictionary benutzen, ISerializable implementieren, GetObjectData korrekt überschreiben und dann in deinen Datenverträgen den Wrapper anstelle von Dictionary<T1,T2> benutzen.


class SimpleSerializedDictionary<TKey,TValue> : ISerializable
{
    private readonly Dictionary<TKey,TValue> _wrappedDictionary;
    //weggelassen: implementieren der üblichen Zugriffsmethoden für Dictionaries

    public void GetObjectData( SerializationInfo info, StreamingContext context )
    {
        _wrappedDictionary.ToList().ForEach(p => info.AddValue(p.Key.ToString(), p.Value);
    }

...fertig.

LaTino
PS: dein Anwendungsfall - SOAP und JSON/REST-Endpunkte parallel anbieten - liegt auch bei 75% der von mir betreuten WCF-Services vor. Meiner Meinung nach kann WCF hier richtig glänzen - das Zeug funktioniert einfach. (Genauso wie SOAP Anwendungsfälle hat, in denen es glänzen kann.) Die Technologie ist nicht halb so tot, wie sie gern geredet wird.

10.02.2017 - 16:52 Uhr

Macht man das nicht mit PictureBox.Load() ? (resp. ImageLocation)

LaTino

10.02.2017 - 13:38 Uhr

Ist wahrscheinlich einer dieser Tage 😉


//@Taipi: 
if(blubb) 
{
    DoSomething();
    bla();
}
else 
{
    bla();
}

//besser:
if(blubb) DoSomething();
bla();

//Pseudocode oben einfach (Zeile für Zeile) umgesetzt:
private IEnumerable<string[]> GetBlocks(string filePath)
{
    var blocks = new List<string>();
    using (var reader = new StreamReader(filePath))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            if (line.StartsWith("#") && blocks.Any())
            {
                yield return blocks.ToArray();
                blocks.Clear();
            }
            blocks.Add(line);
        }
    }
}

10.02.2017 - 12:38 Uhr

[Tipp] Anfängerhinweis == true / == false
Außerdem typischer Anwendungsfall für IEnumerable und yield return, wenn du schon Speicher sparen möchtest. Außerdem liefert dein Ansatz nur die Zeilen, die nicht mit '#' beginnen, anstelle von Blöcken.

LaTino

10.02.2017 - 09:05 Uhr

Geht es wirklich darum wenn die Zeile mit einem # anfängt oder einfach nur grundsätzlich nach jedem # trennen?

Wenn es wirklich darauf ankommt nur eine mit # beginnende Zeile auszulesen:

Weder, noch 😉. Unterteilung in Blöcke, deren erste Zeile jeweils mit # beginnen, und alle weiteren Zeilen nicht.

LaTino

10.02.2017 - 09:00 Uhr

Solange zeilen da sind, lies die nächste Zeile
   beginnt sie mit '#'?
   ja: 
       speichere Inhalte des Arrays, wenn vorhanden
       leere Array
   füge eingelesene Zeile dem Array hinzu

LaTino

09.02.2017 - 08:12 Uhr

Unter Umständen bist du sogar auf der sichereren Seite mit einem einfachen stringsplit. Bis zur Logmeldung sollte, soweit ich das sehen kann, die Anzahl der Leerzeichen bei jedem Logeintrag identisch sein, und ab da kannst du es wieder joinen. string.split und string.join sind beide wirklich schnell, insofern vergibst du dir nix. Nur als Gedanke 😃.

LaTino

09.02.2017 - 07:57 Uhr

Nach meinem Verständnis müsste das optimale Ergebnis so bestimmt werden können:

  1. starte beim Ziel
    2.1 Solange du nicht am Start bist:
    2.2 ermittle die am weitesten links stehende Zahl, die so viele Schritte vom aktuellen Feld entfernt ist, wie ihr Zahlenwert ist.
    2.2.1 wenn es eine gibt, ist die das neue aktuelle Feld
    2.2.2 wenn es keine gibt, mach dasselbe nach rechts, aber mit dem ganzzahligen Anteil der Hälfte. des Zahlenwerts des Feldes, und nimm das am weitesten links stehende Feld.
  2. drehe die Reihenfolge der gefundenen Felder um.

Ergebnis für dein Beispiel:
(Zahlenangabe: 8[4] ist die vierte 8 von links)
0[2]-7[2]-5[4]-5[3]-5[2]-5[1], also 6 Schritte.

EDIT: bei genauerem Nachdenken bin ich nicht mehr so sicher, dass man so die optimale Lösung findet, insb. weil man ebenso wie bei der Vorwärtssuche, die du machst, teilweise einige Schritte zurückgehen muss. Also mit Vorsicht genießen.

Grüße,

LaTino

07.02.2017 - 10:15 Uhr

leider werde ich daraus nicht schlauer. 😦

Hm, wieso nicht? Ich fand den Link und besonders den Beispielcode dort eigentlich ziemlich gut. Hast du dir das Beispiel mal heruntergeladen und ausgeführt? Reingesteppt? Am Code herumgespielt? Das sollte an sich alle Fragen beantworten.

LaTino

07.02.2017 - 09:14 Uhr

Nimm's mir nicht übel, aber die Frage liest sich etwa so:

"Ich möchte mir gern Einstellungen speichern. Ich weiss, dass es dafür bessere Möglichkeiten gibt, würde mir aber trotzdem gern in den Fuß schießen. Also, wie schieße ich mir am besten in den Fuß?"

.ini ist tot. Und das nicht erst seit gestern, sondern seit gut 15 Jahren, das Konzept weigert sich nur hartnäckig, zu sterben. Tu' dir einen Gefallen und beschäftige dich damit, wenn du es wirklich musst. Lern stattdessen, wie .NET das Problem von persistenten Einstellungen löst (ja, mit XML, aber soweit abstrahiert, dass einen das eigentliche XML nicht interessieren muss).

Nachdem ich das losgeworden bin:

Reading and Writing Values from INI Files with C#

(aber nachher nicht heulen, wenn der Fuß weh tut!)

LaTino

06.02.2017 - 15:04 Uhr

Am Topic arbeiten wir aber noch, ja? Da wird ja kein Mensch schlau draus 😄 (ebenso irreführend übrigens der Hinweis darauf, dass es um irgendwelche Packets geht).

Ich schau mal, ob ich's richtig verstanden habe.

Beim Einlesen erstellst du eine Liste aus Tupeln (2er-Paare) von ObjId und UniqueId.

Frage eins: wenn die UniqueId auch wirklich unique ist, nimm doch bitte ein Dictionary, dessen Schlüssel die UniqueId, und deren Wert die ObjId sind. (Dictionary<uint,uint>). Das befreit dich von der Last, auch prüfen zu müssen, ob die UniqueID eines neuen Objekts wirklich eindeutig ist oder wegen eines Fehlers schonmal vorkommt (sowas erledigt das Dictionarty gleich mit).

Nun soll - ich weigere mich wegen der Verwechslungsgefahr zum Disposing, das ganze "zerstören" zu nennen - ein Objekt mit einer bestimmten UniqueId wieder aus unserem Dictionary entfernt werden.

Naja:


//if( wenn in der liste wo (a und b) stehen a = c ist ) {
if(myDictionary.ContainsKey(c)) myDictionary.Remove(c);

Das ist so einfach, dass ich befürchte, ich hab' dein Anliegen komplett falsch verstanden. Falls dem so ist, erklär' es bitte noch einmal so, dass auch deine Oma es verstehen würde.

LaTino

06.02.2017 - 14:43 Uhr

Nicht nötig. Nur der überflüssige Quantifier ("?") in seiner regex hat ihm das Genick gebrochen.


var regex = new Regex(@"^(?<type>[A-Z]+)\s\((?<time>.*)\s+-\s+(?<source>.*)\)\s\[(?<message>.+)\]$");
var result = regex.Match(@"INFO (2017-06-02 10:12:22,625 - LOADER) [Forced listening port to [9083] in .config file]");

new [] { "type", "time", "source", "message" }.ToList().ForEach(p => Console.WriteLine(result.Groups[p]));

LaTino

06.02.2017 - 14:28 Uhr

\[(.+)\]

(Getestet.)

LaTino

06.02.2017 - 13:14 Uhr

Meine Güte. Hast du es wenigstens ausprobiert, was ich dir hier sage? Ich hab dir sogar den Code hingeschrieben, was brauchst du noch? Ja, ist ausprobiert, funktioniert hier bei mir lokal. Hätte mich auch gewundert, wenn nicht.

Nochmal zum mitmeißeln:

  1. Encoding wählen, Codepage 437 (das ist die übliche nfo-Codepage)
  2. beliebige - BELIEBIGE - Festbreitenschriftart einstellen, sehe screenshot oben

Mr-Know-It-All, vielleicht beschäftigst du dich mal ein bisschen mit Zeichensätzen und Schriftarten?

LaTino

06.02.2017 - 12:55 Uhr

Hier wird garnix illegal irgedwie kopiert oder sonstiges ... es geht nur um eine nfo datei einzulesen und sonst gar nix

und die Datei selber habe ich im netz gefunden .. also bitte nichts unterstellen !!!

Klar, und wir ziehen uns die Hosen mit der Kneifzange an. Macht man so, wenn der erste Kontakt mit Warez mehr als 25 Jahre her ist. Korrekte Codepage auswählen, beliebige Festbreitenschriftart verwenden. Steht so auch 1:1 in der Wikipedia, aber was wissen wir schon.

Leute gibt's...

06.02.2017 - 12:46 Uhr

@LaTino
leider geht das net ... falscher Zeichencode

Zeichencode? Meinst du eventuell Encoding? Wieso stellst du das nicht einfach ein?


using(var reader = new StreamReader(@"example.nfo", Encoding.GetEncoding(0x1b5))
   richtextbox1.Text = reader.ReadToEnd().Replace("\r", string.Empty);

Davon abgesehen war das von meiner Seite die letzte Hilfestellung beim Versuch, illegale Filmkopien zu archivieren. Pfui.

LaTino

06.02.2017 - 11:16 Uhr

In der RichTextBox einfach eine Festbreitenschriftart einstellen, war dir zu einfach?

LaTino

06.02.2017 - 07:45 Uhr

Spätestens an der Stelle würde ich auch nicht mehr von Hand parsen, sondern mein XML in die Zwischenablage tun, als Klasse einfügen, etwas refaktorieren und dann per XmlSerializer arbeiten:


var serializer = new XmlSerializer(typeof(TextureCollection));
TextureCollection collection;

using(var file = File.OpenRead("example.xml"))
using (var reader = XmlReader.Create(file))
    collection = (TextureCollection)serializer.Deserialize(reader);

...und fertig.

LaTino
EDIT: grad mit Stoppuhr in der Hand ausprobiert, Aufwand waren 48 Sekunden inkl. Erstellen der Klassen 😉

31.01.2017 - 16:23 Uhr

TimeSpan.Subtract()


myShinyNewTextbox.Text = tagesarbeitszeit.Subtract(TimeSpan.FromHours(8.5)).ToString();

Außerdem, sobald du das Windows.Forms-Projekt als richtiges Programm und nicht nur zur Ausgabe deiner Tests nutzen möchtest:

Windows Forms Databinding

Schließlich und endlich sind für Anwendungsfälle, wie du einen hast (sprich: "ich probier ein bisschen code aus und brauche nur eine Ausgabe") die sogenannten Unit Tests (Komponententests) perfekt geeignet.

Einführung in die Komponententests

Viel Erfolg beim Lernen!

LaTino

31.01.2017 - 15:39 Uhr
  
public int Bar => _data.Value;  
  

ist aber kurz und knapp und IMHO sehr gut lesbar und darum darf das dann bleiben.

Jupp. Ich würde behaupten wollen, der Hauptgedanke dahinter war tatsächlich, wrapping zu erleichtern. Zum Beispiel so ein Konstrukt hier, was in der Art hin und wieder mal vorkommen kann:


public class WrappingList<T> : IList<T> 
{
    private readonly List<T> _internalList;
    
    #region IList-Implementierung
     public IEnumerator<T> GetEnumerator() => _internalList.GetEnumerator();
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     
     //..usw usf.

    #endregion
}

Verringert den Tippaufwand einfach enorm und zeigt beim Lesen auch gleich an: "Achtung, nur ein Wrapper, bitte weitergehen, hier ist nichts interessantes!".

Ansonsten ist es eh' nur für Einzeiler geeignet. Wenn es da zu unübersichtlich wird, sollte man an seinem Stil arbeiten.

LaTino

31.01.2017 - 10:04 Uhr

Was Sir Rufo sagt. Ich wollte nur das Coderauschen (alles, was nicht relevant fürs Beispiel ist) gering halten. Die Schreibweise ist ab C# 6.0 (Visual Studio 2015) im Sprachstandard.


public string FormatAsShortDate(DateTime example) => example.ToString("d");
//ist dasselbe wie:
public string FormatAsShortDate(DateTime example) 
{
    return example.ToString("d");
}

public int CalculatedBmi => Mass / (Height * Height);
//ist dasselbe wie:
public int CalculatedBmi
{
   get 
   {
        return Mass / (Height * Height);
    }
}

LaTino

31.01.2017 - 07:48 Uhr

Ich wollt's gestern nicht noch editieren, aber wie gesagt, für eine reine "Konvertierung" Textdatei -> Textdatei ist Linq nicht (unbedingt) der beste Weg, besonders, wenn man in den Operationen Zeichenketten verkettet oder andersweitig mehrfach enumeriert werden muss.

Das laesst sich auch in wenigen Zeilen so erschlagen, dass der Leser (im Zweifel dein 12 Monate älteres ich) sofort nachvollzieht, was los ist:


var outputLines = new Dictionary<string, StringBuilder>();
using (var file = new StreamReader("input.csv"))
{
    string line;
    while ((line = file.ReadLine()) != null)
    {
        var splits = line.Split(';');
        if(splits.Length != 3) continue;

        if (!outputLines.ContainsKey(splits[0])) outputLines.Add(splits[0], new StringBuilder(splits[0]));
        outputLines[splits[0]].Append($";{splits[1]} {splits[2]}");
    }
}

using (var file = new StreamWriter("output.csv"))
    outputLines.Select(p => p.Value).ToList().ForEach(p => file.WriteLine(p.ToString())); //sortieren, filtern, was auch immer: hier, nach dem Select/vor dem ForEach ist der Zeitpunkt für Linq.

LaTino

31.01.2017 - 07:40 Uhr

@Abt, ich glaube, es geht bb1898 vielmehr darum:


private int GetInt() => 6;

DoThis(GetInt, 25);
DoThat(GetInt(), 25);

abstract void DoThis(Func<int> firstParameter, int secondParameter);
abstract void DoThat(int firstParameter, int secondParameter);

In dem Fall (ersterer) würde man aber von einem Delegaten sprechen. Insofern sehe ich da nicht die Verwechslungsgefahr, eher die Gefahr, den TE völlig unnötig zu verwirren.

LaTino

30.01.2017 - 16:32 Uhr

Zudem: schlechte Rechtschreibung aus fehlgeleiteter Tolleranz einfach zu ignorieren, hilft im endeffeckt niemandem. Darauf hunzuweisen jedoch schon.

Da hast du völlig Recht. Allerdings geht es nicht darum, jemanden auf Fehler hinzuweisen (da bin ich immer dabei!), sondern ihn gleich auszusperren, weil man sich von ihm respektlos behandelt fühlt. Und so sehr besonders und einmalig jeder von uns - besonders ich - hier ist, sollten unsere Gefühle beim Lesen eines scheinbar lieblos hingeschluderten Beitrags doch keine Rolle dabei spielen, wer hier mitreden darf, und wer nicht.

LaTino

30.01.2017 - 16:07 Uhr

Sich keine Mühe zu geben, einen ordentlichen Beitrag zu verfassen finde ich im Übrigen nicht nur schade, sondern respektlos!

Wir drehen uns im Kreis. Die "respektlos"-Argumentation wurde bereits diskutiert. Es ist nicht alles das, wonach es sich anfühlt, und die Moderatoren sehen sich (dankenswerterweise, möchte ich sagen) nicht bemüßigt, Beiträge danach zu moderieren, wie sie sich für einzelne Leser anfühlen könnten. Das sage ich als jemand, der in seinen Bekannten- und Kollegenkreisen als Rechtschreibnazi bekannt ist. Die Gründe für laxe Rechtschreibung sind vielfältig, und im Zweifel bin ich für den Angeklagten.

LaTino

30.01.2017 - 13:47 Uhr

Halte ich erstens nicht für einen besonders geeigneten Fall für Linq, und zweitens kannst du doch einfach den hier machen:


StringBuilder myStringBuilder = new StringBuilder();
erg.ToList().ForEach(element => 
{
    var idString = string.Join(";", element.ID_Menge);
    myStringBuilder.AppendLine($"{element.Gruppe};{idString}");
});

File.WriteAllText(outputFile, myStringBuilder.ToString());

In diesem speziellen Fall ist zeilenweises Einlesen, dabei "manuelles" Umgruppieren, und schließlich eine direkte Ausgabe vermutlich schneller und besser nachvollziehbar.

LaTino

30.01.2017 - 11:39 Uhr

Das zeigt wieder einmal das viele Leute nicht verstanden haben was das var statement ist.

Ohje, erst mit deinem Statement habe ich überhaupt verstanden, was die Vorposter dachten...das sind ja Abgründe.

@lukasS, das ist eher eine VBA-Frage: dein Ansatz, object[] zurückzugeben, ist mMn schon korrekt. Das Auspacken wird, wenn ich dich richtig verstehe, von deinem VBA-Schnippsel aus erledigt. Du müsstest also dort (und hier verlassen mich meine VBA-Kenntnisse - CTYpe oder so?) auf die wichtigsten Datentypen, die vorkommen können, testen, und entsprechend umwandeln.

LaTino

27.01.2017 - 15:00 Uhr

Bisschen umständlich, all das oO


(1) (!A & !B & C) | (A & !B & C) | (!A & !B & !C) =                    //!B ausklammern
(2) !B & (!A & C | A & C | !A & !C) =                                       //innen: C aus den ersten beiden ausklammern
(3) !B & (C & (!A | A) | !A & !C) =                                          //!A | A ist überflüssig
(4) !B & (C | !A & !C) =                                                        //aus"multiplizieren", i.e. erweitern
(5) !B & ((C | !A) & (C | !C))                                                 // C | !C ist überflüssig
(6) !B & (C | !A)                                                                  //und da ist schon die KNF

Schritt 4->5 wäre auch die Herleitung der Antwort auf deine Frage im ersten Post.

LaTino
(EDIT: falsche Ausgangformel. (mittlerer Term müsste !C sein, richtig?) Ändert aber nichts an den Schritten.)

27.01.2017 - 13:46 Uhr

Oder bring den Ausdruck in die KNF, dann sieht man's sofort.

LaTino