Switch mit generellen bool'schen Ausdrücken ist doch schon in C#7 drinnen. Kurz: Pattern Matching.

Mehrmals pro Sekunde (ich würd ca. 10-100ms nehmen) die Mausposition abfragen, dabei die vorherige immer speichern. Einfach die neue Position - die alte rechnen, damit hast du die Delta-Position, also die Verschiebung.

Mit den trigonometrischen Funktionen (Sinus, Cosinus, Tangens) kannst du dann den Winkel berechnen. Die Delta-Koordinaten (Vektor) stellen dabei die Hypotenuse (die lange Seite des daraus gebildeten Dreiecks) dar. Im Endeffekt sind die neue Position und die alte Position damit die Eckpunkte des Dreiecks, welche die Hypotenuse, also eben längste Kante bilden. Der letzte Eckpunkt ergibt sich aus einer Kombination von X und Y Koordinaten beider Positionen (X1 + Y2 oder X2 + Y1).

Mit den trigonometrischen Funktionen kannst du also den Winkel berechnen. Den dann einfach am "virtuellen Kreis" ansetzen und den Punkt am Rand entlang zeichnen (siehe diesen Artikel - es ist verdammt einfach: Find the point on a circle with given center point, radius, and degree)

Dazu findest du genug auf Wikipedia und Google. Das sind sehr einfache, normalerweiße intensiv-gelernte Funktionen, die du auch nach 20 Jahren noch hinkriegen dürftest.

Ja, meine Aussage, dass WPF ein Abstellgleis-Projekt ist, ändert sich damit ja nicht. Ich bin mir dem was du/ihr gesagt habt absolut bewusst. Aber auch wenn der Standard geschaffen wird, heißt es nicht, dass WPF aktiv in Entwicklung ist. Das steht schon eine Weile überholt da. Aber langsam driften wir hier ziemlich off topic 😉

Naja, es war keine Rede von WPF, oder hab ich da was überlesen? (Hab das nach Feierabend gelesen, also durchaus fehleranfällig 😄).

Okay, XAML wird standardisiert für diverse Plattformen. Das würd ich jedoch dennoch nicht auffassen als "WPF wird weiterentwickelt". Bisher hat sich an WPF nichts geändert. Die meiner Meinung nach wichtigsten Neuerungen sollten mit "WPF vNext" kommen, das irgendwie mal besprochen wurde aber irgendwie nie wieder erwähnt wurde. WPF hat ein paar massive Probleme in Sachen Performance und ist mit DirectX 9 als Rendering-Basis alles andere als zukunftssicher.

Ich les aus dem Artikel lediglich, dass ich ein WPF Projekt nach Xamarin oder UWP portieren könnte. Und hier hab ich die Befürchtung, dass sich meine damalige Investition in eine professionelle UI Library als Verschwendung rausstellt.

Wie auch immer, es sind erfreuliche News - gar keine Frage 😃

Danke Abt, interessanter Artikel. Mir gefällt, wohin .Net geht.
Ich hab mir zwar Xamarin.Forms noch nicht angeschaut und hab grad keine Information zum Vergleich von WPF und Xamarin.Forms (mit dem XAML Standard) - aber sollte man WPF Programme nahezu problemlos portieren können, wäre das sehr fein.

Ich bedauere momentan, dass WPF schon wieder ein Abstellgleis-Projekt seitens Microsoft ist, das nun hoffentlich endlich durch etwas zukunftssichereres ausgetauscht wird. Forms kamen für mich nicht in Frage, jedoch ist fehlende Portabilität und das quasi nicht-vorhandensein von DirectX10+ Support traurig.

Nichtsdestotrotz, ich würd mich gern mal austauschen. Du kannst ja mal irgendwelche Kontaktmöglichkeiten per PN durchreichen.

Ich arbeite selber an einem Projekt der gleichen Idee. Zwei Iterationen in WinForms und die dritte und aktuelle nun in WPF, da so ein umfangreiches Programm mit WinForms einfach nur eine Tortur darstellt.

Das Projekt läuft bereits seit ~2012 und ist mittlerweile gut gereift. Ich hab regelmäßig gezweifelt, ob es denn wirklich Sinn mache, da Unity und Unreal bereits sehr starke Editoren besitzen.

Noch gibt es ja wenig zu bestaunen, ich wünsche aber viel Glück bei dem Unternehmen. Ich arbeite auch alleine und kann nur sagen: Es dauert Ewigkeiten so ein Projekt zu stemmen.

Ich weiß, etwas spät, aber als weiterer Ansatz der Komfort schafft und etwas nach "Separation of Concerns" geht:

Verwende doch Extension Methods:

public static Vector2 ToDisplay(this Vector2 vector)
{
     return UnitConverter.ToDisplayUnits(vector);
}

Das macht die Verwendung wesentlich einfacher und kompakter und im Falle zusätzlicher Transformationen kannst du das zentral in der EM machen, ohne überall den Code zu ändern (bspw. wenn du den Vector noch normalisieren würdest zuvor - klar macht kein Sinn, aber als Beispiel).

SpriteBatch.Begin();
SpriteBatch.Draw(IrgendeineTexture, position.ToDisplay());
SpriteBatch.End();

Mit DataAnnotations und Enterprise Library hab ich noch nie gearbeitet, drum kann ich dir auch nicht sagen was besser / schlechter wäre.

Wers braucht kann es verwenden, wer nicht, nicht. Was HVS kann ist (momentan noch nur auf Codeplex) beschrieben (ich werd aber bald den Thread updaten).

Das ganze System ist halt sehr simpel und multifunktional gehalten. Man kann vieles damit machen - und wie gesagt, wer Anregungen / Wünsche hat kann sie gerne stellen 😃

Ich kann nur sagen, dass es wesentlich besser und komfortabler ist als WinForms-Validations 😉

MfG
TBR

Eben wurde Version 3.0 released. Es hat ein komplett überarbeitetes System und viele neue Funktionen die das ganze noch weitaus mehr vereinfachen.

Genauere Informationen finden sich auf der Projektseite: http://hvs.codeplex.com/
(Ich kann leider nicht überall die Informationen sofort aktualisieren)

Das Problem ist, dass ich nicht weiß ob der Handler hinzugefügt ist.
Ich dachte eigentlich, das .Net den selben Delegate nur einmal ans Event bindet, bzw. nru einmal aufruft... oder wenigstens eine Möglichkeit bietet, dass man prüft ob der Delegate an das Event gebunden ist.

Aber naja, da scheitert .Net wohl noch.

Ich werds einfach mit einer Variable machen. Ich finds zwar umständlich, aber gut...

Mit Reflection möcht ichs gar nicht machen, da wär der Aufwand höher als der Sinn.

Aber danke für die Tipps 😃
MfG
TBR

Ja mir ist klar dass hier der Fehler liegt.

Ich update es, denn sobald sich ein Int nicht 1 oder 2 ist sollen sich alle Handler vom Event ablösen. Wenn er wieder 1 oder 2 ist sollen sie sich wieder registrieren.

Das Problem ist, wie ich prüfe ob der Handler schon hinzugefügt worden ist 😕
Click auf null prüfen geht nicht, "=" anstatt "+=" geht nicht ...

Irgendwie muss das doch ganz einfach gehen, oder ist das etwa ein .Net Fail?

Hallo, ich hab grad ein Problem...

Mein Code added per Timer immer eine Methode fürs Click-Event eines Controls.
Nun bei einem Klick wird, jenachdem wie lang das Programm schon läuft immer öfters die Methode aufgerufen...

Kann man das verhindern, ohne zigtausend Variablen und if´s?

Durch das wiederholte aufrufen geht das ganze nicht gescheit ...

Danke
TBR

Das sieht mir danach aus, dass es ziemlich einfach ist so mit TS zu arbeiten 😃

Ich werds mir mal anschauen, danke dir 😉

Ja im Gegensatz zum Sample - was das komische ist ...

Ich hab ein Problem. Ich hab das Sample mal übernommen, jedoch kommt beim Aufurf von:

            uint error = ts3client.ts3client_initClientLib(ref cbs, ref cbs_rare, LogTypes.LogType_FILE | LogTypes.LogType_CONSOLE, null);

Ein Fehler:> Fehlermeldung:

Die DLL "ts3client_win32.dll": Das angegebene Modul wurde nicht gefunden. (Ausnahme von HRESULT: 0x8007007E) kann nicht geladen werden.

Ich hab keinen Plan wieso, im Sample gehts auch ...

Ich hab zweimal geschaut, das waren irgendwie nur 4 Enums und ein Haufen vordefinierterer Dinge ... Aber kein Sample wie mans nutzt 😮

Ich hab noch nie mit nativen Libs gearbeitet - wie man sie verwendet usw. drum bin ich da jetz auch nich so helle wie das Sample funktioniert ...

Ich schaus mir nochmal an..

EDIT: Ok, ich versuchs mal. Werd schon irgendwie scheitern 😄

Hallo,
ich hab mal eine kurze Frage:

Kann ich in eine C# App irgendwie das Teamspeak 3 SDK einbauen?
Das SDK ist ja nativ kompiliert. Ich vermute das "DllImport"-Verfahren kann man hier nicht anwenden, einen Wrapper gibts leider noch nicht und sonst?

Irgendwie muss man doch auf die Funktionen zugreifen können, oder nicht? Ich hab vor kurzem mal was gelesen, dass es dafür eine Loader-API von Windows gibt oder so, die man verwenden kann um die Funktionen zu suchen und zu Invoken ...

Aber gibts keine einfache Lösung?

Danke
TBR

Ja werden korrekt registriert.

Also die GUI wird nicht ausgelastet. Ich hab zwar einen Timer der alle 4 Sekunden alle Controls updated (State-Property und Text), sie aber nicht irgendwie löscht und neu erstellt oder so...

Also ich glaub irgendwie nicht dass das das ganze so auslastet... sind 63 Controls insgesamt...

Also blockiert wird nichts, habs getestet... aber irgendwie zögert das teils echt extrem -.-

EDIT: Ach herje ... jetz hab ich das Problem. Das ist ja das Klick-Event des userControls. Wenn man nun auf die Labels die drauf sind klickt, dann geht das ned ... 😕

Hallo,
ich hab eine Liste von Usercontrols. Im Code füge ich denen beim Setzen des "SelectionMode" Propertys eine Methode als Handler für das Click-Event an.

Beim Testen jedoch klappt das nur ab und an. Man muss oftmals 10-20x klicken bis es wargenommen wird, manchmal wirds auch doppelt wargenommen (scheinbar) und manchmal gehts sofort...

Kann das irgendwo dran liegen, oder meint ihr ich hab irgendwo einen Fehler im Code?

(Das ist eine Methode die beim Ändern der "UsageMode" Property ausgelöst wird, sowie beim Setzen der "State"-Property)

            if (!UsageMode)
            {
                context_status.Enabled = true;
                switch (State)
                {
                    //...
                }
            }
            else
            {
                context_status.Enabled = false;
                if (State == 1 | State == 2)
                {
                    BackColor = Color.LimeGreen;
                    ForeColor = Color.Black;
                    Click += Controller.SelectionMode_Selected;
                }
                else
                {
                    BackColor = Color.LightGray;
                    ForeColor = Color.Black;
                    Click -= Controller.SelectionMode_Selected;
                }
            }

Und hier der Handler:

            StateControl state = (StateControl) sender;
            if (state.State != 2 & state.State != 1) return;

            state.ItemSelected = !state.ItemSelected;

            if (state.ItemSelected)
            {
                Selection.Add(state);
                state.BorderStyle = BorderStyle.FixedSingle;
                state.BackColor = Color.Orange;
            }
            else
            {
                Selection.Remove(state);
                state.BorderStyle = BorderStyle.None;
                state.BackColor = Color.LimeGreen;
            }

            if (VehicleSelected != null)
                VehicleSelected(this, EventArgs.Empty);

Danke euch 😃
TBR

Bisher noch nicht, aber wenn das gewünscht wird kann ich es gern in 3.0 umsetzen.

Bisher war ja nur die "Standard"-Verwendung geplant. Sprich WinForms und stinknormale .Net-Control geerbte Controls 😉

Das sollte aber kein Problem darstellen...

Oder wenn ich micht nicht ganz täusche (hab jetzt eine Zeit nicht weitergearbeitet und bin mir nicht sicher ob es in 3.0 oder in der 2.0er hier war) aber falls "LinkObject"´s "Base"-Property von "object" abgeleitet ist, dann sollte es auf jedenfall mit allen Dingen gehen (und das glaub ich ist so...).

Spätestens in 3.0 wird es möglich sein 😉

Btw, da ich das schonmal gefragt wurde:
HVS ist nicht eine andere Implementation der WinForms-eigenen Validation-Methoden. Es ist ein einfacheres und flexibleres System.
Zwar kann WinForms eigentlich im Endeffekt das selbe, jedoch müsste man für Controls jeweils eine Funktion schreiben, so genügt eine Zeile Code und in 3.0 ein wenig Designer-Arbeit 😉

Von daher, es ist doch besser als WinForms-Validations 😉

Hier das ganze nochmal, nur jetzt ist das Passwort optional.
Wie man sieht werden "RequiredPassword" nun ignoriert und es wird trotzdem als gültig anerkannt.

Hallo,
ich möchte euch mal mein kleines Tool vorstellen, das ich mal vor einiger Zeit gebaut habe.

Ich persönlich finde es wahnsinnig sinnvoll und hilfreich - vielleicht ihr auch.

Die Informationen, Bilder und der Code-Snippet sind veraltet. Aktuelle Informationen finden sich auf der Projektseite: http://hvs.codeplex.com/
Es tut mir Leid dass ich die Informationen nicht immer überall sofort aktualisieren kann.

Das ganze ist ein System um Forumlare in WinForms abzufragen.
Ihr kennt das bestimmt, wenn man 5 Textboxen, 2 Checkboxes, 3 Optionale Felder und noch ein Zahlenfeld hat, welche man alle prüfen muss um den "Abschicken"-Button freizugeben (aktivieren).

HVS schafft hier ab. Mit nur wenig Code kann man sehr komplexe Abfragen erstellen und somit viel schneller seine Formulare korrekt abfragen.

Der Spaß bietet die Möglichkeit, jede Eigenschaft von etwas zu prüfen.
Je nach Einstellung kommt was anderes dabei raus - es wird ausgewertet ob alle Bedingungen erfüllt sind.
Dabei kann man für jede Abfrage eines Objektes noch zusätzlich Bedingungen stellen. Diese wiederrum haben einige Einstellungsmöglichkeiten um den Verlauf der Abfrage zu modellieren.

Das System ist gerade zu dieser vollen Stunde in die Version 2.0 aufgestiegen, mit einigen Änderungen und ein paar neuen Funktionen.

Hier ein Beispiel wie ihr folgende Applikation korrekt auswerten könnt seht ihr im Anhang.
Das geht mit soviel Code:

        private void mainFrm_Load(object sender, EventArgs e)
        {
            hvsValidator = new HVS();
            validStruct = new LinkStruct();

            validStruct.Add (new LinkObject ("Name", txb_name, txb_name.GetType ().GetProperty ("Text"), new TextValidator(false)));
            validStruct.Add (new LinkObject ("LastName",txb_lastname, txb_lastname.GetType ().GetProperty ("Text"),
                                           new TextValidator(false)));
            validStruct.Add (new LinkObject ("Email", txb_email, txb_email.GetType ().GetProperty("Text"), new EmailValidator ()));
            validStruct.Add (new LinkObject ("Agree",chb_tou, chb_tou.GetType ().GetProperty ("Checked"), new BoolValidator (true)));

            LinkObject txb_passwordLink = new LinkObject("Password",txb_password, txb_password.GetType().GetProperty("Text"),
                                                         new TextValidator(false));
            validStruct.Add(txb_passwordLink);

            LinkObject txb_repeatPasswordLink = new LinkObject ("RepPassword",txb_repeatPassword,
                                                               txb_repeatPassword.GetType ().GetProperty ("Text"),
                                                               new TextValidator (false), false,
                                                               new LinkCondition ("PassOptional",txb_passwordLink,
                                                                                 txb_passwordLink.GetType ().GetProperty(
                                                                                     "IsOptional"),
                                                                                 new BoolValidator (true), true, true));
            txb_repeatPasswordLink.Conditions.Add(new LinkCondition ("PasswordEqual",txb_repeatPassword,
                                                                    txb_repeatPassword.GetType ().GetProperty("Text"),
                                                                    new ValidationObjectValidator (txb_passwordLink)));
            validStruct.Add(txb_repeatPasswordLink);

            validationCheckTimer.Start();
        }

Sprich, viel weniger als wenn man es per Hand macht 😉

Ich hab auch schon einiges für 3.0 geplant - dann werden es eventuell Sachen sein, um das ganze noch viel besser und schöner zu integrieren. Vielleicht klappts mit Design-Time-Support 😃

Wen es interessiert:
http://hvs.codeplex.com/

Das hilft mir nicht wirklich ... zumindest find ich nichts hilfreiches 😕

Danke aber 😉

Hallo,
ich hab ein kleines Problem mit SOAP:

Ich verwende für mein Programm SOAP auf Basis eines PHP-Servers mit Zend-Framework.

Ich hab das Projekt jetzt gute 2 Monate liegen gelassen, vorher ging es jedoch noch.
Das Problem ist, dass nun immer wenn ich den Service aufrufe (also eine Methode davon), kommt ein Fehler:

"Möglicher SOAP-Versionskonflikt: Unerwartetes Einschließen des Namespaces 'http://schemas.xmlsoap.org/wsdl/'. Erwartet wurde http://schemas.xmlsoap.org/soap/envelope/."

Es ging vorher garantiert! Und ich hab auch nichts an der API geändert.
Nun kommt jedoch dieser Fehler und ich weiß nicht wie ich den beheben kann.

Wenn ich das WSDL anschaue finde ich nirgends einen solchen Namespace. Was ist hier bitte los? Ich kann mein Programm ohne funktionierende API blöderweise nicht großartig weiterentwickeln, da das meiste darauf basiert und ich die zum Testen bräuchte 😕

Das Problem ist ja öfters aufgetaucht, Google spuckt nur keine Lösung aus 😕
Weiß hier wer Bescheid?

Danke
TBR

Verständlich, aber wir kommen da ganz gut mit klar 😉
Mir ist es nur lieber das implizit zu machen als explizit casten zu müssen, denn dann schlägt das wieder fail wenn man das per Reflection setzt, soweit ich weiß ...

Mich wundert nur, wieso AssetData den Operator haben muss, denn AssetData<T> ist von AssetData ja castbar, aber er will unbedingt den Operator von AssetData 😦

Irgendwie muss es doch ne Lösung geben 😕

EDIT: Bin haarscharf dran. Ich versuch es gerade so, und es geht beinahe. Problem ist wieder das Casten, da ich den Generischen Typ nicht hab...

                foreach (PropertyInfo pinf in comp.GetType().GetProperties())
                {
                    for (int i = 0; i < cdata.PInf.Count; i++)
                    {
                        if (cdata.PInf[i] != pinf.Name) continue;

                        AssetData assetData = new AssetData
                                                  {
                                                      AssetName = cdata.AN[i],
                                                      AssetType = Type.GetType(cdata.AT[i], true)
                                                  };
                        Application.Game.GetSystem<ContentManager>().LoadContent(ref assetData);

                        if (pinf.PropertyType.IsGenericType)
                        {
                            Type cast = pinf.PropertyType.GetGenericTypeDefinition().MakeGenericType(assetData.AssetType);
                            dynamic instance = Activator.CreateInstance(cast);
                            instance.AssetName = assetData.AssetName;
                            instance.Asset = Convert.ChangeType(assetData.Asset, assetData.AssetType);
                            instance.AssetType = assetData.AssetType;

                            pinf.SetValue(comp, instance, null);
                        }
                    }
                }

Problem ist, dass das Asset einfach nicht implizit konvertiert werden kann. Fällt wem ne spontane Lösung ein, wie man das umgeht?
So kurz vorm Durchbruch ...

Ich dreh noch durch damit 😄

EDIT2: Schade. Der Operator funktioniert hier nicht, denn sonst hätt ich das AssetData in das dynamische Objekt werfen können ... das dynamische ist jetzt z.B. "AssetData<Texture2D>", jedoch fehlen die Felder - der Operator überschreibt, und setzt nicht 😦

EDIT3: Problem gelöst.
AssetData hat eine generische Funktion "Cast<T>()" bekommen, welche ich per Reflection invoke und fertig:

                        if (pinf.PropertyType.IsGenericType)
                        {
                            MethodInfo method =
                                assetData.GetType().GetMethod("Cast").GetGenericMethodDefinition().MakeGenericMethod(
                                    assetData.AssetType);

                            dynamic castedAsset = method.Invoke(assetData, null);

                            pinf.SetValue(comp, castedAsset, null);
                        }

Hallo, ich hab grad ein riesen Problem.

Ich arbeite momentan stark mit Reflection um mir hardcoded-Zeugs zu sparen.
Dabei hab ich folgende Klassen:

AssetData und AssetData<T>. Diese haben keinen geerbten Bezug, jedoch selbige Eigenschaften. Bei AssetData ist "Asset" ein object und bei "AssetData<T>" ist es eben "T".

Erstes brauch ich für allgemeine Arbeiten, wo ich nicht weiß was es für ein Typ ist.
"AssetData<T>" ist implizit castbar in AssetData - funktioniert.

Problem ist, ich muss bei einer PropertyInfo die z.B. den Typ "AssetData<Texture2D>" hat, ein AssetData setzen. Ich will nicht wieder was hardcoden, da ich bei neuen Typen sonst alle Codestellen erneuern muss, damit diese den Typ richtig verwenden oder erkennen.

Wie kann ich die nun am blödesten Setzen? Ich kann AssetData leider nicht casten, da ich den Typ "T" nicht habe. Im Grunde ist Asset bei beiden der gleiche Typ, jedoch erkennt er es logischerweise nicht so.

Gibt es eine Möglichkeit das zu umgehen? Ich muss irgendwie das object "Asset" von "AssetData" in das "T Asset" von "AssetData<T>" bringen.

Hier die Klassen:

    public class AssetData
    {
        public string AssetName;
        public Type AssetType;
        public object Asset;

        public bool IsQualified
        {
            get
            {
                return AssetName != "" & AssetType != null & Asset != null;
            }
        }
    }

    public class AssetData<T>
    {
        public static implicit operator T(AssetData<T> data)
        {
            return data.Asset;
        }

        public static implicit operator AssetData(AssetData<T> data)
        {
            return new AssetData
                       {
                           AssetName = data.AssetName,
                           AssetType = data.AssetType,
                           Asset = data.Asset
                       };
        }

        public static implicit operator AssetData<T>(AssetData data)
        {
            if (data.Asset != null) throw new NullReferenceException("Can´t cast AssetData because it´s Asset is null!");
            if (data.AssetType == typeof(T))
                return new AssetData<T>
                           {
                               AssetName = data.AssetName,
                               AssetType = data.AssetType,
                               Asset = (T) data.Asset
                           };

            throw new InvalidCastException("Could not cast AssetData with Asset '" + data.AssetType.Name +
                                           "' into AssetData<" + typeof (T).Name + ">!");
        }

        public string AssetName;
        public Type AssetType;
        public T Asset;

        public bool IsQualified
        {
            get
            {
                return AssetName != "" & AssetType != null & Asset != null;
            }
        }
    }

Danke euch 😃
TBR

Hallo Leute,
ich hab ne Frage zu der ich momentan null Plan habe, wie man das nur ansatzweiße machen könnte...

Ich habe verschiedene Objekte von der Hauptklasse Component, die zur Laufzeit per Reflection aus einer Assembly geladen werden.

Ich kann diese erstellen, hab sie in einem TreeView und bei Auswahl werden diese in das PropertyGrid geladen.

Nun möchte ich wenn ich bei der Property "TextureAsset" im Grid auf den Auswahlbutton klicke, dass sich eine Tabpage zeigt und ich dort in einer Treeview was auswählen kann, und per klick auf den Button "Assign" dies zugewiesen wird.

Knackpunkt ist hier lediglich, wie ich beim Drücken dieses Buttons im Propertygrid die Tabpage anzeige 😉

Kann man das irgendwie realisieren? Andernfalls muss ich es anders machen, was nich so schön wär 😕

Von daher, danke euch 😃
TBR

Respekt, das Ding ist echt sehr gelungen 😃

Was mir nach einem 5 Minuten Test als einziges aufgefallen ist und gefehlt hat:
Wenn man eine Klasse auswählt (keine Member davon), dass diese KOMPLETT dargestellt wird 😉

Aber ansonten echt Klasse Tool, gefällt mir irgendwie sogar mehr als Reflector... 😃
Weiter machen 😉

Hallo,
ich möchte in diesem Post mal fragen ob wer sowas oder ähnliches kennt, bzw. den Vorschlag an Erfahrene VS-Addin Programmierer (ich schaffs bis heute nicht ... irgendwie bin ich zu dumm oder es ist wirklich so extrem kompliziert).

Die Idee:
Ein Addin, welches einen visuellen Changelog-Editor implementiert, der für das Projekt und/oder für die Projektmappe Changelogs generiert.
Man kann diese manuell ändern oder, was auch sehr nützlich wär, durch Erkennung von neuen "//BUG: meine Notiz" oder bspw. "//TODO: Implementieren" neue Einträge hinzuzufügen (als Schattenkopie, bis diese Solved sind, oder gelöscht werden).

Am besten wärs, wenn man in einem Kontextmenu oder dem Editor den Kommentar auswählen kann, bzw. im Kontextmenu er diesen erkennt und dann per Klick auf "Solved" dieser ins Changelog eingetragen wird und der Kommentar gelöscht wird.

Sowas in der Art halt. Das manuelle Schreiben ist zwar auch einfach, aber oft blöd, wenn man mal was vergisst einzutragen, was mir zum Beispiel oft passiert.
Man könnte da ja viel draus machen 😉

Was haltet ihr davon? Gibts sowas schon (in irgendeiner Form)?

MfG
TBR

verwendetes Datenbanksystem: XML

Hallo, kurz und knapp:
Gibt es eine Möglichkeit, Sachen, welche "ISerializable" implementieren, damit sie überhaupt serialisierbar sind, nicht binär zu serialisieren?

Es gibt ja irgendwie nur BinaryFormatter und SoapFormatter...
Binär kann ichs nicht brauchen, weils manuell editierbar sein muss.

Problem ist, ich hab eine Klasse mit mehrdimensionalen Arrays. Der XmlSerializer will diese Klasse serialisieren und wird deswegen eine Exception.
Die "GetObjectData"-Methode von ISerializable ignoriert der irgendwie - oder mach ich was falsch?

Die Implementation:

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            List<LayeredMapSerialization>[] convertedElements = new List<LayeredMapSerialization>[LayersCount];
            for (int layer = 0; layer < LayersCount; layer++)
            {
                for (int x = 0; x < _width; x++)
                {
                    for (int y = 0;y<_height;y++)
                    {
                        convertedElements[layer].Add(new LayeredMapSerialization
                                                         {
                                                             Element = _items[layer][x, y],
                                                             X = x,
                                                             Y = y
                                                         });
                    }
                }
            }

            info.AddValue("elements", convertedElements);
            info.AddValue("elementInfo", new LayeredMapSerializationInfo
                                             {
                                                 Layers = LayersCount,
                                                 Width = _width,
                                                 Height = _height
                                             });
        }

        [Serializable]
        private struct LayeredMapSerialization
        {
            public int X { get; set; }
            public int Y { get; set; }
            public T Element { get; set; }
        }

        [Serializable]
        private struct LayeredMapSerializationInfo
        {
            public int Layers { get; set; }
            public int Width { get; set; }
            public int Height { get; set; }
        }

Serialisierungs-Funktion:

        public static void Serialize<T>(object data, string path)
        {
            try
            {
                var sw = new System.IO.StringWriter();
                var sr = new XmlSerializer(typeof(T));
                sr.Serialize(sw, data);
                System.IO.File.WriteAllText(path, sw.ToString());
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message + ex.StackTrace);
                while (ex.InnerException != null)
                {
                    ex = ex.InnerException;
                    MessageBox.Show(ex.Message + ex.StackTrace);
                }
            }
        }

Der Aufruf:

            XMLSerializer.Serialize<LayeredMapList<Element>>(gamelevel, "levelMap.xml");

Danke euch 😃
TBR

Arrays[][] gehen, ja. Aber mehrdimensionale leider nicht.
Ich hab inzwischen eine saubere alternative gefunden, also ist das Problem eigentlich gelöst.

Und genauer kann ichs eigentlich nicht formulieren. Ist halt ne Blöde Situation...

Am Ende hab ichs halt per XMLs, einer Klasse und LUA gelöst, mit dem tollen Vorteil dass man eigene Objekte erstellen kann.

MfG
TBR

verwendetes Datenbanksystem: XML

Hallo Leute,
ich hab ein riesen Problem. Google läuft bald heiß wenns so weiter geht... Hab zig Sachen versucht, aber nichts geht wie es soll.

Folgende Situation:
Ich hab ein 10x10 Spielfeld für mein Spiel. Das ganze Spielfeld beinhaltet jeweils pro Feld eine Erbung von "ABSElement" (eine abstrakte Klasse mit Basis-Properties und Funktionen - diese sind aber mit XmlIgnore gekennzeichnet).

Das Problem nun: XML kann keine Mehrdimensionale Arrays (ABSElement[,]) auflösen. Ich habs mit Arrays in Arrays probiert (ABSElement[][]), was dann ging, aber leider serialisiert er mir die Eigenschaften nicht, nur den Typ 😕

BinaryFormatter weiß ich leider nicht ob der geht - scheint so, aber weiß ich nicht genau - da der eben Binär schreibt 😕

Zur ABSElement-Klasse: Die Properties sind alle abstrakt.

Zur GroundPlate-Klasse, welche ich als Test verwende: Diese überschreibt die jeweiligen Properties (nur Getter, die mit Setter werden per XmlIgnore ignoriert).

Bei meiner "Level" Klasse hab ich noch ein "XmlInclude(typeof(GroundPlate))"-Attribut, da er sonst Fehler schmeißt.

Hat irgendwer eine Idee? Ich hätte es gern im lesbaren Format. Binär würd ich ungern nehmen, aber wenns wirklich wär ... schon.
Problem ist dass ich nicht sehen kann ob es richtig speichert.

In diesem Fall mache ich es so (ABSElement):

        public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("TextureLayer", TextureLayer);
            info.AddValue("IsConductor", IsConductor);
            info.AddValue("IsElectricSource", IsElectricSource);
            info.AddValue("IsStatic", IsStatic);
            info.AddValue("MaximumPower", MaximumPower);
            info.AddValue("MaximumHeat", MaximumHeat);
        }

und in GroundPlate:

        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info, context);
            info.AddValue("IsConductor", IsConductor);
        }

Geht das dann auch wirklich? Problem ist halt, dass es alles abstrakte Klassen sind.

Danke euch 😃
TBR

Ohje ...
Das Sample hab ich gefunden und versucht, war aber dann nich das richtige und das anpassen ging irgendwie schwer - war ein wenig verplant.

Da bin ich auch ned auf die Idee gekommen das zu nehmen ...

Aber danke 😃 Es geht nun tatsächlich 😃

Das hilft mir nicht weiter, du hast mich wohl missverstanden.

Ich will die Eigenschaften von beiden Objekten miteinadner vergleichen ohne zu Casten. Aber Objekt == Objekt geht nicht, jedenfalls bei string nicht.

Es wär halt viel Aufwand für jeden Datentyp den ich brauch wieder eine Klasse oder Eigenschaft oder what ever zu basteln ...

Irgendwie muss mans doch lösen können oder?

Hallo,
ich hab hier folgendes:

Ich hab 2 Objekte (beides Textboxen in dem Fall), sowie zwei PropertInfos von denen (beide vom Property "Text").

Ich will nun prüfen ob die Werte der PropertyInfos gleich sind, ohne speziell casten zu müssen. Sonst müsst ich wieder für jeden Datentyp einen neuen Comparer basteln...

Geht das irgendwie?

...GetValue(...) == ...GetValue(...) geht nicht 😦

Danke euch!
TBR

Na ok, wenn das so ist.
Dann werde ich es wohl internal machen. Aber an sich könnte man das denke ich doch selber programmieren?!

Wenn man die Klasse übergibt, dazu die Methode und diese dann Invoked, falls der Aufrufer diese Klasse ist. Schwer nur, falls es geerbt ist...

Aber gut, zu sinnlos, ich machs per Internal.

Danke dir
MfG
TBR

Hallo,
gibt es eigentlich eine Möglichkeit, womit eine Funktion nur von einer bestimmten Klasse aufrufbar ist?
Ich denke mal, das kann man sich ganz nett selber basteln, was aber in meiner Idee etwas unschön und aufwändig wäre.

Es wird in C# doch bestimmt etwas dafür geben oder?
Ggf. ein Attribut oder so?

Finde leider nichts dies bezüglich ...

Danke euch
TBR

Weil XML zu unübersichtlich ist. Ich erstelle damit
einen HTML-Report. Mit XML kann ich hier nix anfangen 😉
Ich müsste halt nur Arrays, Listen und Dicitionarys konvertieren.

Irgendwelche .Net-Klassen gibts dafür nicht, oder?

Hmm ja ok, das wäre vielleicht ein Ansatz.

Ich kämpfe momentan mit dem Problem, dass ich Objekte reflektier (Eigenschaften und Felder) und deren Namen und Werte später in eine Datei speichere.
Leider werden dabei IEnumerable-erbende Felder und Eigenschaften nicht übernommen.

foreach (KeyValuePair<string, object> pair in tdata.Values)
                                            {
                                                sw.WriteLine("<b>" + pair.Key + ":</b> " + pair.Value + "<br>");
                                            }

Die Frage ist halt nun, wie ich diese Arrays und Listen auslesen kann, auch wenn ich nicht weiß von welchem Typ diese sind, bzw. ich nur das object davon hab.

Könnt ihr mir da auf die Sprünge helfen? Ich denke, ein paar Stichworte wären schon genug dass ich vom Schlauch falle.

Danke euch
TBR

Hallo,
ich hab grad ein kleines Problem und finde keine Lösung dafür:

Ich habe ein Interface "ITypeReflector<T>". Davon erben andere Klassen mit einem "where T : ...". ITypeReflector hat eine Funktion "string ReflectType(T type);"
Ich muss nun ein Dicitionary "<Type, ITypeReflector>" machen.

Später will ich dann verschiedene Werte prüfen, ob deren Typ als Key im Dicitionary ist und ggf. dann den TypeReflector mit diesem Type benutzen.

Das Problem ist, dass ich beim Deklarieren des Dicitonary den generischen Typ übergeben soll. Wie kann ich das nun deklarieren?

public interface ITypeReflector<T>
    {
        string ReflectType(T type);
    }

foreach (KeyValuePair<string, object> pair in tdata.Values)
                                            {
                                                if (TypeReflectors.ContainsKey(pair.Value.GetType()))
                                                {
                                                    string reflectedValue = TypeReflectors[pair.Value.GetType()].ReflectType(pair.Value.GetType();
                                                }

Danke euch
TBR

Verdammt, an die hab ich gar nicht gedacht... Und es klappt sogar.
Ok danke 😉 Wusste das mit dem TypeConverter nicht.

Danke dir 😉
TBR

Hallo,
ich hab was anderes vor, drum der Edit:

Kann man irgendwie eine Klasse erstellen, mit einem string "title" und einer undefinierten Variable, welche ich später durch einen Typ setze, sodass im PropertyGrid für diese nur noch dieser Typ eingegeben werden kann?

Sprich, wenn ich es zu einem int mache, dass man dann keinen String mehr eingeben kann.

EDIT: Var geht ja nicht. Und bei Object kann ich dann den Wert im PropertyGrid nicht mehr ändern. Kann ich das irgendwie so machen, dass der Typ dann fix ist, aber der Wert geändert werden kann? "Dynamic" funktioniert leider auch nicht besser 😦

Danke
TBR

Sind da dann andere Anwendung auch eingeschlossen?
Also Programme zum Tracen, Debuggen und was weiß ich?

Ich kenn mich nicht wirklich damit aus, wie man Prozesse debuggt o.ä.,
damit hab ich mich noch nicht befasst.

Wichtig ist für mich nur, dass man nicht direkt ohne Umwege einfach den Vorgang
einsehen kann und alles sieht was man braucht.
Eine gewisse Sicherheit soll geboten sein 😉

Hallo,
ich arbeite mich grad in Kryptographie verstärkt ein.
Hauptziel momentan ist, etwas über Produktaktivierung und hauptsächlich über
die Sicherung dieser Vorgänge zu lernen.

Ich hab ein Programm gesehen, das durch 10 heuristische Tests prüft, ob ein Debugger oder Tracing-Programm läuft.

Nun ist meine Frage, auch wenn ich das nicht schaffen würde, wie testet man sowas am besten und sichersten?

Danke euch 😃
TBR

Wie kann man die Handles überwachen, bzw. prüfen wohin sie gehen?
Geht das mit Reflection?

Hallo,
mich interessiert es momentan, ob man irgendwie prüfen kann was ein bestimmtes Assembly oder ggf. eine bestimmte Funktion von dieser macht.
Quasi, dass man prüfen kann, ob dieser auf eine Datei zugreift und man auch z.B.
die Berechtigung dafür abfangen kann und manipuliert weitergibt.

Ein Virenprogramm schafft das ja scheinbar auch irgendwie, micht interessiert jetz einfach, wie weit und ob überhaupt das geht, bzw. mit welchen Mittel und was man dafür braucht und wie hoch der Aufwand ist.

Danke für alle Tipps 😃
TBR

Kann gut sein dass es im OnPrint auch geht, aber bei mir sah man nichts.
Eventuell ein Fehler im Code...

Font ist eine Basis-Property von UserControl, welches ich gleich dafür verwende (ich will auch noch mal eine Funktion für unterschiedliche Fonts einbauen 😃)

Ok, die Optimierungen hab ich noch nicht gemacht, das kommt aber noch, danke für die Anmerkung.

Zum base: Das hab ich komplett übersehen. Ich hab zuerst "OnPaint" benutzt und dann fiel mir ein, dass ich mit dem Paint-Ereignis zeichnen muss.
Das "base." hab ich dann komplett übersehen, da ich nur den Funktionsnamen geändert hab.

Und jetzt die große Frage: Geht es? Ja! Es geht 😃

Ich danke euch an der Stelle sehr. Das Problem hät ich eigentlich sehen müssen,
aber manchmal sieht man den Wald vor lauter Bäumen nicht 😦

Das Control werd ich nach erfolgreichen Optimierungen und den restlichen Änderungen hier OpenSource veröffentlichen 😉

Hallo,
ich hab ein komisches Problem.

Da ich nirgends was gefunden hab, hab ich mir ein eigenes Label gebaut,
welches durch "" im Text diesen bis zu einem weiteren Zeichen farbig zeichnet.
Für "" kann man entweder .Net-Color Namen eingeben, wie bei HTML solche Hex-Farben oder RGB-Werte. Wenn man ein "n" eingibt wird die Standardfarbe (z.B. Schwarz) verwendet.

Der Code zum Teilen und zur Farberkennung läuft einwandfrei.
Das Zeichnen klappt eigentlich auch, nur entsteht dabei ein StackOverflow.

Ich weiß ja, das Forum ist nicht für Probleme lösen da, aber ich
hab echt keinen Plan wieso es da zu einer Stackoverflow kommt, bzw. wie ich diese
verhindern könnte.

Der Code des Controls hat mein VS schon mehrere Male zum Absturz gebracht, einmal musste ich im Designer-File das Control manuell löschen, da VS immer die Form geladen hatte und gleich wieder abstürtzte.

Hier der Paint-Code. Ich hab im Kommentar die Fehlerstelle markiert. Einmal trat sie auch beim ersten "g.MeasureString()" auf.

        private void RainbowLabel_Paint(object sender, PaintEventArgs e)
        {
            try
            {
                Graphics g = e.Graphics;

                PointF _lastPoint = new PointF(CON_SideSpace, CON_SideSpace);
                int c = 0;
                foreach (string str in _strings)
                {
                    if (_lastPoint == new PointF(CON_SideSpace, CON_SideSpace))
                    {
                        SizeF _size = g.MeasureString(str, Font);
                        if ((_lastPoint.X + _size.Width) <= Size.Width - CON_SideSpace)
                        {
                            if ((_lastPoint.Y + _size.Height) <= Size.Height - CON_SideSpace)
                            {
                                //Passt in Zeile, zeichnen
                                Brush brush = new SolidBrush(_colors[c]);
                                g.DrawString(str, Font, brush, _lastPoint); //HIER ist die STACKOVERFLOW

                                _lastPoint = new PointF(_lastPoint.X + _size.Width + CON_SignSpace, _lastPoint.Y);
                            }
                            //Andernfalls nichts zeichnen
                        }
                    }
                    else
                    {
                        SizeF _size = g.MeasureString(str, Font);
                        //Prüfen ob aktueller String in Zeile passt, wenn nicht, prüfen ob in nächste Zeile passt
                        if ((_lastPoint.X + _size.Width) <= Size.Width - CON_SideSpace)
                        {
                            if ((_lastPoint.Y + _size.Height) <= Size.Height - CON_SideSpace)
                            {
                                Brush brush = new SolidBrush(_colors[c]);
                                g.DrawString(str, Font, brush, _lastPoint);
                                _lastPoint = new PointF(_lastPoint.X + _size.Width + CON_SignSpace, _lastPoint.Y);
                            }
                        }
                        else
                        {
                            _lastPoint = new PointF(CON_SideSpace, _lastPoint.Y + _size.Height + CON_LineSpace);
                            if ((_lastPoint.Y + _size.Height) <= Size.Height - CON_SideSpace)
                            {
                                Brush brush = new SolidBrush(_colors[c]);
                                g.DrawString(str, Font, brush, _lastPoint);
                            }
                        }
                    }

                    c++;
                }
            }
            catch (StackOverflowException ex)
            {
                MessageBox.Show("Error in RainbowLabel: " + ex.Message + ex.StackTrace);
            }
            
            base.OnPrint(e);
        }

Ich hoffe, mir kann wer helfen, denn ich versteh nicht, wie das hier ein StackOverflow erzeugen kann... 😦

Danke
TBR

Hallo,
ich arbeite momentan an einem simplen Container-Format, womit ich meine
Daten ganz einfach komprimieren kann und in einer Datei fassen kann.
Das ganze mache ich für meine GameEngine und es soll das ausschlaggebende Feature haben, dass man eine einzelne Datei auslesen und direkt der Engine übergeben kann.

Das Problem ist, dass z.B. .CAB-Extraktoren usw. alles temporär auf der Platte lagern müssen.
Ich will es aber direkt laden, sodass ich keine Umweg gehen muss und keinen Temporären Platz brauche.

Leider gibts ein Problem. Ich schreibe zuerst die Dateiliste in die Datei per StreamWriter. Da wird auch eingetragen, von welcher Position (Streamposition) bis zu welcher anderen eine Datei geht. Dann schreibe ich per BinaryWriter die Datei hinein (noch unkomprimiert) und speichere Anfangs und End-Position.
Danach schreib ich mit dem StreamWriter in den Header in die vorgefertigten Lücken die Positionen.

Das ganze klappt eigentlich soweit. Leider schreibt er mir die Positionen in der FIlelist nie an die richtige Stelle, bzw. überschreibt scheinbar jede Menge sachen dabei ...

Seit gut 2 Monaten hab ich das ganze und ich find den verdammten Fehler nicht.

Es ist viel Code und teilweise unkommentiert (habs nun noch schnell etwas kommentiert), wenn man sich das ganze aber genau anschaut versteht man das Prinzip sehr schnell.

Ich hoffe dass mir jemand helfen kann... Ich bin inzwischen total ideenlos.

public void _bgw_DoWork(object sender, DoWorkEventArgs e)
        {
            //Stopwatch setzen und starten
            var trans = (BGW_Trans)e.Argument;
            var sw = trans.Stopwatch;
            sw.Start();

            _isRunning = true;
            //Stream öffnen und Streamwriter initialisieren
            var _output = new FileStream(_currentContainer, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
            BinaryWriter _Bwriter;
            var _Swriter = new StreamWriter(_output) {AutoFlush = true};

            try
            {
                var _filesB = trans.Files;

                int _filesCount = _filesB.Count;

                //Header schreiben
                _Swriter.Write(string.Format("[HEADER]FilesCount={0},FileList:", _filesCount));

                FileInfo fi;
                //Array speichern, welche die Platzhalter-Positionen für die Daten-Bereiche darstellt.
                var _fileListPositions = new long[_filesB.Count,2];
                for (int fileY = 0; fileY < _filesB.Count; fileY++)
                {
                    //Filelist schreiben (Schema: ->%Dateiname%;%Anfang des Datenbereiches (Platzhalter)%;%Ende des Datenbereiches (Platzhalter)%<-)
                    fi = new FileInfo(_filesB[fileY]);
                    _Swriter.Write("->");
                    _Swriter.Write(fi.Name + ";");
                    //Platzhalter für den Anfang des Datenbereiches einer Datei setzen
                    _fileListPositions[fileY, 0] = _Swriter.BaseStream.Position;
                    _Swriter.Write(";");
                    //Platzhalter für das Ende des Datenbereiches einer Datei setzen
                    _fileListPositions[fileY, 1] = _Swriter.BaseStream.Position;
                    _Swriter.Write("<-");
                }
                _Swriter.Write("[CONTENT]");

                FileStream _fileStream;
                long _currentWriterPosition = _Swriter.BaseStream.Position;

                //BinaryWriter initialisieren
                _Bwriter = new BinaryWriter(_output);
                _Bwriter.BaseStream.Position = _currentWriterPosition;

                //Anfangs und End-Position der Datenbereiche aller Dateien erstellen
                long[,] _filePositions = new long[_filesB.Count,2];

                for (int fileX = 0; fileX < _filesB.Count; fileX++)
                {
                    fi = new FileInfo(_filesB[fileX]);
                    //Datei öffnen und gebuffert mit dem BinaryWriter schreiben
                    _fileStream = new FileStream(_filesB[fileX], FileMode.Open, FileAccess.Read, FileShare.Read);
                    byte[] _buffer = new byte[2048];

                    //Anfangsposition speichern und schreiben
                    _filePositions[fileX, 0] = _Bwriter.BaseStream.Position;
                    while (_fileStream.Read(_buffer, 0, _buffer.Length) > 0)
                        _Bwriter.Write(_buffer);
                    _Bwriter.Flush();
                    //End-Position speichern
                    _filePositions[fileX, 1] = _Bwriter.BaseStream.Position;

                    _fileStream.Close();

                    _filesCompressed++;

                    var info = new BG_Info
                                   {
                                       compressedfiles = _filesCompressed
                                   };

                    _bgw.ReportProgress(55, info);
                }

                //Streamwriter initialisieren
                _Swriter = new StreamWriter(_output) {AutoFlush = true};

                for (int x = 0; x < _filesB.Count; x++)
                {
                    //Für jede Datei den SW an die Position des Platzhalters setzen und ...
                    _Swriter.BaseStream.Seek(_fileListPositions[x, 0], SeekOrigin.Begin);
                    //den Anfang des Datenbereiches für diese Datei schreiben
                    _Swriter.Write(_filePositions[x, 0]);

                    //An die Stelle des zweiten Platzhalters setzen (immer zwischen den ";")
                    _Swriter.BaseStream.Seek(_fileListPositions[x, 1], SeekOrigin.Begin);
                    //Ende des Datenbereiches schreiben
                    _Swriter.Write(_filePositions[x, 1]);
                }

                _Swriter.Close();
            }
            catch (IOException IOex)
            {
                MessageBox.Show("Error(IOEX) occured in GFCC: " + IOex.Message + IOex.StackTrace);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error occured in GFCC: " + ex.Message + ex.StackTrace);
            }
            finally
            {
                _isRunning = false;
            }
        }

Findet wer den Fehler ... irgendwie kommt statt:

[HEADER]FilesCount=1,FileList:->meineDatei.exe;124;230403<-[CONTENT]
sowas raus:
[HEADER]FilesCount=1,FileList:->DhtmlEd.msi;5354360TENT]

Ich hab bereits rausgefunden, dass die erste Zahl die erste Zahl von der Anfangs-Position ist und der Rest korrekt die Position des Endes ist. Leider wird ein ";" überschrieben + das "[CONTENT]" zum Teil ...

Ich hab echt keinen Plan mehr an was das liegt. ... vorhin waren die Zahlen ganz am Ende, nun sind sie schon halbwegs korrekt da wo sie sein sollen, nur wird immer was überschrieben -.-

Ich danke euch und spring euch dafür einen Kreis in den Boden, wenn mir wer den Fehler nennen kann! Ich hab echt absolut null Ideen. Alles versucht, nix ging ...

Seht´s als ein Art Rätsel. Bin jetzt eine Woche in Berlin, bis dahin habt ihr Zeit 😛 Ne Scherz 😉 Aber danke wer sich die Mühe macht, sich da durch zu beisen 😉

Danke!
TBR