Forenbeiträge von generalpd Ingesamt 18 Beiträge
Stimmt! Danke für den Hinweis! 😃
Ich mein, die erste Methode war praktischer, aber im Endeffekt sollte das nach demselben Prinzip gehen, wie "Warnmeldungen als Fehler" ausgeben. Ist dann halt weniger Arbeit/Debuggen später...
Beschreibung:
Aus der Arbeit an einer eigenen, erweiterten Bitmap-Klasse habe ich ein Pixel-Struct erstellt, das das System.Drawing.Point-Struct um diverse Eigenschaften und Methoden, wie Farbe oder "in Graustufe umwandeln", erweitert.
Eine Auflistung der einzelnen Member dieses Structs findet Ihr in meinem Blog unter http://marcel.kloubert.info/blog/?p=229
Und nun hier der Quelltext (BSD-Lizenz):
//
// Pixel-Struct
// Copyright (c) 2009, Marcel Joachim Kloubert ([URL]http://marcel.kloubert.info/blog/[/URL])
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this list
// of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
//
// - Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to
// endorse or promote products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &AS IS& AND ANY EXPRESS
// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using System;
using System.Drawing;
namespace MarcelJKloubert.Drawing
{
/// <summary>
/// Beschreibt einen Pixel.
/// </summary>
public struct Pixel : ICloneable
{
#region Felder
private Color _color;
private int _x;
private int _y;
public static readonly Pixel Empty = new Pixel(Point.Empty, Color.Transparent);
#endregion
#region Konstruktoren
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="p">Koordinaten</param>
public Pixel(Point p)
: this(p, Color.Transparent)
{
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="c">Farbe</param>
public Pixel(Color c)
: this(Point.Empty, c)
{
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="p">Koordinaten</param>
/// <param name="c">Farbe</param>
public Pixel(Point p, Color c)
: this(p.X, p.Y, c)
{
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="x">X-Koordinate</param>
/// <param name="y">Y-Koordinate</param>
/// <param name="c">Farbe</param>
public Pixel(int x, int y, Color c)
{
this._x = x;
this._y = y;
this._color = c;
}
#endregion
#region Eigenschaften
/// <summary>
/// Gibt die Farbe dieses Pixels zurück, oder legt diese fest.
/// </summary>
public Color Color
{
get { return this._color; }
set { this._color = value; }
}
/// <summary>
/// Gibt die X-Koordinate dieses Pixels zurück, oder legt diese fest.
/// </summary>
public int X
{
get { return this._x; }
set { this._x = value; }
}
/// <summary>
/// Gibt die Y-Koordinate dieses Pixels zurück, oder legt diese fest.
/// </summary>
public int Y
{
get { return this._y; }
set { this._y = value; }
}
#endregion
#region Methoden
/// <summary>
/// Berechnet den neuen RGB-Wert mit einem neuen Kontrast.
/// </summary>
/// <param name="rgbVal">Rot-, Grün- oder Blauwert</param>
/// <param name="contrast">Kontrast</param>
/// <returns>Neuer Wert</returns>
private static byte _CalcContrast(byte rgbVal, double contrast)
{
double p = rgbVal / 255.0;
p -= 0.5;
p *= contrast;
p += 0.5;
p *= 255;
if (p < 0)
{
p = 0;
}
else if (p > 255)
{
p = 255;
}
return Convert.ToByte(p);
}
/// <summary>
///
/// </summary>
/// <see cref="System.ICloneable.Clone"/>
public object Clone()
{
return new Pixel((Point)this, (Color)this);
}
/// <summary>
/// Erstellt eine Kopie dieser Instanz mit einer neuen Farbe.
/// </summary>
/// <param name="newColor">Neue Farbe</param>
/// <returns>Kopie dieser Instanz</returns>
public Pixel Copy(Color newColor)
{
return new Pixel((Point)this, newColor);
}
/// <summary>
/// Erstellt eine Kopie dieser Instanz mit neuen Koordinaten.
/// </summary>
/// <param name="newX">Neue X-Koordinate</param>
/// <param name="newY">Neue Y-Koordinate</param>
/// <returns>Kopie dieser Instanz</returns>
public Pixel Copy(int newX, int newY)
{
return this.Copy(new Point(newX, newY));
}
/// <summary>
/// Erstellt eine Kopie dieser Instanz mit neuen Koordinaten.
/// </summary>
/// <param name="newLoc">Neue Koordinaten</param>
/// <returns>Kopie dieser Instanz</returns>
public Pixel Copy(Point newLoc)
{
return new Pixel(newLoc, (Color)this);
}
/// <summary>
/// Erstellt eine "graue Version" dieses Pixels.
/// </summary>
/// <returns>Graue Version dieses Pixels.</returns>
public Pixel CreateGray()
{
Color c = this.Color;
byte bGray = Convert.ToByte(.299 * c.R + .587 * c.G + .114 * c.B);
return new Pixel((Point)this, Color.FromArgb(bGray, bGray, bGray));
}
/// <summary>
/// Invertiert die Farbe dieses Pixels.
/// </summary>
/// <returns>Invertierter Pixel</returns>
public Pixel CreateInvert()
{
Color c = this.Color;
return new Pixel((Point)this, Color.FromArgb(255 - c.R, 255 - c.G, 255 - c.B));
}
/// <summary>
/// Gibt alle Pixel eines Bitmaps zurück.
/// </summary>
/// <param name="bitmap">Bitmap</param>
/// <returns>Pixel</returns>
public static Pixel[,] FromBitmap(Bitmap bitmap)
{
return Pixel.FromBitmap(bitmap, bitmap.Size);
}
/// <summary>
/// Gibt alle Pixel eines Bitmaps aus einem bestimmten Bereich zurück.
/// </summary>
/// <param name="bitmap">Bitmap</param>
/// <param name="size">Grösse des Bereichs ausgehend von der oberen, linken Ecke.</param>
/// <returns>Pixel</returns>
public static Pixel[,] FromBitmap(Bitmap bitmap, Size size)
{
return Pixel.FromBitmap(bitmap, new Rectangle(new Point(0, 0), size));
}
/// <summary>
/// Gibt alle Pixel eines Bitmaps aus einem bestimmten Bereich zurück.
/// </summary>
/// <param name="bitmap">Bitmap</param>
/// <param name="area">Bereich</param>
/// <returns>Pixel</returns>
public static Pixel[,] FromBitmap(Bitmap bitmap, Rectangle area)
{
Pixel[,] pixels = new Pixel[area.Size.Width, area.Size.Height];
if ((pixels.GetLength(0) > 0) && (pixels.GetLength(1) > 0))
{
for (int offsetX = 0; offsetX < area.Size.Width; offsetX++)
{
for (int offsetY = 0; offsetY < area.Size.Height; offsetY++)
{
pixels[offsetX, offsetY] = Pixel.FromBitmap(bitmap, area.Location.X + offsetX, area.Location.Y + offsetY);
}
}
}
return pixels;
}
/// <summary>
/// Erstellt eine neue Pixel-Instanz aus einem Bitmap.
/// </summary>
/// <param name="bitmap">Bitmap</param>
/// <param name="p">Koordinaten</param>
/// <returns>Pixel</returns>
public static Pixel FromBitmap(Bitmap bitmap, Point p)
{
return Pixel.FromBitmap(bitmap, p.X, p.Y);
}
/// <summary>
/// Erstellt eine neue Pixel-Instanz aus einem Bitmap.
/// </summary>
/// <param name="bitmap">Bitmap</param>
/// <param name="x">X-Koordinate</param>
/// <param name="y">Y-Koordinate</param>
/// <returns>Pixel</returns>
public static Pixel FromBitmap(Bitmap bitmap, int x, int y)
{
if (null == bitmap)
{
throw new ArgumentNullException("bitmap");
}
return new Pixel(x, y, bitmap.GetPixel(x, y));
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diff">Unterschied</param>
/// <returns>Verschobener Pixel</returns>
public Pixel Move(Point diff)
{
return this.Move(diff.X, diff.Y);
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diffX">Unterschied zur X-Kooridnate.</param>
/// <param name="diffY">Unterschied zur Y-Kooridnate.</param>
/// <returns>Verschobener Pixel</returns>
public Pixel Move(int diffX, int diffY)
{
return this.MoveX(diffX).MoveY(diffY);
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diff">Unterschied zur X-Kooridnate (diff.X).</param>
/// <returns>Verschobener Pixel</returns>
public Pixel MoveX(Point diff)
{
return this.MoveX(diff.X);
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diff">Unterschied zur X-Kooridnate.</param>
/// <returns>Verschobener Pixel</returns>
public Pixel MoveX(int diff)
{
return new Pixel(this.X + diff, this.Y, this.Color);
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diff">Unterschied zur Y-Kooridnate (diff.Y).</param>
/// <returns>Verschobener Pixel</returns>
public Pixel MoveY(Point diff)
{
return this.MoveY(diff.Y);
}
/// <summary>
/// Erstellt eine verschobe Version dieses Pixels.
/// </summary>
/// <param name="diff">Unterschied zur Y-Kooridnate.</param>
/// <returns>Verschobener Pixel</returns>
public Pixel MoveY(int diff)
{
return new Pixel(this.X, this.Y + diff, this.Color);
}
/// <summary>
///
/// </summary>
/// <see cref="System.Object.ToString"/>
public override string ToString()
{
return string.Format(
"Pixel {0},{1} [A={2}, R={3}, G={4}, B={5}]"
, this.X, this.Y
, this.Color.A
, this.Color.R, this.Color.G, this.Color.B
);
}
/// <summary>
/// Erstellt einen neuen Pixel mit einer bestimmten Helligkeit.
/// </summary>
/// <param name="brightness">Helligkeitunterschied, in Prozent</param>
/// <returns>Neuer Pixel</returns>
public Pixel UpdateBrightness(double brightness)
{
Color c = this.Color;
double fact = 1.0 + brightness / 100.0;
int cR = Convert.ToInt32(c.R * fact);
int cG = Convert.ToInt32(c.G * fact);
int cB = Convert.ToInt32(c.B * fact);
if (cR < 0)
{
cR = 1;
}
else if (cR > 255)
{
cR = 255;
}
if (cG < 0)
{
cG = 1;
}
else if (cG > 255)
{
cG = 255;
}
if (cB < 0)
{
cB = 1;
}
else if (cB > 255)
{
cB = 255;
}
return new Pixel(
this.X
, this.Y
, Color.FromArgb(Convert.ToByte(cR), Convert.ToByte(cG), Convert.ToByte(cB))
);
}
/// <summary>
/// Erstellt einen neuen Pixel mit einem bestimmten Kontrast.
/// </summary>
/// <param name="contrast">Kontrast, (-100.0 <= x <= 100.0)</param>
/// <returns>Neuer Pixel</returns>
public Pixel UpdateContrast(double contrast)
{
if (contrast < -100)
{
contrast = -100;
}
else if (contrast > 100)
{
contrast = 100;
}
contrast = (100.0 + contrast) / 100.0;
contrast *= contrast;
Color c = this.Color;
return new Pixel(
this.X, this.Y
, Color.FromArgb(
_CalcContrast(c.R, contrast)
, _CalcContrast(c.G, contrast)
, _CalcContrast(c.B, contrast)
)
);
}
/// <summary>
/// Wandelt einen Pixel in eine System.Drawing.Color-Instanz um.
/// </summary>
/// <param name="p">Pixel</param>
/// <returns>System.Drawing.Color-Instanz</returns>
public static explicit operator System.Drawing.Color(Pixel p)
{
return p.Color;
}
/// <summary>
/// Wandelt eine System.Drawing.Color-Instanz in einen Pixel um.
/// </summary>
/// <param name="c">System.Drawing.Color-Instanz</param>
/// <returns>Pixel</returns>
public static explicit operator Pixel(System.Drawing.Color c)
{
return new Pixel(c);
}
/// <summary>
/// Wandelt eine System.Drawing.Point-Instanz in einen Pixel um.
/// </summary>
/// <param name="p">System.Drawing.Point-Instanz</param>
/// <returns>Pixel</returns>
public static explicit operator Pixel(System.Drawing.Point p)
{
return new Pixel(p);
}
/// <summary>
/// Wandelt einen Pixel in eine System.Drawing.Point-Instanz um.
/// </summary>
/// <param name="p">Pixel</param>
/// <returns>System.Drawing.Point-Instanz</returns>
public static explicit operator System.Drawing.Point(Pixel p)
{
return new Point(p.X, p.Y);
}
/// <summary>
/// Addiert einen Pixel mit einer Point-Instanz.
/// </summary>
/// <param name="pixel">Pixel</param>
/// <param name="point">Point-Instanz</param>
/// <returns>Summe als Pixel</returns>
public static Pixel operator +(Pixel pixel, Point point)
{
return pixel.Move(point);
}
/// <summary>
/// Addiert einen Pixel mit einer Point-Instanz.
/// </summary>
/// <param name="point">Point-Instanz</param>
/// <param name="pixel">Pixel</param>
/// <returns>Summe als Pixel</returns>
public static Pixel operator +(Point point, Pixel pixel)
{
return pixel.Copy(point.X + pixel.X, point.Y + pixel.Y);
}
/// <summary>
/// Addiert 2 Pixel.
/// </summary>
/// <param name="p1">1. Pixel</param>
/// <param name="p2">2. Pixel</param>
/// <returns>Summe als Pixel</returns>
public static Pixel operator +(Pixel p1, Pixel p2)
{
return p1.Move((Point)p2);
}
/// <summary>
/// Subtrahiert einen Pixel mit einer Point-Instanz.
/// </summary>
/// <param name="pixel">Pixel</param>
/// <param name="point">Point-Instanz</param>
/// <returns>Differenz als Pixel</returns>
public static Pixel operator -(Pixel pixel, Point point)
{
return pixel.Move(-point.X, -point.Y);
}
/// <summary>
/// Subtrahiert einen Pixel mit einer Point-Instanz.
/// </summary>
/// <param name="point">Point-Instanz</param>
/// <param name="pixel">Pixel</param>
/// <returns>Differenz als Pixel</returns>
public static Pixel operator -(Point point, Pixel pixel)
{
return pixel.Copy(point.X - pixel.X, point.Y - pixel.Y); ;
}
/// <summary>
/// Subtrahiert 2 Pixel.
/// </summary>
/// <param name="p1">1. Pixel</param>
/// <param name="p2">2. Pixel</param>
/// <returns>Summe als Pixel</returns>
public static Pixel operator -(Pixel p1, Pixel p2)
{
return p1.Move(-p2.X, -p2.Y);
}
#endregion
}
}
Schlagwörter: System.Drawing struct pixel point color
@SerialDataReceivedEventHandler: Alles klar. Jetzt ist es einleuchtend 🙂
Wenn Du das als normale Windows-Anwendung kompilierst, dann wirst Du keine Konsolenausgabe bekommen.
Du kannst:
a.) Dein Programm als Konsolenprogramm erstellen (Projekteigenschaften >> Anwendung >> Ausgabetyp: >> Konsolenanwendung) oder
b.) Eine Textfbox in Deine Form einbauen und die Ausgabe da hin leiten oder
c.) Du leitest, das ist allerdings etwas aufwendiger und eigentlich sinnlos, mit Console.SetOut(Stream stream) die Konsolenausgabe in einen Stream Deiner Wahl (einen eigenen oder einen Dateistream).
Visual Studio XML Dokumentation um eigene Tags erweitern, die auch von IntelliSence angezeigt werden
Beispiel für eine Dokumentation:
/// <summary>
/// Beschreibung der Methode.
/// </summary>
/// <param name="para1">Beschreibung des Parameters para1</param>
/// <param name="para2">Beschreibung des Parameters para2</param>
/// <param name="para3">Beschreibung des Parameters para3</param>
/// <returns>Beschreibung des Rückgabewertes.</returns>
static bool Methode(int para1, string para2, object para3)
{
return true;
}
Dazu in den Projekteinstellung (hier für VS 2005) in der Kategorie "Erstellen" das Häkchen bei "XML-Dokumentationsdatei" setzen und den Dateinamen angeben.
Zum Erstellen einer Doku empfehle ich Dir das Tool Sandcastle: http://blogs.msdn.com/sandcastle/
Also helfen kann ich Dir bei dem Problem zwar nicht, aber ich kann Dir eine Alternative nennen:
SQLite.NET: http://sqlite.phxsoftware.com/
Benutze ich bei meinen Projekten und klappt wunderbar 🙂
Das Problem ist, der Quellcode ist nicht vollständig, da Du nur den ersten Teil der Main-Klasse kopiert hast. Der andere ist in der "Main.Designer.cs"(?)-Datei.
Daher meine Frage: Was für einen Compiler-Fehler hast Du?
Ich finde z.B. nichts zu dem "comport" in der serialCommunication-Klasse. Und wo ist das Delegate "SerialDataReceivedEventHandler"?
Mach doch statt ner Klasse ein Struct, also einen Wertetyp:
public struct cVektor3D
{
public double x,y,z;
public static cVektor3D operator =(cVektor3D a)
{
// Werte übernehmen und neuen Vektor zurückgeben
}
}
Dann werden alle Referenzen und Werte innerhalb der Klasse automatisch kopiert, sowohl bei einem "A = B" also auch bei einer übergabe an eine Funktion. Du kannst dann zwar nicht mehr von einer anderen Klasse ableiten. Von Schnittstellen aber schon.
Und da diese (noch) Klasse eigentlich einen Wert darstellen soll, ist struct die bessere Alternative.
Nachtrag:
UnmanagedType-Enumeration: http://msdn2.microsoft.com/de-de/library/system.runtime.interopservices.unmanagedtype(VS.80).aspx
Was mir spontan einfällt: Schaut Euch mal das MarshalAs-Attribute und das CharSet-
Feld an:
C# Script findest Du hier: http://www.members.optusnet.com.au/~olegshilo/CurrentRelease.html
Lade Dir den Quelltext und die Doku herunter und füge Deinem Projekt folgende Dateien hinzu:
AsmHelper.cs
AssemblyExecutor.cs
AssemblyResolver.cs
csparser.cs
csscript.cs
fileparser.cs
GACHelper.cs
CSScriptLib.cs
Jetzt Kannst Du folgendermassen Code als String ausführen:
// skript ausführen mit DEBUG-Informationen und ohne eine Datei zu erstellen
System.Reflection.Assembly asm = CSScript.LoadCode (strSourceCode, null, true);
// statische Methode im Quelltext ausführen
CSScriptLibrary.AsmHelper asmHelper = new AsmHelper(asm);
asmHelper.Invoke("DerNamespaceInDemSichDieMethodeBefindet.DieStatischeMethode", new object[] { /* liste der parameter, die der methode übergeben werden */ };
Das wars eigentlich 🙂
Gehe von VS 2005 aus:
Die Bilder werden zwar hinterher nach dem kompilieren in der EXE-Datei gespeichert.
Im Projekt findest du die in den RESX-Dateien. Und zwar nicht als einzelne Bild-Elemente bzw. Pfadverweise, sondern als ImageStream.
Öffne dabei mal die RESX-Datei der Form, in der sich die ImageList befindet, und wähle als Typ oben-links Andere aus.
Dort siehst Du nun den Namen Deiner ImageList mit einem Punkt dahin, gefolgt von dem Ausdruck ImageStream, also z.B. MeineImageList.ImageStream.
In der Designer-Datei Deiner Form, z.B. MeineForm.Designer.cs, findest Du irgendwo einen Ausdruck, wie this.MeineImageList..ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("MeineImageList.ImageStream" ) ) ;
Über Ausdrücke, wie this.MeineImageList.Images.SetKeyName(0, "datei.png" ) ; , werden dann die Namen festgelegt.
Vorschlag:
public static DirectoryInfo[] GetAllDirs(string dir) { return GetAllDirs( new DirectoryInfo(dir) ); }
public static DirectoryInfo[] GetAllDirs(DirectoryInfo dir)
{
ArrayList alFiles = new ArrayList();
DirectoryInfo[] subDirs = dir.GetDirectories();
foreach (DirectoryInfo subDir in subDirs)
{
DirectoryInfo[] dirs = GetAllDirs(subDir); // rekursion (unterverzeichnis auslesen)
if (dirs.Length > 0)
alFiles.AddRange(dirs);
}
if (subDirs.Length > 0)
alFiles.AddRange(subDirs);
return (DirectoryInfo[])alFiles.ToArray(typeof(DirectoryInfo));
}
public static FileInfo[] GetAllFiles(string dir) { return GetAllFiles(new DirectoryInfo(dir)); }
public static FileInfo[] GetAllFiles(DirectoryInfo dir)
{
ArrayList alFiles = new ArrayList();
DirectoryInfo[] subDirs = dir.GetDirectories();
foreach (DirectoryInfo subDir in subDirs)
{
FileInfo[] files = GetAllFiles(subDir); // rekursion (unterverzeichnis auslesen)
if (files.Length > 0)
alFiles.AddRange(files);
}
if (true)
{
// dateien auslesen
FileInfo[] files = dir.GetFiles();
if (files.Length > 0)
alFiles.AddRange(files);
}
return (FileInfo[])alFiles.ToArray(typeof(FileInfo));
}
Dann kannst Du z.B. mit GetAllFiles(@"C:\WINDOWS" ) ; bzw. GetAllDirs(@"C:\WINDOWS\System32" ) ; arbeiten.
Und zurück bekommst Du dann ein Array aus FileInfo- bzw. DirectoryInfo-Werten: s. hier:
1.) http://msdn2.microsoft.com/de-de/library/system.io.fileinfo(VS.80).aspx
2.) http://msdn2.microsoft.com/de-de/library/system.io.directoryinfo(vs.80).aspx
Noch als Ergänzung:
Wie in C oder Java kannst Du auch die Methode ToString() für jeden Datentyp anwenden, da alle von System.Objekt abgeleitet sind und letzteres die Methode ToString() besitzt.
Alle "Zahlentypen" besitzen dann noch verschiede (überschriebene) "Versionen" mit diversen Paramtern. Interessant für Dich ist dann wahrscheinlich ToString(string format).
z.B.:
int iZahl = 0; strZahl = iZahl.ToString(formatString);
uint uiZahl = 0; strZahl = uiZahl.ToString(formatString);
float fZahl = 0.0f; strZahl = fZahl.ToString(formatString);
Das gilt dann, wie gesagt, auch für alle anderen "Zahlentypen", wie decimal, (u)short, double oder (u)long, etc.
Ist im Prinzip dasselbe, wie als wenn Du mit string.Format(formatString, iZahl), etc.
Genaueres steht hier: http://www.galileocomputing.de/openbook/visual_csharp/visual_csharp_10_005.htm#Xxx999340
Original von BigMAv
HalloEinen ähnlichen Thread gabs hier schon einmal...
Es gibt einen Patch für McAfee, Infos dazu findest Du hier:
Gruss
Cool, Dankeschön! 😁
Original von Programmierhans
Lass die Combo mal ne Viertelstunde stehen..... wenn Du nachher auf die Items klickst sind diese sichtbar....Habe auf meinem Laptop dasselbe Problem....
Hast Du McAffee installiert ??.... habe schon hinweise darauf gefunden, dass dies durch McAffee ausgelöst wird.... (aber auch nicht auf allen PC's)
Alter, Schwede! Ich werd bekloppt!! Das scheint wirklich am McAffee gelegen zu haben!
Seitdem ich den Scanner nicht mehr drauf habe, funktioniert es wieder! Danke für den Tipp! freu
Woran kann das Deiner Meinung denn liegen? Macht McAffee in den .NET Einstellungen irgendwelchen Pseudo-Sicherheitskram?
Das glaube ich nicht, denn dann müsste das Problem bei den anderen, normalen Programmen auch auftreten und dem ist nicht so.
Um im Code habe ich farbtechnisch nichtsgeändert. Das sind (für die ComboBox) die Standardfarben (Schwarze Schrift, Weisser Hintergrund).
Hi!
Ich weiss nicht, ob das nur ein Problem ist, was ich habe oder ob es schonmal aufgetaucht ist.
Wenn ich versuche eine MessageBox, z.B. über:
MessageBox.Show( "Text", "Titel" );
aufzurufen, dann kommt Folgendes dabei raus:
Normalerweise müsste bei der obigen Zeile im Textfeld der Ausdruck Text und im Button der Ausdruck OK.
Etwas Ähnliches habe ich auch mit ComboBoxen:
In der ComboBox sind definitv 5 Ausdrücke, die nicht leer sind! Die werden aber komischerweise nicht angezeigt.
Gibt es in .NET eine Einstellung, die ich machen muss, damit diese Probleme nicht auftreten? Und sind andere Steuerelemente ebenfalls betroffen?
Ich würde mich sehr freuen, wenn mir jemand bei diesem blöden Problem weiterhelfen kann 🙂