Gehe nicht davon aus, dass listView1.SelectedItems[0] existiert.
Wenn Du nichts auswählst, dürfe spätestens dann listView1.SelectedItems.Count == 0 sein und listView1.SelectedItems[0] würde dann nicht existieren --> Index out of Range.

oder

SomeClass someObject = obj as SomeClass;
if (someObject != null)
{
  //Cast erfolgreich
   ...
}

Ich stimme P!lle bei.

#nullable liest sich für mich auf dem ersten Blick als #nullableValuesAreNowAllowed und nicht als
#nullableExplicit oder #nullableReferenceTypes.

Die Benennung #nullableExplicit oder #nullableReferenceTypes hätte ich wesentlich besser empfunden.

Mein erster Gedanke war:

    public partial class Form1 : Form
    {
        //Dem Form1 noch folgendes hinzufügen:
        //
        // * TextBox mit Namen textBoxEingabe
        // * TextBox mit Namen textBoxAusgabe
        // * Ereignis Form1_Load
        // * Ereignis textBox1_TextChanged

        public Form1()
        {
            InitializeComponent();
        }

        List<Kombi> _kombis;
        private void Form1_Load(object sender, EventArgs e)
        {
            _kombis = new List<Kombi>();

            _kombis.Add(Kombi.GetKombi("Dreier", "1|1|2"));
            _kombis.Add(Kombi.GetKombi("Dreier", "2|4|6"));
            _kombis.Add(Kombi.GetKombi("Dreier", "3|7|8"));
            _kombis.Add(Kombi.GetKombi("Dreier", "4|10|12"));
            _kombis.Add(Kombi.GetKombi("Dreier", "5|7|1"));
            _kombis.Add(Kombi.GetKombi("Dreier", "6|4|10"));

            _kombis.Add(Kombi.GetKombi("Vierer", "7|1|2|7"));
            _kombis.Add(Kombi.GetKombi("Vierer", "8|4|6|10"));
            _kombis.Add(Kombi.GetKombi("Vierer", "9|7|8|1"));
            _kombis.Add(Kombi.GetKombi("Vierer", "10|10|12|4"));

            _kombis.Add(Kombi.GetKombi("Vierer Würfel", "11|1|10|11"));
            _kombis.Add(Kombi.GetKombi("Vierer Würfel", "12|1|4|5"));
            _kombis.Add(Kombi.GetKombi("Vierer Würfel", "13|4|7|3"));
            _kombis.Add(Kombi.GetKombi("Vierer Würfel", "14|7|9|10"));

            _kombis.Add(Kombi.GetKombi("Vierer Neuner", "15|2|6|14"));
            _kombis.Add(Kombi.GetKombi("Vierer Neuner", "16|6|8|15"));
            _kombis.Add(Kombi.GetKombi("Vierer Neuner", "17|8|12|16"));
            _kombis.Add(Kombi.GetKombi("Vierer Neuner", "18|2|12|13"));

            _kombis.Add(Kombi.GetKombi("Fünfer", "19|1|2|7|8"));
            _kombis.Add(Kombi.GetKombi("Fünfer", "20|4|6|10|12"));

            _kombis.Add(Kombi.GetKombi("Knickfünfer", "21|1|2|4|6"));
            _kombis.Add(Kombi.GetKombi("Knickfünfer", "22|4|6|7|8"));
            _kombis.Add(Kombi.GetKombi("Knickfünfer", "23|7|8|10|12"));
            _kombis.Add(Kombi.GetKombi("Knickfünfer", "24|10|12|1|2"));

            _kombis.Add(Kombi.GetKombi("T-Fünfer", "25|1|2|4|10"));
            _kombis.Add(Kombi.GetKombi("T-Fünfer", "26|1|4|6|7"));
            _kombis.Add(Kombi.GetKombi("T-Fünfer", "27|4|7|8|10"));
            _kombis.Add(Kombi.GetKombi("T-Fünfer", "28|1|7|10|12"));

            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "29|1|10|11|2"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "30|1|10|11|12"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "31|1|4|5|2"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "32|1|4|5|6"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "33|4|7|3|6"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "34|4|7|3|8"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "35|7|9|10|8"));
            _kombis.Add(Kombi.GetKombi("Würfel Fünfer", "36|7|9|10|12"));
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            try
            {
                //int[] istwerte = Werte.GetWerte("8|5").ToArray();
                int[] istwerte = Werte.GetWerte(textBoxEingabe.Text).ToArray();

                List<string> trefferTexte = new List<string>();
                foreach (var kombi in _kombis)
                {
                    if (kombi.Treffer(istwerte))
                    {
                        trefferTexte.Add(kombi.Anzeige());
                    }
                }

                if (trefferTexte.Count == 0)
                {
                    textBoxAusgabe.Text = "Keine Kombi";
                }
                else
                {
                    textBoxAusgabe.Text = string.Join(", ", trefferTexte.ToArray());
                }
            }
            catch (ArgumentException ex)
            {
                textBoxAusgabe.Text = ex.Message;
            }
        }
    }

    public static class Werte
    {
        public static int[] GetWerte(string text)
        {
            if (string.IsNullOrEmpty(text)) throw new ArgumentException("Keine Werte angegeben.");
            string[] felder = text.Split('|');

            List<int> ziel = new List<int>();
            {
                foreach (var feld in felder)
                {
                    int wert;
                    if (!int.TryParse(feld, out wert))
                        throw new ArgumentException("Keine gültiger Wert (\"" + feld + "\").");

                    ziel.Add(wert);
                }
            }
            return ziel.ToArray();
        } 
    }

    public class Kombi
    {
        //Eigenschaften:
        private string _Name = string.Empty; 
        public string Name { get { return _Name; } }

        private List<int> _Sollwerte = new List<int>(); 
        public List<int> Sollwerte { get { return _Sollwerte; } }

        public static Kombi GetKombi(string name, string text)
        {
            Kombi ziel = new Kombi();
            {
                ziel._Name = name;
                ziel._Sollwerte = new List<int>(Werte.GetWerte(text));
            }
            return ziel;
        }

        public string Anzeige()
        {
            List<string> solltexte = new List<string>();
            foreach (var sollwert in _Sollwerte)
            {
		        solltexte.Add(sollwert.ToString());
            }
            return _Name + ": " + string.Join("|", solltexte);
        }

        public bool Treffer(params int[] istwerte)
        {
            if (istwerte == null) return false;
            if (istwerte.Length != _Sollwerte.Count) return false;
            List<int> istrest = new List<int>(istwerte);

            foreach (var sollwert in _Sollwerte)
            {
                int istrestIndex = istrest.IndexOf(sollwert);
                if (istrestIndex == -1) return false;
                istrest.RemoveAt(istrestIndex);
            }
            return true;
        }
    }

Nachfolgend ein Link zum Verschwinden der Menüleisten:

Controls disappear from a form although they are still in the Designer code

Generell sollte man die Designer.cs nicht editieren. Stimmt schon.
Aber ich denke um die Menüleisten wiederherzustellen, kann man die Designer.cs editieren. Geht wesentlich schneller und ist sauberer als alle Menüeinträge neu zu erstellen. Vorausgesetzt man hält sich an die Designerschreibweise, wüsste ich jetzt nichts, was dagegen spricht.

Mit öffentliche Eigenschaft erstellen dachte ich eher an sowas:

        public class Communicator : IDisposable
        {
            //öffentliche Eigenschaft
            private MemoryStream _buffer = new MemoryStream();
            public byte[] buffer { get { return _buffer.ToArray(); } }

            public void AddBuffer(byte[] toAdd)
            {
                _buffer.Write(toAdd, 0, toAdd.Length);
            }

            private void _FreeManaged()
            {
                if (_buffer != null)
                {
                    _buffer.Dispose();
                    _buffer = null;
                }
            }
            private void _FreeUnmanaged()
            {
                //
            }

            public bool isDisposed { get { return this._disposed; } }

            #region Dispose

            // Track whether Dispose has been called.
            private bool _disposed = false;

            // Implement IDisposable.
            // Do not make this method virtual.
            // A derived class should not be able to override this method.
            public void Dispose()
            {
                Dispose(true);
                // This object will be cleaned up by the Dispose method.
                // Therefore, you should call GC.SupressFinalize to
                // take this object off the finalization queue
                // and prevent finalization code for this object
                // from executing a second time.
                GC.SuppressFinalize(this);
            }

            // Dispose(bool disposing) executes in two distinct scenarios.
            // If disposing equals true, the method has been called directly
            // or indirectly by a user's code. Managed and unmanaged resources
            // can be disposed.
            // If disposing equals false, the method has been called by the
            // runtime from inside the finalizer and you should not reference
            // other objects. Only unmanaged resources can be disposed.
            private void Dispose(bool disposing)
            {
                // Check to see if Dispose has already been called.
                if (!this._disposed)
                {
                    // If disposing equals true, dispose all managed
                    // and unmanaged resources.
                    if (disposing)
                    {
                        // Dispose managed resources.
                        _FreeManaged();
                    }

                    // Call the appropriate methods to clean up
                    // unmanaged resources here.
                    // If disposing is false,
                    // only the following code is executed.
                    {
                        //Unmanaged code like Handles
                        _FreeUnmanaged();
                    }

                    // Note disposing has been done.
                    _disposed = true;

                }
            }

            // Use C# destructor syntax for finalization code.
            // This destructor will run only if the Dispose method
            // does not get called.
            // It gives your base class the opportunity to finalize.
            // Do not provide destructors in types derived from this class.
            ~Communicator()
            {
                // Do not re-create Dispose clean-up code here.
                // Calling Dispose(false) is optimal in terms of
                // readability and maintainability.
                Dispose(false);
            }
            #endregion
        }

Aufruf:

            using (Communicator communicator = new Communicator())
            {
                communicator.AddBuffer(Encoding.Default.GetBytes("Hallo "));
                communicator.AddBuffer(Encoding.Default.GetBytes("Welt."));

                //Ausgabe: "Hallo Welt."
                byte[] current = communicator.buffer;
                MessageBox.Show(Encoding.Default.GetString(current, 0, current.Length));
            }

        void ReadMyFile()
        {
            //Datei lesen
            string[] fileLines = System.IO.File.ReadAllLines(@"C:\test\MeineDaten.csv");

            //Datei parsen
            List<Record> records;
            {
                const int HEADERS = 2;
                if (fileLines.Length <= HEADERS) throw new ArgumentException("Keine Daten");

                records = new List<Record>();
                for (int i = HEADERS; i < fileLines.Length; i++)
                {
                    records.Add(ParseRecord(fileLines[i]));
                }
            }

            //Ausgabe:
            {
                StringBuilder sb = new StringBuilder();
                foreach (var record in records)
                {
                    sb.AppendLine(record.timestamp.ToString("dd.MM.yyyy HH:mm") + " | " + record.text);
                }
                MessageBox.Show(sb.ToString());
            }
        }

        class Record
        {
            public DateTime timestamp { get; set; }
            public string text { get; set; }
        }

        static Record ParseRecord(string line)
        {
            const int COLUMNS = 3;

            if (string.IsNullOrEmpty(line)) throw new ArgumentException("No data");

            string[] tupel = line.Split(';');
            if (tupel.Length != COLUMNS) throw new ArgumentException("Invalid column quantity");

            Record record = new Record();
            {
                const string DATE_FORMAT = "dd.MM.yyyy";
                const string TIME_FORMAT = "HH:mm";
                record.timestamp = DateTime.ParseExact
                (
                    tupel[0] + tupel[1],
                    DATE_FORMAT + TIME_FORMAT,
                    System.Globalization.CultureInfo.InvariantCulture
                );
                record.text = tupel[2];
            }
            return record;
        }

Du willst, dass Deine Methode "intPositions" Dir alle Positionen zurückgibt.
Daraus folgt: Als Rückgabewert willst Du eigentlich einen Sammelbehälter für die einzelnen Positionen haben.

Als Sammelbehälter ist ein Integer-Array/-Liste/Enummerierbares Integer Objekt genau das richtige für die Aufgabe.

Ein String verwendet man für Text, aber nicht als Sammelbecken für einen bestimmten Typ. Ein String kann theoretisch alles mögliche sein. Z.B. "Ich, Du auch". Gut, Deine Methode gibt derzeit nur sowas wie "1,5,9,16,62" zurück. Aber der schlecht ausgewählte Typ hat folgende Negativeigenschaften:
*Der komische Rückgabetyp verwirrt Dich zur Zeit zwar nicht, aber andere Personen *Du musst es mit "split(',')" nachträglich Parsen, um an eine Liste oder Array ranzukommen, die du so schon hättest (Array = Stichwort List.ToArray()) *Es ist fehleranfälliger

Edit: Vorletzten Satz geändert. List.ToString() nach List.ToArray() geändert.

Ich vermute mal Du suchst die Split-Funktion.
Diese zerteilt die "Output Value" Zeichenfolge in ein Zeichenfolgenarray.

            string[] returnValue1 = "Output Value".Split(' ');
            List<string> returnValue2 = new List<string>(returnValue1);

            //bzw.
            List<string> returnValue3 = new List<string>("Output Value".Split(' ') );

Anbei ein Beispiel wie man es machen könnte.
Bei der Map gibt es folgende Einschränkung:
*keine Leerzeichen. *keine leeren Zeilen. *Alle Zeilen müssen gleich lang sein.

Den Code kann man noch in vielen Bereichen verbessern. Aber für den Anfang sollte es reichen.

Die Map:

\**********
____*___**
\*_*_*_*___
\*_***_****
\*________*
\**********

Der Code:

        void Test()
        {
            string[] fileLines = System.IO.File.ReadAllLines(@"C:\test\map.txt");

            //Anzahl Zeilen prüfen:
            if (fileLines.Length < 1) throw new ArgumentException("Keine Daten");

            //Anzahl Spalten prüfen:
            for (int y = 0; y < fileLines.Length; y++)
            {
                if (fileLines[y].Length != fileLines[0].Length) throw new ArgumentException("Spaltendifferenz in Zeilenindex " + y.ToString());
            }

            //Map füllen:
            char[][] map = new char[fileLines.Length][];//Zeilen initialisieren
            for (int y = 0; y < map.Length; y++)
            {
                map[y] = new char[fileLines[y].Length];//Spalten der Zeile initialisieren
                for (int x = 0; x < fileLines[y].Length; x++)
                {
                    map[y][x] = fileLines[y][x];//Position füllen
                }
            }

            //Map anzeige vorbereiten:
            StringBuilder sb = new StringBuilder();
            for (int y = 0; y < map.Length; y++)
            {
                for (int x = 0; x < fileLines[y].Length; x++)
                {
                    sb.Append(map[y][x]);
                }
                sb.AppendLine();
            }

            //Map anzeigen:
            System.Diagnostics.Debug.Write("Anzeige über Debugger:\r\n\r\n" + sb.ToString());
            System.Console.Write("Anzeige über Konsole:\r\n\r\n" + sb.ToString());
            System.Windows.Forms.MessageBox.Show("Anzeige über Meldungsfenster von Windows:\r\n\r\n" + sb.ToString());
        }

Edit:
Man kann sich ja mal überlegen, wie man den Code verbessern kann. Hier geht so einiges.

Palin war schneller ....

Hier meine Antworten:

MyDelegate bezeichner; //hier hast du "bezeichner" nichts zugewiesen
MyDelegate bezeichner = null; //hier hast du "bezeichner" den null-Wert zugewiesen

//--------------------------------------

MyDelegate bezeichner;
if (input3 == "A")
{
    bezeichner = Klasse.Addieren;
}
else
{
    WriteLine("Ungültige Eingabe");
    ReadKey();
    return;
}

double ergebnis = bezeichner(input1, input2);
//Der Compiler erkennt, dass die Variable zugewiesen wird, oder Du rausgehst.


//--------------------------------------


MyDelegate bezeichner;
if (input3 == "A")
{
    bezeichner = Klasse.Addieren;
}

double ergebnis = bezeichner(input1, input2);
//Der Compiler erkennt, dass wenn input3 != "A" ist, dass dann bezeichner nichts (noch nicht mal der null-Wert) zugewiesen ist.


//--------------------------------------


MyDelegate bezeichner = null;
if (input3 == "A")
{
    bezeichner = Klasse.Addieren;
}

double ergebnis = bezeichner(input1, input2);
//Der Compiler erkennt, dass Du immer was zugewiesen hast (Klasse.Addieren oder null-Wert) und meckert nicht. Obwohl eine NullReferenceException ausgelöst werden kann.

Hi,

warum machst Du nicht statt

 public double Key1 { get; set; }

public double[] Key { get; set; }
public int KeyCount { get { return Key.Length; } }

?

dann brauchst du nicht Key1 bis Key16 mehrfach programmieren.

Umso mehr Geräte unterstützt werden, um so besser. Hier eine Copy&Paste-Liste aus Wikipedia:
*Windows CE 5.0 *Windows Embedded CE 6.0 *Windows Embedded Compact 7 *Windows Embedded 8 (...)

*Windows Mobile 6 *Windows Mobile 6.1 *Windows Mobile 6.5 *Windows Mobile 6.5.3 *Windows Embedded Handheld *Windows Mobile 7 / Windows Phone *Windows Mobile 8 / Windows Phone *Windows 10 Mobile *Windows 10 IoT Mobile Enterprise

Bei Barcodelesegeräten wird der Scanner nicht über die Anwendung gesteuert, sondern dauerhaft aktiv sein. Die Softwareansteuerung der Scannerengines per Datalogic-/Motorola-/... Dlls lohnt sich nicht/zu aufwändig.

Eine Webanwendung wäre gut. Nur muss ich die Daten per TCP/IP senden können. Wie mach ich das?

Perfekt wäre, wenn ich eine Webseite habe, welche die Eingabe an ein Dienst weiterreicht und der Dienst sich dann um den TCP/IP Datentransfer zum Computer/Gegenstelle kümmert.

Ich habe einen interessanten Artikel über ein Url-Protokoll von Rainbird gefunden. Nun kann ich ein Programm aus meiner Webseite aufrufen. Hier der mögliche Lösungsweg per URL-Protokoll:
1.Eingabe '1234' in Webseite 1.Webseite ruft Anwendung 'Weiterleiter.exe' mit Parameter '1234' auf 1.Programm 'Weiterleiter.exe' leitet '1234' weiter an 'Dienst.exe' (z.B. per WindowsMessage) 1.'Dienst.exe' sendet '1234' per TCP/IP an den PC

Diese oben genannte 'Lösung' per URL-Protokoll möchte ich aber aus mehreren Gründen vermeiden. Zum Beispiel: 1. ist es ein Hack des Internetbrowsers um ein URL-Addon, dass ggf. nicht überall funktioniert z.B. wegen Sicherheitsrisiko. 2. ruft die Webseite ständig ein Programm auf, anstatt Daten an einen Dienst direkt weiterzureichen.

ja, Windows CE soll mit dabei sein.

Danke. OK WPF kann ich dann doch nicht verwenden.

In einem Eingabefeld soll etwas eingegeben werden, dass dann über ein Netzwerksocket übertragen wird.

Wenn es nur ein Gerätetyp wäre, würde ich das mit einem Windows Form erschlagen. Nun habe ich aber verschiedene Auflösungen und verschiedene Betriebssysteme, so dass ich mit dem C# Windows Form Designer hier nicht weiter komme.

Eine Webseite mit einem Textfeld erscheint mir da schon vielversprechend, da Geräteunabhängig. Nur muss ich die Eingabedaten dann noch per Netzwerksocket übertragen können. Als Beispiel gebe ich "Hallo" ein und das wird dann an "192.168.0.1:9999"als "Hallo;" übertragen. Die Verwendung einer Datenbank ist nicht geplant.

Was würdest verwenden bzw. wie würdest du das lösen?

Ich suche hier die beste Programmiersprache/Entwicklungsumgebung für folgende Anforderung:
*Abdeckung aller gängigen mobilen Geräte mit Windows CE und Mobile *Auflösungsunabhängig (z.B. 240x320 / 640x480 / 640x800) *mindesten 1 Eingabe-Textfeld *Fullscreen *Datenübertragung per TCP/IP

Im Augenmerk habe ich zur Zeit WPF. Aber evtl. gibt es noch was passenderes?
Vielen Dank im Voraus.

Ich kapiers nicht. Eine reine Zeichensuche muss doch schneller sein als eine Zeichenkettenmanipulation. Und Regex müsste doch auf Grund seiner Komplexität langsamer sein, als eine auf die Anforderung spezialisierte Suchfunktion. Wo ist mein Denkfehler?

Wow! LaTinos Methode ist sogar schneller als meine.

Etwas komplizierter:

        public static int CountString(string source, string find, StringComparison comparison)
        {
            const int INVALID_FIND_VALUE = -1;
            if (string.IsNullOrEmpty(find)) return INVALID_FIND_VALUE;
            if (string.IsNullOrEmpty(source)) return 0;

            int startIndex = 0;
            int sum = 0;

            while (startIndex < source.Length)
            {
                int newIndex = source.IndexOf(find, startIndex, comparison);

                if (newIndex == -1)
                {
                    return sum;
                }
                else
                {
                    sum++;
                    startIndex = newIndex + find.Length;
                }
            }

            return sum;
        }

Und hier der Aufruf:

        private void textBox1_TextChanged(object sender, EventArgs e)
        {
            DoCountString();
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {
            DoCountString();
        }

        void DoCountString()
        {
            textBox3.Text = "Counted strings = " + CountString(textBox1.Text, textBox2.Text, StringComparison.OrdinalIgnoreCase);
        }

wirft System.IO.Directory.GetFiles(...) bei >260 Zeichen dann eine Exception?

@MrSparkle:

kann sein, dass ich einen Gedankenfehler hier habe (dann einfach ignorieren):

1. sofern kein Alpha verwendet wird.
2. Stride Overhead ignorieren.

Zum Stride:

Eine Bildzeile besteht aus den Pixeln einer Bildzeile + ggf. zusätzliche Füllbytes:

Auszug aus MSDN - BitmapData.Stride:

Ein Schritt ist die Breite einer einzelnen Zeile von Pixeln (einer Scanzeile), aufgerundet auf eine 4-Byte-Begrenzung. Wenn der Schritt positiv ist, verläuft die Bitmap von oben nach unten. Wenn der Schritt negativ ist, verläuft die Bitmap von unten nach oben.

Auf dem PC gibt es System.Net.NetworkInformation.Ping.
Gibt es sowas nicht auch für CE?

Ich denke Da an OpenNETCF.Net.NetworkInformation.Ping

Hier ein simples Beispiel für den PC:

using System.Net.NetworkInformation;

(...)



Ping ping = new Ping();

//Senden der Anfrage
PingReply reply = ping.Send
(
	"127.0.0.1", //Host
	1000, // Timeout in Millisekunden
	new byte[1024], //Buffer
	new PingOptions()
);

//Statusüberprüfung
if (reply.Status == IPStatus.Success)
	System.Windows.Forms.MessageBox.Show(reply.RoundtripTime + " ms");
else
	System.Windows.Forms.MessageBox.Show("Fehler")
;

Float, double und decimal haben eines Gemeinsam: sie sind endliche Gleitkommazahlen. Dementsprechend sollte man denen Vertrauen.

Bei float und double wird intern im Binärzahlensystem gerechnet. Beim Darstellen ins Dezimalsystem entstehen dabei kleine Rundungsfehler. Da wir Menschen nicht binär denken, sind diese kleinen Fehler zum Teil schwer nachzuvollziehen. Beim decimal wird intern im Dezimalsystem gerechnet und ist auf Rechnungen mit Geldsystemen ausgelegt. Daher sind diese für uns Menschen wesentlich genauer und deren Rundungen entsprechen auch meist unseren Erwartungen.

Je nach Anwendung würde ich aber auch ein Delta für decimal verwenden.

@ BlackArtC#

        private void button3_Click(object sender, EventArgs e)
        {
            List<string> list = new List<string>();
            list.Add("A");
            list.Add("B");
            list.Add("C");
            list.Add("D");
            for (int i = 0; i < list.Count; i++)
            {
                System.Diagnostics.Debug.WriteLine(list[i]);
                list.Remove(list[i]); //list.RemoveAt(i); macht das Gleiche
            }
            System.Diagnostics.Debug.WriteLine(list.Count.ToString());
        }

        //  Debug-Ausgabe:
        //  A
        //  C
        //  2

Versuche das mal nachzuvollziehen. Dann siehst Du es 😉

Nachfolgender Code ist Fehlerhaft:

for (int i = 0; i < breakOut.Count; i++)
{
    ...
    breakOut.Remove(breakOut[i]);
    ...
}

Grund: nach dem Entfernen hat sich die Liste geändert

mach mal

  txt_An.Text += (spalte1[x]) + "\r\n";

ist zwar sehr uneffizient ... aber fürs erste...

(für Texte zusammenführen besser "StringBuilder" verwenden. oder...)
(für "\r\n" besser "Environment.NewLine" verwenden. oder...)

Edit: ..und mach mal:

txt_An.Multiline = true;
txt_An.WordWrap = false;
txt_An.ScrollBars = ScrollBars.Both;

Ich wollte mich nochmal kurz melden.
Ein verzögerungsfreies feststellen, ob Daten da sind habe ich nicht gefunden. Aber zur Zeit benötige ich es auch nicht mehr. Das Thema könnte somit theoretisch geschlossen werden, aber vielleicht findet ja noch jemand heraus wie man verzögerungsfrei feststellt, ob Daten da sind.

Hier die Lösung:

Zur Zeit verwende ich 1 Thread für Benutzeroberfläche und 1 Thread für Prozessor mit USB-Schnittstelle. Der Endlosschleife des Threads des Prozessors sieht ganz grob nun wie folgt aus:*Schleifenverarbeitung stoppen? ja/nein *Erwartete Daten per USB lesen (blockiert nun bis hin zu 3 Sekunden) *Lese-Ergebnis für Benutzeroberfläche in Queue wegschreiben *Daten verarbeiten *Daten per USB schreiben *Schreib-Ergebnis für Benutzeroberfläche in Queue wegschreiben

Die Benutzeroberfläche sieht ganz grob nun wie folgt aus:*Benutzer startet Prozessor-Thread *per Timer ca. alle 100 Millisekunden die Ergebnisse aus der Queue holen und bereinigen *Benutzer stoppt Prozessor-Thread

(Effizienter wäre, wenn ich statt des Timers+Queue echte Events verwende. Aber dann muss ich mich um die Deadlock-Problematik von Events in unterschiedlichen Threads kümmern und so geht es auch.)
Danke Euch beiden. LG CoLo

Oh man. Deklarationsfehler:

[DllImport("winusb.dll"] muss
[DllImport("winusb.dll", SetLastError = true)] lauten, sonst bleibt GetLastWin32Error "0".

Ok, wenn nun keine Daten vorhanden sind:

"NativeMethods.WinUsb_ReadPipe" gibt "false" zurück.
"Marshal.GetLastWin32Error()" gibt "121" bzw. "ERROR_SEM_TIMEOUT 121 (0x79): The semaphore timeout period has expired." zurück.

            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();

            UInt32 bufLen = 0;
            bool fResult = NativeMethods.WinUsb_ReadPipe
            (
                winUsb.context.Dev,
                winUsb.context.BulkInPipe,
                buf,
                maxBuf,
                ref bufLen,
                IntPtr.Zero //overlapped
            );

            stopwatch.Stop();
            System.Diagnostics.Debug.WriteLine(stopwatch.ElapsedMilliseconds + "|" + stopwatch.ElapsedTicks);

Wenn keine Daten da sind:100|354218
99|353121
99|350529
100|353657
99|352027
99|352493

Wenn Daten da sind:0|3080
0|3125
0|3197
0|3388
0|3139
0|3394

Ich denke, dass die 100ms kein Messfehler sind. Wenn ich es ebenfalls zu Testzwecken im GUI Thread laufen lasse, dann hängt mein GUI Thread kurz.

Du meinst es gibt aufgrund der Controller keine Möglichkeit Verzögerungsfrei festzustellen, ob erstmal Daten vorhanden sind?

Ich möchte verzögerungsfrei feststellen, ob Daten da sind. Wie mache ich das?

Ich möchte gerne über eine Art ReadDataAvailable Funktion feststellen, ob Daten vorliegen.
Wenn keine vorliegen, soll unverzüglich quasi ohne Delay die Funktion zurückkehren.

Um über USB-Kabel Daten zu transferieren verwende ich folgende Funktion:

            [DllImport("winusb.dll")]
            public static extern bool WinUsb_ReadPipe(
                IntPtr InterfaceHandle, //IN WINUSB_INTERFACE_HANDLE
                byte PipeID,//IN UCHAR  PipeID,
                byte[] Buffer,//IN PUCHAR  Buffer,
                UInt32 BufferLength,//IN ULONG  BufferLength,
                ref UInt32 LengthTransferred,//OUT PULONG  LengthTransferred
                IntPtr overlapped//IN LPOVERLAPPED  Overlapped
            );

Wenn aber keine Daten vorliegen, habe ich ein Delay von gefühlt 100 Millisekunden bis die Funktion zurückkehrt. Dummerweise habe ich in der MSDN-Doku für winusb nichts dergleichen gefunden.

Der Datentransfer funktioniert ansonsten.

Hi,

1. Frage:

angenommen ich habe zwei C# Standardprojekte
Projekt1.sln mit Projekt1.csproj und
Projekt2.sln mit Projekt2.csproj.

In beiden möchte ich eine häufig genutzte Klasse Class1.cs verwenden.
Nun möchte ich in den Projekten aber nicht 2 unterschiedliche Kopien von Class1.cs verwenden, sondern auf die Original-Class1.cs verweisen, so dass wenn ich was in der Klasse verändere, dass diese Änderung sich direkt auf die Projekte auswirken.

Vorteil:*eine Verbesserung (z.B. Fehlerkorrektur/Beschleunigung) der Class1.cs würde sich sofort auf alle Projekte auswirken.

Nachteil:*Gegebenenfalls können sich Änderungen der Klasse an einem Projekt zu unerwarteten Problemen führen und Veränderungen sind gegebenenfalls schwer nachvollziehbar usw.

2. Frage dazu:

Kennt jemand eine Art Quellcodeverwaltung, die einem bei Veränderung der Datei informiert, Veränderungen anzeigt und z.B. "Veränderte Datei übernehmen JA/NEIN" anbietet?

MfG CoLo

Kannst du noch mal schöner beschreiben, was du Vergleichen willst?

So in der Form etwa:

123; 456; 789; 123; 456; 789;
123; 456; 789; 123; 456; 789;

Dein Merker finde ich ungünstig. Stattdessen würde ich eine List verwenden. z.B.:

List<string> nichtGefundenListe = new List<string>();

//Such-Schleife
.. 
bool nichtGefunden = ...
...
if (nichtGefunden)
{
  nichtGefundenListe.Add("123; 456; 789; 123; 456; 789");//<-- string durch gefundenes Element ersetzen 
}
...

//Ausgabe
foreach(string eintrag in nichtGefundenListe)
{
     Console.WriteLine(eintrag);
}

Statt Deiner while-Schleifen würde ich doch eher for(i..-Schleifen oder foreach-Schleifen verwenden.

also

String p_hex.Length = "Blabalbal";

funktioniert bei mir nicht. Hätte mich auch gewundert, wenn es funktioniert hätte. 😃

Hier ist ein schöner Artikel zum Thema Hex-Konvertierung:
How do you convert Byte Array to Hexadecimal String, and vice versa?

Wenn ich mir die Enumeration anschaue steht da:

public enum Keys
...
        //
        // Zusammenfassung:
        //     Die OEM 4-TASTE.
        Oem4 = 219,
        //
        // Zusammenfassung:
        //     Die OEM-abhängige Taste mit der öffnenden Klammer auf einer US-Standardtastatur
        //     (Windows 2000 oder höher).
        OemOpenBrackets = 219,
...

Das sieht komisch aus. Ich würde lieber KeyPress verwenden:

private void txtSource_KeyPress(object sender, KeyPressEventArgs e)
        {
            txtResult.Text += e.KeyChar.ToString();
        }

_
Edit:
Formatierung korrigiert_

Tipp:

//statt
for (int i = 0; i < errList.Count; i++)
{
   Console.WriteLine("Error Name: " + errList[i].ErrorName);
}

//kannst Du auch folgendes verwenden:
foreach (errorCase err in errList)
{
   Console.WriteLine("Error Name: " + err.ErrorName);
}

//bzw:
foreach (var err in errList)
{
   Console.WriteLine("Error Name: " + err.ErrorName);
}

Falls es möglich ist, der Speicherschutz spricht gegen die Verwendung. Es ist auch nicht besonders objektorientiert auf den privaten Anwendungsbereich, wo die Textbox sich befindet, von außerhalb per Pointer zuzugreifen.

Alternativ: falls das fremde Programm auch von Dir ist, kann Dein fremdes Programm ja per Send-/PostMessage Usermessages versenden und Dein eigenes Programm kann darauf reagieren.

static public void Main()
{
    xFunktion.funktionPRG.ePrint("Programmieren ohne IDE war vorgestern.");
}

Du solltest nicht erwarten, dass wenn ein x beliebiger Fehler auftritt, dass dann gilt "Die Daten wurden nicht eingetragen". Prüfe, ob "e.ReturnValue" bzw. "e.ReturnValue[ i ]" einen Wert enthält. Bei "workRow[ i ] = e.ReturnValue[ i ]" musst Du sicherstellen, dass die Längen beider Arrays identisch sind. Ansonsten erhälst Du ggf. die Fehlermeldung "Die Daten wurden nicht eingetragen".

Falls Du es vermeiden kannst bzw. der Aufwand nicht zu groß ist, solltest Du immer statt "catch (Exception)" einen bestimmten Fehlertyp verwenden wie z.B. "catch (ArgumentException)", da Du mit "catch (Exception)" auch alle Systemfehler abfängst wie z.B. OutOfMemoryException.

Wieso 366 Tage in einer Tabelle vorhalten?

Ich habe ein Aufgaben-Objekt bestehend aus
einem Namen (z.B. Meeting) und einer Zeitspanne (Von- und Bis-Zeitstempel).
Ein Tag/Stunde/Minute ist eine Abfrage einer Zeitspanne in der dieses Meeting fällt oder auch nicht.

Also besteht meine Tabelle statt aus 366 Tagen nur aus Aufgaben-Objekten.

Das wäre meine erste Idee, wie ich es machen würde.

Bei Anchor = None bleibt das Element in der Mitte ohne Größenänderung.
Es sollte aber zuvor schon mittig plaziert werden und nicht am Rande.

Zitat aus msdn AnchorStyles:

... Wenn die Anchor-Eigenschaft eines Steuerelements auf AnchorStyles.None festgelegt ist, wird das Steuerelement um die Hälfte des Werts verschoben, um den die Größe des entsprechenden Containers geändert wird. Wenn z. B. die Anchor-Eigenschaft von Button auf AnchorStyles.None festgelegt ist und das Form, in dem das Steuerelement enthalten ist, um 20 Pixel in einer der Richtungen vergrößert wird, wird die Schaltfläche um 10 Pixel in beide Richtungen verschoben ...

Und hier mit eigenem Rückgabewert (geht bestimmt noch besser):

Form1:

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 frm = new Form2();
            frm.ClosedWithArgs += frm_ClosedWithArgs;
            frm.Show();
        }

        void frm_ClosedWithArgs(object sender, Form2.ClosedWithArgsEventArgs e)
        {
            Form2 frm = ((Form2)sender);
            frm.ClosedWithArgs -= frm_ClosedWithArgs;

            MessageBox.Show("Return Value = " + e.ReturnValue.ToString());
        }

    }

Form2:

    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        public class ClosedWithArgsEventArgs : EventArgs
        {
            public ClosedWithArgsEventArgs(bool ReturnValue)
            {
                _ReturnValue = ReturnValue;
            }

            private bool _ReturnValue;
            public bool ReturnValue { get { return _ReturnValue; } set { _ReturnValue = value; } }
        }


        public delegate void ClosedWithArgsEventHandler(object sender, ClosedWithArgsEventArgs e);
        public event ClosedWithArgsEventHandler ClosedWithArgs;
        void OnClosedWithArgs(bool ReturnValue)
        {
            if (ClosedWithArgs != null) ClosedWithArgs(this, new ClosedWithArgsEventArgs(ReturnValue));
        }



        private void Form2_FormClosed(object sender, FormClosedEventArgs e)
        {
            bool ReturnValue = ((DateTime.Now.Second % 2) == 1);
            OnClosedWithArgs(ReturnValue);
        }
    }

Auszug aus [FAQ] Kommunikation von 2 Forms geklaut:

  Form1                                              Form2
+-------+                                          +-------+
|       |   direkt über Properties und Methoden    |       |
|       |----------------------------------------->|       |
|       |                                          |       |
|       |                                          |       |
|       |   indirekt über Events                   |       |
|       |<-----------------------------------------|       |
+-------+                                          +-------+

Beispiel:

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 frm = new Form2();
            frm.FormClosed += frm_FormClosed;
            frm.Show();
        }

        void frm_FormClosed(object sender, FormClosedEventArgs e)
        {
            Form frm = ((Form2)sender);
            frm.FormClosed -= frm_FormClosed;
            MessageBox.Show("Closed");
        }

Hier ist ein Fehler:

Wuerfel1 = dice1.Next(1, Wuerfel1 + 1);

Hier ist Wuerfel1 das Ergebnis und die Anzahl Würfelseiten.
Somit ist es sehr wahrscheinlich, dass Wuerfel1 nach jedem Schleifendurchlauf kleiner wird.

eventuell empfängst Du nicht darstellbare oder Steuerzeichen wie z.B. das Zeichen '\0' bzw. in Hex = 00.

Bisher habe ich so wie Du nur mit ReadExisting gearbeitet, weil ich nur das benötigte.

Aber ich kann mir vorstellen, dass

public int BytesToRead { get; }
public int Read(byte[] buffer, int offset, int count)

interessant für Dich sind.

Bei der Umwandlung von einem Bytearray-Wert zu einem String-Wert und zurück zum Bytearray-Wert (Stichwort System.Text.Encoding) kann es zu einem veränderten Ergebnis kommen. Die Erfahrungen habe ich gemacht.

Von daher ist es wichtig zu wissen, wie dein Protokoll aussieht. Ob Du im String-Format lesen und senden kannst oder ob Du im Byte-Format lesen und senden musst.