Forenbeiträge von Easyrider Ingesamt 200 Beiträge
Hallo zusammen,
wie der Threadname schon sagt, suche ich ein Tool, mit dem ich bestimmte Logfiles einer Anwendung überwachen kann. Das Tool muss folgende Features können:
*X-beliebige Anzahl von Logfiles zur Laufzeit überwachen. Die Logfiles dürfen dabei nicht gesperrt werden, da immer wieder neue Einträge geschrieben werden.
*Sobald ein neuer Eintrag im Logfile ist, muss dieser pro Logfile gegen mehere Regex-Ausdrücke geparst werden.
*Ist ein solcher Ausdruck wahr, dann muss eine selbst definierbare Aktion erfolgen (Userbenachrichtigung, Mail, eigener Logeintrag, Programmaufruf, etc)
*Logfile-Überwachungen müssen zur Laufzeit aktiviert / deaktiviert werden können
Wichtig: Die Logfiles sind entweder XML-Dateien oder reine Textdateien.
Hab die letzten eineinhalb Stunden Google bemüht, mit Schlagwörtern wie "logfile" "watch" "überwachen" etc. Ich finde zwar eine Unmenge an Tools, aber keines das meine Bedürfnisse trifft.
Kennt jemand von euch ein brauchbares Tool? Bzw. gibts so was ähnliches?
mfg
Easy
Sagt mal, sind diese Kurzarbeiten mit starken Einschnitten im Gehalt verbunden?
Hallo billGates,
der Anteil ist nicht gefühlt, der ist aus unserem Bewerbungseingang entnommen. Ich kann und soll die Bewerbungen mit anschauen bei uns, und da hat sich dieser Schnitt fast jeden Monat ergeben, mal mehr, mal weniger. Wir hatten sogar Monate dabei, wo er auf über 90% hoch geschossen ist.
In unserer Firma sind bis jetzt ca. 1/3 ausländische Angestellte. Mein Team besteht aus einem Afghanen, einem Weißrussen, einer Usbekin, einem Deutschen und mir als Niederbayer (auch Ausland hier in Franken 😉 ). Ich distanziere mich von jedweder Art von Rassismus, auch wenn ich sich hier manchmal so anhört!
Ein sehr wichtiger Punkt ist, das die Kollegschaft aus einer guten Mischung der Kulturen besteht. Nicht zu viele, aber auch nicht zu wenig. So lernt man andere Kulturen, Religionen, Sprachen und Menschen kennen. In unserem Geschäftsfeld ist das sehr wichtig, da fast alle unsere Kunden rund um den Globus tätig sind und wir bis zu 14 Länder pro Kunde betreuen.
Ein weiterer wichtiger Punkt ist, das die meisten unserer Belegschaft direkt beim Kunden arbeiten. Die Kollegen beim Kunden sind meistens auch Deutsche, und es macht (leider) immer noch einen Unterschied, ob wir einen Einheimischen oder einen anderen zu unseren Kunden schicken. Erste recht macht es einen Unterschied, wenn wir ein ganzes Team hinschicken.
Auch die Sprache der Kollegen ist manchmal ein Hinderniss. Wir haben einen Inder bei uns in der Firma, der ein eher mangelhaftes Deutsch spricht. Es gab und gibt regelmäßig Themen, die ich ihm auf Englisch erklärt habe, da er das leichter verstand. Dafür schreibt er die besten Dokus die ich je gesehen habe 😁
So, das war eigentlich schon fast zuviel Informationen. Mehr darf ich echt nicht mehr sagen, ausser back2topic. 8)
Bei unserer Firma ist auch genau das Gegenteil der Fall. Wir sind mit Arbeit so überlastet, das wir bereits die ersten krankheitsbedingten Ausfälle haben. In den letzten drei Monaten hab ich alleine über 100 Überstunden geschuftet... X(
Mein Mittelständisches Unternehmen (ca. 35 Mitarbeiter) hat große Probleme, gute und bezahlbare Anwendungsentwickler zu finden. Im .NET-Bereich ists leider sehr schwer, gute Leute zu bekommen. Die meisten sind bereits in größeren Firmen engagiert oder wollen dort hin. Und viele die sich bewerben, sind nicht wirklich zu gebrauchen. Entweder sie haben nicht wirkliche Erfahrungen in .NET, oder sie passen nicht zum Team. Ohne Rassistisch klingen zu wollen ist der Ausländeranteil leider auch zu hoch (ca. 70-80%).
P.S.: Wir suchen immer noch neue, aktive und flexible Mitarbeiter:
domdv.de
Oder, so wie derzeit, oder ich programmiere die Funktionalität in eine Klasse. Bis auf die Animation sind die Granaten bis jetzt identisch. 😉
Hallo kleines_eichhoernchen,
werd auch mal kurz zitieren, das erhöht die Übersichtlichkeit:
- Kleiner Tip, bau auf Interfaces (MicroController) um, da bist du zum Schluss wesentlich flexibler.
Warum so kompliziert? Eine Granate ist in die Taktik eingebettet. Ohne eine Taktik kann eine Granate nicht existieren. Eine Taktik kann aber sehr wohl ohne Granate existieren.
Die Dateien selbst liegen in einer Assembly; sie stellen eine geschlossene Logik dar. Mit der Implementierung von (internen) Interfaces würde es nur den Komplexitätsgrad und den Aufwand aufblähen. Wir haben jetzt bereits Mehrfachvererbung mit generischen Interfaces in Richtung GUI / Commands drin.
- Konstruktoren haben das Problem, dass die nicht vererbt werden. Verwende stattdessen einen Standard-Konstruktor (keine Parameter) und eine überschreibbare Init-Methode
Wieder was neues gelernt, danke. 😁 Das Problem betrifft mich zwar derzeit noch nicht, aber ich werde es ab jetzt berücksichtigen.
Eine Text/Xml-Serialisierung ist denkich geeigneter, da man diese Dateien anschließend mit nem Text-Editor leicht bearbeiten kann. Beispiel, die Config-Dateien von HalfLife 2
Für nachträgliches Bearbeiten ist er sicherlich einfacher. Auch für die Eigenschaften wär der XML-Serializer flexibler. Aber beim speichern der Objekt-Referenzen beißts aus. Warum hab ich bereits weiter oben beschrieben.
Für was war eigentlich der Link zu JuyJuka's Konsole gedacht? Als Vorlage für das Command-Pattern?
Hallo Hajoseb,
dieser Gedanke ist mir auch schon durch den Kopf gegangen. Damit du meine Argumentation weiter unten verstehst:
Bis gestern habe ich BinaryFormatter mit AssemblyFormat Full benutzt.
Ab heute benutze ich den BinaryFormatter mit AssemblyFormat Simple. Dazu werde ich einen revolutionären Schritt in meiner Software machen, da ich intern die Architektur auf Command-Patter umbaue. Damit werden zwar alle bisher gemachten Taktiken nicht mehr ladbar, aber ich tue mich später leichter. Alle neuen Eigenschaften und Funktionen werden mit Versionstoleranter Serialisierung arbeiten und als Optional gekennzeichnet werden.
Für die Zukunft: Mein Kollege schreibt gerade seine Diplomarbeit, bei der es um Beziehungen zwischen Objekten und deren Darstellung geht. Er wird die Serialisierung in seiner Arbeit beachten, ich hoffe das ich seine Arbeit später produktiv einbauen kann. Ein Teil seiner Arbeit ist die Serialisierung von Objektbeziehungen als Referenz in XML.
Auf eine aktuelle Struktur zu aktualisieren war und ist nicht das Hauptproblem Hajoseb. Mein großes Problem war der rückwärtige Weg. Mit einem veralteten Programm eine aktuelle Taktik laden. Da die neue Taktik bereits neue Eigenschaften besaß, sind die Größen der Klassen verschoben gewesen, und das Programm hat eine Serialize-Exception geschmissen. Selbst wenn ich einen Loader dazwischen hätte, muss erstmal der BinaryFormatter es schaffen, die Taktik zu deserialisieren.
Genauso hatte ich große Probleme, als ich die serialisierten Klassen von der Hauptanwendung in eine DLL verschoben habe. Das war plötzlich eine andere Assembly, BinaryFormatter streikt...
Der aktuelle Lösungsweg löst meine beiden Probleme nicht zu 100%. Ich werde (muss) einfach mal so weiterarbeiten, den Rest wird die Zeit ergeben. Hoffentlich ist die Diplomarbeit so sauber, das ich sie ohne weiteres verwenden kann.
Trotzdem vielen Dank für deinen Input. Ich mag solche Ideen / Anreize, die bringen einem der Lösung immer ein Stück näher. Danke dir! 👍
mfg
Easy
Ok, das ist wahr. Wenn der Entwickler was falsch macht, ist er selbst schuld.
Die anderen Probleme bleiben aber leider immer noch bestehen 🙁
Hallo,
alles was du brauchst findest du im Namespace System.Globalization. Um die aktuellen Einstellungen auszulesen, benutz System.Globalization.CultureInfo.CurrentCulture.
Ob ich die Klasse von Hand als [Serializable] markiere oder von jedem Entwickler verlange, das Interface ISerializable zu implementieren ist egal. Dann bin ich / er wieder genauso weit und muss alles selbst programmieren.
Allerdings ist es bei sowas auch sinnig, das immer alle Clients die selbe Version haben müssen, ähnlich wie bei CS(S) selbst.
Und das ist genau einer der Punkte, die ich unbedingt vermeiden möchte. Das ist wie beim TeamSpeak. Blos weil ich nicht die aktuellste Version habe, möchte ich trotzdem alle Dinge benutzen, die mir mein Client (oder halt die Taktik) anbietet...
Hallo Lynix,
deine Aussagen helfen mir weiter, ja. Aber ich komme dann wieder an die gleichen Probleme wie bei dir. Erstens muss das ganze erst mal programmiert werden. Das wird sicherlich kein Pappenstiel. Zweitens muss man sehr auf Rekursion achten.
Das mit den Ausnahmefällen und Exceptions mit anderen Entwicklern kenn ich. Das ist genau einer der Gründe, warum ich eigentlich von der binären Serialisierung wegmöchte.
Fazit: Anscheinend gibt es keine existierende, saubere und einfach nutzbare Methode, um dieses Problem zu lösen. Werd ich mich wohl selbst dahinter klemmen und was schreiben müssen. 🙁
Falls jemand noch andere Ideen oder Anregungen hat, nur her damit.
Danke für deine Antwort Lynix! 👍
Servus,
hatte gerade ein wenig Wartezeit, und da hab ich mir gedacht ich übersetze meinen Translator mal ins Niederbayrische:
Unter teamsandtactics.de/downloads findet ihr die Datei "Translator.de-AT.xml". Diese müsst ihr downloaden und ins Anwendungsverzeichnis unter "C:\Programme\Translator\Translations" kopieren. Dann die Anwendung neustarten, voila.
Das ganze ist ein nicht allzu ernst gemeinter Versuch, ich hoffe der eine oder andere freut sich daran.
mfg
Easy
P.S.: Das de-AT.xml im Namen wurde nur benutzt, um eine gültige CultureInfo bekommen zu können. Es soll keine Anspielung oder sonstiges in Richtung Österreich sein! de-DE.xml war halt schonmal vergeben...
Hallo Blue_Dragon,
ich kann dir ein paar Dinge aus Sicht des Arbeitgebers sagen. Bei uns in der Firma bin ich derjenige, der alle .NET-Bewerber auf ihr Fachwissen hin überprüft und dann ja oder nein sagt. Dabei verlange ich jedesmal ein Stück Quellcode. Eine Klasse, eine Beispielanwendung, eine DLL, egal was. Die Datei muss nur digital vorliegen und größer als 1000 Zeilen sein. Es muss nicht mal kompilierfähig sein.
Dabei achte ich auf folgende Punkte:
- Sauberer Programmierstil (Variablendeklaration oben, sinnvolle Benahmung der Klassen, gute Gliederung der Funktionen)
- Benutze Namespaces, Klassen und Funktionen. Wurden Sie korrekt eingesetzt? (z. B. Streamreader, Try-Catch)
- Kennt der Programmierer OOP, bzw. benutzt er es auch?
- Wie gut ist der Quellcode auskommentiert? (Inline-Kommentare)
- Benutzt der Bewerber XML-Kommentare? Sind diese auch aussagend, oder hat er nichts-sagende Kommentare benutzt?
///<summary>
/// Get or set the dataset.
///</summary>
public static DataSet GlobalDataset
{
get { return _ds_glob_ds; }
set { _ds_glob_ds = value; }
}
Das sind mal die wichtigsten Punkte. Wir hatten bei uns in der Firma schon einige Bewerber für .NET, die absolut keinen Peil von nichts hatten, entgegen ihren angegebenen Skills. Das man spezielle Dinge wie Command-Patterns oder ähnliches nicht kennen muss ist mir klar, aber die Grundlagen muss man schon beherrschen. Hier ein Auszug von zwei meiner Fragen beim Vorstellungsgespräch, die jeder beantworten können muss:
- Nennen Sie den Unterschied zwischen strukturierter und objektorientierter Programmierung und geben Sie ein Beispiel dazu!
- Für was stehen sind folgende Namespaces? Nennen Sie wenn möglich eine Beispielklasse daraus:
> System.Data
> System.Drawing
> System.IO
Hallo serial,
habs mir mal durchgelesen. Damit habe ich schon mal was gemacht, war auch mein erster Gedanke. Was mich daran aber sehr gestört hat ist folgender Punkt:
Das Entfernen eines veralteten Felds ist nicht möglich. Bei meinem Projekt sollte später ein Server + TCP-Kommunikation hinzukommen. Es wird definitiv vorkommen, das ich veraltete Felder löschen will, um Bandbreite zu sparen.
Hier mal ein Auszug, welche Regeln alle befolgt werden müsste, wenn wir das machen:
*Entfernen Sie nie ein serialisiertes Feld.
*Wenden Sie das NonSerializedAttribute-Attribut nie auf ein Feld an, wenn das Attribut in der vorherigen Version nicht auf das Feld angewendet wurde.
*Ändern Sie nie den Namen oder den Typ eines serialisierten Felds.
*Wenden Sie beim Hinzufügen eines neuen serialisierten Felds das OptionalFieldAttribute-Attribut an.
*Wenden Sie beim Entfernen eines NonSerializedAttribute-Attributs von einem Feld, das in einer vorherigen Version nicht serialisierbar war, das OptionalFieldAttribute-Attribut an.
*Legen Sie für alle optionalen Felder sinnvolle Standardwerte fest, indem Sie die Serialisierungsrückrufe verwenden, sofern 0 oder null nicht als Standardwerte zulässig sind
Das sind meiner Meinung nach etwas zu viele Einschränkungen. Das sich jemand nicht an eine der Regeln hält, ist sehr wahrscheinlich. Zwar unschön, aber leider Realität. Und schon schepperts... 🙁
Hallo liebe Community,
derzeit bin ich wieder am weiterentwickeln meines Tools Teams and Tactics. Dabei bin ich aber auf ein "Problem" gestoßen, wo ich nicht weiterkomme. Zwar kein richtiges Problem, aber es ist doch sehr störend. Es geht um die Speicherung (serialisierung) der Taktik.
Prerequisites
Eine Taktik besteht aus einem Objekt clsTactic, welches intern Listen von anderen Objekten besitzt. Diese anderen Objekte (Granaten, Spieler, etc) sind sozusagen als Referenz durch diese Liste eingebunden. Dabei entstehen auch Ringbeziehungen, z. B. braucht eine Granate im Konstruktor einen Verweis auf die Original-Taktik, um Funktionen davon aufrufen zu können. Wichtig für mein Problem dabei ist, das alle Klassen und Unterklassen serializable sind.
Bildlich sieht das ganze so aus:
[Serializable]
class clsTactic
{
// (clsGrendade ist serializable)
List<clsGrenade> myGrenades;
// (clsPlayer ist serializable)
List<clsPlayer> myPlayers;
//...
}
Aktueller Status:
Derzeit werden die Taktiken über einen BinaryFormatter serialisiert. Alle Klassen und Eigenschaften, die serialisieren werden können, werden gespeichert, alle anderen Objekte (z. B. Graphics) sind mit [NonSerializable] markiert. Die Taktik selbst wird mit einem BinaryFormatter serialisiert.
Probleme:
Mit dem BinaryFormatter habe ich genau zwei Probleme:
a) Updates sind zwar möglich, aber der rückwärtige Weg ist nicht möglich. Beispiel: Jemand besitzt die Version 5.0 meines Tools und entwickelt damit Taktiken. Nun kommt jemand mit der Version 4.0. Zwischen den Versionen wurden drei neue Eigenschaften für einen Spieler hinzugefügt. Der Anwender aus der Version 4.0 kann die Taktik nun leider nicht mehr öffnen. Er ist sozusagen gezwungen, auf die neueste Version umzusteigen.
b) Strukturänderungen sind nicht möglich. Damit meine ich nicht, das ich die Objekte selbst ändere. Ich habe in meiner aktuellen Version die serialisierten Objekte aus der GUI in eine eigene DLL ausgegliedert. Schon kann ich die Taktik nicht mehr deserialisieren. (SerializationException, "Der ObjectManager hat eine ungültige Anzahl von Fixups gefunden. Dies weist meist auf ein Formatierungsproblem hin.")
Lösungsversuche:
Ich hab mir bis jetzt zwei Serialisierungsmöglichkeiten angeschaut. Leider haben beide Nachteile, die ich nur ungern in Kauf nehmen möchte:
BinaryFormatter:
Siehe oben beschriebene Probleme. Ich habe es sogar schon mit FormatterAssemblyStyle.Simple ausprobiert, das macht leider keinen Unterschied. Erst recht nicht, wenn alte Taktiken noch mit dem FormatterAssemblyStyleFull gespeichert wurden (FormatterAssemblyStyle Enumeration).
XMLFormatter:
Ist eher dazu geeignet, Eigenschaften wegzuspeichern. Objektreferenzen gehen nur sehr umständlich, indem ich eine ID für jedes Objekt generiere und diese abspeichere. Beim Laden dann wieder Objekte erzeugen, die ID dem Objekt zuweisen und den ganzen Objektbaum wieder herstellen. Es gibt zwar die Klasse ObjectIDGenerator Class, aber der Aufwand bleibt trotzdem hoch.
Fazit: Zuviel Aufwand, noch mehr Overhead, vor allem beim Laden...
Ziel:
Ich bräuchte eine Möglichkeit, die mir:
a) Updates zulässt. Eigenschaften können ihren Typ ändern. Beispiel: Aus einem Int32 wird ein Enum.
b) Ältere Objekt-Versionen in aktuellen Programmen lädt. Alle fehlenden Werte werden mit einem Standardwert geladen.
c) Neuere Objekt-Versionen in älteren Programmen lädt. Unbekannte Werte werden einfach ignoriert.
d) Strukturänderungen zulässt. Wenn ich die Datei nur innerhalb eines Namespaces und / oder Ordners verschiebe, aber das Objekt selbst nicht ändere, muss die Klasse in der Lage sein, das zu handlen.
Fragen:
- Kennt jemand von euch eine Serialisierungsart, die meine Ziele unterstützt?
- Könnte man den BinaryFormatter so hinbiegen, das er wenigstens die Punkte a-c kann?
- Gibt es evtl. noch externe Komponenten, die ich bis jetzt noch nicht kennengelernt habe?
Würde mich sehr freuen, wenn mir jemand weiterhelfen könnte. Google und MSDN helfen mit leider nicht mehr weiter. Vielleicht fehlen mir nur die richtigen Schlagworte, ka. Aber ich finde nix passendes...
Ich verbleibe mit einem lieben Gruß
Easy
Hallo Andreas@Tricept,
wenn ich ein bischen Eigen-Werbung machen darf: Translator.
Das Tool erfüllt
Vorhandene C# Projekte sollen die Fähigkeit bekommen Mehrsprachig zu sein
Kann es.Die Einstellung der Sprachbezeichnungen muss in einem Standard-Tool für einen nicht-Programmierer bedienbar sein.
Noch einfach gehts kaum. Du brauchst fünf Minuten um das Tool zu beherrschen. ^^Das Tool muss erkennen was neu internationalisiert werden soll und muss dies dem Lokalisierer melden.
Mein Tool hat eine "Update"-Funktion, mit der eine alte Übersetzung (z. B. englisch) mit einer neuen Übersetzung verglichen werden kann. Die Differenz dazwischen wird in die alte Übersetzungsdatei eingetragen; alle fehlenden Übersetzungen werden rot markiert.Nach der Lokalisierung muss das Ergebnis leicht in das neue Projekt (Ohne neu-kompilierung) eingebunden werden können.
Wenn du die paar Codezeilen einmal eingebaut und compiliert hast, kannst du jederzeit die Übersetzung austauschen, ohne neu zu compilieren. Einfach die entsprechende XML-Datei für die Sprache austauschen, Programm neu starten, fertig.
Das einzige was der Translator noch nicht kann ist es, C#-Projekte zu "parsen" und die Strings rauszusuchen.
Würde mich freuen wenn du mit dieser Vorlage was anfangen könntest, oder noch besser, meinen Translator weiter entwickeln würdest.
mfg
Easy
Kleines Update: Wir haben uns dazu entschlossen, diesen Thread wieder zu eröffnen, um eine Diskussion unter Entwicklern über diese Software anzuregen. Kommentare, Feuer Frei!
Hallo mosspower,
Bücher, Software- sowie Entwicklungsprozesse und Schulungen sind das kleinere Übel. Das ist alles Fachwissen, da geht man davon aus das du dir das anlernst. Dazu möchte ich nichts sagen.
Was viel wichtiger ist sind deine Mitarbeiter. Um eine Gruppe richtig leiten zu können, müssen sie dir vertrauen. Sie müssen Respekt vor dir haben und dich achten, sonst bringen dir die besten Entscheidungen nichts. Damit meine ich nicht, das sie einem als "Oberboss" oder so etwas ansehen. Nein, damit meine ich, das Sie dich als Freund ansehen. Das du für sie da bist und ihnen hilfst, wann immer sie Hilfe brauchen. Das ist das wichtigste.
Diese Dinge aber kann man nicht lernen. Vertrauen braucht Zeit, Geduld und vor allem viel Fingerspitzengefühl. Du bist neu in der Firma. Du kennst du internen Gegebenheiten nicht, wer mit wem gut auskommt, wer welchen Job gerne macht, wer mag was nicht etc etc. Halte dich am Anfang ein wenig zurück. Schau dir die Personen an, studiere sie. Achte, wer sich wie zum anderen Verhält. Das ist sehr interessant 😉
Ich kann dir nur empfehlen das du dich ein wenig mit Psychologie beschäftigst. Konfliktbehandlung, menschliche Denkweisen, Verhaltensforschung, um nur einen Teil zu nennen. Du brauchst nicht mal allzu tief gehen. Wenn du weißt, wie ein Mensch in einer bestimmten Situation reagiert, kannst du darauf vorbereitet sein und ihm helfen. Dann verstehst du auch, warum ein Mensch manchmal eine irrationale Entscheidung trifft. Und vor allem, was deine Mitarbeiter brauchen.
Umgekehrt ist es extrem wichtig, das du dich für dein Team einsetzt. Wenn einer deiner Jungs / Mädels einen Fehler gemacht hat, dann gib den Anschiss nicht einfach so weiter. Du bist die Schnittstelle zwischen oben und unten. Du kannst ab jetzt entscheiden, wer wann und aus welchem Grund Ärger verdient hat. Wenn du ihnen aber in aller Ruhe die Fehler erklärst, warum es falsch ist haben, und wie sie es nächstes Mal besser machen können, werden sie dir dankbar sein. Glaub mir, den Unterschied merkst du!
Entschuldige bitte diesen etwas psychologischen Teil, aber das musste ich loswerden. Ich kenne einige Führungskräfte (Kollegen, Kunden), die zwar in einem der drei Kernbereiche gut sind (Fachwissen, Mitarbeiterführung, Verhalten), aber dafür in den anderen beiden absolute Nieten. Einen guten Projektleiter erkennst du daran, das er alles ein wenig kann. Neben dem besitz von Fachwissen seine Mitarbeiter führen, ohne sich dabei wie ein Arschloch oder ein Wichtigtuer aufzuführen, ist schwer.
Falls du dich fragst woher ich das weiß, sag ich nur ich hab damit bereits ein klein wenig Erfahrung: Fussballtrainer C-Jugend, Vorstand Verein, seit ca. 3/4 Jahr Projektleiter bei uns in der Firma, meine Frau ist Erzieherin für schwer Erziehbare Kinder mit einer Ausbildung zur Psychologin. Die Infos kommen also alle aus erster Hand 😉
mfg
Easy
Anbei ein kleiner Screenshot mit einer geladenen Taktik.
Zuerst erstellen wir über Datei - Neu eine neue Taktik. Als Namen geben wir Beispieltaktik ein. Den Typen lassen wir auf 5on5. Danach klicken wir auf Öffnen und wählen eine Karte aus. Alle Übersichten sind unter dem Installationspfad der Anwendung (Normalerweise "C:\Programme\TeamsAndTactics") im Ordner Overviews zu finden. In der Übersicht könnt ihr nun die Karte im Miniaturformat sehen. Klickt nun auf Laden, und eine neue Taktik mit de_nuke im Hintergrund wird erstellt.
Nun wollen wir die leere Taktik erst einmal wegsichern. Klickt dafür auf Datei - Speichern und wählt einen Speicherort eurer Wahl aus.
Fügt einen Spieler zur Taktik hinzu: Öffnet links das Einfügen-Fenster und klickt einmal auf Terrorist. Nun könnt ihr, wenn ihr mit der Maus über die Taktik fahrt, sehen das ein Spieler an eurer Maus klebt. Klickt ihr am T-Spawn in der Overview auf diesen Spieler, so wird dieser an dieser Position gesetzt.
Klickt ihr ein zweites Mal auf diesen Spieler, wird er selektiert. In der rechten Seite im Eigenschaftsfenster könnt ihr nun die Eigenschaften zum jeweiligen Spieler sehen. Das ganze sieht extrem IDE-Mäßig aus. Ganz oben ist die Eigenschaft Name. Diese wollen wir nun auf "Spieler 1" ändern. Sobald ihr den Text eingegeben und auf Enter gedrückt habt, wird der neue Name beim Spieler übernommen. Das könnt ihr auch links in der Karte sehen.
Wir ignorieren die restlichen Eigenschaften und gehen weiter zu den Waypoints. Klickt mit der rechten Maustaste auf "Spieler 1" und wählt den Menüpunkt "Wegpunkte - Neu" aus. Der Cursor ändert sich nun in ein Fadenkreuz. Wie bei Bots könnt ihr nun die Waypoints für den Spieler setzen. Mit jedem Punkt wird ein neuer Waypoint gesetzt. Lasst Blade mal auf das Dach vor der Halle laufen. Sobald ihr alle Waypoints gesetzt habt, drückt einmal Escape um das erstellen neuer Wegpunkte zu beenden.
Um die Punkte besser sehen zu können, klickt in der Toolbar auf das Zeichen mit den drei Linien und den Roten Punkten und setzt einen Haken bei "Anzeige - Wegpunkte". Daraufhin erscheinen rote Punkte an jedem der Endpunkte eines Waypoints.
Wir lassen den Spieler jetzt eine Blendgranate werfen. Klickt links im Einfügen-Menu auf das Bild der Blendgranate. An der Maus klebt jetzt eine Granate. Sobald wir in der Taktik auf einen Punkt klicken, haben wir den Explosionspunkt der Granate gesetzt. Ich habe ihn in meinem Beispiel auf das linke Dachfenster der Halle gesetzt.
In der Granate könnt ihr einen roten Punkt sehen. Klickt mit der Maus auf diesen Punkt, haltet die Maus gedrückt und zieht den Punkt über den Spieler. Dort könnt ihr die Maus dann loslassen. Wenn ihr alles richtig gemacht habt, wird der rote Punkt verschwinden und eine Linie zwischen dem Spieler 1 und der Granate erscheinen. Wir haben die Blendgranate soeben dem Spieler zugewiesen.
Bei dem roten Punkt des Spielers erscheint nun ein grünes Viereck (sehr schlecht sichtbar, werde ich noch ändern). Dieses Viereck definiert den Abwurfpunkt der Granate auf den Wegpunkten. Klickt mit der Maus auf das Viereck, haltet es und bewegt die Maus solange nach rechts, bis der Punkt in etwa bei der Erhöhung über der Leiter ist.
Wenn ein Spieler eine Kiste hochklettert, ist er nicht mehr so schnell wie vorher. Diesen Aspekt müssen wir beachten. Dazu markieren wir den ersten Wegpunkt bei ersten Kiste hinter dem LKW, klicken mit der rechten Maustaste darauf und wählen den Punkt "Bewegung ändern - Kriechen". Beim Abspielen ist er hier nun abgebremst und läuft nur noch mit 60% seiner Geschwindigkeit.
Wir wollen nun den Granatenabwurf zu einer bestimmten Sekunde erledigen. Meistens ist es ja so, das mehrere Personen Granaten gleichzeitig werfen. Unser Spieler 1 darf die Blendgranate bei 2:15 werfen. Dazu klicken wir mit der rechten Maustaste auf den Wegpunkt kurz vor dem Abwurfpunkt und wählen "Bewegung ändern - Stehen - Bis ... Sekunde" und geben als Wert 135 an.
Zum Schluss speichern wir die Taktik noch einmal ab.
Wenn ihr jetzt auf Play drückt, dann werdet ihr den Ablauf der Taktik sehen können. Viel Spass beim gucken!
P.S.: Für die faulen gibt es im Download-Ordner eine Testtaktik sowie eine echte Taktik, die wir in EAS-Wars eingesetzt haben!
Hallo Zony,
diesen Fehler habe ich heute Abend auch bemerkt, als ich deine Button-Geschichte getestet habe. Komisch das es mir bis jetzt noch nicht aufgefallen ist.
Hab den Fehler gefunden und auch gleich gefixt, da ich dieselben Probleme in einem anderen Projekt von mir hatte. Ab der Version 1.0.2.0 funktionieren auch ToolStripDropDownButtons sowie ToolStripSplitButtons. Hab das ganze mit Untermenüpunkten getestet, das geht auch soweit. Die Dateien findest du an gewohnter Stelle.
Um ein zuspamen dieses Threads zu vermeiden, bitte ich euch zukünftige Fehler / Kritik / Featurewünsche über das Bugtracking-Tool Mantis (siehe erster Post) zu melden. Das erhöht die Übersichtlichkeit dieses Threads und gibt mir mehr Möglichkeiten bei der Kontrolle der offenen Punkte.
mfg
Stefan
Hallo Zony,
hab das ganze gerade mal in einem kleinen Testprojekt ausprobiert. Das Übersetzen des Tool-Strip-Buttons ging bei mir. Hier kannst du dir auch mein Beispielprojekt (VS 2008) downloaden.
Überprüf doch bitte noch mal die Namen des Controls bzw. den Key in den Übersetzungsdateien, vielleicht hast du einen Rechtschreibfehler, Zahlendreher oder unsichtbare Zeichen drin. Ist mir schon des öfteren passiert...
Was mir aufgefallen ist: Ein Label in einem ToolStrip wird nicht übersetzt. Hab das mal auf meine Bugliste im Mantis geschrieben.
mfg
Stefan
Hallo,
hatte heute ein wenig Zeit, an dem Tool weiter zu arbeiten. Folgende Punkte sind gemacht worden:
- Neu: Fehlende Übersetzungen werden nun mit einem leichten Rot hervorgehoben.
- Neu: Es ist jetzt möglich, eine Übersetzung zu aktualisieren. Dazu muss eine (alte) Übersetzung geladen werden, dann klickt auf in Datei -> Aktualisieren... und gibt die (aktuellere) Übersetzung an. Das Programm merged automatisch die fehlenden Schlüssel ein und hinterlegt sie rot.
- Fixed: Eine fehlende Übersetzung wurde korrigiert.
Dann ist mir noch die Idee mit einer Suche eingefallen. Bis jetzt ist es etwas schwer, bestimmte Übersetzungen zu finden. Mit einer kleinen Suche würde das leichter gehen. Habs mal in die Feature-Liste mit aufgenommen.
Hallo Haggy,
nein, die meisten Graphiker wissen nicht viel über Windows-GUI-Design. Als Anwendungsentwickler ist dies ein Teil unseres Jobs, Windows-konforme GUIs zu erstellen. Einen speziellen Beruf dafür gibt es meines Wissens nach nicht.
Bei uns in der Firma gibts dazu ein Buch, falls dir das etwas helfen würde. Es ist zwar schon etwas Älter, aber die meisten Richtlinien sind noch gültig.
Name: GUI-Design - Richtlinien zur Gestaltung ergonomischer Windows-Applikationen
ISBN: 3-446-19389-8
Preis: 69 DM (!!)
Darin sind auch noch Referenzen auf weitere Bücher von Microsoft Press:
"The Windows Interface Guidelines for Software Design"
ISBN 1-55615-679-0
"Die Windows-Oberfläche. Leitfaden zur Softwaregestaltung"
ISBN 3-86063-226-4
Wenn du da noch ein wenig weiter suchst, wirst du noch aktuellere Bücher darüber finden. Als das Buch gedruckt wurde, gab es noch kein Vista / Windows 7.
Hoffe das hilft dir weiter.
mfg
Stefan
P.S.: Such mal unter Amazon nach "GUI Design" 😉
Hallo Zony,
solche Antworten gefallen mir, dankeschön.
Zu den Lizenzen: Die Software besitzt derzeit keine Hinweise auf irgendwelche Lizenzen, das habe ich leider übersehen. Das Projekt war bis jetzt nur ein "Nebenprodukt" meines anderen Projekts "Teams and Tactics". In Zukunft wird der Translator unter der GNU (General Public License) stehen. Du kannst also damit machen was du willst.
Auch habe ich schon weitere Funktionen in meiner Aufgabenliste, die ich umsetzen werde:
- farbiges Hervorheben von fehlenden Übersetzungen.
- Eine Funktion, eine bestehende Übersetzung anhand einer Referenz zu "aktualisieren" (alle fehlenden Einträge werden neu erstellt, vor allem für Updates bequem).
Wenn jemand noch Vorschläge oder Ideen hat, nur her damit.
Eine weitere Frage: Wie oft wird auf Wikimedia-Inhalte verwiesen, wie oft auf Wikipedia?
Ich denke mal das das 4 - 1 für Wikipedia ausfallen dürfte. Sollte das so sein, könnte man ja trotzdem ein W machen.
Just my 2 cent..
Hier nochmal ein Screenshot des Editors:
<Translation>
<GUI>
<Translation name="mnuFile">
<Value>&File</Value>
<Description>Menupoint File.</Description>
</Translation>
</GUI>
</Translation>
Die XML-Datei hat drei unterschiedliche Kategorien: GUI für die Oberfläche, Message für Nachrichten, Code für Quellcode-Übersetzungen. Jeder einzelne Eintrag hat den key, also den Namen des Controls, in einem XMLAttribute namens "name". Die eigentliche Übersetzung ist in zwei weitere Nodes aufgeteilt, Value und Description. Aus der Value wird der Text (bzw. TabText) eines Controls, aus der Description der ToolTip.
Editor:
Der Editor ist einfach, dafür aber leicht zu handeln. Man kann mit ihm neben den Standardfunktionen "Neu / Öffnen / Schließen / Speichern / Speichern unter" auch Sonderfunktionen aufrufen. Eine davon wäre "Referenz öffnen". Im Standard hat man fünf Spalten auf der Oberfläche: Schlüssel, Referenz Übersetzung, Übersetzung, Referenz Beschreibung und Beschreibung. Mit "Referenz öffnen" kann man sich die Übersetzung von einer bereits vorhandenen einblenden lassen.
Eine weitere Sonderfunktion ist "Aktualisieren". Anhand einer anderen Übersetzungsdatei können so fehlende Übersetzungen (z. B. neu hinzugekommene Controls) in die gerade geöffnete übernommen werden.
Quellcode:
- Es muss zuerst ein Verweis auf die Datei "TranslatorDLL.dll" gesetzt werden.
- In der entsprechenden Datei muss ein "Imports Translator;" eingebaut werden.
Eine zu übersetzende Form leitet man von "frmTranslatedForm" bzw. "frmTranslatedDockContent" ab.
Für ein initiales Übersetzen der Form muss this.InitializeTranslations aufgerufen werden. Beim ändern der Übersetzung zur Laufzeit muss wiederum InitializeTranslations sowie clsTranslator.SetTranslationForControls(this) aufgerufen werden.
Übersetzungen für Messageboxen und Code können über "clsTranslator.GetMessage" bzw. "clsTranslator.GetCodeText" und danach jeweils den entsprechenden Key geladen werden.
Anbei sind die binären Dateien. Weiter unten könnt ihr eine beispielhafte Implementierung dazu finden.
Wenns sonstige Fragen oder Diskussion gibt, könnt ihr mich auch gerne unter Stefan-Aigner@web.de erreichen...
Update 1: (Mai 09) Rechtschreibfehler + Überschrift korrigiert
Update 2: (Mai 09) Hinweis zum Dateinamen hinzugefügt.
Update 3: (Mai 09) Neue Version 1.0.1.0 veröffentlicht.
Update 4: (Jun 09) Arbeitsliste eingefügt.
Update 5: (Jun 09) Versionen aktualisiert, Neuen Todo-Punkt eingetragen.
Update 6: (Sep 09) Versionen aktualisiert, Dateiaufbau + Editor überarbeitet, Datum zu der Updatelist hinzugefügt.
Update 7: (Okt 09) Arbeitsliste aktualisiert.
Update 8: (Jun 12) Veraltete Links entfernt, Text angepasst, Beispielimplementierung angehängt.
Deinen Kommentar find ich ja fast noch geiler als den Codeschnippsel 😁
Die Liste hat sich erledigt, siehe Süddeutsche. Ist seit gestern Abend gesetzlich geregelt 🙁
Fehlt nur noch zu jedem If ein Else sowie GoTos, dann sind die Russen vollends verwirrt* 😉
:::
Ich will hier raus -_-:
For j = iStart To iEnd Step iStep
If bDelLast Then
iStart2 = j - 1
Else
iStart2 = j + 1
End If
For i = iStart2 To iEnd Step iStep
If T(j).slength = T(i).slength Then
If T(j).szPOSItemID = T(i).szPOSItemID Then
If T(j).dPrice = T(i).dPrice Then
If T(j).dOrgPrice = T(i).dOrgPrice Then
If T(j).szItemLink = T(i).szItemLink Then
If T(j).szXXX = T(i).szXXX Then
If T(j).szYYY = T(i).szYYY Then
If T(j).szInputString = T(i).szInputString Then
If T(j).bTax = T(i).bTax Then
If T(j).szDiscount = T(i).szDiscount Then
ReDim Preserve T(1 + UBound(T))
...
' Mach was...
Exit For
End If
End If
End If
End If
End If
End If
End If
End If
End If
End If
End If
Next
Next
Angelehnt an den Vorschlag von kleines_eichhoernchen Zitat:
webschmied.net (.de und com gibts bereits)
Mal wieder ein kleines Schmankerl gefunden, auch wenns dieses Mal VB.NET ist:
SqlString = "SELECT * FROM Parameter"
PARAMETERRECSET.Open(SqlString, Property_Renamed.con, ADODB_CursorTypeEnum.adOpenForwardOnly, ADODB_LockTypeEnum.adLockReadOnly)
ReDim Preserve Property_Renamed.theParams(0)
With PARAMETERRECSET
i = 1
Do While Not .EOF
ReDim Preserve Property_Renamed.theParams(i)
'Mach was mit dem Parameter
i = i + 1
.MoveNext()
Loop
End With
PARAMETERRECSET.Close()
Und ich wunder mich warum die Software langsam ist. Schädel -> Wand
Hallo zusammen,
ich stehe derzeit vor einer Architektonischen Entscheidung: Wie implementiere ich die Mehrsprachigkeit für meine Anwendung?
Folgende Punkte sind dabei zu beachten:
- Die Sprachpakete sollen über eine eigene kleine Anwendung erstellt und bearbeitet werden können.
- Die Software schreibt die Sprachdateien fertig weg, kann bereits erstellte wieder laden und ist nicht versionabhängig, d. h. man kann erweitern wie man will.
- Alle Texte für eine Sprache sind in einer globalen Datei vorhanden.
- Das Anziehen der Texte für die GUI soll automatisiert erfolgen. Nur bei Message+Errornachrichten soll das Auslesen per Hand geschehen.
- Die Sprachumschaltung ist zur Laufzeit in jeder beliebigen Form möglich.
Das sind mal in einer Grobübersicht die Anforderungen. Um das ganze zu realisieren sind mir folgende Möglichkeiten eingefallen:
- Serialisierung
- Textdatei
- XML-Datei
- Ressource-File
- Datenbank
Aus programmtechnischer Sicht fallen die Serialisierung (schlechte Erweiterbarkeit) sowie Datenbank (keine Vorhanden) weg. Für mich ergeben sich aber noch ein paar Grundlegende Fragen:
- Gibt es noch andere Möglichkeiten, mehrsprachige Programme zu realisieren?
- Welche Art ist schnell / langsam?
- Welche Vor- / Nachteile haben die jeweiligen Möglichkeiten?
- Wo gibt es spezielle Fallen, die man unbedingt vermeiden sollte?
- Was würdet ihr empfehlen?
Wie ihr seht, möchte ich von euren Erfahrungen lernen und bereits gemachte Fehler vermeiden. Bestimmt haben einige von euch so etwas schon einmal gemacht. Ich würde mich freuen wenn sich ein paar davon äußern würden.
Hallo JAck30lena,
ich habe PointF nicht benutzt, weil ich ein paar eigene Eigenschaften in die Klasse hinzufügen musste. In dem obigen Beispiel sind diese nur entfernt worden.
warum ist es eine klasse und nicht ein struct, so wie die anderen datentypvertreter?
In meinem Fall war eine Klasse vorteilhafter
Der Cast von double nach int ist in meinem Projekt (wo ich die Klasse rauskopiert habe) explizit erwünscht. Wenn jemand lieber ein Math.Round(x, 0) haben will kann er es ja gerne noch einbauen. 😉
Entschuldigt bitte wenn die Klasse nicht 100%ig generell ist.
*edit: JunkyXL hat recht. Falls du noch antworten willst, bitte per PM.
Hallo Vril,
a) Nenne die Variable zum Berechnen "ZoomFactor" oder ähnlich, damit sieht man sofort, für was die gut ist.
b) Ich rate dir dringend alle Berechnungen vor dem Zeichnen mit einem double zu machen. Du kommst in Teufels Küche wenn du mit Integer-Werten rechnst. Für solche Dinge habe ich mir eine eigene Klasse geschrieben:
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
namespace XXX
{
/// <summary>
/// Defines a pair of x and y coordinates as double, which defines a
/// point in a two dimensional room.
/// </summary>
[Serializable()]
public class clsExactPoint
{
#region " Private Variables "
private double myX = 0.0; // Value for the horizontal axis.
private double myY = 0.0; // Value for the vertical axis.
private Point myPoint; // Variable for the value as integer.
#endregion
#region " Properties "
/// <summary>
/// Get or set the value of the x coordinate.
/// </summary>
public double X
{
get { return this.myX; }
set {
this.myX = value;
this.myPoint.X = (int)this.myX;
}
}
/// <summary>
/// Get or set the value of the y coordinate.
/// </summary>
public double Y
{
get { return this.myY; }
set {
this.myY = value;
this.myPoint.Y = (int)this.myY;
}
}
/// <summary>
/// Returns the x and y coordination pair as class from type Point.
/// This includes a cast from double to int values.
/// </summary>
public Point GetPoint
{
get { return this.myPoint; }
}
#endregion
#region " Constructors "
/// <summary>
/// Default constructor with zero zero coordinates.
/// </summary>
public clsExactPoint()
{
myPoint = new Point(0, 0);
}
/// <summary>
/// Constructor with the values of the axis as integer.
/// </summary>
/// <param name="x">The horizontal position of the point.</param>
/// <param name="y">The vertical position of the point.</param>
public clsExactPoint(int x, int y)
{
myPoint = new Point(0, 0);
this.myX = (double)x;
this.myY = (double)y;
}
/// <summary>
/// Constructor with the values of the axis as double.
/// </summary>
/// <param name="x">The horizontal position of the point.</param>
/// <param name="y">The vertical position of the point.</param>
public clsExactPoint(double x, double y)
{
myPoint = new Point(0, 0);
this.myX = x;
this.myY = y;
}
/// <summary>
/// Constructor with a point as position.
/// </summary>
/// <param name="point">The position of the clsExactPoint as class from type point.</param>
public clsExactPoint(Point point)
{
if (point != null)
{
myPoint = point;
this.myX = (double)point.X;
this.myY = (double)point.Y;
}
}
/// <summary>
/// Constructor to create a new clsExactPoint from a
/// already existing clsExactPoint.
/// </summary>
/// <param name="point"></param>
public clsExactPoint(clsExactPoint point)
{
if (point != null)
{
myPoint = new Point(point.GetPoint.X, point.GetPoint.Y);
this.myX = (double)point.X;
this.myY = (double)point.Y;
}
}
#endregion
}
}
Machs dir doch einfacher:
Die Textdatei selbst ist nicht verschlüsselt, nur ihr Inhalt. Jedes Mal, wenn du eine Zeile in die Datei (bzw. in den Stream) schreibst, verschlüsselst du nur die Zeile. Diesen verschlüsselten string schreibst du dann einfach weg. Beim laden muss es halt genau anders rum gehen, jede Zeile einzeln entschlüsseln.
Wie das verschlüsseln selbst geht, kannst du hier über die Suche rausfinden. Stichwort "CryptIt". 😉
Ok, deine Antwort ist logisch. Aber auch verwirrend. :evil: Nur gut das ich es verstanden habe.
Wie wäre es, wenn du (für den Anfang) einfach Mantis installierst und dies benutzt? Zumindest bis das eigene, interne Bugtracking-Tool funktioniert. Dann kann man eh noch umsteigen. Ich sag das nur, weil die wenigsten Lust darauf haben, die ersten paar Wochen die Fehler immer per PM zu melden...
Wie siehts mit einer Bugtracking-Software zum Melden von Bugs in YAPPS für YAPPS aus? (Das is mal n Satzbau O_o)
Ich verdiene zu 100% meine Brötchen mit der Softwareentwicklung. Da ich als "Springer" in unterschiedlichen Projekten mitarbeite kommen bei mir C, C++, C#, Java und SQL dran.
Was auch noch sein könnte:
Schau dir die Pfade zu den compilierten Assemblies an. Mir ist regelmäßig der Fehler unterlaufen, eine DLL im Code aktualisiert zu haben, aber die compilierte DLL nicht ins Debug / Release-Verzeichnis des eigentlichen Projekts kopiert habe.
Hallo,
gut, eine Lösung ist gefunden. 😁
@ herbivore: Du hast natürlich recht das man das Event auch nur so abonnieren kann, aber haargel hat ja schon eingehend geschrieben, das er das Event überschreiben möchte. Somit bin ich nur davon ausgegangen, das er eine eigene Klasse schreibt.
Korrigiert mich wenn ich falsch liege, aber soweit ich das bei dem Objekt gesehen habe sind diese beiden Events die einzigen, die fehlen...
Servus,
ich habe gerade das grundlegende Problem, mich mit einer SolidDB von IBM zu verbinden. Anscheinend bin ich zu blöd, einen funktionierenden ODBC-Connectionstring dafür zu finden.
a) Hat jemand ein (C#, VB, J#).NET Beispiel für den Verbindungsaufbau für mich?
b) Gibt es für SolidDB noch bessere Möglichkeiten ausser ODBC? Ich denke dabei speziell an ADO.NET o. ä.
Leider gibt es bei google nicht genügend Informationen zu meinen Stichwörtern (solid, soliddb, connectionstring, connection), oder ich suche mit den falschen Stichwörtern. Auch in der Original-Doku von IBM finde ich nur mangelhafte Informationen, da dort nur der Aufbau mit normalem Java bzw. mit dem includieren von .c oder .h Files dargestellt wird.
Ich glaube ihr habt ihn (teilweise) falsch verstanden. Das es die Methoden gibt ist klar, aber er möchte Sie überschreiben. Ich hab grad eine Klasse von SplitContainer abgeleitet abgeleitet und mit public override nach OnSplitterMoved oder OnSplitterMoving geschaut. Die Methoden gibts echt nicht zum überschreiben.
Versuch es einfach anders. Schreib dir eine eigene Klasse, die das event SplitterMoved registriert. Dort kannst du dann deinen Code einfügen.
class Class1 : System.Windows.Forms.SplitContainer
{
public Class1()
{
this.SplitterMoved += new System.Windows.Forms.SplitterEventHandler(Class1_SplitterMoved);
}
void Class1_SplitterMoved(object sender, System.Windows.Forms.SplitterEventArgs e)
{
throw new Exception("The method or operation is not implemented.");
}
}
Du musst die drei Proxy-Variablen setzen, auch wenn du sie nicht benötigst. Ein leerer String ("") reicht vollkommen aus. Ich hatte den gleichen Fehler und hab ihn so gelöst.
Servus,
habe hier gerade ein etwas ungewöhnliches Verhalten. Ich benutze eine modifizierte Version der Richtextbox, welche mir ein paar mehr Features bereit stellt. Um mein Problem zu verstehen kurz ein Aufbau meiner Anwendung:
Form A hat eine Richtextbox, in der eine Beschreibung von
Klasse B steht. Klasse B kann mit OpenFile(string) und SaveFile(string) serialisiert / deserialisiert werden. Somit steht der RTF-Text in der Klasse selbst drin.
Mein Problem ist, das nach dem Speichern und erneuten Laden einige Formatierungen verschwunden sind. Nicht alle, nur ein paar. Zu Testzwecken habe ich den RTF-Text aus der Richtextbox in eine Datei schreiben lassen und ihn mir im Word angeschaut. So wie auf der linken Seite der angehängten Grafik sollte der Text eigentlich aussehen und so sieht er im Word auch aus.
Rechts daneben könnt ihr sehen, wie meine Richtextbox den Text anzeigt. Neben der Schriftgröße und den Styles fehlt auch die Schriftfarbe. Der Texthintergrund und die Ausrichtung sind aber da. 🤔
Hier ein paar Quellcode-Ausschnitte:
Form A:
internal FormA(clsB b)
{
this.myB = b;
this.rtbTextbox = new ExtendedRichTextBox();
this.rtbTextbox.Dock = DockStyle.Fill;
this.rtbTextbox.ContextMenuStrip = this.ctmDescription;
this.rtbTextbox.ScrollBars = RichTextBoxScrollBars.Vertical;
this.rtbTextbox.TextChanged += new EventHandler(rtbTextbox_TextChanged);
this.rtbTextbox.ClassB = this.myB;
this.rtbTextbox.AcceptsTab = true;
this.rtbTextbox.ShortcutsEnabled = true;
this.rtbTextbox.Rtf = this.myB.Description;
this.tbpDescription.Controls.Add(this.rtbTextbox);
}
private void rtbTextbox_TextChanged(object sender, EventArgs e)
{
this.myB.Description = this.rtbTextbox.Rtf;
}
Class B:
private string myDescription = ""; // The description (Richtextbox)
/// <summary>
/// Get or set the description of the tactic.
/// </summary>
public string Description
{
get { return this.myDescription; }
set
{
this.myDescription = value;
this.HasToSave = true;
}
}
public bool OpenFile(string filename)
{
// Laden des Objects per BinaryFormatter aus einem Stream nach TempObject...
formatter.Deserialize(stream, TempObject);
this.myDescription = TempObject.Description;
this.FormA = new FormA(this);
this.FormA.Show();
}
public bool Save()
{
//Temporärer Export des Files.
//this.myForm.rtbTextbox.SaveFile(@"C:\Dokumente und Einstellungen\Administrator\Desktop\Test.rtf");
// Binäre Serialisierung des Objekts
formatter.Serialize(stream, this);
}
Kennt jemand so ein Verhalten? Oder hat er so etwas schon mal gesehen? Bin mit meinem Latein langsam am Ende... X(
*edit: Fehlerteufel der du bist auf Erden...