Wie willst du sowas erreichen mit einem Betriebssystem, wo sich die Systemzeit nur ca. alle 20ms aktualisiert? Das geht einfach nicht. Da wirst du auf ein Echtzeitbetriebssystem umsteigen müssen, was aber dann kein .NET beherrscht...

Moment mal, wir reden hier immernoch über Schule - nicht über Sklavenarbeit. Und wenn ein Lehrer die Schüler nicht entsprechend mit Aufgaben versorgt (es wäre ja was anderes, wenn sie im inet surfen würden, wenn sie noch nicht fertig sind), dann kann man dann machen, was man will. Selbst wenn der Lehrer begründete und dingfeste Einwände hätte würde es aber vernünftigere Lösungen geben als ohne Vorwarnung den Rechner neu zu starten. Das hört sich für mich eher an, als ob der Lehrer die verschiedenen RC-Werkzeuge, die er so zur Verfügung hat, austesten will.

Und mit den Einwänden gegen den Lehrer ist das auch so eine Sache... wenn du in einem Bundesland bist, in dem Lehrer Mangelware sind, dann kann das durchaus schwer werden...

du kannst alternativ auch gleich die 2008er Express Version nehmen, damit kann man genauso gut .NET 2.0 (wenn nicht sogar besser) entwickeln. Und wenn du dann irgendwann auf .NET 3.0 oder 3.5 umsteigen willst (oder die einfach mal ausprobieren willst) ist das total einfach.

//edit: Wie bei der 2005er Version ist die Lizenz immernoch kostenlos und voll kommerziell einsetzbar

Du hast die 1.0 vergessen.🙂

1.1 enthaelt die 1.0

2.0 ist komplett neu

3.0 enthaelt die 2.0

3.5 enthaelt 2.0, 3.0, 2.0 SP1, 3.0 SP1

somit hast du wenn du 3.5 und 1.2 installierst alles 🙂

Das Stichwort, wonach du suchen musst, lautet Regex (regulaere Ausdruecke)

ständig IndexOf zu benutzen ist aber nicht so toll, weil man dann (wenn der Compiler das nicht wegoptimiert) ständig das gesamte Array durchsucht. Ein Zugriff auf ein diskretes Arrayelement per Index ist dagegen deutlich schneller.

writer.Flush() vor writer.Close()? Hilft das nichts?

Ja, klar ist auch Decimal in der Genauigkeit begrenzt, aber 0,7 und 0,2 sind halt dezimal endlich. sehr endlich sogar. Die kann man sehr wohl exakt ausdrücken.

Weil sich die using-Direktive nicht auf Assemblies, sondern auf Namensräume bezieht, aber das sind Grundlagen...

Naja, das ist ja kein Problem von Fliesskommazahlen generell, sondern Fliesskommazahlen im hexadezimalen Zahlensystem (0,2 und 0,7 sind hexadezimal unendliche rationale Brueche), bei Decimal hast du das Problem logischerweise nicht (ist ja dezimal, bzw gaukelt dezimal vor).

Die Standardimplementierung von PropertyTabs delegiert einfach an die TypeConverter. Was ich meinte ist, wenn du das da ueberschreibst, dann musst du erst das entsprechende Objekt untersuchen, was es fuer ein Objekt ist. Es sei denn du fügst einfach Eigenschaften hinzu (zb IExtenderProvider).

Besser, viel besser, ist es, wenn man auf Basis des Objektes das ganze machen kann. Und da gibt sehr wohl Möglichkeiten (die warum auch immer aber ziemlich in Vergessenheit geraten): ICustomTypeDescriptor (dynamisch, wird aber teils nicht unterstuetzt und verletzt m.E. die Polymorphie) und TypeConverter (statisch über Attribute und einfach mal genial). Wenn man da seinen eigenen TypeConverter schreibt und da GetProperties überschreibt kann man in Verbindung mit eigenen PropertyDescriptor-Klassen eine ganze Menge lustiger Dinge anstellen.

naja, der Weg ueber PropertyTabs wuerde ja bedeuten, dass du entscheidest, welche Eigenschaften angezeigt werden sollen. In vielen Fällen ist es aber besser das Objekt selbst (bzw Hilfsklassen) entscheiden zu lassen, welche Eigenschaften angezeigt werden sollen, weil dann nicht noch ewig gucken musst, was das fuer ein Objekt ist, da das Objekt oder damit verbundene Hilfsklassen das Objekt kennen. Was einen Performancegewinn bringen sollte und die Komplexitaet der Anwendung reduziert. Das waere dann der Weg ueber TypeConverter (statisch), bzw. ICustomTypeDescriptor (dynamisch, könnte daher einer der wenigen Fälle sein, in denen das mal gut ist, aber ich weiss nicht, ob das PropertyGrid das unterstützt).

Ich arbeite zwar nicht in einer Softwarebude (noch nicht, hoffe ich 🙂), aber bin in einem Sportverein, der zum überwiegenden Teil von einem 140 Mann starken Softwareunternehmen getragen wird. Ich kann nicht sagen, wie es da mit Essen und Getraenken bei der Arbeit steht 🙂, aber zumindest habe ich als Mitglied des Sportvereins Zugang zur firmeneigenen Sauna und Fitnessraum und Kletterwand...

Es scheint auch in Deutschland also auch positive Beispiele zu geben 🙂

Also mal ein paar Dinge:

1. Falsches Forum, sowas wird normalerweise in Entwicklungs- und Laufzeitumgebung behandelt

2. Vergiss ganz schnell ICustomTypeDescriptor, der macht nur Aerger, weil tw. nicht unterstuetzt. Besser und flexibler ist an der Stelle das TypeConverterAttribute (wie du es ja auch schon mal gemacht hast)

3. Die "Eigenschaften" die dann angezeigt werden sollen sind nicht real existierend, du musst die also selbst beschreiben, sprich: einen eigenen PropertyDescriptor implementieren.

Ich würde das lieber ohne untergruppe haben also die Parameter direkt eintragen...

meinst du Kategorien? Dann musst du im PropertyGrid Ansicht auf alphabetisch umstellen.

Geht das ?

ohne genau zu wissen was, aber es geht mit Sicherheit. Der Ansatz, den MS da verfolgt ist extrem flexibel

Ansonsten erstmal herzlich Wilkommen!

Wenn du Fragen zum Verständnis oder konkrete Probleme hast, weil irgendwelche Beispiele nicht gehen, dann kann dir das Forum mit der Suchfunktion gute Dienste leisten. Wenn nicht, dann frag einfach 🙂

Also: Das letzte gleich als erstes, Resourcen zum durcharbeiten stehen 1a Links links unter Ressourcen. Am Anfang sind besonders die beiden genannten Openbooks zu empfehlen (C# und Visual C#), wenn du willst auch noch OO (sehr informativ, weniger für .NET im Speziellen, als vielmehr OO allgemein) und natürlich auf der Guide to C# von golo. Wenn du die durch hast, hast du erstmal einen guten Einstieg. 🙂

Was die IDE angeht, sicher ist VS erstmal eine Reizüberflutung, aber ich würde gerade als Anfänger unbedingt dazu raten, dich damit anzufreunden, Intellisense ist so eine große Hilfe, auf die kann man als Anfänger eigentlich nicht verzichten. Und wenn du dich nur auf den Code-Editor beschränkst, dann ist VS gar nicht mehr so komplex. Falls du das gar nicht willst gibt es da noch #develop, aber das würde ich dir verglichen mit VS Express (beide kostenlos) nicht empfehlen.

Als Sprache hast du C# schon ganz gut getroffen, wenn du aus dem PHP Umfeld kommst, die Syntax ist, naja, vergleichbar. Du must dich halt dran gewöhnen, dass C# anders als PHP absolut streng typisiert ist, aber das ist eigentlich eher positiv als negativ.

Ich würde dir aber als Einstieg erstmal ein bisschen Windows.Forms- oder gar Konsolenprogrammierung empfehlen, die ist einfacher als ASP.NET, wenn du dann die Basis kennst und verstanden hast, dann geht ASP.NET auch viel leichter.

50,6 ist hexadezimal gesehen ein unendlicher rationaler bruch, d.h., du kannst ihn nicht in einen endlichen datentyp quetschen, das wiederum heißt, es mag zwar vielleicht gehen, wenn du jetzt in diesem fall mit double arbeitest, aber du machst deine Software damit unnötig fehleranfällig. Benutz bei For-Schleifen immer int, wie du an die rankommst ist dir überlassen, aber du kannst die kontrollieren.

und bitte verbessere mal die Grammatik! man kann momentan nur in etwa raten, was du meinen koenntest.

meinem Arraylist Enthält (einen combobox und einen RichTextBox ) .

wenn ich einen Item Aus Meinem Combobox Selektiere Sollte , einen Combobox und einen RichTextBox aus der Array list genommen und auf die Gui Eingefügt.

Wenn die Deutschkenntnisse nicht reichen im Zweifel auch auf Englisch, aber damit kann man meiner Meinung nach nichts anfangen.

moment mal, der Code ist so definitiv nicht richtig.

public RequirementEditorControl()
{
this.InitializeComponent();

            list = new ArrayList();
            placeholders = new RichTextBox();
            aggregatedFragment = new ComboBox();
            item1 = new ComboBoxItem();
list.Add(combo);
list.Add(text);

}

1. Die Klasse heisst Form1, der Konstruktor ist aber fuer RequirementEditorControl
2. Die Variable "placeholders" existiert nicht.

Bitte poste hier erstmal eine konsistente Variante deines Codes!

Kleiner Tip: Die Encoding-Klasse hat auch einige statische Eigenschaften fuer die gelaeufigsten Codings, brauchst dich also nicht mit den Iso-Normen rumschlagen, sondern kannst gleich System.Text.Encoding.UTF8 nehmen 🙂

Da steht es wird eine Kopie uebergeben, das ist auch richtig, aber eben halt eine Kopie des Zeigers. Anders sieht die Sache bei Strukturen aus, da gibt es keine Referenz und die Struktur wird kopiert. Enthaelt die Struktur Referenzen werden auch da nur die Referenzen kopiert.

Nein, macht es nicht. Zumindest nicht in VB.NET, vllt in VB6, aber das ist ja was fundamental anderes. Vielleicht hat es in VB6 so funktioniert, aber davon hab ich keine Ahnung (hab noch nie VB6 angeruehrt)

naja jein, der ja ach so tolle WF-Designer ist eigentlich der gleiche wie der WinForms Designer und der ist sowohl in den Express-Versionen integriert. Man muss die Express-Versionen gewissermaßen nur austricksen: Man erstelle eine neue Klasse, lasse die halt erben von was weiß ich was, was man halt gerade brauch und clicke dann doppelt auf das Datei Symbol. VS erkennt, dass es sich um eine Komponente handelt (IComponent) und öffnet standardmäßig deren Designer. Den WF-Designer. Hab allerdings noch nicht geprüft ob die Persistenz auch so gut funktioniert, aber sie sollte. Schließlich tut sie das ja auch bei "normalen" Komponenten.

@frank#:
Eine günstige (kostenlose) Variante für Reporting wären auch die Reporting Services (die allerdings einen MS SQL Server mindestens Express (kein Compact) vorraussetzen. Bei der Express-Version ist der ReportViewer auch nachträglich installierbar. Und ich find den Designer dafür wesentlich besser, als den von CR...

@codestar:
Als jemand, der auch VB.NET bevorzugt wollte ich mal ein paar Dinge klarstellen:

1. VB.NET hat als Sprache kaum etwas, was C# nicht auch hätte, aber das sind im Wesentlichen parametrisierbare Properties, die Unterstützung von LateBinding und leider auch die Möglichkeit, explizite Typenkonversionen implizit durchzuführen (was man ja aber Gott sei Dank auch abschalten kann), ByVal gehört NICHT dazu. Alle VB.NET-"eigenen" Funktionen kann man durch Einbinden der Microsoft.VisualBasic.dll auch aus C# heraus nutzen (was aber keiner macht).

2. C# hat als Sprache gleichfalls kaum etwas, was VB.NET nicht auch hätte, was sich aber im wesentlichen auf die Verwendung von unsafe beschränkt.

3. Der IL-Code, der letztendlich über den JIT-Compiler zur Ausführung gebracht wird, ist bei VB.NET und C# meist identisch (sollte er zumindest, weiß nicht, evtl hat MS auch einen Compiler mit Optimierungen bevorzugt, aber das sollte an dieser Stelle keine Rolle spielen), es ist also völlig klar, das der VB.NET Code das selbe Ergebnis bringt, wie der C#-Code, und ein "portieren" (ich würde es eher übersetzen nennen) bringt rein gar nix.

Konkret sieht es im Falle des ByVal-Problems so aus, dass VB.NET immer zwischen ByVal und ByRef unterscheidet, während C# sich auch ohne Spezifizierer begnügt (ist 1:1 ByVal) oder man kann eben auch ref davor schreiben (entspricht ByRef). Man kann in VB.NET auch eine Entsprechung für out hinbekommen, das sieht allerdings dann hässlich aus (einfach ein Attribut an den Parameter).

Ich weiß, das gehört nicht in diese Diskussion, sondern eher in "Was sind die Unterschiede zwischen C# und VB.NET?", aber das musste jetzt mal sein.

Die Dokumentengliederung zeigt es nicht mehr an, weil es nirgendwo mehr zugeordnet ist. Eine solche hierarchische Ansicht aller Komponenten ist mir nicht bekannt, aber du siehst die Komponenten natürlich in der Form.Designer.cs Codedatei aufgelistet. Und wenn du da eine Komponente rausloeschst (am besten Membervariable zuerst loeschen, und dann einfach die Fehler durchgehen 🙂), dann ist die logischerweise auch im Designer nicht mehr sichtbar.

Ich finde einfach die Idee gut: Einen Programmablauf persistierbar machen.
Man darf aber nicht vergessen: WF ist ein Framework, KEIN Produkt. Beim einem Webcast wurde von einem MS regional Director mal gesagt, dass WF in .net 3.0 eher eine 0.9er Version ist, denn ein ausgereiftes Framework.

Das war Christian Weyer in der Webcast Serie WCF und WF beleuchtet (sehr zu empfehlen).

nur mal eine Architekturfrage: Wenn du sagst, das Programm kann dann kompiliert werden, erzeugst du C#-Code oder CodeDOM-Objekte? Und noch eine zweite, bindest du Ressourcen mit ein?

sorry, hatte ich vergessen mit dazu zu schreiben, ich habe mich auf die Rueckgabewerte bezogen. Mit der Taktik Klassenmethoden immer so genau wie moeglich geht man ja der Thematik sehr galant aus dem Weg, nur leider lässt sich das bei überschriebenen Basisklassenmethoden nicht beeinflussen, weil da evtl die Basisklasse abstrakt ist und der genauen Implememtierung der Methode Spielraum lässt.

Als ich meinen Post geschrieben habe war grad der Beitrag von FZelle der Aktuellste, auf den ich mich auch bezogen habe.

Hm, für die meisten Anwendungsfälle reicht das und ist ziemlich optimal, aber was, wenn du virtuelle Methoden aus Basisklassen überschreibst? Dann stehst du vor diesem Problem, ob du willst oder nicht. Die Parameter in der Basismethode wirst du nicht ändern können...

Bei manchen Auflistungen kann man zur Compile-Zeit auch einfach noch nicht wissen, ob sie schreibgeschuetzt sind, oder nicht. Wenn man ueber einen O/R-Mapper eine Collection implementiert, mit der man Datensaetze hinzufuegen kann, dann entscheidet sich erst zur Laufzeit, ob die Auflistung schreibgeschuetzt ist (naemlich ob der angemeldete User die entsprechenden Berechtigungen auch hat). Meiner Meinung nach ist das ein gewaltiger Vorteil von .NET, flexible Auflistungen zu haben. Und bei statischen Geschichten wie List<T> ist der Aufruf von IsReadonly ja nun wirklich nicht mit irgendwelchen einigermassen relevanten Performanceeinbußen verbunden.

Aber nehmen wir mal an, er castet gar nicht, sondern benutzt die Collection tatsächlich nur über das Interface IList, zum Beispiel in dem er mit Add eigene Elemente hinzufügt. Dann könnte man ja später auf Idee kommen, ReadOnlyCollection statt List zurückzugeben und obwohl auch ReadOnlyCollection das Interface IList implementiert, würde es beim Add knallen.

Hier wäre es schon nicht mehr so klar, dass es die "Schuld" des Aufrufers ist.

Doch, das waere sehr wohl klar. Schliesslich sollte man, wenn man in eine Auflistung, die als Interface kommt schreibend zugreifen will immer erstmal pruefen, ob die Auflistung ueberhaupt derlei Zugriffe ueberhaupt gestattet.

Aber ich sehe ein anderes Problem: Wenn ich durch eine Auflistung durchenumeriere, dann weiss ich nicht, ob das eine gecachte Auflistung ist, was ja bedeuten wuerde, dass ich mehrfach ohne Probleme durch iterieren kann ohne Performanceprobleme zu bekommen, oder ob eine Streaming Technik zum Einsatz kommt und bei jedem Iterieren ein neuer Datenbankzugriff geschieht und die Auflistung evtl sogar unterschiedliche Elemente enthaelt.

BTW: Get- und Set-Methoden sind bei C# selten. Meistens verwendet man stattdessen Properties.

Wobei die Verwendung von Methoden tw durchaus angebracht ist, um zu unterscheiden, ob es sich einfach um die Wiedergabe eines gecachten Objektes (Property) oder um eine Berechnung bzw Abfrage/sonstwie Beschaffung der Daten handelt.

Ich finde eine allgemeine Antwort kann man (wie meistens bei sowas) nicht geben. List ist einfach, IList oder ICollection ist flexibel. Beides hat seine Vorteile.

aber das sollte doch bei der Menge an kostenlosen Symbolen nicht das Problem darstellen, oder?

unserer Stadt scheint es ja gerade nicht so besonders gut zu gehen, hm?

evtl noch statt String.Remove String.Substring verwenden, aber viel schneller gehts nicht, meiner Meinung nach. Jedenfalls nicht managed, wobei unmanaged hier nicht wirklich schneller sein duerfte.

Aber ist das so gewollt, dass aus

string[0]="font=Arial"
string[1]="gesuchteeigenschaft=wert"
....

nur Arial zurueckgegeben wird

Ist es möglich einen Prozess anhand des Fensterhandles und das Fensterhandle anhand eines Mausclicks zu idendifizieren? Ich will so etwas aehnliches schreiben wie xkill bei Linux, nur eben halt unter .NET und fuer Windows. Nach dem Programmstart soll das naechstbeste Fenster, in das man clickt, samt zugehoerigem Prozess (d.h., im Falle des Internet Explorers auch optimalerweise nur das Fensters und nicht der ganze Prozess) zu killen?

45,5 min bei voller Bitrate, vmtl aber mehr, weil die Bitrate von 1,5Mb bei 160x120 Pixel (plus Audio?) wahrscheinlich nicht erreicht wird.

512Mb*8bit/byte/1,5Mbit=2730,7s=45,5min

...bzw waren so intelligent die gefundene Lösung nicht kund zu tun...

Parsen ist nur die eine Seite der Medaille, man muss das Xaml ja auch generiueren koennen...

MycroXaml ist schon mal auf der Parser-Seite so ziemlich genau das, was ich gesucht hab...

Ebenfalls vielen Dank!

vllt ist WPF Masterpages in diesem Zusammenhang eine Erwähnung wert...

Sieht so ziemlich nach dem aus, was ich machen wollte, ja. Vielen Dank! Werds mir mal genauer anschauen...

Auch wenn die definitiv nicht den XamlReader genommen haben, sondern was eigenes gemacht haben...

Mir würde spontan nur System.Runtime.Serialization.Formatters.Soap.SoapFormatter einfallen...

Hallo an alle,

mal so ein Gedanke, Xaml ist ja an sich theoretisch nur ein Xml-Dialekt und hat ja von der Theorie mit WPF oder WF erstmal nichts zu tun, das sind halt die Anwendungsgebiete, wobei sich der resultierende Xaml-Code eigentlich nur in den Xml-Namespaces unterscheidet.

Meine Frage wäre jetzt die: Wenn man jetzt versucht einen eigenen Xaml-Dialekt zu implementieren, kann man dann so etwas wie XamlReader benutzen oder muss das alles neu programmiert werden?

Oder geht Xoml (was ja letztendlich auch wieder Xaml ist) über eine eigene Variante von XamlReader o.ä., was dann wahrscheinlich wirklich zur Folge haben würde, dass man einen eigenen XamlReader bauen müsste 🙁

Danke schon mal

Musst du ja auch nicht, kannst dem XmlSerializer ja auch bei der Erstellung sagen, was alles drin vorkommen kann. Damit bist du flexibler als mit Attributen, der Aufwand ist aber auch ungleich höher. Auf alle Fälle musst du dem XmlSerializer irgendwie sagen, was er erwarten kann und soll und was nicht.

Dann nimm doch die VS-Express Variante, die hat nicht so viel Power, aber eben auch nicht so viel Macken. Und vor allem kannst du damit Framework 2.0 und im Falle von VS 2008 Express auch 3.0 und 3.5 entwickeln

Grad als Anfänger finde ich, solltest du lieber erst gar keinen Blick auf Framework 1.1 werfen, da es aus meiner Sicht nix bringt sich mit Problemen rumzuschlagen, zu denen es schon sehr gute und performante Standardlösungen gibt, die du aber nicht nutzen kannst wegen Framework 1.1 (Musterbeispiel stark typisierte Listen)

Naja, zum einen, wenn es nur um den Rang gehen würde könnte man ja auch gleich immer nur Einwohner pushen (60 Clicks für 60 Einwohner) und zum anderen arbeiten Softwareentwickler nicht in Fabriken, wollen aber anständig bezahlt werden. Also ich wäre für die Wirtschaftsvariante...

Naja, ich hätte eigentlich auch gern ein DOM für Solutions und die sind ja sowas von gar nicht xml sind, und das MS.Build enthält auch "nur" die Projekte, aber schon mal vielen Dank dafür, das erleichtert vieles, auch wenn der Link momentan nicht gehen will (war da heute, d.h, gestern, schon drauf, naja).

Auf jeden Fall vielen Dank

Wenn du mit WinForms arbeitest bietet dir die Drawing.Image-Klasse das aber auch an (GetThumbnailImage oder so), brauchst also kein externes Programm verwenden... 🙂

schade