Hab was gefunden:

[Serializable]
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack=1)]
    public struct BroadcastPacket
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)] 
        public String hostname;
        public int port;

        public BroadcastPacket(string hostname, int port)
        {
            this.hostname = hostname;
            this.port = port;
        }

    }

Ich spiele grade wieder mit Serialisierung. Ich möchte Packets übers Netwerk senden. Dafür habe ich Methoden die strucs serialisieren und deserialisieren können. Leider habe ich da mit Strings noch einige Probleme.

Ob als class oder struct ist erstmal nicht ganz so wichtig. Aber als Struct bin ich auf 8 byte gekommen und als class auf ~250. Außerdem habe ich den Anspruch später auch vorgegebene Datenstrukturen empfangen zu können die später evtl. von einem Microcontroller versendet werden. Zur Not kann man immer noch manuell den Stream für bestimmte Packets parsen. Generisch über Strucs / Klassen wäre aber schon feiner.

Also, dies soll Serialisiert werden:

[Serializable]
    public struct BroadcastPacket
    {
        public String hostname;
        public int port;

        public BroadcastPacket(string hostname, int port)
        {
            this.hostname = hostname;
            this.port = port;
        }
    }

Hiermit probiere ich es:

public static byte[] SerializeStruct<T>(T input) where T : struct
        {
            int objsize = Marshal.SizeOf(input);
            IntPtr buffer = Marshal.AllocHGlobal(objsize);
            Marshal.StructureToPtr(input, buffer, false);
            byte[] data = new byte[objsize];
            Marshal.Copy(buffer, data, 0, objsize);
            Marshal.FreeHGlobal(buffer);
            return data;
        }

        public static T DeserializeStruct<T>(byte[] data) where T : struct
        {
            int objsize = Marshal.SizeOf(typeof(T));
            if (objsize > data.Length) throw new Exception("Objectsize bigger than given bytearray");
            IntPtr buffer = Marshal.AllocHGlobal(objsize);
            Marshal.Copy(data, 0, buffer, objsize);
            T retStruct = (T)Marshal.PtrToStructure(buffer, typeof(T));
            Marshal.FreeHGlobal(buffer);
            return retStruct;  
        }

Der String kommt entweder verkrüppelt an oder es wirft eine Exception:

Zeile:
T retStruct = (T)Marshal.PtrToStructure(buffer, typeof(T));

Exception:
Es wurde versucht, im geschützten Speicher zu lesen oder zu schreiben. Dies ist häufig ein Hinweis darauf, dass anderer Speicher beschädigt ist.

Ich freue mich immer, wenn ich Konfigurationsdateien lesen und von Hand verändern kann. Das spricht gegen die (binäre) Serialisierung von .NET-Objekten. Aber auch XML-serialisierte .NET-Objekte lassen sich manuell kaum mehr anpassen, ohne Fehler zu machen.

Kriterium für leserliche Dateien ist aber auf ob der Benutzer die Daten ändern soll / darf. Und eventuell die Größe, xml ist eben mehr als binär.

Oder ganz dynamisch. Dann musst du nur gut deine fps berechnen.

if (fps < x) { waitTime--; }
else {waitTime++; }
Thread.Sleep(waitTime);

Klingt nach 3ms Thread.Sleep() + 14ms rendern = 17ms pro Schleifendurchlauf.

Gibt es sowas wie

int foo = bx1011

Ich meine das mal gesehen zu haben aber weiß nicht mehr wo und finde es auch nicht.

Das mit dem OnBackground reicht noch nicht, es klappt irgendwie nach dem minimieren und wieder maximieren. Ich hab auch schon mit OnPaint rum gespielt. so richtig will das alles noch nicht.

Mit dem Global kannst du alle Klicks abfangen und checken ob sie im oder außerhalb dem Bereich deiner Form waren.

Ansonsten kann man vielleicht noch auf den Focus des Programmes zugreifen, der müsste verloren gehen wenn du außerhalb klickst.

Meine Lösung.

private void panelMenu_Resize(object sender, EventArgs e)
        {
            AdjustPanelMenu();
        }

        private void FormMain_Resize(object sender, EventArgs e)
        {
            AdjustPanelMenu();
        }

private void AdjustPanelMenu()
        {
            int pWidth = panelMenu.Width;
            int pHeight = panelMenu.Height;

            int fWidth = this.Width;
            int fHeight = this.Height;


            int x = fWidth - pWidth - ((fWidth - pWidth) / 2);
            int y = fHeight - pHeight - ((fHeight - pHeight) / 2);


            panelMenu.Location = new Point(x, y);
        }

Gehts schöner? Und kann man das Panel noch beschneiden / partiell Transparent machen?

Du kannst systemweite Maus und Tastaturevents abfangen.

Suche mal nach dem Stichwort Hook.

Ich benutzte in meinem aktuellen Programm diese Bibliothek dafür. Ich glaub die ist von CodeProject und ein wenig verbessert von mir.

[assembly: AssemblyTitle("GlobalHook")]
[assembly: AssemblyDescription("This class library contains components which monitor all mouse and keyboard activities globally (also outside of the application) and provides appropriate events.")]
[assembly: AssemblyCompany("George Mamaladze, Tobias Kaupat")]
[assembly: AssemblyProduct("GlobalHook")]
[assembly: AssemblyCopyright("Free to use, copy, modify and redistribute")]

Hast du BruteForce mal implementiert? Sollte bei < 100 zahlen noch relativ schnell gehen und auch deutlich später noch. (So aus dem Bauch)

Du suchst ja irgend eine Lösung. Es kann ja leicht mehrere Lösungen geben, dann funktioniert das mit dem streichen nicht mehr. Wenn du all Lösungen willst brauchst du auch jede Lösung einzeln.

1. Alle zahlen in eine Liste
2. Alle Zahlen die größer als gesuchte Zahl sind raus werfen.
3. Systematisch alle Kombinationen bilden und jeweils abbrechen wenn man größer als die gesucht Zahl ist.
4. Bei gefundener Lösung abbrechen (Oder weitersuchen wenn man alle Lösungen will)

Ich kann mir vorstellen das Sortierung der Zahlen von groß nach klein oder andersrum noch Performance bringt. Aber Optimieren kann man später wenn es zu langsam wird.

Gibt es ne schöne Lösung ein Panel (in dem später ein Usercontrol eingeblendet wird) mittig über der Form an zu ordnen.
Toll wäre wenn man das sogar beschneiden könne (z.B. Rund) oder Transparenz hätte, aber erstmal tut es das auch in einfach.

Wenn ich es per Designer in die mitte schiebe ist es child von einem Split control was teilweise deaktiviert wird. Daher habe ich das mit etwas tricksen auch so grob in die mitte bekommen. Aber es bleibt beim Skalieren der Form eben nicht in der Mitte.

Ein Ansatz wäre natürlich das control im Resize event der Form immer neu zu positionieren.

Edit:
Ich hab das jetzt so realisiert das die Form bei Resize die Position neu bestimmt. Klappt gut. Fällt euch was besseres ein?

Und wenn dann eher so, damit du für kleine Änderungen nicht alle Funktionen ändern musst.

public class Base
{
  private DataObj myData;

  protected abstract DoSomethingSpecial(out DataObj dataObj);

  public void DoSomething()
  {
    DoSomethingSpecial(out myData);
  }

}

Aber die Lösung mit den protected variablen ist im allgemeinen schon gut. Sobald du eine übergabe von aprametern machst auf denen gearbeitet wird kannst du auch wieder eine hasA relation machen und bist ja frei von der Basisklasse bis auf evtl. einer Referenz darauf.

Sehr oft ist es in solchen Fällen sinnvoller eine HasA relation statt a IsA relation zwischen den Objekten zu machen.

Also:

public class Base
{
  private Algorithm myAlgorithm = new SpecialAlgorithm();
  
  public void DoSomething() {
    myAlgorythm.DoItSpecial(/*Übergebe this oder ein betroffenes Datenobjekt*/);
  }

}

Wenn das gar nicht in Frage kommt, würde ich die Felder oder Variablen Protected machen. So ist es in vielen Frameworks die eine Möglichkeit zum überschreiben bieten. Siehe WinForms. Es ist für mich überhaupt der wichtigste Anwendungsfall für den Protected acces modifier.

Edit:
Es ist möglich eine abstrakte Basisklasse durch überschreiben von Methoden und Zugriff auf deren Felder "Kaputt" zu machen. Auch hier wäre ein HasA relation die auf einem speziellen Datenobjekt arbeitet "sicherer".

Da es aber auch vom Anwendungsfall abhängt wäre es vielleicht Hilfreich wenn du dein Beispiel etwas konkretisieren könntest.

Besser wäre wohl das include in ein using um zu wandeln und das header file in ein eigenes .cs file zu übersetzten.

TreeNode TempNode = new TreeNode(); // TempNode.Parent == null

            for (int i = 0; !reader.EndOfStream; i++)
            {
                string zeile = reader.ReadLine();

                isDirectory = zeile.Substring(0, 1);
                isName = GetLastWordOfString(zeile);


                TempNode.Parent.Nodes.Add(isName);  // Immernoch: TempNode.Parent == null

Kannst du mal den Code der die Exception wirft posten mit Angabe woe die Exception geworfen wird. Das sollte sich dann schneller lösen lassen.

Du brauchst in c# keine Header, und Defines haben genug nachteile, dass ich denen nicht hinterher trauere. Wenn du c code nach c# konvertierst, würde es sich vielleicht anbieten alle Konstanten in einer eigenen Klasse oder als Enum zu realisieren.

C Defines sind nicht mal typisiert und können sogar Anwendungscode wie if Anweisungen enthalten. Du muss dich also in jedem Fall um verschiedene Defines auf verschiedene Weise kümmern. Sie also oftmals auch als Methoden implementieren. Dafür würde sich eine eigene (Statische?) Klasse wieder anbieten.

Und was soll an der Stelle stehen wenn man es einklappt? Oder soll man den BAum an der Stelle nicht einklappen können?
Ein Baum ist ein Mathematisch ein Kriesfreier Graph, dies kann man in einem TreeView abbilden.

root

• kind1
• kind2
  -- kind2.1
  -- kind2.2
• kind3

Bei dir hätte in diesem Beispiel kind 2 keinen Namen? Oder gibt es den Knoten nicht?
Dann müsste der Baum so aussehen:

• kind1
• kind2.1
• kind2.2
• kind3

Auch das lässt sich einfach darstellen. Wenn es wirklich keine weitere Ebene gibt besser sogar als Liste. Aber man kann nur Knoten die Kinder haben auf und zu klappen.

Vielleicht kannst du den Anwendungsfall auch nochmal deutlicher beschreiben.
Wenn du deine Daten nur einrücken willst ist der TreeView auch nicht unbedingt die beste Wahl. Dafür kannst du auch eine Liste nehmen und Tabs oder Leerzeichen vor den namen setzten. Das geht sauber über die Format events.

Du kannst die Daten in einer eigenen Klasse verwalten die Insert() und GetArray() anbietet.

Ich habs nicht ausprobiert aber hilft. DataGridView.EndEdit() um den editiermodus zu verlassen? Oder besser: DataGridView.CanelEdit();
Man kann auch abfragen ob es eine temporäre Zeile gibt und dann entsprechend vor dem speichern / beenden der Ansicht Canel oder EndEdit aufrufen, je nachdem was man will.

Hast du ein konkreten Anwendungsfall?
Ich denke beide Möglichkeiten können gut sein.

Hi,
ich stehe davor eine Website, in meinem Fall jetzt mal PHP aber das sollte keine Rolle spielen, zu übersetzten.
Das will ich mit TMX Files machen. Kennt da jemand einen guten freien Editor der quellcode auf zu übersetzende Strings parsen kann und dann Möglichkeiten zur Übersetzung bietet?

Ich möchte dabei selber z.B. ein RegExp angeben können der zum Quellcode parsen genutzt wird.

Auch bei Create Instance braucht man ja den typ.
Ich habe mal ein Dictonary gemacht in dem zu jeder "message ID" der Type steht und dann die Message ID empfangen und den entsprechenden Typ erstellt.

Dann hat man nur ganz viele Aufrufe von "RegisterPacket(int id, type t)" irgendwo.

Und wenn es ein fremder OpenFileDialog ist kannst du abfragen ob deine Form den Focus hat.

Erster Versuch: TextBox mit dem Feld verknüpft (mittels BindingSource). Die Text-Form des Wertes wird ganz richtig angezeigt (z.B. "3 mons" für 3 Monate), aber wenn ich die Zahl ändere, wird diese Änderung beim Speichern rückgängig gemacht. Die übrigen Felder kann ich ganz normal bearbeiten und speichern.

Es gibt noch events für das Format wenn du den Wert änderst und speichern willst. Such mal nach Validate, Format und ähnlichem. Dann solltest du das was der user eingibt in deinen Datentyp parsen können.

Das einfachste wäre eine boolsche Variable die angibt ob der OpenFileDialog offen ist. Dann noch ne kleine if in Verschieben() und es läuft.

Wieso allerdings das Click event durch einen OpenFileDialog hindurch funktioniert wundert mich auch etwas.

Naja, sieht nett aus, aber ist in der Form schwer in eine WinForms Anwendung ein zu bauen. Ich bräuchte das eher als UserControl (damit wohl leider auch in einem Quadratischen Rahmen)

Oder bekommt man ein UserControl auch als Kreis auf seine Form eingeblendet?

Hi,
ich suche ein Menu was möglichst animiert ist. Es sollte mit der Maus und alternativ mit 3-4 Knöpfen bedient werden können. Also z.B. ein Ringmenu bei dem immer ein Item aktiv ist.
Es kommt halt darauf an das es gut aussieht und am besten sogar animiert ist.

Ich hab z.B. IrisMenu gefunden:
http://www.sunisoft.com/irismenu/

Hat damit jemand Erfahrungen, oder kann irgendwas Empfehlen?
Wenns frei ist wäre super. Wenn es was kostet muss ich halt meinen Chef überzeugen es zu kaufen 😉 Hätte dann aber gerne den ein oder anderen Erfahrungsbericht.

Gibt es da vernünftige freie Lösungen? Das sieht schon ziemlich cool aus.

Wohl höchstens über andere Treiber. Die Treiber sind ja nun mal die Schnittstelle zwischen bequemer Programmierung und Komplexer Hardware.

Schau dir dazu auch mal das MVC Pattern an. Ich habe das mittlerweile für meine Zwecke soweit angepasst, dass ich damit alles realisiere.

Zuletzt hatte ich eine Anwendung die deiner sehr Ähnlich ist. Ich habe einen Controller der alle GUI Elemente (MainForm, UserControlls) erstellt. Die MainForm hat dann Methoden um in Panels (Dein Menu und deine rechte Arbeitsseite) beliebige Controlls zu laden. Das macht der Controller dann auch darüber. Mein Controller war ein Singleton, besser wäre aber wenn die GUIs events werfen und den Controller gar nicht kennen.
Dann gibt es noch ein Model in dem die Daten sind. Auch das wird vom Controller erstellt (Oder ist ein Singleton). Nun kann der Controller den UserControlls die nötigen Datenobjekte geben. Wenn die Objekte im Model das Interface IPropertyChanged implementieren kann man die sogar einfach per DataBinding einbinden. Ansonsten muss man in den UserControlls die Gui mit dem Model synchron halten, geht auch.

Damit hat man alles was man braucht:

• Beliebig viele Forms arbeiten auf dem gleichen Datensatz
• Alle Forms werden zentral verwaltet (Controller)
• Model und Gui sind einigermaßen getrennt. Man kann das noch perfektionieren und alles über den Controller machen, geht bei WinForms meiner Meinung nach aber zu weit (Wofür hat man sonst DataBindings)
• Man kann Guis sehr Dynamisch zusammen pappen

Hoffe das hilft dir etwas.

Wieso packst du die SplashScreen Klasse nicht in eine DLL? Das macht alles viel einfacher und hat auch keine Nachteile.

Du rufst dann auch nur SplashScreen.Show() und SplashScreen.Close() auf.
Was ist an deinem Ansatz das "Stylische"? Der Enduser sieht davon nix...

Vielleicht liegt es daran, dass beim Deserialisieren der Konstukror nicht aufgerufen wird.

Ansonsten kann man nur mutmaßen, am besten du schreibst ein kleines übersichtliches Beispielprogramm in dem das Problem auftritt.

Wir haben sogar in der Firma nur die Express und es reicht. Okay ist ne kleine Firma aber dennoch.
ICh selbst hab nur die Team Edition weil ich sie von der Uni umsonst bekomme. Die Code Metrik und Testsachen sind natürlich cool aber werde eigentlich wirklich erst bei großen Projekten benötigt.

Ganz egal was schöner ist. Aber ein wirkliches Argument sind für mich die Refactor funktionen von VS. Wenn ich eine Datei / Ordner umbenenne, dann kann VS damit nur richtig umgehen wenn die Namespaces auch den Ordnern entsprechen.
Irgendwann fällt man immer drüber wenn man sich mal wieder nicht an den Standart hällt. Desshalb akzeptiere ich mittlwereile die paar usings mehr.

Der '==='-Operator macht auch nur bei Sprachen mit dynamischen Datentypen Sinn (daher fallen die "üblichen Verdächtigen" raus -).

class Caprio : Car {

}

//...

Car x;
Caprio y;

if (x === y) {} // True wenn in der Variable Car auch ein Caprio steckt

Ich weiß es gibt den "is" Operator. Aber ganz so weit hergeholt finde ich mein Beispiel jetzt nicht.

Als erstes würde mir einfallen, alle Operanden und Zahlen in einem Baum oder einem Stack zu organisieren. Dann mal gucken wie man Infixnotation so behandelt.

Frohe Weihnachten euch allen. Und schönen Code im neuen Jahr 😉

Moin,
ich baue gerade an einer GUI Anwendung in welcher der Hauptteil mit 4 Tasten (einem Presenter) bedienbar sein soll.
Die Aktionen sind daher:

• Nächstes Item selektieren
• vorheriges Item selektieren
• Enter (z.B. Untermenu öffnen, Aktion ausführen)
• Escape (z.B. Menu verlassen, Zum 1. Menuitem springen)

Dafür habe ich auch folgendes Interface:

public interface IMenuItem
    {
        void SelectMenuItem();
        void DeselectMenuItem();
        bool ActivateMenuItem();
        bool DeactivateMenuItem();
    }

Ich habe ein UserControl welches das Interface implementiert und darüber entscheiden kann ob es als Highlight z.B: die Farbe ändern soll. Klappt super.

Ich habe einen MenuHandler welcher globale Funktionen wie "SelectNext" hat und Programmweit die Tastendrücke auf entsprechende Aktionen mappt. Klappt auch gut.

Die Klasse Menu soll (bisher unabhängig von der GUI) ein Menu repräsentieren. Sie Implementiert ebenfalls IMenuItem. Hier funktioniert aber noch nicht alles wie es soll, was mich auch zur eigentlichen Frage führt.

Ausschnitte aus dem MenuHandler:

// Selected item
private IMenuItem selected;
// Current menu
private Menu current;
private RootMenu root;

private void Init()
        {
            root = new RootMenu();
            current = root;
// Kapselt Tastendrücke Programm / Systemweit
            GlobalHook.HookManager.KeyUp += new System.Windows.Forms.KeyEventHandler(HookManager_KeyUp);
        }

        void HookManager_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyData == Keys.PageDown)
            {
                SelectNext();
            }
            else if (e.KeyData == Keys.PageUp)
            {
                SelectPrev();
            }
            else if (e.KeyData == Keys.Enter)
            {
                Enter(selected);
            }
            else if (e.KeyData == Keys.Escape)
            {
                Leave(current);
            }
        }

public void RegisterMenuItem(IMenuItem item, Menu parent) {
// Zum aufbauen der Menustruktur.
// Wird von der GUI, oder dem Controller aufgerufen oder ist unnötig wenn das Menu im MenuHandler komplett erstellt würde.
}

public void UnregisterMenuItem(IMenuItem item, Menu parent) {
// Bisher nicht implementiert.
}

Die Frage die sich mir stellt ist wer nun die Menustruktur kennt.
Möglichkeiten die mir einfallen:

1. Die Gui bestimmt auch die Struktur.
   Vorteil: Was man im Designer Baut ist auch über die Navigation erreichbar.
   Nachteil: Die Gui hat Code für die Menulogik welche Programmübergreifend ist

2. Es gibt eine Datenstruktur welche das Menu repräsentiert und ggf. UserControls erzeugt / beinhaltet die angezeigt werden sollen.
   Dann hätte meine Menu Klasse eine Referenz auf ein Control
   Vorteil: Man könnte diese Struktur generell von überall laden (Xml Datei)

3. Man Trennt die Struktur und die Gui komplett z.B. über den Controller der einmal die Gui Struktur erstellt und das Menumodell beobachtet und ggf nötige Aktionen einleitet.
   Nachteil: Ich muss die Menustruktur an 2 Stellen im Code "kennen". Und ist auf den ersten Blick etwas kompliziert.

Wie würdet ihr das umsetzten? Was fallen euch noch für vor und Nachteile zu meinen 3 Vorschlägen ein oder habt ihr einen komplett anderen Ansatz?

Hi,
ich suche ein gutes freies Docking Framework. Wie bei Visual Studio oder Matlab. Dabei spielt es weniger eine Rolle das es genau wie bei VS aus sieht.

Ich habe dies hier über die Forensuche gefunden:
http://sourceforge.net/projects/dockpanelsuite/

Das sieht sehr gut aus. Hat jemand Erfahrungen damit oder kann ein Anderes Empfehlen? Es gibt viele aber wie soll man entscheiden welches man nimmt. Gibt es Favoriten?

Oder welche Kommerziellen sind noch besser, ich werde wahrscheinlich ein freies nehmen aber wenn es deutliche Vorteile hat kann man auch über etwas kommerzielles nachdenken.

Gruß, Tarion

das habe ich mittlerweile auch gefunden 😃 Ist wohl tatsächlich besser.

Hi,
ichh abe spec# installiert und möchte es gerne in meinen c# code einbinden. Dafür gibt es ja die Kommentare:

/^ ... SPEC# CODE ... ^/
und
//^ SPEC# CODE ...

Auch in den Projektoptionen konnte ich einstellen, das er runtime checks und compiletime checks machen soll. Er tut nur nichts.

public int Sum(int start, int end)
        /*^ require start >= 0 ^*/
        {
            int result = 0;

            for (int i = start; i <= end; i++)
            {
                result += i;
            }

            return result;
        }

Ich rufe die Funktion mit Sum(-5, 0); auf.
Muss ich noch was beachten? Ich habe auch den einzeiligen Kommentartyp probiert.

Noch ein Punkt wo wirklich mehrere Klassen in eine Datei können:
Automatische Code generierung.
Hier wird es wesentlich eine Datei als Output seines Code generators zu haben als viele.

Hi,
ich habe mal gehört das man auch alles nötige mit in die exe Compilieren kann, so dass man kein .net Framework auf dem rechner braucht. Wo findet man dazu informationen, oder gibt es eine einfache Einstellung um das Projekt so zu compilieren?

Gruß, Tarion

Hi,
ich würde für ein Projekt gerne SMS versenden. Das soll online möglich sein und muss auch für den Kommerziellen Gebrauch erlaubt sein.
Kennt da jemand einen oder mehrere Anbieter die einen entsprechenden Service zur Verfügung stellen?

Gruß, Tarion

Validate, AfterValidate, Validated oder ähnlich gibt es dafür.

Es gibt viele Gründe, ein besonders schöner lief mir eben wieder über den Weg:

Wenn du abzählbar viele Typen hast kannst du es so machen:

class MyClass
{
// ...
Dictionary<string, string> dictStrings;
Dictionary<string, int> dictInts;
Dictionary<string, bool> dictBools;

// ...

	getInt(string s, int val) {
		// Check if exists!
		return dictStrings[s];
	}

	getString(string s, string val) {
		// Check if exists!
		return dictStrings[s];
	}
	getBool(string s, bool val) {
		// Check if exists!
		return dictStrings[s];
	}
}

Eine Funktion kann nur einen Rückgabe typ haben. Also entweder für jeden Typ eine Funktion, oder casten.
Wenn du dann das Casten verhindern willst braucht du mehrere Funktionen. mehr Performance -> mehr Code.

Der BackgroundWorker ist wahrscheinlich nicht so performant wie deine / oder andere Lösungen. Aber im Normalfall ausreichend.

Wenn man wirklich nen Flaschenhals bei der Performance hat sollte man aber wieder drauf verzichten und es selber bauen. Hab nur mal was in die Richtung gelesen, leider keine Referenzen zur Hand.