Forenbeiträge von onlinegurke Ingesamt 778 Beiträge
Also von der ListView würd ich dir auch abraten, weil das DataGridView doch erheblich besser ist, was die Darstellung von tabellarischen Daten anbelangt. Die Zeile kannst du mit row.HeaderCell.Value beschriften (hoffe ich, ungetestet)
Naja, mit dem Abfangen des GotFocus-Events kriegst du schon mal das aktive Steuerelement raus. Jetzt kannst du entweder davon ausgehen, dass die Text-Eigenschaft dich in jedem Fall befriedigt (nehm ich aber mal nicht an, ansonsten würde dir das wohl nicht so große Probleme bereiten). Da .NET keine Mehrfachvererbung unterstützt bleiben dir noch genau zwei Möglichkeiten:
Deklaration einer Funktion auf Formebene, die für jedes Steuerelement den Text zurückgibt, der kopiert werden soll und eine Methode, die den Text auch wieder einfügt (wenn du mich fragst ist das nicht nur schlechter Stil, sondern auch ineffizient, deshalb lieber 2.)
Eine Schnittstelle definieren
Public Interface ICopyAndPasteControl
Sub Copy
Sub Paste
Event Selected
End Interface
Damit überlässt du jedem Steuerelement, was es in die Zwischenablage schieben sollte (d.h., eine PictureBox kann dann auch ein Bild in die Zwischenablage schieben usw.)
...musst du nur noch alle Steuerelemente, die du brauchst ableiten und wenn du das sowieso schon tust kannst du auf diesem Wege auch gleich das Problem mit den Kontextmenüs erledigen... 🙂
@DarKlajid: Es war so definiert, dass es nur eine Unterscheidung gibt, d.h, alle Gleichheiten in der Mitte werden ignoriert.
Also zumindestens in Windows Forms gibt es das Focus-Event, auch wenn es GotFocus heißt...
@KochMich: Genauso ist mein Code realisiert 🙂, bei der 'Länge des Unterschiedes' hab ich mich halt für die im Zweifel im größere Variante entschieden.
Hallo zusammen, ich habe eine kleine Frage zu VB.NET.
Du meinst sicher .NET, VB.NET-spezifisch ist da nix
@JAck30lena: glaube ich nicht, man kann höchstens noch (wenn sehr viele Steuerelemente gleichen Typs benutzt werden) die dazugehörige Klasse erben und die ContextMenu-Eigenschaft überschreiben
(Hab eine Idee woran es liegen könnte)
Welchen Typ hat denn xpNodeIterField.Current.Value? Vielleicht ist der Hashcode ja identisch...
allgemeines Problem bei .net ist? halt ich für sehr unwahrscheinlich. Dann schon eher ein Problem mit ArrayList.
Aber warum benutzt du solche Konstrukte? Warum nicht eine eigene Struktur definieren, die ist Typsicher und etwaige Fehler werden dir sofort angezeigt.
public struct Item
{
private Bool _allowNull
private Bool _primaryKey
...
}
Dictionary<String,Item> dict=new Dictionary<String,Item>;
Die Vorgehensweise die ich bevorzugen würde, wäre, auf die gleiche Art und Weise den letzten Abweichungsindex zu suchen:
int GetFirstDiff(String Input1,String Input2)
{
for (int i = 0; i < Input1.Length; i++)
{
if (i = Input2.Length)
{
return i;
}
if (hallo1[i] != hallo2[i])
{
return i;
}
}
if (Input1.Length<Input2.Length) return Input1.Length
return -1
}
int GetDifferenceLength(String Input1,String Input2)
{
int Start=GetFirstDiff(Input1,Input2)
if (Start=-1) return 0
char chars1[]=Input1.ToCharArray
char chars2[]=Input2.ToCharArray
Array.Reverse(chars1)
Array.Reverse(chars2)
int End=GetFirstDiff(new String(chars1),new String(chars2))
return Math.Max(Input1.Length,Input2.Length)-Start-End
}
@DarKlajid
aus
wie kann man denn die Stelle finden, ab denen zwei Strings unterschiedlich sind? würd ich mal rauslesen, dass die erste Position, ab der die Zeichenketten unterschiedlich sind, gesucht ist. Insofern führt dein Algorithmus u.U. nicht zum Ziel (z.B. "ab" und "bbb" würde bei dir 2 rauskommen, korrekt wäre aber 0)
eher so:
string hallo1 = "ifsdjik";
string hallo2 = "ifsdjdik";
int hereIsADifference = -1;
for (int i = 0; i < hallo1.Length; i++)
{
if (i > hallo2.Length)
hereIsADifference = i;
if (hallo1[i] != hallo2[i])
hereIsADifference = i;
}
dann kannst du nämlich unterscheiden, ob die Zeichenketten sich an der Stelle Null oder eben gar nicht unterscheiden
Hallo,
ich habe mir für mathematische und physikalische Berechnungen zwei Strukturen erstellt, die eine (zur darstellung komplexer Zahlen besteht aus zwei Double-Werten und die andere zur Darstellung von physikalischen Größen besteht aus einem Double-Wert und sechs SByte-Werten.
Dazu jetzt drei Fragen:
Wie viel Speicherplatz verbraten solche Strukturen dann (inklusive Header), die reinen Daten sind ja 28 bzw. 18+6*1 Byte
(mir noch viel wichtiger): Wie kann man für solche Strukturen die GetHashCode-Funktion gut implementieren (meines Wissens hängt davon ja die Effizienz der Datenverarbeitung ab)
Welche Schnittstellen sollte man für die Datenverarbeitung implementieren? (Hab jetzt IEquatable<T>, IComparable<T> und IFormattable)
Hab die Assembly manuell geladen:
reflection.assembly Resolve(object sender,ResolveEventargs e)
{
if (e.name="..."){return reflection.assembly.loadfile("Pfad...")}
return reflection.assembly.load(e.Name)
}
Und naja, der Debugger hat ein Verhalten an den Tag gelegt, was ich mir eigentlich nicht erklären kann. Er hat 'return reflection.assembly.load(e.Name)' auch ausgeführt, wenn e.name den fraglichen Wert angenommen hat und ist dann immer hin und her zwischen 'return reflection.assembly.load(e.Name)' und } (d.h., ich vermute, dass es das in C# auch } ist, ich arbeite eigentlich mit VB.NET und da hat zwischen 'return reflection.assembly.load(e.Name)' und 'End Function' gependelt).
Aber das hat sich jetzt erstmal erledigt, weil ich ne bessere Bibo für den Job (Pdf-Export) gefunden hab...
Trotzdem Danke!
Da gibt es zwei Varianten, die wenn du willst auch beide kombinierbar sind: Editoren und TypeConverter. Erstere Bewirken, dass dir die Entwicklungsumgebung einen Editor anzeigt, wie du ihn z.B. kriegst, wenn du die Elemente eines ToolStrips bearbeiten willst, die andere Variante ist wahrscheinlich das, was du eigentlich gemeint hast (wobei das schwerer umzusetzen ist), nämlich dass du die einzelnen Eigenschaften der Struktur oder gleich die Struktur direkt bearbeiten kannst.
Schau am besten mal unter codeproject.com und such nach 'Designtime'
Naja, Visual Studio beendet die Debugsitzung, wortlos, ich krieg nur den QualifiedName angezeigt, ohne Pfadangabe (was ja bedeuted, dass er im StartupPath nachschauen müsste, oder? und da ist die Assembly definitiv da.)
Hallo,
Hab gerade ein Problem: Mein Startprojekt A verweist auf meine Projekte B und C, und ruft daraus über Projekt B im Projekt C Funktionen auf, die in einer Assembly D liegen, die wiederum auf E verweist. D und E sind dabei extern (E ist die SharpZipLib).
A und C verweisen auf B, D und E.
Beim Aufruf der Funktionen krieg ich aber eine Fehlermeldung, dass das System die Assembly D oder eine ihrer Abhängikeiten nicht gefunden wurde. Sie wurde aber ordnungsgemäß ins Ausgabeverzeichnis von Projekt A kopiert, wie auch B, C und E.
Was kann da falsch sein?
Mit:
int i= Invoke(...);
geht es ja nicht.
Noch nie was von Invoke (im Sinne einer statischen Methode) gehört. Wenn du einen stinknormalen Delegate aufrufst, dann bietet der dir die Funktion oder Methode (kommt auf den Delegatetyp drauf an, bei Delegatefunktionen dementsprechend die Funktion) Invoke an, die die Funktion oder Methode, auf die das Delegateobjekt zeigt. Wenn das eine Funktion war gibt Invoke dann auch den Rückgabewert zurück.
Das DefaultEventAttribute ist wie der Name schon nahelegt ein Attribut, d.h., du musst es der Klassendefinition voranstellen
[DefaulEvent("Click")]
public class MyPanel:Panel
{
}
Dieses Verhalten wird durch das System.ComponentModel.DefaultEventAttribute bestimmt.
Ich hab jetzt schon hier mehrere Leute gesehen, die sich gegen die Verwendung von Nested Classes (oder Class-in-Class oder wie auch immer man das in Deutsch bezeichnen mag) gestellt haben. Da ich darauf öfter mal zurückgreife wollt ich Fragen, wo die Gründe für diese Apathien liegen und ob es sogar Effizientgründe dagegen gibt.
die Alternative wären natürlich Schnittstellen, damit würdest du Erweiterungen noch mehr Spielraum geben. Musst du wissen, was du brauchst...
Normalerweise sollte ein BrowsableAttribute reichen. In Extremfällen kann es passieren, dass du einen neuen Designer machen musst.
dann würd ich das auch in ner XML unterbringen und die Bilder nur als Dateipfade speichern. Die Bilder kannst du auch mit .NET-Mitteln komprimieren, und dann beim ersten Aufruf laden.
Ich Depp hab dem XmlWriter ja auch nicht die Settings zugewiesen, kein Wunder das das nicht funktioniert...
Das
XmlWriterSettings sett
sett.Indent = True;
sett.OmitXmlDeclaration = True;
sett.CheckCharacters = True;
sett.NewLineOnAttributes = True;
Zweite Variante (Bla und auch wirklich nur Bla hat Zugriff auf Keks):
public class Bla
{
private class keks:Bla
{
public keks() // public oder internal ist in dem Fall egal
{
}
}
}
Ja aber wie soll das gehen? Wie kann ich den nur bestimmten Klassen (wie in meinem Beispiel Bla) erlauben anderen Klassen zu instanziieren (wie in meinen Beispiel Keks) ? Ich glaube das geht nicht ueber den Konstruktor!
Geht ja wohl!
public class keks
{
internal keks()
{
}
}
wo findet man eigentlich die von Sandcastle ja nu benötigten Dateien HHC.exe und HXCOMP.exe?
//edit: Hab sie gefunden, bei VS2003-Überresten, wo gibts die denn sonst noch?
- Wie krieg ich NDoc dazu, deutsch zu reden?
Und? wo liegt da das Problem?
PrintDialog1.Document=PrintDocument1;
Public Interface IBothList<T> : {IList<T>,IList} {}
und
IBothList<String> l
int i=l.Count //geht nicht weil doppelt definiert
int i=(IList)l.Count //geht, aber ich muss mich halt entscheiden
wenn man mit konkreten Klassen arbeitet passiert das natürlich nicht, aber so...
Wie kriege ich den XMLWriter dazu für jedes Element eine neue Zeile zu erstellen?
Hab in MSDN nachgeschaut und demnach NewLineOnAttributes auf True gesetzt, aber das ändert nichts.
Ja, klar, das Problem ist nur, dass du dich jedes Mal beim Aufruf eines auf diese Weise doppelt definierten Members entscheiden musst, welchen du jetzt meinst (IList oder IList<T>). Das ist unübersichtlich und stiftet Verwirrung.
da IList<T> von IList abgeleitet ist
Stimmt nicht. IList<T> ist von ICollection<T>,IEnumerable<T> und IEnumerable abgeleitet. Und wenn man jetzt eine Schnittstelle macht, die IList und IList<T> erbt, dann kann man wichtige Eigenschaften wie Count nicht mehr verwenden, da diese sowohl in IList als auch in IList<T> definiert sind.
Naja, die einzigen in der Natur vorkommenden Zufälle sind quantenphysikalischer Natur, und da heutige Computer noch keine Quantencomputer sind, machen die nix anderes als Zufälle berechnen. Theoretisch kann man Zufälle nicht berechnen, ja. Faktisch muss man aber sagen, Computer machen es trotzdem und gern und oft. 🙂
Für RGB reicht das aus, in der Tat, ja, für ARGB aber nicht. Da gibt es möglicherweise noch einen Alphakanal.
Die Konsequenz daraus ist, dass du überlegen musst, ob es bei dir dazu kommen kann, dass die Farben einen Alphakanal haben. Weil wenn der Benutzer ein 99,5% durchsichtiges Weiß einstellt und die Fläche darunter aber schwarz ist kannst du den Text auch wieder nicht lesen.
Wie du das anstellen kannst kann ich dir aber auch nicht sagen. Ich schätze mal, du müsstest dafür auf die WinBibliotheken zugreifen.
Du kannst das Problem aber umgehen, wenn du den Alphakanal einfach lässt, kann aber dann u.U. passieren, dass man den Text nicht so richtig sieht
Color GetColor(Color FeldColor)
{
int helligkeit=...
int faktor=1-(int)(helligkeit/255);
Return Color.FromArgb(FeldColor.A,faktor*255,faktor*255,faktor*255)
}
//edit: Quatsch, helligkeit sollte double sein, ansonsten zweimal sinnlose TypCasts
wenn du's einmal machen willst reicht
Convert.ToString(double,System.Globalization.CultureInfo.InvariantCulture)
ansonsten könntest du folgendes probieren:
System.Windows.Forms.Application.CurrentCulture=System.Globalization.CultureInfo.InvariantCulture
Bei 64bit-Systemen sollte aber definitiv Double in absolut jedem Fall schneller sein...
also zum einen hab ich wirklich einem Irrglauben unterlegen und bei Double und float nur die Hälfte der Bits veranschlagt. Aber das Double schneller als Float ist hab ich mir nicht selber ausgedacht, das war Michael Kofler, der in seinem Buch 'Visual Basic 2005' (mit dem ich die Programmierung mit .NET und überhaupt die Programmierung gelernt hab) die Aussage los gelassen hat.
Der Defaultdatentyp für Fließkommazahlen und Fließkommaberechnungen ist Double. Dieser Datentyp kann auch am effizientesten verarbeitet werden. Single (VB-Alias für float) sollte nur dann eingesetzt werden, wenn der Platzbedarf eine wichtige Rolle spielt (etwa bei riesigen Feldern)
Woher der das hat? Keine Ahnung, bei mir hat sich halt nur festgesetzt, dass Double schneller ist, zumal ich mit den Bytes durcheinander gekommen bin (dachte Double hat 32 und float 16bit)
Naja, es liegt ja wohl nicht daran, dass das DataGrid keine DataSets darstellen kann, oder? Also muss es ja wohl daran liegen, dass die XML irgendwie eigenartig interpretiert wird. Aber eh du dich da reingedacht hast und den Fehler gefunden hast, schreib dir doch selber einen Interpreter. Wenn du die Datei kennst müsste der m.E. u.U. sogar schneller sein...
Fehler 1 Der Typ- oder Namespacename delLogFile ist im Namespace ExceptionHandler nicht vorhanden. (Fehlt ein Assemblyverweis?) D:\Microsoft Visual Studio
d.h., ExceptionHandler wird ganz offensichtlich als Namespace erkannt,
ExceptionHandling.ExceptionHandler.delLogFile();
könnte da vielleicht deine Probleme lösen, notfalls auch
Global.<Stammnamespace>.ExceptionHandling.ExceptionHandler.delLogFile();
Wie oft willst du denn rechnen? Und was willst du erreichen? Das musst dir klar werden. Ich hab dir dann mal eine Entscheidungshilfe zusammengestellt
decimal
- Innerhalb des Dezimalsystems (d.h., bei Zahlen ohne Perioden, z.B. Geldbeträgen) 100% genau
- langsamer als die anderen beiden (recht deutlich)
float (entspricht Single)
- geringer Speicherbedarf
- evtl. langsamer als Double (wird ja gerade diskutiert)
- dieselben Rundungsfehler wie double, niedrigere Genauigkeit
double
- schnellster von den dreien
- Rundungsfehler z.T. recht deutlich, z.B. (1-1)~10^-324
Class Class1
Shared Sub Main()
Dim i As Integer = 1
Dim j As Integer = 40
Select Case i
Case 1, 2, 3
Console.WriteLine("Zwischen 1 und 3")
Case 4
Console.WriteLine("4")
Case 5 To 20
Console.WriteLine("Zwischen 5 und 20")
Case Is < j
Console.WriteLine("Zwischen 21 und 39")
Case Else
Console.WriteLine("Größergleich 40")
End Select
End Sub
End Class
Kompiliert und per .NET-Reflector reflektiert ergiebt das in C#
internal class Class1
{
// Methods
[STAThread]
public static void Main()
{
int i = 1;
int j = 40;
int VB$t_i4$L0 = i;
if ((VB$t_i4$L0 == 1) || (VB$t_i4$L0 == 2))
{
}
if (((VB$t_i4$L0 == 3) ? 1 : 0) != 0)
{
Console.WriteLine("Zwischen 1 und 3");
}
else if (VB$t_i4$L0 == 4)
{
Console.WriteLine("4");
}
else if ((((VB$t_i4$L0 >= 5) && (VB$t_i4$L0 <= 20)) ? 1 : 0) != 0)
{
Console.WriteLine("Zwischen 5 und 20");
}
else if (VB$t_i4$L0 < j)
{
Console.WriteLine("Zwischen 21 und 39");
}
else
{
Console.WriteLine("Gr\x00f6\x00dfergleich 40");
}
}
}
Und was ist, wenn rowControls.Length ungerade ist?
Ich kenn die Syntax von C# nicht so genau, wie der Modulo-Operator definiert ist (ich meine %), aber du wirst, wenn auch ungerade Zeilenanzahlen auftreten können, dir noch ein paar mehr Gedanken machen müssen. Dürfte aber auch nicht wirklich dramatisch sein
for (int i=0; i < GetUpper(rowControls);i=i+2)
{
DataRow rowControls = rowsControls[i];
//auswerten
DataRow rowControls2 = rowsControls[i+1];
//auswerten
}
private int GetUpper(Array arr)
{
return arr.GetUpperBound(0)-(arr.GetUpperBound(0)%2)
}
aber wie gesagt, bei dem Modulo bin ich mir nicht sicher, wie der in C# aussieht...
Habs jetzt nach zweiwöchigem Urlaub behoben gekriegt. Der Fehler war, dass in den Ressourcen eines Projektes in der Projektmappe ein solches 'Shorttable' Objekt serialisiert worden ist, ich dann aber außerhalb der Projektmappe die Serialisierung und Deserialisierung dieser Klasse geändert hab. Das lag zwar schon weit zurück und ich weiss weder, warum diese Objekte überhaupt gespeichert worden sind, aber ein manuelles Öffnen der Ressourcendatei (die war 3000 Zeilen lang, was hauptsächlich an ein paar Bildern in Textform lag) im Notepad und dann löschen der entsprechenden Knoten hat das Problem dann gelöst...
Naja, einen Assistenten für die Installationsroutine zu schreiben kannst du ja die IDE deiner Wahl benutzen, und wenn das ganze gut aussehen soll, dann sieh dich mal bei http://www.codeproject.com um (ich benutze das Wizardframework von Gary Noble, das allerdings in VB.NET geschrieben ist). Für das Entpacken der Programmdateien auf die Platte macht die SharpZipLib einen guten Eindruck...
Steht MV für Microsoft VisualStudio?
Wenn ja, dann geht das nicht wirlich, da die Expressversion keine Setup-Projekte unterstützt, aber du annst natürlich ein herkömmliches Projekt erstellen, das nur dein Programm installiert, Werkzeuge dafür bietet dir das .NET Framework genügend, allerdings setzt diese Vorgehensweise ein bereits vorinstalliertes .NET-Framework vorraus, und der Aufwand ist höher, dafür hast du dann aber alle Freiheiten, die man sich vorstellen kann...
Die Alternative dazu wäre natürlich das Ausweichen auf eine andere IDE, die das unterstützt...