Siehe mein Edit. (Math.Pow ist an der Stelle leichter lesbar, daher. Normal nimmt man natürlich die bitverschiebung). Und nein, zum Ausmaskieren checkt man auf 0.

LaTino
EDIT: viel zu selten verlinkt: [Artikel] Bitoperationen in C#

EDIT (letzter Edit, ich schwör): @th69 jetzt weiss ich, was du machen möchtest...wenn du so vorgehen willst, checkst du, ob bit i als einziges bit gesetzt ist. ((1 << i) & dataAsNumber) == (1 << i)) würde sogar gehen dann. Wenn man wissen will, ob bit i gesetzt ist, checkt man auf != 0.

Da fragt man sich schon, was du da eigentlich erreichen möchtest und wieso du jedes mal noch auf binär verweist...du machst da Handstände, wo nicht klar ist, wozu.

var data = " ;0002";

var dataAsNumber = Convert.ToInt32(data.Trim(' ',';'), 16);

for (int i = 0; i < 12; i++)
{
    if(((int)Math.Pow(2,i) | dataAsNumber) == dataAsNumber) Console.WriteLine($"Eingang {i+1} ist an.");
}

LaTino
EDIT: mal abgesehen von deiner umständlichen Weise, eine hex-Zahl auszulesen - beim zweiten Lesen scheint mir, als ob dir einfach nicht klar ist, wie der bitweise &-Operator funktioniert.

Binär 5: 101
Number in deinem Beispiel: 2 entspricht 010

&-Verknüpft: Ergebnis ist 000 (exp 2: 1 & 0 = 0, exp 1: 0 & 1 = 0, exp 0: 1 & 0 = 0, macht 000)
000 ist 0 (in jeder Zahlenbasis 😉 ) und das ist != number (s.o., ist 2).

Für eine Prüfung "ist bit i in Zahl n gesetzt?" lautet die bitweise Operation:
(n | 2^i) == n ("wenn ich an Stelle i das Bit auf 1 setze, bleibt der Wert dann gleich?")

Alternative Prüfung dazu (wie die funktioniert, ist Hausaufgabe :evil: ):
(n & (1 << i)) != 0

Aber das sind eigentlich wirklich Grundlagen.

Du bist da ein bisschen auf dem Holzweg. Was du da hast, ist kein Vorschlag, sondern eine Quick Action, d.h. eine mögliche Refaktorierung, die du an der Stelle vielleicht vornehmen willst. Dh das ist nur eine Hilfe für den Fall, dass du die Property umgestalten willst. Hast du das nicht vor - ignorier die quick action 😃. Ein besseres Beispiel für eine derartige Quick Action nwäre zB die angebotene Möglichkeit, ein if-else-Statement in ein switch umzugestalten (und anders herum). Auch das ist nicht BESSER, nur anders.

Und ja, sowohl die Stelle als auch die Art der Umgestaltung sind eher...dämlich. Dedizierte Tools wie Resharper spielen da immer noch in einer ganz anderen Liga. Im Anhang Resharpers Vorschläge (die Quick Action ist immer noch da, 5. Option im Screenshot).

Grüße,

LaTino

Ich sag's ungern, aber dein Bild besteht aus 8 Polygonen, von denen nur 4 Dreiecke sind...

LaTino

Nunja, xbox revenue allein ist so bei 2-3,5 mrd USD / Quartal (schwankt halt quartalsweise recht stark), Surface geht zwischen 800 Mio und 1.5 Mrd USD - damit ist man schon jenseits von 15-20% Consumer und hat die letztens sehr, sehr starke Consumer-Office-365-Sparte noch nicht mal berücksichtigt.

Wie dem auch sei: Apple hat (wenn ich die Zahlen richtig im Kopf habe) 2017 fast 10mal soviel verdient (um die 40 Mrd Profit) wie Microsoft, und zwar (beinahe) ausschließlich mit B2C. Der Vergleich hinkt also wirklich.

LaTino

Tut mir wirklich leid, dass ich nicht alle Produkte der letzten 27 Jahren aufgelistet hab.

Darum ging's nicht. Das von dir skizzierte Bild des Konzerns, der von B2B lebt und keine Ahnung von B2C hat, ist einfach nicht richtig. Ein kurzer Blick in die Finanzberichte zeigt das. Microsoft hat drei Reporting-Segmente, und das Consumer-Segment ("More Personal Computing", ausschließlich Consumer-Geschäft plus Bing) ist das mit Abstand größte. Microsoft kann man also nicht als B2B-Konzern bezeichnen, und erst recht ist die Aussage, 90% des Umsatzes sei aus B2B-Geschäften, einfach mal komplett falsch. Richtig ist lediglich, dass die Ausrichtung des Konzerns überhaupt nicht mit bspw. Apple vergleichbar ist.

LaTino

Aber ja, Microsoft hat von Konsumgütern absolut keine Ahnung in meinen Augen - bis auf die Surface Reihe.

Xbox.
Die sehr erfolgreichen Mäuse.
Natural keyboard. (wie lange gibt's die Reihe jetzt schon? 20 Jahre?)

"absolut keine Ahnung"....aha.

LaTino

Die Antworten (EDIT: bis auf p!lle) stimmen zwar inhaltlich, erklären aber nicht das Phänomen, das wir hier haben.

Was hier steht:

Console.WriteLine((int)(100 * 18.9));
//Output: 1889
//übrigens:
Console.WriteLine(100 * 18.9); //hu?

Obacht beim Arbeiten mit Gleitkommazahlen 😃.

LaTino
EDIT: wer sich fragt, was da beim "hu?" los ist: https://referencesource.microsoft.com/#mscorlib/system/double.cs,de581d5a1a6b2a1a

Die Klasse, die du oben erwähnt hast, mit Property A - wo du eine Instanz hast, an die dein Form gebunden ist - das ist eigentlich schon ein Controller. Er vermittelt zwischen View und Model(s) und steuert das Verhalten und den Zustand der beiden. Dazu braucht er eine Abbildung von eventuellen UI-Logiken (zB Validierung, interessiert uns an der Stelle nicht) sowie Kenntnis darüber, wie Daten aus dem Model bei ihrer Anzeige umzuformen sind. Punkt 1 lagerst du in eine Basisklasse aus, Punkt 2 in konkrete Implementierungen dort, wo sie sich unterscheiden, in deinem Fall eben bei den verwendeten Skalen.

LaTino

Guten Morgen.

Ich werde euren Rat befolgen und alle Properties des Models in den Controlern bereitstellen obwohl m. E. weder das Model noch die Controler eigentlich wissen müssten, welches System in der GUI eingestellt ist (ähnlich dem Dezimaltrennzeichen).

Der Controller steuert die UI. Natürlich sollte er über ihren Zustand informiert sein. Tatsächlich ist er sogar der einzige, der ihren Zustand ändern darf. Das Model braucht diese Information wirklich nicht.

LaTino

Die Aufteilung der Zuständigkeiten wird in WinForms so gut wie immer über das MVC-Pattern (Model-View-Controller) realisiert, DEN Controller meine ich. Ich war davon ausgegangen, dass, wenn ihr schon lobenswerterweise DataBinding benutzt, die Trennung entsprechend auch realisiert ist (alles andere würde nicht sehr viel Sinn ergeben). Falls das nicht so ist, müsstet ihr das sowieso nachholen bzw konsequenter umsetzen: so, wie ich dich verstehe, ist deine Klasse mit der Property A
der Kern eines zu entwickelnden Controllers. Das ist nicht so viel Aufwand, wie es klingt, ich würde vermuten, dass ihr da schon mehr als die Hälfte von dem habt, was ihr braucht.

([Artikel] Drei-Schichten-Architektur)

LaTino

In WinForms? Den Controller splitten in abstrakten BasisController mit Implementierungen für anzuzeigende Skalen. Dann kannst du on the fly den Controller austauschen und kriegst die passenden Werte in den gebundenen Steuerelementen.

LaTino

Servicepost.

LaTino 😉

Hallo zusammen,

ich wundere mich, dass meine Abfrage:

  
if (!Int32.TryParse(selectedOrderLine.Gr_1, out int parsedInt) && parsedInt - 1 > -1)  
    selectedOrderLine.Gr_1 = "0";  
  

nicht funktioniert, bzw einfach nichts tut, wenn ich mein Programm ausführe.

Ich nicht so sehr. Wenn TryParse fehlschlägt, hat deine implizit deklarierte Variable parsedInt den Wert 0, und der abzüglich 1 ist nicht größer als -1. Diese Codezeile wird also nicht durchlaufen.

LaTino
EDIT: um's deutlicher zu machen: deine Bedingung entspricht, wenn man sie auseinandernimmt, dem Ausdruck !A && A, und der ist immer false.

Zum einen ist Reflection teu(r)er, wenn man Werte setzt - auslesen geht so.
Zum anderen darf bezweifelt werden, dass er tatsächlich soviele Controls hat, dass sich eine extene Bibliothek bezahlt macht. Ich würde behaupten, dass sich bei seinem Einsatzzweck Performancebetrachtungen nicht lohnen.

LaTino

Jein. Ich benutze in diesem Szenario VS gar nicht (mal abgesehen vom Projektfile). Ausschließlich powershell und nuget (4.4.1). Möglich aber, dass eine ähnliche Ursache vorliegt, ich schau mal ob ich was finde dazu.

LaTino

Ich versuche momentan, unsere buildscripts um einige Projekte zu erweitern, aus denen direkt nuget-Pakete erstellt (und später auf dem Intranet-Nugetserver bereitgestellt werden) sollen und stolpere über ein Verhalten, das ich mir nicht erklären kann.

nuget pack -Build .\project.csproj -Prop Configuration=Release

Buildvorgang läuft durch, beim Pack-Step kommt dann:

Fehlermeldung:
Der Buildvorgang wurde erfolgreich ausgeführt.

//ein paar zeilen warnung wg Prozessorarchitektur weggelassen

Verstrichene Zeit 00:00:00.68

Paketerstellung der Dateien aus "C:\pfad\zu\solution\project\bin\Release\PublishOutput\solution\bin\Release".
Ein Teil des Pfades "C:\pfad\zu\solution\project\bin\Release\PublishOutput\solution\bin\Release" konnte nicht gefunden werden.

...was mich nicht wundert, weil es den Pfad nicht gibt und das Ergebnis des Buildprozesses brav dort liegt, wo es soll (c:\pfad\zu\solution\project\bin\release). Habe jetzt an einigen Einstellungen herumprobiert - egal, was ich tue, nuget beharrt auf diesem Pfad.

Kommt das jemandem bekannt vor? Ich bin erst einmal mit meinem Latein am Ende.

LaTino
(Interessant auch die "PublishOutput"-Erwähnung: das Textfragment "PublishOutput" kommt in keiner Datei im gesamten Solution-Verzeichnis vor...wtf?!

Gibt es irgendwie ne Möglichkeit, da dennoch an eine aussagekräftige Fehlermeldung ranzukommen, denn ich bin inzwischen hier mit meinem Latein am Ende, was VS zu k*cken hat ... 😭

Eigentlich steht da genug. An die Anwendung ist (sehr wahrscheinlich) ein Debugger angehängt, der sich im Haltemodus befindet. Wenn du nicht derjenige bist, der das debugging initiiert hat, dann häng dich selbst in die Anwendung und schau nach, wer das ist, und wieso.

VS hat nix zu k*cken, sondern geht davon aus, dass ein Entwickler am Bildschirm sitzt.

LaTino

WCF hat die steilere Lernkurve. Wenn man beides noch nicht kennt, hat man mit WebAPI schneller ein funktionierendes Ergebnis. (Mit WCF hat man daegegen das bessere Ergebnis in diesem Fall. net.tcp drängt sich ja geradezu auf, da stimme ich BhaaL zu.

Klingt eher wie etwas, das ich über ein Plugin-System lösen würde. Wie das mit dem "automatischen Entstehen" funktionieren kann, schrieb ich ja oben bereits.

LaTino

Geht das, ohne dass man für jeden neuen Entrag wieder im UI ergänzen muss? Eventuell eine Art automatisch generierte Tabelle oder sowas, die alles frisst und darstellt, was ihr geschickt wird?

Ja *. Ich würde die entsprechenden Methoden und ihre Parameter mit eigenen Attributen dekorieren und dann die Attribute bei der Erstellung des Optionsmenüs auswerten. Alles zusammen genommen klingt die Idee aber nicht so sexy - Ziel ist, wenig Optionen zu haben, und nicht automatisiert seine Einstellungen zuzumüllen.

LaTino

• grundsätzlich geht alles. Die Frage ist nicht, ob es eine Lösung gibt, sondern, ob ich das richtige Problem habe und wie eine gute Lösung dazu aussieht.

EDIT: @emuuu ich glaube nicht, dass das seine Frage war.

könnte man ja auch so umschreiben, dass die Exception im try geworfen wird.

Ja, könnte man, aber dann hätte man im Fall, dass eine Exception geworfen wird, die Erzeugung dieser Exception am Hacken, obwohl man die sowieso wegwerfen möchte. Man spart sich eine Propagation.

Eine exception, die im finally geworfen wird, sorgt dafür, dass eventuell im try geworfene Ausnahmen verworfen werden. Stattdessen wird die finally-Ausnahme hochgebubbelt.

C# Language Spec
*blätter*
S. 438 bei mir, Abschnitt 8.9.5. Lohnt sich, den ganzen Abschnitt mal gründlich zu lesen.

LaTino

Den Stacktrace deiner Ausnahme. Andererseits, wenn du den hast, kannst du das Problem auch selbst eingrenzen...

LaTino

Du hast die Tuple-Klasse falsch verstanden. Tupel sind Paare geordneter Werte. Was du suchst, ist eine Menge von Zeichenketten, denen eine Liste von double-Zahlenwerten zugeordnet ist. Das kann man zwar mit der Tuple-Klasse abbilden, aber dafür ist sie eigentlich nicht da (sondern eher für sehr kurzlebige Konstrukte).

class MappedValue
{
    public string Ident { get; set; }
    public IEnumerable<double> Values { get; }
    
    public MappedValue(string ident, IEnumerable<double> values)
    {
        //selbst ausfüllen
    }
}

public IEnumerable<MappedValue> GetValuesFromStream(Stream inputStream)
{
   using(inputStream)
   {
       while(...)
       yield return new MappedValue(...); //yield in einem using ist möglicherweise nicht optimal. Schwer einschätzbar ohne mehr Code von dir zu kennen
    }
}

LaTino

EDIT: [Hinweis] Wie poste ich richtig? pro Thema ein Thread. Jetzt muss ein Admin das Abtrennen, weil du zu faul warst 😦

Ich kann mich irren, aber der Fehler wird vermutlich (hier müssen wir raten, weil du uns diese Information vorenthältst) von dieser Zeile hier ausgelöst:

byte[] cipherBytes = Convert.FromBase64String(cipherText);

Ist, wenn ich nix übersehe, auch die einzige Zeile, die genau diesen Fehler bringen kann. Die Methode erwartet eine gültige Base64-Zeichenkette. Die Länge muss eine durch 3 teilbare Zahl sein, ist sie es nicht, werden hinten ein oder zwei Gleichheitszeichen angehängt, damit sie es wird. Offenbar ist dies in deinem Versuch nicht der Fall, weshalb der Fehler kommt.

Anders als von dir dargestellt wäre das aber in der Decrypt-Methode, nicht in der Encrypt-Methode. Wie gesagt, wir raten hier etwas.

LaTino

Wenn ich einen Btn hinzufüge wird ja automatisch im form.Designer.cs der code erzeugt. Anschließend kann ich den Namen in der GUI ändern der code wird auch geändert.
So was mich aber jetzt stört wenn ich etwas umbenenne wird meine Methode mit dem Ereignis Click nicht umbenannt.

Die Refactoring-Tools von Visual Studio werden zwar mit jedem Release besser, aber mit so etwas haben sie so ihre Schwierigkeiten. Dedizierte VS-Addons bekommen das naturgemäß viel besser hin, finden die meisten relevanten Erwähnungen und benennen die dann gleich mit um. Beispielsweise:

partial class SimpleBoundForm : Form
{
    public SimpleBoundForm(ExampleController controller)
    {
        InitializeComponent();
        _exampleTextbox.DataBindings.Add("Text", controller, "TextProperty");
    }
}

Wird jetzt per VS-Refaktoring die Property "TextProperty" der Klasse "ExampleController" umbenannt, übersieht VS diese Zeile, was zu einer ungültigen Datenbindung führt. Resharper (nur ein Beispiel) hat dagegen damit überhaupt kein Problem.

Langer Rede kurzer Sinn: die richtigen Tools verwenden, oder mit den Einschränkungen leben.

LaTino

Du willst für eine vorgegebene Zahl r zwei beliebige aufeinander folgende Primzahlen, die kleiner sind als [EDIT] eine zufällige Zahl, die kleiner ist als r[/EDIT]?

Ich habs eher so gemeint: Ich erzeuge eine Zufallszahl zwischen 0 und r. Dann uberprüfe ich ob diese eine Primzahl ist --> Nein --> Zufallszahl um eins erhöhen --> überprüfen
Wenn ich eine finde dann speichere ich diese in der Variable a ab.
Dan erhöhe ich wieder die Zufallszahl und speichere die nächste Primzahl in der Variable b ab.

Dann lautet deine Aufgabe also:
"Finde für eine gegebene Zahl x eine zufällige Zahl r zwischen 0 und x, und gib die ersten beiden Primzahlen p0 und p1 aus, für die gilt: r ≤ p0 < p1."

Lagerst du das Erzeugen der Zufallszahl in den Kontext aus (was du tun solltest, denn, wie Abt sagt: so funktioniert Random nicht), bleibt übrig:

Tuple<int, int> FindPrimes(int startValue) (bzw mit den neuen Tupeln (int FirstPrime, int SecondPrime) FindPrimes(int startValue))

Der Pseudocode dafür sollte sein:

in einer Endlosschleife
    ermittle, ob der Zählwert eine Primzahl ist
    wenn ja und bereits eine Primzahl gespeichert wurde
        gib ein Tupel aus bereits gespeicherter Primzahl und dem Zählwert zurück, beende Funktion
    wenn ja und noch keine Primzahl gespeichert wurde
         speichere Zählwert als erste Primzahl
    erhöhe den Zählwert um eins

Tatsächlich ist die gesamte Methode auch nur 5 Zeilen lang und du brauchst nur eine einzige lokale Variable (statt 4). Schau dir dafür mal das hier an. Werd' außerdem die Inline-Methode los, in diesem Fall bringt die dich nur dazu, sie mehrfach aufzurufen: bedenke, dass bei jedem Aufruf von IstPrim() eine Schleife durchlaufen wird, die für sehr große Zahlen eine Weile brauchen wird. Jeder zusätzliche Aufruf dauert dann wieder...

Das wichtigste, um wirkliche Zufallszahlen zu erhalten, wäre aber, das Random aus deiner Methode zu verbannen.

LaTino

Du missverstehst. Ich weiß die Lösung nicht genau, aber ich bin mir relativ sicher, dass es sich um ein Problem beim skalieren handelt, dafür ist das Bild typisch. Und deshalb solltest du, was du ja auch machst, alle Stellen, an denen (vielleicht) skaliert wird, eliminieren, danach Stück für Stück wieder einfügen und während der ganzen Zeit das Ergebnis abgleichen. Stattdessen machst du - so mein Eindruck - lieber einen Nebenschauplatz auf und diskutierst die Frage, ob du nicht DrawImageUnscaled benutzen kannst, obwohl im Quelltext von .NET zu sehen ist, dass beides identisch ist und eine Diskussion darum mehr als sinnlos. Bring das Bild erstmal unskaliert auf's Papier, prüfe die Qualität, dann skaliere so, dass du's unter Kontrolle hast (i.e. ohne Methoden zu nutzen, die implizit skalieren). So wird ein Schuh draus.

LaTino

"verkehrt" ist daran nichts, die Methode sieht halt so aus:

  
public void DrawImageUnscaled(Image image, int x, int y) {  
            DrawImage(image, x, y);  
        }  
  

Ich dachte allerdings, du wolltest dein Problem lösen und nicht Haare spalten. Mein Fehler.

LaTino

danke für deine Antwort, du meinst wahrschein DrawImageUnscaled.

Nein. Ich meine das, was ich schrieb. In der Dokumentation steht, welche Methode skaliert, und welche nicht: Graphics.DrawImage.

LaTino

Dein DrawImage-Aufruf skaliert das Bild, dabei gehen dir einige Informationen verloren. Stattdessen Bild vorher händisch skalieren und eine Überladung von DrawImage benutzen, die nicht skaliert.

LaTino

Das mag damit zusammen hängen, dass die URL in deiner Browserleiste mycsharp anzeigt, nicht myvb 😉

http://bfy.tw/EgZK

LaTino

Du willst für eine vorgegebene Zahl r zwei beliebige aufeinander folgende Primzahlen, die kleiner sind als [EDIT] eine zufällige Zahl, die kleiner ist als r[/EDIT]? Verstehe ich das richtig?

LaTino

Wie ist denn der Grund dafür, dass du das unbedingt selbst entwickeln möchtest?

(TLS)

Möglicherweise hast du ja gute Beweggründe, aber im Allgemeinen sind gerade im Sicherheitsbereich die etablierten Lösungen besser als alles, was man sich selbst am Küchentisch ausdenkt.

LaTino

Sehr ich auch so. Stellenausschreibungen oder auch Bewerbungen mit dem Begriff sind schon Papierkorb-Kandidaten. Erfahrungsgemäß nichts als heiße Luft.

LaTino

Damit mir keiner unkonstruktive Kritik vorwirft.

public delegate void SynchronizingEventHandler(byte[] data, bool writeToData);

public interface ISyncBehaviour
{
    event SynchronizingEventHandler Synchronizing;
    void RegisterNewSyncObject(SynchronizedObject syncObj);
    void SyncRead();
    void SyncWrite();
}

//"Observable"
public class SynchronizedObject
{
    private bool _isDirty;
    private int _value;

    public int Value
    {
        get => _value;
        set
        {
            if (EqualityComparer<int>.Default.Equals(_value, value)) return;
            _value = value;
            _isDirty = true;
        }
    }

    public SynchronizedObject(int value)
    {
        _value = value;
    }

    public void Sync(byte[] data, bool writeToData)
    {
        if (!writeToData) Value = BitConverter.ToInt32(data, 0);
        else
        {
            if (!_isDirty) return;
            _isDirty = false;
            var valueBytes = BitConverter.GetBytes(Value);
            Array.Copy(valueBytes, data, sizeof(int));
        }
    }
}

//"Observer"
public class ExampleClass : ISyncBehaviour
{
    public byte[] Data { get; } = new byte[sizeof(int)];

    public void Init(int value)
    {
        var bytes = BitConverter.GetBytes(value);
        Array.Copy(bytes, Data, sizeof(int));
    }

    #region Kann auch in eine abstrakte Basis verlagert werden
    public void RegisterNewSyncObject(SynchronizedObject syncObj)
    {
        Synchronizing += syncObj.Sync;
    }

    public void SyncRead() => OnSynchronizing(Data, true);
    public void SyncWrite() => OnSynchronizing(Data, false);

    public event SynchronizingEventHandler Synchronizing;
    protected void OnSynchronizing(byte[] data, bool writeToData) => Synchronizing?.Invoke(data, writeToData);
    #endregion
}

Natürlich wird bei mehreren synchronisierten Objekten data immer wieder überschrieben, aber das ist ja quasi eine Anforderung von dir (soll heissen: über das Thema hast du kein Wort verloren, und es ist auch in deinem Code so.)

Anwendung:

var synchronizedObjects = new List<SynchronizedObject> {new SynchronizedObject(10), new SynchronizedObject(20)};

var syncingContext = new ExampleClass();
syncingContext.Init(-100);
synchronizedObjects.ForEach(syncingContext.RegisterNewSyncObject);

syncingContext.SyncWrite(); //alle SynchronizedObjects haben jetzt denselben Wert
synchronizedObjects.ForEach(p => Console.WriteLine(p.Value));

synchronizedObjects.First().Value = 9999; //beide "dirty" markieren, damit sich beide melden
synchronizedObjects.Last().Value = 99;

syncingContext.SyncRead(); //der Wert aller SynchronizedObjects wird nach Data gelesen. Das letzte gewinnt.
Console.WriteLine(BitConverter.ToInt32(syncingContext.Data, 0));

LaTino

@LaTino:. Mal ehrlich, einen Bitoperator tippt man doch nun wirklich nur sehr bewusst ein!

Stimmt, damit hast du den Grund für meine Kritik präzise in einen Satz gefasst. Es hat immer - IMMER - das Prinzip der geringsten Überraschung zu gelten. Möglicherweise benutzt jemand deine Klasse, um Werte einer auf int basierenden flags-Enumeration zu speichern, und will dem aktuellen Wert ein Bit hinzufügen. Na, der wird sich umschauen.

Der Punkt ist, und ich formuliere es mal ganz hart: was du da machst, ist nicht weiter als möglichst originellen Code zu schreiben und sich auf die eigene Cleverness einen runter....naja. Nur: weder ist es clever, noch ist es kollegial, noch professionell. Wenn du das Bedürfnis nach so was hast: dafür gibt's Sprachen wie Brainfuck.

Der Rest deines Codes ist eine sehr krude Neuerfindung des Observer-Patterns. Wird in c# wie gesagt mit Events geregelt, in deinem Fall würde die Methode syncall einfach das Event feuern, und die Abonnenten würden sich dann eben synchronisieren.

Aber das wäre dir aufgefallen, wenn du nicht auf Gedeih und Verderb Elemente aus C in c# abbilden wollen würdest.

LaTino
EDIT: deine Operatorüberladung funktioniert übrigens nichtmal, du greifst im statischen Kontext auf eine Membervariable zu.

Joar, hab mich von dir aufs Glatteis führen lassen.

@LaTino
Width und Height kann man ja in der Draw Methode festsetzen.

Was natürlich nicht stimmt, denn während doc.Width und doc.Height die Dimensionen des SVG festlegen, legt Draw(int, int) die Größe der Rasterung fest.

Also einfach mal das tun, was ich im allerersten Post schrieb, dann klappt's auch mit dem Nachbarn.

LaTino
EDIT: das ist der Grund, wieso man a) sich Dokumentationen genau anschaut und b) Vorschläge aus dem Forum erst einmal 1:1 probieren sollte, bevor man selbst kreativ wird.

Es gibt direkt svg2xaml-Konverter. Die Möglichkeit, die Grafik direkt im View zu zeichnen, finde ich schon recht cool bei WPF. Abgesehen davon schau ich mir das morgen nochmal an, lässt mir keine ruhe.die lib sollte so Probleme nicht haben.

LaTino

Wait, what? Du überlädst den binären oder-Operator so, dass er sich nicht mehr wie ein binärer oder-Operator verhält?

Na, was soll dabei schon schiefgehen.

Zur eigentlichen Frage: was du da machst, erreicht man sauber und ohne Aufwand mit Events.

LaTino

Wir reden aneinander vorbei, oder?

• finde heraus, wieviel Platz dir in der Picturebox für dein Bild zur Verfügung steht (Hint: es ist NICHT PictureBox.Width/Height)
• rendere das SVG mit Hilfe von Draw() in dieser Größe
• setze die Quelle des Bildes der picBox auf den Output von Draw()

Ist jetzt nicht direkt Raketenwissenschaft 😉

LaTino
EDIT: Anhang.

Nein, ist richtig. Vorher möchte man das SVG noch in einer möglichst passenden Größe rendern, darum geht es. Ansonsten müsste man das gerenderte Bild skalieren, und dabei geht der einzige Vorteil von SVG flöten.

LaTino

Wenn ich mich richtig erinnere, zum skalieren einfach vor dem rendern width und height des svgdocument-objekts anpassen.

LaTino

Das wiederum entspricht nicht den Anforderungen, dass Kommas nicht in den Werten ersetzt werden sollen.

@TE: Hier, das Werkzeug deiner Wahl: Regex.Replace()

...und hier ein Hilfsmittel zum Ausprobieren: RegEx 101

Damit hast du alle Tools, die du brauchst.

LaTino
EDIT: für den Fall, dass wirklich ALLE Werte IMMER in Anführungszeichen stehen, geht auch die Variante von ThomasE, aber nach meiner Erfahrung kann man sich da nicht drauf verlassen.

Du bist ziemlich schnell auf deiner Insel der Eingeschnappten, kann das sein?

Es ist zu spät, mit richtiger Serialisierung zu beginnen, weil du schon mitten im CSV-Frickeln bist. Das ist ein Fakt, oder etwa nicht? Und ich wage mich nicht zu weit auf's Glatteis, wenn ich vorhersage, dass dich das in Schwierigkeiten bringt, sobald du versuchst, mit XML zu arbeiten. Das ist schade, weil's dich beim Lernen frustrieren wird, aber jetzt nun einmal nicht mehr zu ändern. Es sei denn natürlich, du hättest eine Zeitmaschine.

LaTino
(EDIT: und wirklich, du solltest etwas abgeklärter sein und nicht alles sofort auf deine Person beziehen.)

Ich finde, dass es nicht schaden kann, wenn man sowas als kleine Übung mal gemacht hat.

Und ob es das kann.
Aus didaktischer Sicht ist das aber eine Katastrophe. Erst Serialisierung benutzen, DANN von Hand Textdateien schreiben und lesen - so herum wird ein Schuh draus. Ansonsten, das das wird dir jeder bestätigen, der mal C#-Kurse für Schüler oder Studenten gegeben hab, wird IMMER von Hand serialisiert und gefrickelt, wo man eine normale Serialisierung benutzen müsste.

Naja, ist hier eh zu spät.

LaTino

(Das alles könnte man sich sparen, wenn man ein vernünftiges Dateiformat anstelle von CSV genommen hätte...)