Forenbeiträge von feadur Ingesamt 722 Beiträge
bool CanOpenFile(string file)
{
try
{
File.Open(file, FileMode.Open)
}
catch
{
// Datei wird verwendet
return false;
}
return true;
}
mhh also ich kann mir zwar nicht vorstellen, dass das ab 10 MB wirklich schon langsam wird, aber insgesamt ist das DataSet halt ein ziemliches "Overkill-Objekt". Vielleicht ist es in deinem Fall sinnvoll, auf XmlReader umzusteigen.
einzelne strings würde ich nicht zippen, damit erreichst du wie gesagt meistens das gegenteil.
die frage ist wohl ehr wie du die xml datei verarbeitest? nimmst du XmlDocument oder XmlReader? Letzteres ist vorzuziehen, wenn du dein programm auf performance optimieren willst.
Laut :rtfm: heisst das Property was du suchst Login.UserName.
überschreibst du in deinem UserControl die Arrange oder Render Methoden?
Welche Eigenschaft des UserControls setzt du?
hallo,
ich verstehe nicht so ganz wo dein problem ist.
der username ist doch ein string, den kannst du doch sehr leicht als Text des Labels ausgeben.
hört sich irgendwie danach an, als ob du innerhalb der for schleife den schleifenzähler manipulerst.
um dir weiter helfen zu können solltest du am besten deinen code posten.
XML ist dafür gedacht, dass es menschen- und maschinenlesbar ist. wenn du platz sparen willst, kannst du die ganze xml datei mit GZipStream komprimieren.
*lol*
Ein seltsamer Ansatz und eine seltsame Allegorie... aber ich finde es lustig! 😉
hallo,
ControlCollection.CopyTo
hallo,
string s = "der die das";
s = Regex.Replace(s, " *", string.Empty);
//EDIT: mal wieder nicht flott genug =)
In den alten Versionen kam immer eine Fehlermeldung, man konnte aber kompilieren wenn die Angabe korrekt war.
Kannst du kompilieren wenn du alle (Designer-)Fenster schließt?
Ansonsten hast du vielleicht wirklich was falsch gemacht.
Poste doch mal deine xmls Definition.
Gruß
In VS2005 ist das normal, da dort noch eine Beta Version des Designers läuft. Es gibt außerdem Probleme mit VS 2008 Express.
Welche Version hast du?
Ich weiss es auch nicht genau, aber vielleicht sowas wie
Server.MapPath("/")
?
hallo little_budda,
File.Exists
hallo ernsti,
System.Reflection.PropertyInfo pi = typeof(Properties.Resources).GetProperty("Hello", BindingFlags.NonPublic | BindingFlags.Static);
hi,
ich denke auch, dass caching die beste lösung dafür ist. falls ich doch mal "magischen" code finden sollte melde ich mich. =)
Abgeteilt von DynamicFieldAccessor statt Reflection - schneller dynamischer Zugriff auf Felder/Properties
also es geht um folgendes:
meine software parst XAML code und erstellt daraus den entsprechenden objektgraphen (z.b. ein Window). Dabei muss ich natürlich enorm viel mit Reflection arbeiten, vor allem eben eigenschaften zuweisen per PropertyInfo.SetValue.
Leider bringt mir der beschriebene ansatz nur recht wenig, da es natürlich viele verschiedene properties sind die ich schreiben muss. (ich mache es jetzt so dass ich mir DynamicAccessor instanzen für die meist frequentierten propertys erstelle.)
ich suche eigentlich nach einem weg, properties schneller schreiben zu können als mit PropertyInfo.SetValue. deshalb wäre es natürlich schön, wenn der DynamicAccessor seinen IL code dynamisch ändern könnte, je nachdem welches property als nächstes gesetzt werden soll.
Hier die DynamicMethod Lösung:
public class DynamicAccessor
{
delegate object Getter(object target);
delegate void Setter(object target, object value);
Getter _getter;
Setter _setter;
public DynamicAccessor(PropertyInfo propertyInfo)
{
_getter = EmitGetter(propertyInfo);
if (propertyInfo.CanWrite)
{
_setter = EmitSetter(propertyInfo);
}
}
Getter EmitGetter(PropertyInfo propertyInfo)
{
DynamicMethod dynMethod = new DynamicMethod("Get",
typeof(object),
new Type[]{typeof(object)},
propertyInfo.DeclaringType);
ILGenerator il = dynMethod.GetILGenerator();
MethodInfo getterMethod = propertyInfo.GetGetMethod();
il.DeclareLocal(typeof(object));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
il.EmitCall(OpCodes.Callvirt, getterMethod, null);
OpCode box = propertyInfo.PropertyType.IsValueType ?
OpCodes.Box :
OpCodes.Castclass;
il.Emit(box, propertyInfo.PropertyType);
il.Emit(OpCodes.Ret);
return (Getter)dynMethod.CreateDelegate(typeof(Getter));
}
Setter EmitSetter(PropertyInfo propertyInfo)
{
DynamicMethod dynMethod = new DynamicMethod("Set",
null,
new Type[]{typeof(object),
typeof(object)},
propertyInfo.DeclaringType);
ILGenerator il = dynMethod.GetILGenerator();
MethodInfo setter = propertyInfo.GetSetMethod();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Castclass, propertyInfo.DeclaringType);
il.Emit(OpCodes.Ldarg_1);
OpCode box = propertyInfo.PropertyType.IsValueType ?
OpCodes.Unbox_Any :
OpCodes.Castclass;
il.Emit(box, propertyInfo.PropertyType);
il.EmitCall(OpCodes.Callvirt, setter, null);
il.Emit(OpCodes.Ret);
return (Setter)dynMethod.CreateDelegate(typeof(Setter));
}
public void Set(object target, object value)
{
if (_setter == null)
throw new NotSupportedException("Property is read-only");
_setter(target, value);
}
public object Get(object target)
{
return _getter(target);
}
}
Ich suche jetzt nach einer Möglichkeit, die Zieltypen im IL Code zu verändern, dann könnte man das ganze dynamisch für verschiedene Properties verwenden. DynamicILInfo könnte dabei helfen.
Hat jemand damit schon Erfahrungen gemacht?
naja, die "ref" klassen sind managed klassen und die anderen halt eben native. um diese benutzen zu können kannst du z.b. DllImport verwenden.
Das ist ne tolle Sache, ich habe mir direkt mal die DynamicMethod Variante zusammengebastelt.
Aber leider lohnt sich das ganze nur, wenn ich sehr oft ein und das selbe Property schreibe oder lese. Ansonsten ist der Aufwand zu groß, den Code zu erzeugen.
Wie auch immer, trotzdem ne gute Sache!
Gruß
das liegt daran, dass du number innerhalb des if-blocks definierst. dadurch ist die variable außerhalb des blocks nicht verfügbar.
naja, irgendwas musst du ja schon in der c++ anwendung ändern. du könntest für deine c# dll auch einen wrapper in c++\cli schreiben und diesen dann wie eine "normale" c++ dll ansprechen.
es gibt da auch noch andere alternativen.
du kannst deine c++ anwendung auch unter c++\cli kompilieren (mixed mode assembly) und deine c# dll als referenz hinzufügen.
alternativ kannst du in nativem c++ die clr hosten und dann dein assembly laden und ausführen. siehe z.b. http://www.codeproject.com/KB/COM/simpleclrhost.aspx
Um dich in C# einzuarbeiten reichen SharpDevelop oder Visual Studio Express wunderbar aus.
Nach welchen Add-Ins suchst du denn?
das hört sich zwar irgendwie sehr umständlich an, aber um deine frage zu beantworten:
Enum.GetNames
feadur
"Strukturierte Programmierung in C#" geht ja eigentlich gar nicht, weil C# zwingend objektorientiert ist, d.h. man kommt an kassen nicht vorbei.
man kann auch nicht sagen "wir machen unser projekt jetzt in OOP", so wie man sagen könnte "wir machen unser projekt jetzt in C".
ich denke ihr wollt ehr so etwas wie ein refactoring eures projekts machen, indem ihr das vorhandene objektmodell (das "strukturierte" modell) in ein besseres objektmodell umwandeln wollt.
als einstieg empfiehlt sich da z.b. das openbook OO (siehe link unter "Ressourcen")
Klar, ich meinte damit jetzt eine einfache Windows Anwendung. =)
Fakt ist halt, dass es nach wie vor Software gibt, die in C++ entwickelt wurde und auch darin weiterentwickelt wird, weil eine komplette Neuimplementierung einfach zu teuer wäre. Deshalb kommt man auch als .Net Programmierer oftmals nicht an C++ vorbei.
Wenn eine Firma allerdings eine Neuentwicklung in C++/MFC aufsetzt, kann ich darüber ehrlich gesagt nur den Kopf schütteln. =)
Hallo Wax,
das Vorgehen hängt stark mit der Struktur der Daten zusammen. Deshalb wäre es für eine sinnvolle Beurteilung am besten, wenn du mal Beispieldaten posten würdest.
C++\CLI, da ich ab und an nativen und managed Code mischen muss. Ansonsten bietet mir C# alles was ich brauche.
Gibts denn eine Exception nach dem Aufruf von Save?
was ist denn jetzt genau dein problem?
Problem dabei ist allerdings, dass die Abfrage teilweise bis zu 5 Sekunden dauert.
Mein Frage ist nun wie ich am besten Zeit gut machen kann bei der Abfrage.
das hängt davon ab wie deie abfrage aussieht und wie die datenbank aufgebaut ist. ExcecuteScalar() ist auf jeden fall schon mal die richtige herangehensweise.
Ist es hier besser beim Start des Programms die komplette Datenbank in ein DataSet zu laden, oder eventuell eine Klasse zu verwenden?
bei 1 mio datensätzen würde ich die DB besser nicht in ein DataSet laden! =)
hallo Dexter323,
deine vermutung war richtig, du hast aber die anführungszeichen vergessen =)
Process.Start("rundll32.exe", "user32.dll, LockWorkStation");
das liegt daran dass die datei nicht gefunden wurde...
versuch mal anführungsstriche um den pfad von rundll.exe zu setzten.
so etwas gibt es in .Net nicht. vielleicht hilft dir zum testen ja AOP weiter, mit Postsharp Laos z.b. kann man Aspekte für Exceptions erstellen.
System.String ist immer ein Unicode-String. Du kannst ihn mit Encoding.GetBytes in eine andere Codierung umwandeln, hast aber dann halt eben nur die Bytes.
Wie ermittelt denn der Designer die Struktur? Wohl indem er schlicht InitializeComponents (für sich irgendwie) so ausführt, wie wenn das zur Laufzeit geschehen würde.
Nein. Der Code wird vermutlich geparst und die entsprechenden Zuweisungen und Instanziierungen dazu verwendet, die Form im Designer aufzubauen.
Wenn du MessageBox.Show("xy") in die Methode schreibst, passiert im Designer gar nichts.
Mein Problem war nämlich gerade, dass in InitializeComponents eine Zeile war, die zur Designzeit eine Exception geben musste. Als Folge davon, bekam ich im Designer eben eine Fehlermeldung anstelle des erwarteten Forms.
Man soll ja den Code von InitializeComponent auch nicht ändern... =)
Wenn du eigene Controls schreibst dann wird (deren) InitializeComponent Methode natürlich auch vom Designer aufgerufen, wenn er das Control erzeugt.
Meine Aussage bezog sich jetzt auf InitializeComponents der jeweiligen Form im Designer... =)
Der Unterschied besteht halt darin dass der Code nicht ausgeführt wird (im Sinne der CLR), sondern der Designer untersucht den Code um die Struktur der Form zu ermitteln.
Gruß
InitializeComponent() wird durch den Designer nicht aufgerufen, sondern der Code wird zur Design-Zeit interpretiert wenn eine Form im Designer geöffnet wird.
ok, mal wieder nicht gerade aufmerksam den post gelesen =)
Die Entities sehen auch so komisch aus, da mit zwei Ampersand am Anfang. Aber vielleicht sind das ja keine "echten" xml Entities.
Denke aber auch, dass man da mit RegEx am besten weiterkommt.
Gruß
das habe ich ehrlich gesagt auch nicht verstanden. =)
sentence += " " + word; //das aktuelle word mit Leerzeichen an den Satz anfuegen
Verwende dazu lieber StringBuilder. Ansonsten wird dein Programm bei großen Datenmengen sehr langsam.
Actovator.CreateInstance erwartet den Namen des Assemblys, nicht den Dateinamen. Siehe dazu auch die MSDN Dokumentation.
Alternativ kannst du das Assembly über den Dateinamen per Assembly.LoadFrom laden, den Type ermitteln und daraus eine Instanz erzeugen.
Wenn du den Full-Name des Types kennst (Namespace und Klassenname) sowie den Namen des Assemblys, verwende Activator.CreateInstance.