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 😦
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
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
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)
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:
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
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:
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.
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.)
Tu dir einen Gefallen und schau dir async/await an. Du machst dir das Leben so dermaßen unnötig schwer...
LaTino
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
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
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.)
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
Kannst du erläutern, wieso du glaubst, BeginInvoke nutzen zu müssen?
LaTino
Ergänzend zu dem, was p!lle schrieb:
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
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
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
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 😉
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
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:
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
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
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.
Macht man das nicht mit PictureBox.Load() ? (resp. ImageLocation)
LaTino
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);
}
}
}
[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
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
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
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
Nach meinem Verständnis müsste das optimale Ergebnis so bestimmt werden können:
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
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
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
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
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
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:
Mr-Know-It-All, vielleicht beschäftigst du dich mal ein bisschen mit Zeichensätzen und Schriftarten?
LaTino
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...
@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
In der RichTextBox einfach eine Festbreitenschriftart einstellen, war dir zu einfach?
LaTino
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 😉
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:
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
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
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
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
@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
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
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
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
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
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.)
Oder bring den Ausdruck in die KNF, dann sieht man's sofort.
LaTino