Forenbeiträge von Pulpapex Ingesamt 939 Beiträge
Es gibt in dem Code zwei Stellen, die die NullReferenceException auslösen können:
this.label1.Text = Fobs.ontext;
- label1 ist null
- Fobs ist null
Bei null-Werten können keine Member abgefragt werden. Wenn man es versucht, gibt es die NullReferenceException. In C++ würde es ne Access Violation geben oder merkwürdige Seiteneffekte.
Gruss
Pulpapex
Hast du in die SerialTools-FAQ geschaut? Es gibt einen Eintrag zu "SerialTools und Threads" und einen wo es um Port.BufferSize != 0 geht, OnRead wird in dem Fall erst ausgelöst, wenn der Buffer voll ist.
Wenn es keins von beiden ist, wird es am Thread.Sleep liegen. Ich vermute mal SerialTools wird seinerseits keinen eigenen Thread für die Kommunikation verwenden. D.h., wenn du Thread.Sleep aufrufst, legst du damit dem Empfang für die Zeit lahm. Der Code, der Daten empfängt und OnRead auslöst, wird im Thread ausgeführt, den du schlafen gelegt hast.
Gruss
Pulpapex
Was möchtest du denn erreichen? Vielleicht bekommt man es alleine mit .Net-Mitteln hin.
Gruss
Pulpapex
Kann ich mir gar nicht vorstellen, dass das nicht gehen soll. In den Projekt-Optionen gibt es bestimmt die Einstellung zwischen Windows-Anwendung, Konsolen-Anwendung oder Bibliothek zu wählen.
Ansonsten wäre das ein trifftiger Grund auf eine andere IDE zu wechseln: #Develop, C#Builder oder VC# Express 2005 z.B.
Gruss
Pulpapex
Ich tippe auf Programmierfehler. Du müsstest jetzt anhand von Code das Gegenteil beweisen.
Gruss
Pulpapex
PS: Ein Scherz, nimm's leicht. 😉
Mit dem Graphics-Objekt, das man im Paint-Ereignis der PictureBox bekommt, zeichnet man nicht im Bild, sondern nur auf dem Control. Um auf dem Bild zu zeichnen, muss man Graphics.FromImage verwenden.
Zu dem Code im ersten Post: das Ganze müsste ereignis-orientiert ablaufen. Auf der Form sind neben der PictureBox zwei Buttons, "Laden" und "Speichern". Klickt man auf "Laden" wird ein Bild in die PictureBox geladen. Nun kann der Benutzer im Bild zeichnen. Irgendwann klickt er "Speichern" und das geänderte Bild wird abgespeichert. Mit nur einer for-Schleife wie im Code geht es nicht.
Gruss
Pulpapex
Hast du es schon mit "Win32_NetworkAdapter" probiert? Die Klasse hat auch 'ne MACAddress-Eigenschaft.
Gruss
Pulpapex
RTF ist ein Dokumenten-Format mit eigenen Formatierungscodes. So wie ps, pdf, html usw. Den Text ohne Formatierungen bekommt man über die Text-Eigenschaft. Den müsstest du nehmen und mit eigenem Code abspeichern: File.OpenWrite usw.
Gruss
Pulpapex
// Edit: ich habe gerade gesehen, dass die SaveFile-Methode mehrere Überladungen
hat. Mit rtb.SaveFile(dateiname, RichTextBoxStreamType.PlainText)
kann einfacher Text ohne Formatierungen gespeichert werden.
Welche Zeichenfolge soll hier gesendet werden?
byte[] myArray = new byte[3];
//Befehl senden zum Abfragen des Status
myArray[0] = 27;
myArray[1] = 107;
myArray[2] = 255; // 0 funktioniert bei Bluetooth nicht hier 255 nötig
oSerial.Output = myArray;
27 ist ein nicht darstellbares Zeichen (Escape), ist das so angedacht? Ansonsten hatte ich irgendwo von einem Protokoll für die serielle Schnittstelle gelesen, wo die Zeichenketten mit einem Zeilenumbruch abgeschlossen wurden. '\n' oder "\r\n", weiss ich nicht mehr.
Darstellbare Zeichen könntest du der besseren Lesbarkeit wegen auch so angeben:
myArray[1] = (byte)'k'; //107
Warum es ausserhalb der Form nicht funktioniert, weiss ich leider auch nicht. Sind vielleicht Threads mit im Spiel?
Gruss
Pulpapex
// Edit: das mit dem Zeilenumbruch Anfügen hatte ich hier gelesen, weiss nicht ob das auf dein Problem zutrifft:
I don't get an answer when sending AT commands to a modem
Ich weiss wie es letztendlich in Html aussieht. Mit der Asp.Net-API kenne ich mich nicht aus.
<head>
<meta http-equiv="refresh" content="5; URL=relativeUrl" />
</head>
Gruss
Pulpapex
// Verschoben nach Asp.Net
NHibernate ist ein anderer O/R-Mapper für .Net.
Ich programmiere unter Java mit Hibernate. Man stellt SQL-ähnliche Anfragen nach Objekten mit bestimmten Eigenschaftswerten und bekommt als Ergebnis eine Liste mit den passenden Objekten zurückgeliefert. Ist sehr angenehm damit zu programmieren.
NHibernate die Variante für .Net. Kannst du dir ja mal angucken. Ich weiss allerdings nicht wie ausgereift es ist.
http://nhibernate.sourceforge.net/
Gruss
Pulpapex
Hi dN!3L,
vielleicht hilft dir dieser Thread weiter. Weiss nicht, ob du den schon gesehen hast:
Überlappende Steuerelemente
Gruss
Pulpapex
Jede Form1-Instanz ist ein eigenes Fenster.
Folgender Code zeigt zwei Fenster an:
Form1 a = new Form1();
a.Show();
Form1 b = new Form1();
b.Show();
Tut mir leid, ich hätte den Code zusammenschreiben und den Text als Kommentar einfügen sollen. Die Umleitung muss vor dem Prozess-Start erfolgen:
p = new Process();
p.StartInfo.FileName = "ping";
p.StartInfo.Arguments = "pc013064";
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.Start();
string str = p.StandardOutput.ReadLine();
Es ist eigentlich gar nicht so kompliziert. Beispiel Google pingen:
Process p = new Process();
p.StartInfo.FileName = "ping";
p.StartInfo.Arguments = "www.google.de";
p.Start();
Soll kein Dos-Fenster angezeigt werden, fügt man noch folgendes ein:
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
Den umgeleiteten Standard-Output bekommt man über p.StandardOutput.
Gruss
Pulpapex
@Guggsdu
wäre das also endlich geklärt.
@dschmoegner
Der Fehler liegt hier:
// Form1-Klasse
private Form1 f;
private void NewTextBoxText(object sender, EventArgs e)
{
f = new Form1();
MessageBox.Show("vorher: label: " + f.label1.Text);
f.label1.Text = Fobs.ontext;
MessageBox.Show("Erfolgreich" + f.label1.Text + Fobs.ontext);
//this.label1.Text = f.label1.Text;
}
Das mit der this-Instanz war schon richtig. Die Form1, die du auf dem Bildschirm siehst, ist this. Du hast in dieser Instanz noch einmal ein zweites Form1-Fenster f definiert, das nicht angezeigt wird. In diesem wird label1 geändert.
Die Membervariable f muss also verschwinden. Warum du bei this.label1.Text eine Exception bekommst, weiss ich allerdings auch nicht.
Gruss
Pulpapex
Hi Sabine,
in .Net gibt es dafür die Klassen System.Diagnostics.Process und System.Diagnostics.ProcessStartInfo. Mit ProcessStartInfo werden das zu startende Programm und dessen Einstellungen festgelegt. Über die Process-Klasse hat man Zugriff auf das laufende Programm.
MSDN: Process Class
Gruss
Pulpapex
@Guggsdu
Du willst hier weissmachen, dass folgendes ein Bug ist:
class EventHolder {
public void FireChanged() {
Changed = null;
// Bug: löst eine NullReferenceException aus.
Changed(this, EventArgs.Empty);
}
public event EventHandler Changed;
}
Du sagst, an diesem Verhalten hat sich was in C# 2.0 geändert. Natürlich schaue ich da in die MSDN2. Ich habe auch in der Sprachspezifikation zu C# 2.0 geguckt, habe nirgends etwas finden können (war mir eigentlich schon vorher klar).
Nur um ganz sicher zu gehen, habe ich es noch ausprobiert. In .Net 2.0 wie in .Net 1.1 wird die NullReferenceException ausgelöst, wenn eine Ereignisvariable null ist. Was anderes wäre auch völliger Blödsinn.
Du weisst es nicht genau, stellst es aber als Wahrheit da. So entstehen Gerüchte.
In welchem Verzeichnis befindet sich die Datei denn? Die Pfadangabe "\texture.bmp" ist das Root-Verzeichnis des aktuellen Laufwerks. Wieso packst du die Datei nicht ins Anwendungsverzeichnis, so dass der Pfad relativ als "texture.bmp" angegeben werden kann?
Gruss
Pulpapex
Strong Names haben aber nicht viel mit Sicherheit und Rechten zu tun. Sie enthalten einen Signatur-Token, der dient aber zum eindeutigen Identifizieren einer versionierten Assembly. Mit Strong Names ist es möglich festzulegen, welche Version einer Assembly von einer Anwendung erwartet wird.
Im Gegensatz dazu kann eine Assembly ohne Strong Name im Quellcode verändert, neu compiliert und der Anwendung untergeschoben werden. Die Anwendung bemerkt keinen Unterschied (kann höchstens passieren, dass sie nicht mehr funktioniert).
In den Config-Dateien kann festgelegt werden wie abweichende Versionen behandelt werden sollen. Ich hab mich damit auch noch nicht beschäftigt (beim Entwickeln sind Strong Names eher lästig). Auf jeden Fall kann die erwartete Version angepasst werden. Eine Einstellung, dass neuere Assembly-Versionen toleriert werden, gibt es wahrscheinlich auch.
Gruss
Pulpapex
Es geht um diesen Code:
private MyObserver Myobs;
public TestObserver(MyObserver myobs)
{
Myobs = myobs;
Myobs.Changed += new EventHandler(Addition);
}
Myobs ist eine Membervariable in TestObserver. Ein TestObserver-Objekt bekommt im Konstruktor ein MyObserver-Objekt übergeben, das in der Membervariablen gespeichert wird. Detach verwendet später diese Membervariable, um den TestObserver-eigenen Delegaten wieder zu entfernen.
wenn man es so schreibt, wird es vielleicht deutlicher:
private MyObserver myobs;
public TestObserver(MyObserver myobs)
{
this.myobs = myobs;
this.myobs.Changed += new EventHandler(Addition);
}
Gruss
Pulpapex
Ich würde die überlappenden Steuerelemente, jedes für sich, einzeln im Designer entwickeln. Auf der Form zusammengebracht werden sie dann aber nicht mehr im Designer, sondern durch selbstgeschriebenen Code.
Am besten du entwickelst ein eigenes Steuerelement dafür. Das Steuerelement würde dafür sorgen, dass jedes Controls in der Controls-Eigenschaft mit DockStyle.Fill die gesamte Fläche ausfüllt und dass immer nur ein Control gleichzeitig sichtbar ist.
Gruss
Pulpapex
Mit 'Verbatim-Strings', einfach ein @-Symbol vor den String schreiben.
string s = @"Das ist ein vorformatierter
String über mehrere Text-Zeilen. Escaped Characters
wie '\\n' bleiben so erhalten. Pfadangaben kann
man mit einzelnem Backslash schreiben. Statt
'c:\\\\programme\\\\' reicht 'c:\\programme\\'.";
Gruss
Pulpapex
Probier' es mal so:
private void Aktualisieren() {
MethodInvoker setVisible = new MethodInvoker(SetVisible);
// 'pictureBox.Visible = true' im UI-Thread ausführen.
pictureBox.Invoke(setVisible);
}
private void SetVisible() {
pictureBox.Visible = true;
}
Nur der UI-Thread - der Thread, der Form und Controls erstellt hat - darf direkt auf Controls zugreifen. Alle anderen Threads müssen Control.Invoke verwenden. Ich denke daran wird es liegen.
Gruss
Pulpapex
Das hast norman_timo schon vorgeschlagen. Ist meiner Meinung nach auch der beste Ansatz. Ansonsten könnte man auf Klassen und Strukturen gleich ganz verzichten und alles in mehrdimensionalen Arrays speichern .. naja. 😉
Wo steht etwas dazu, dass in C# 2.0 etwas an den Events geändert wurde? Hast du einen Link?
In der MSDN2-Doku steht es wie gehabt:
How to: Use Events (C#)
Create a class that contains:
An event created from the delegate.
(optional) A method that verifies that an instance of the delegate declared with the event keyword exists.
Otherwise, this logic must be placed in the code that fires the event.
Methods that call the event. These methods can be overrides of some base class functionality.
This class defines the event.
Also: Ereignisvariable definieren, (optional) OnXxx-Hilfsmethode schreiben, die die Ereignisvariable vor dem Aufruf auf ungleich null testet. Hat sich nichts geändert.
// Edit: wenn mit Threads gearbeitet wird, müssen Zugriffe auf gemeinsam genutzte Ressourcen immer auf die eine oder andere Art synchronisiert werden. Ist mit allen Ressourcen so, auch mit Events.
Das ist doch kein Bug,
man muss einen Event-Delegaten auf ungleich null prüfen, bevor man ihn aufruft. Macht dschmoegner ja auch:
protected virtual void OnChanged(EventArgs e)
{
if(Changed != null)
Changed(this, e);
}
Event-Member sind da wie alle Variablen. Wenn se null sind, kann man auch nichts aufrufen.
Gruss
Pulpapex
Der Ausdruck \w+(\s|-|\w+)* lässt doch quasi alles durch. Im Text "test & test" wird "test " gefunden, in "123abd-§$&" wird "abd-" gefunden.
Ich weiss es nicht, aber vielleicht prüfen die Tools ob wirklich der gesamte Text von Anfang bis Ende gematcht wird - sowas wie ^\w+(\s|-|\w+)*$. Dann schlägt der Vergleich bei "test & test" jedenfalls fehl.
Gruss
Pulpapex
Setze form.KeyPreview = true, dann sollte das KeyDown-Event des Formulars reagieren.
Gruss
Pulpapex
Man kann mit form.KeyPreview = true Tastaturereignisse in der Form vorauswerten, bevor sie zur TextBox weitergeleitet werden (dafür Ereignishandler für Tastaturereignisse der Form einrichten). Mit e.Handled = true kann das Weiterleiten zur TextBox verhindert werden. So richtig schön finde ich das eigentlich nicht. Geht bestimmt auch noch anders.
Gruss
Pulpapex
Diese unsägliche Convert-Klasse. 😉
wie wäre es so?
double millisDouble;
long millis = (long)millisDouble;
Man kann auch das Click-Ereignis der PictureBox delegieren.
public class MyUserControl : UserControl {
// PictureBox
private PictureBox pictureBox;
// PictureBoxClick-Ereignis
public event EventHandler PictureBoxClick {
add { pictureBox.Click += value; }
remove { pictureBox.Click -= value; }
}
}
// Anwenden.
MyUserControl c = new MyUserControl();
c.PictureBoxClick += new EventHandler(HandlePictureBoxClick);
Gruss
Pulpapex
// Edit: ne ist Quatsch, es soll ja MyUserControl.Click ausgelöst werden:
public class MyUserControl : UserControl {
// PictureBox
private PictureBox pictureBox;
private void InitializeComponent() {
pictureBox = new PictureBox();
pictureBox.Click += new EventHandler(HandlePictureBoxClick);
}
// Ereignishandler für pictureBox.Click.
private void HandlePictureBoxClick(object sender, EventArgs e) {
// MyUserControl.Click auslösen.
OnClick(e);
}
}
Eigentlich sollte es funktionieren. Kann es sein, dass du die Millisekunden als int-Wert übergibst? Man muss long verwenden.
Es gibt einen speziellen DateTime-Konstruktor für sowas. Der erwartet jedoch Ticks (100 Nanosekunden):
long millis;
DateTime dt = new DateTime(millis * 10);
Gruss
Pulpapex
So wie ich das verstanden habe, wird bei dir die ArrayList für jeden Node einmal durchlaufen, um die Child-Nodes zu finden. Benutzt du dafür binäre Suche, d.h. ist die ArrayList nach ParentIDs sortiert? Wenn nicht, ist das Ganze extrem ineffektiv - quadratischer Aufwand. Probier' die Variante mit der Hashtable aus, da ist der Aufwand linear.
Nested Sets werden nur unwesentlich schneller sein, ihr Aufwand ist auch linear. Sie sind aber so unflexibel bei Änderungen. Um nur einen Knoten hinzuzufügen oder zu entfernen, muss quasi die gesamte Datenbank-Tabelle geupdatet werden.
Ich hab mir die "Nested Sets" mal angeschaut. Sie sind gut geeignet, um Teilbäume effizient mit nur einer SQL-Anfrage aus der Datenbank zu laden. Dafür steigt der Aufwand beträchtlich, wenn Baumknoten hinzugefügt oder entfernt werden sollen. Kann es sein, dass bei allen Baumknoten, die in Preorder-Reihenfolge hinter dem hingefügten/entfernten Knoten liegen, die Right- und Left-Werte aktualisiert werden müssen? Ich glaube schon. // Edit: es müssen sogar einige Knoten aktualisiert werden, die davor liegen.
Ansonsten ist die Struktur gut geeignet, um den Baum aus der ArrayList aufzubauen. Die Knoten müssen in Preorder vorliegen. Eine rekursive Methode baut daraus den Baum zusammen. Es müssen glaube ich maximal vier Left-/Right-Vergleiche pro Knoten angestellt werden, um seine Position im Baum zu bestimmen. Das dürfte effizienter sein als die Variante mit der Hashtable.
Gruss
Pulpapex
// Edit: Ich hänge noch eine Tabelle zum Vergleich einiger Collections an, die ich mal gemacht hatte. Da sieht man, dass die Hashtable mit int-Keys zirka 12 mal langsamer als die ArrayList ist.
Die Lösung, die mir auf Anhieb einfällt:
// BuildTree: Ergebnis ist der Root-Knoten.
// In der Children-Eigenschaft hängen die direkten Child-Knoten.
private Node BuildTree(ArrayList nodes) {
Node root = new Node();
Hashtable nodeLookup = new Hashtable();
foreach(Node node in nodes) {
nodeLookup[node.ID] = node;
}
foreach(Node node in nodes) {
Node parent = null;
if(node.ParentID != null) {
parent = (Node)nodeLookup[node.ParentID];
} else {
parent = root;
}
parent.Children.Add(node);
}
return root;
}
Die ArrayList muss zweimal durchlaufen werden. Mit einer binären Suche würde es auch gehen. Ist aber langsamer, denke ich.
Gruss
Pulpapex
Die MSDN2-Seiten ist wirklich besser zu navigieren als die von MSDN. Einfach dadurch, dass die Navigationsleiste auf der linken Seite mehr anzeigt. Beim normalen MSDN muss man sich Schritt für Schritt durch die trägen Seiten hangeln, um irgendwo hinzukommen. Da ist man noch schneller über die Suche am Ziel.
Aber schaut euch mal an was NDoc generiert:
NDoc-Reference
Man kann die Navigationsleiste bis auf Member-Ebene aufklappen, ohne dass zwischendurch nachgeladen werden muss. Ein Klick und man ist da wo man hin will. Das sollte Microsoft für die MSDN übernehmen.
Gruss
Pulpapex
Das Flimmern entsteht, weil vor dem Neuzeichnen die Fläche erst komplett gelöscht wird (mit der Hintergrundfarbe gefüllt wird).
Also entweder man aktiviert wie schon gesagt DoubleBuffering oder man verhindert das Löschen vor dem Neuzeichnen. Das geht auch mittels SetStyle:
// ControlStyles-Flags zum Verhindern des Löschens
ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint
Das klappt natürlich nur, wenn immer die gesamte Fläche neu gezeichnet wird.
Gruss
Pulpapex
Hi Sabine,
man kann in einer Datei nichts aus der Mitte entfernen oder hinzufügen. Am einfachsten ist es, du liest die Datei komplett ein, nimmst die Änderungen vor und schreibst alles zurück.
Es geht noch ein bisschen performanter, wenn nur der geänderte Teil zurückgeschrieben wird. Dazu muss man sich beim Einlesen die Position der Änderung im Stream merken (Position-Eigenschaft). Beim Zurückschreiben wird der unveränderte Dateiteil mit Seek(SeekOrigin.Begin, position) übersprungen. Im Anschluss wird der veränderte Dateiteil geschrieben.
Bei einer kleinen Datei macht das aber wenig Sinn. Viel Codeaufwand für einen nur geringen Geschwindigkeitszuwachs.
Gruss
Pulpapex
Ich hätte ja gedacht, dass du es mal ausprobiert. Ich selbst kann es hier leider nicht testen.
Hi herbivore,
ich bin mir nicht sicher ob es so funktioniert. Du kannst es ja mal ausprobieren.
public class A : ICloneable {
private int a;
private ArrayList children;
public A() {
a = 0;
children = new ArrayList();
}
public virtual object Clone() {
// Flache Kopie des aktuellen Typs (A oder B) erzeugen.
A clone = this.MemberwiseClone();
// Um tiefe Kopien muss man sich selbst kümmern.
clone.children = (ArrayList)this.children.Clone();
return clone;
}
}
public class B : A {
private int b;
private Hashtable lookup;
public B() {
b = 0;
lookup = new Hashtable();
}
public override object Clone() {
// Clone-Basisimplementierung aufrufen, liefert den Typ B.
B clone = (B)base.Clone();
// Das Feld b ist in base.Clone geklont worden.
// Deep-Copy des neuen lookup-Feldes.
clone.lookup = this.lookup.Clone();
return clone;
}
}
Gruss
Pulpapex
CodeProject hat jede Menge Kommandozeilen-Parser vorrätig. Such dir den geeignetesten raus. Sind alle nicht sehr gross.
www.codeproject.com: Search "Command Line Parser"
Gruss
Pulpapex
Hi Capi,
probier' mal:
Encoding enc = Encoding.GetEncoding(1252);
Die 1252-Codepage ist der Standardzeichensatz unter Windows (glaube ich). Sie enthält auch die deutschen Umlaute:
http://www.gymel.com/charsets/CP1252.html
Du musst herausfinden welches Encoding der Drucker erwartet. Vielleicht ist es ja dieses.
Gruss
Pulpapex
Original von elron
Stimmt oder man macht es nach Pulpapex in einer for()
Ich hab eigentlich gemeint, dass IsNumber nicht geeignet ist, da die Methode nur ein Zeichen prüft.
Du hast die Lösung doch schon selbst gefunden: TryParse.
Gruss
Pulpapex
Ne IsDigit-Methode gibt es auch. IsNumber liefert true, wenn das Zeichen aus der Unicode-Kategorie 'Number' stammt. Dazu gehören noch ein paar mehr Zeichen als die Ziffern, z.B. '²'.
Hi rs4,
statt des Paint-Ereignis der Form, muss das Paint-Ereignis des Panels abonniert werden. Der Graphics-Kontext in e.Graphics beschränkt sich dann auf den Panel-Bereich.
Panel p = new Panel();
p.Paint += new PaintEventHandler(HandlePaint);
Gruss
Pulpapex
Char.IsNumber(string, index) überprüft nur das eine Zeichen im String am angegebenen Index.
Gruss
Pulpapex
Ereignisse definiert man so. OnChanged ist eine Hilfsmethode zum sicheren Auslösen des Ereignisses:
protected void OnChanged() {
if(Changed != null) {
Changed(this, EventArgs.Empty);
}
}
// Ereignis.
public event EventHandler Changed;
Möchte man Daten im Ereignis mitgeben, muss ein neuer EventHandler und eine neue EventArgs-Klasse definiert werden:
// EventHandler.
public delegate void ChangedEventHandler(object sender, ChangedEventArgs e);
// EventArgs.
public class ChangedEventArgs : EventArgs {
private object newValue;
public object NewValue {
get { return newValue; }
set { newValue = value; }
}
}
Gruss
Pulpapex