Ich vermute deine Frage besteht darin, wie du den wissenschaftlichen Anspruch der an eine Bachelorarbeit gestellt wird in dein Tagewerk unterbringst?
Wie wäre es mit einer ausführlichen UML-Modellierung bevor du überhaupt eine Zeile Code schreibst? Beispiel: Aktivitätsdiagramm

Die lässt sich sehr gut im Dokument unterbringen und man kann schön Risiken einer alten Lösung aufzeigen und anschließend kannst du deinen Optimierungsansatz einbringen und begründen. Du solltest dich aber wie bereits von Coffeebean erwähnt vor allem mit deinem Hochschulbetreuer auseinandersetzen um fürh zu wissen wo dieser den Fokus haben möchte. Häufig werden in solchen Gesprächen schon Kernpunkte aufgestellt die du ausführlich bearbeiten solltest.

Teste es mal bitte mit der folgenden Funktionsüberladung und berichte von den Ergebnissen: https://msdn.microsoft.com/de-de/library/4sahykhd(v=vs.110).aspx

Den Boolean dabei natürlich auf true setzen.

*KopfgegenTisch*
Stimmt du hast recht. Eine Drehmatrix ist ja sogar noch einfacher und schneller.
Habs mal ganz einfach aufgebaut weil mich das Thema interessiert:

private void button1_Click(object sender, EventArgs e)
        {
            Bitmap orig = (Bitmap)pictureBox1.Image;
            Bitmap Shutter = new Bitmap(200, 200);


            for(int i=0;i<Shutter.Width;i++)
                for(int j=0;j<Shutter.Height;j++)
                {
                    double angle=(Math.PI*(3.6*i)/180);
                    int newX = Convert.ToInt32(i*Math.Cos(angle)-j*Math.Sin(angle));
                    int newY = Convert.ToInt32(i*Math.Sin(angle)+j*Math.Cos(angle));

                    if (newX<0)
                        newX=0;

                    if (newX>Shutter.Width-1)
                        newX=Shutter.Width-1;

                    if (newY < 0)
                        newY = 0;

                    if (newY > Shutter.Height - 1)
                        newY = Shutter.Height - 1;


                    Shutter.SetPixel(i, j, orig.GetPixel(newX, newY));
                }

            pictureBox2.Image = Shutter;
        }

Das Ergebnis ist im Anhang ersichtlich.

@MrSparkle

Es soll so ein Effekt nachgebildet werden: Rolling Shutter Animation
Meine Idee zu dem Problem war es virtuell eine Gerade durch das Bild zu schieben welche sich beim Verschieben dreht. Über die Geradengleichung und dem Bresenham sollte man recht schnell die benötigten Koordinaten für das neue Bild erhalten ohne, dass man immer das originale Bild drehen muss.

@Gimmick

Ich würde dir dazu raten das ganze erstmal kleiner anzufangen. Schiebe als erstes einfach mal eine Gerade von unten nach oben durch dein Bild ohne diese zu drehen und teste ob das Ergebnisbild ein umgekehrtes Original ist.

Wenn das funktioniert testest du was passiert wenn du eine Gerade in der Mitte eines Bildes drehst und während der Drehung die Pixel auf der Gerade Zeilenweise in ein neues Bild schreibst. Die Anzahl der Drehschritte ergibt sich aus der Bildhöhe.Ich denke für den Anfang reicht eine Umdrehung für das Ergebnis. Also 360°/Bildhöhe sind deine Winkelinkremente.

Beachte aber bitte den Sonderfall Senkrecht, den musst du abfangen, da ein unendlich hohes m nicht realisierbar ist. Sobald du ein m erhälst welches größer ist als die Bildhöhe (oder ein -m welche kleiner ist als -Bildhöhe) ist das ein Anzeichen dafür, dass es sich um eine Senkrechte handelt und den Fall musst du dann gesondert behandeln um anschließend das Vorzeichen bei m zu ändern.
In etwa sollte es dann so aussehen:

double m = 0;
double increment_m = 1;

            for(int i=0;i<=2*originalPicture.Height;i++)
            {
                m += increment_m;
                if (Math.Abs(m) >= originalPicture.Height)
                {
                    //Senkrecht Sonderfall behandeln                    
                    
                    //Start und Endpunkte bestimmen
                    //Bresenham
                    //neue Bildzeile bestimmen

                    //Anschließend Anstiegsrichtung umdrehen
                    m *= -1;
                }
                else
                {
                    //m in Gleichung einsetzen
                    //Start und Endpunkte bestimmen
                    //Bresenham
                    //neue Bildzeile bestimmen
                }
            }

Wenn dies auch funktioniert sollte es anschließend kein Problem mehr sein beide Funktionen zu kombinieren.

Ja du sprichst da Probleme an die ich bei meiner Erklärung nicht beachtet habe. Senkrechte Gerade hatte ich zum Beispiel komplett vergessen. Um das zu lösen fallen mir spontan zwei Möglichkeiten ein. Zum einen könnte man die Geraden mit Hilfe der Hesseschen Normalform beschreiben oder du richtist dir Stützstellen für Sonderfälle ein.
Dabei musst du vorher wissen wie viele Geradendrehungen in dein Bild passen. Dann bestimmst du bei welchen n deine Gerade Senkrecht oder Waagerecht ist und es ergeben sich folgende Sonderfälle.

Gerade Senkrecht bzw. keine oder halbe Drehung: y=n
Gerade Waagerecht bzw. viertel oder dreivierteldrehung: x=n

Das zweite Problem was du ansprichst ist in etwa das was ich weiter oben mit dem Randproblem gemeint habe. Deine Geraden können kürzer oder länger werden als die eigentlich Bildbreite bzw. -höhe. Du könntest jede Zeile normieren bzw. interpolieren um alle auf die gleiche länge zu bringen aber das ist nicht gerade trivial, da du nur schwer schätzen kannst an welcher Stelle welcher Wert einzubringen ist.
Zum Testen reicht es ja erstmal wenn du dich an der kürzesten Gerade orientierst und die anderen auf diese entsprechende Länge kürzt. Anschließend skalierst du das entstandene Bild auf die ursprüngliche Bildgröße.

Ich kann mir hier keine Bilder von Web-Storage Hostern ansehen. Hänge es doch bitte direkt an deinen Beitrag an. Wenn du das gemacht hast schaue ich es mir mal in Ruhe an und editier dann diesen Beitrag hier und versuche weiter zu helfen.

Edit:
Eigentlich reicht mir der Text auch schon um weiterzuhelfen.

Deine Grundgedanken sind schon mal nicht schlecht wir müssen nur noch etwas Ordnung und System in die Sache reinbringen.
Ja du brauchst Start- und Endpunkte deiner Geraden um dann über den Bresenham alle dazwischenliegenden Pixel zu ermitteln. Der Startpunkt kann aber nicht kleiner als (0,0) und der Endpunkt nicht größer als (Bildbreite,Bildhöhe) sein. Diese Grenzen sind für die nächsten Schritte wichtig. Folgende einfach Geradengleichung:
y= mx+n

• y und x sind Koordinaten
• m ist dein Anstieg welcher sich aus dem Drehwinkel ergibt
• n ist deine Verschiebung nach oben oder unten

Wenn du jetzt anfängst die Gerade nach oben zu bewegen ändert sich nur das n. Um zusätzlich eine Rotation zu erzeugen muss mit jedem Verschiebungsschritt auch das m geändert werden.
Du kannst dir den Startpunkt einfach ausrechnen indem du einfach 0 bei x oder y einsetzt und die fehlende Komponente bestimmst. Du musst natürlich überprüfen welche von den beiden möglichen Koordinaten die gültige ist aber das sollte nicht schwer sein, da kein Wert kleiner als 0 sein darf.
Beim Endpunkt ist das Vorgehen gleich nur das du statt nicht kleiner als Minimum auf nicht größer als Maximum prüfen musst.
Mit den beiden bestimmten Punkten bekommst du anschließend über den Bresenham Algorithmus alle dazwischenliegenden Punkte welche den gewünschten neuen Bildpunkten entsprechen.

Na dann mach das doch. 🤔
Zelle x=MAX dann färbe rot
Wo hängt es denn genau? Das Maximum musst du natürlich vorm färben suchen aber dazu gibt es viele Mittel und Wege.

http://99designs.com/ kommt dem wohl nahe was du suchst.

Nettes Projekt, gefällt mir.

Zum Randproblem. Wenn du dein Bild drehst wird die benötigte Auflösung zur Darstellung aller Pixel größer, wenn der Drehwinkel nicht durch 90° teilbar ist. Wenn du zum Beispiel eine 100x100 Px Abbildung hast und diese um 45° drehst brauchst 142x142 Px um alle Bereiche des ursprünglichen Bildes darzustellen. Bei diesem Beispiel bleiben die Ecken aber undefiniert und müssen mit einer anderen Farbe aufgefüllt werden. Das gleiche tritt auch auf wenn du die Auflösung bei 100x100 Px belässt und die Ränder abschneidest. An den Ecken treten undefinierte Bereiche auf.

Für deinen Rolling-Shutter-Effekt könnte der Bresenham schon das richtige Werkzeug sein. Ich würde an deiner Stelle einfach eine Gerade spalten- oder zeilenweise durchs Bild schieben. Mit jedem Schiebeschritt drehst du die Gerade dann um einen gewünschten Winkel und ermittelst mit Hilfe des Bresenham-Algorithmus, welche Bildkoordinaten du für diese Zeile im resultierenden Bild brauchst.

Hallo Gimmick,

ich bin mir nicht ganz sicher was du vorhast. Wozu musst du das gedrehte Bild Zeilenweise einlesen? Warum nicht das Bild laden, wie gewünscht drehen, sich um die Randprobleme kümmern und dann speichern.
Falls du es Zeilenweise benötigst würde ich dir den Bresenham-Algorithmus empfehlen. Dabei solltest du eine Geradengleichung aufstellen und diese je nach Drehwinkel anpassen, diese anschließend durch dein Bild führen und mit Hilfe des Bresenham Algorithmus überprüfen welche Pixel auf der Geraden liegen.

Zum zweiten Problem.
Drehst du das Original Bild einmalig um einen festen Winkel oder drehst du das resultierende Bild immer wieder um einen kleinen Winkel? Bei der zweiten Variante werden immer Aliasingeffekte auftreten wenn der Drehwinkel nicht durch 90° teilbar ist. Somit verlierst du immer mehr Informationen vom Originalbild und dieses ist nicht mehr verlustfrei rekonstruierbar.

Du suchst den Modulo-Operator

Eingabe % Faktor == 0 -->OK
Eingabe % Faktor >0 --> NEIN

Du musst keine Methode übergeben sondern nur den Inhalt der TextBox an die Versuch Klasse.
Er meint es in etwa so:
Versuch.cs

Public Class Versuch
{
   private string Textboxstring;

   public void set_TB_String(string TB_string)
   {
      Textboxstring=TB_string;
   }
   
   public string get_TB_string()
   {
   return Textboxstring;
   }

//Alles was du sonst noch so in Versuch.cs stehen hast.....

WriteLog(get_TB_string());

}

In deinem Formular musst du dann set_TB_string aufrufen und dabei den Text innerhalb der TextBox direkt in die Textboxstring Variable schreiben.
Beispiel:
Form1.cs

public partial class Form1 : Form
{
   Versuch Versuch_cs_instanz= new Versuch();

   private void TextBox2_TextChanged(object sender, EventArgs e)
   {
      Versuch_cs_instanz.set_TB_string(TextBox2.Text);
   }
}

Deinen Link habe ich mir durchgelesen. smile

und was hast du daraufhin geändert?
Ich hoffe doch, dass du die Datentypen angepasst hast und VERP_DATUM_val jetzt ein DateTime ist oder es sich bei ANZAHL_val um einen Integer handelt? Wenn nicht wird es lustig wenn mal jemand auf die Idee kommt und in eine deiner Textboxen DROP TABLE Tabellenname schreibt.

Hallo tm64,

leider kann ich dir an dem Code den du gepostet hast nicht zeigen was du ändern musst. Die Methode test() von private auf public zu ändern hilft dir bei deinem Problem nicht weiter, da jetzt zwar alle anderen Klassen test() kennen und benutzen können aber deine ListBox immer noch nur innerhalb ihrer eigenen Klasse agieren kann.

Du benötigst einen Datenhalter der als public definiert wird. In diesem können deine ListBox und die test() Methode benötigte Daten reinschreiben oder lesen. Dort kannst du dann immer den SelectedIndex hineinschreiben wenn sich dieser ändert und test() ist jederzeit in der Lage diesen auszulesen.

Deine ListBox befindet sich in einer anderen Klasse als deine test() Methode. Dein Problem mit der Sicherheitsebene liegt an so genannten Zugriffsmodifizierern. Die ListBox auf die du zugreifen möchtest ist private und kann dadurch nur innerhalb ihrer (GUI-)Klasse verwendet werden, was auch gut so ist.
Du benötigst eine weitere Klasse die als Datenhalter fungiert und in der sich alle Daten befinden die du für test() benötigst. Diese Daten sollten dabei den public modifier besitzen damit eine Kommunikation mit anderen Klassen möglich ist.
In dieser neuen Klasse kannst du die Anzahl der Items oder das aktuell ausgewählte Item als Public ablegen und deine ListBox kann problemlos in diese Variablen hineinschreiben oder sie je nach Bedarf vielleicht sogar als DataSource verwenden und deine test() Methode ist in der Lage diese auszulesen oder zu ändern.

Wenn dein Bild wirklich nur Binär ist und keine weiteren Graustufen enthält solltest du über eine Hough-Transformation für Kreise nachdenken. Hough-Transformation

Dabei kannst du auf bestehende Libraries wie Aforge zurückgreifen (http://www.aforgenet.com/framework/docs/html/9b9aedc2-0048-acc8-4d35-0e41788d69da.htm)

Ein weiteres Werkzeug hast du mit EmguCV (http://www.emgu.com/wiki/files/1.4.0.0/html/6f78c3d8-fb1a-5983-2862-549c49019d49.htm). Dabei handelt es sich um einen .NET Wrapper für OpenCV und OpenCV ist eine der mächtigsten und umfangreichsten freien Bildverarbeitungsbibliotheken.

Ist jetzt nicht böse gemeint aber vielleicht solltest du dich wirklich erst einmal mit den Grundlagen der Prozentrechnung beschäftigen bevor du dich an ein solches Problem wagst.
Du hast von gfoidl eigentlich eine sehr gute Lösung für das Problem erhalten, welche dir den Prozentsatz des belegten Speichers ausgibt.

Nach kurzer Überlegung solltest du auch drauf kommen was bei Minimum und Maximum eingesetzt werden sollte. Wie viel Prozent deiner Festplatte wären den belegt wenn diese leer oder voll ist?

Tut mir leid aber meine Glaskugel arbeitet heute irgendwie nicht so richtig und deswegen kann ich dir leider nicht sagen wo der Fehler liegt. Eventuell kannst du uns zeigen was du bisher probiert hast und an welcher Stelle es denn hängt. Der Fehler könnte darin bestehen, dass du vielleicht versuchst den Text aus dem Label zu inkrementieren ohne in vorher in eine Zahl zu wandeln aber das ist auch nur ein Schuss ins Blaue.

Was hast du also bisher probiert und was für Bücher oder Tutorials hast du bisher gelesen um eine Lösung zu finden?

Hallo,
Ich arbeite gerade an einem Bland Altmann Plot und zur besseren Visualisierung setze ich Anhand der Datenpunkte die maximalen und minimalen Werte auf der y-Achse so, dass diese symmetrisch sind.
Ein Bild der Darstellung ist angehängt.
jetzt habe ich das Problem, dass mir dabei die Darstellung des Nullpunktes auf der Y-Achse verloren geht. Gibt es Möglichkeiten bzw. Diagrammeigenschaften die dafür sorgen, dass der Nullpunkt immer eingezeichnet wird unabhängig von Maxima und Skalierung? Ich habe versucht mit IsStartFromZero=true zu arbeiten aber das lösts dieses Problem leider nicht.

Alternativ würde ich eine Series durch 0 zeichnen wenn das Chart selber da nichts anbietet. Ist jemand eine Lösung bekannt um dieses Problem direkt über die Diagrammeigenschaften zu lösen?

Ich habe das Problem jetzt gelöst, indem ich das ganze Projekt als 64Bit DLL realisiert habe. Mit dieser DLL wird das komplette Set in der GUI abgearbeitet ohne Absturz oder sonstige unerwünschte Effekte. Warum dies bei einer 32 Bit DLL und Anwendung nicht der Fall ist erschließt sich mir leider immer noch nicht aber ich bin jedem dankbar, der sich zu meinem Problem Gedanken gemacht hat um mir zu helfen.

Grüße Toxo

bist du dir sicher, dass du alle Ressourcen freigibst. Was passiert, wenn du die Funktion Bilder_verarbeiten in der Konsolen-Anwendung mehrfach (testweise sogar in einer Endlosschleife) aufrufst? Bekommst du dann auch einen Fehler?

Ja ich habe das gleich Bildset von etwa 250 Bildern in der Konsolenanwendung durchlaufen lassen und das komplette Set wird ohne Fehlermeldung verarbeitet.
Da je nach Bild in dieser Umgebung 1-3 Minuten für einen Durchlauf benötigt werden, konnte ich in diesem Durchlauf den Arbeitsspeicherverbrauch im Taskmanager beobachtet und man sieht an den Spitzen sehr gut, dass nach dem bearbeiten eines Bildes die Ressourcen wieder freigegeben werden. Einen stetigen Anstieg nach jedem Bild wie in der C# Umgebung und ein Abbruch nach etwa 100 Bildern tritt dort nicht af.
Ich habe jetzt folgendes probiert. Nach jedem Funktionsaufruf hatte ich die Hoffnunng die genutzten Ressourcen wie folgt wieder frei zu geben:

 foreach(ProcessModule mod in Process.GetCurrentProcess().Modules)
                                {
                                if ("Bilder.dll" == mod.ModuleName)
                                    mod.Dispose();
                                  }

Nachdem das nicht zum Erfolg führte habe nach dem Empfangen der Exception die DLL entladen um zu schhauen ob der Fehler wirklich an dieser Stelle liegt:

[DllImport("kernel32", SetLastError = true)]
        static extern bool FreeLibrary(IntPtr hModule);
 foreach(ProcessModule mod in Process.GetCurrentProcess().Modules)
                                {
                                if ("Bilder.dll" == mod.ModuleName)
                                    FreeLibrary(mod.BaseAddress);

                                  }

Meine Vermutung war, dass nach diesem Vorgang beanspruchte Ressourcen wieder frei sein müssten. Leider ist dies nicht der Fall und jetzt weiß ich nicht wie ich an die Ursache für dieses Problem komme. Mit dem Tool VMMap sehe ich, dass mein Programm beim Auslösen der Exception 1,5GB private Heap Data im RAM beansprucht und das hilft mir bei der Fehlersuche leider auch noch nicht weiter.

Für weitere Hinweise bin ich dankbar.

An Deiner Stelle würde ich mir überlegen, ob Du nicht lieber C++/CLI benutzt...das ist in Deinem Fall wahrscheinlich einfacher

Das ist eine Option die ich noch nicht verfolgen möchte, da ich im C++ Code mehrere externe Libraries zur Bildverarbeitung nutze, welche CLI nativ nicht unterstützen. Falls ich das Problem nicht anders gelöst bekomme denke ich über einen C++/CLI Wrapper nach.

Hallo,

ich habe momentan mit einem ungewöhnlichem Problem zu kämpfen, welches mir so noch nicht untergekommen ist und ich hoffe, dass ihr mir Hinweise geben könnt wie man in so einem Fall vorgeht.
Folgende Ausgangssituation:
Ich habe einen C++ Algorithmus welcher Bilder einliest diese verarbeitet, Ergebnisse in Bild und Textform speichert und anschließend die geladenen Ressourcen wieder freigibt. In einer C++ Konsolenanwendung funktioniert das alles wunderbar und ich kann Komplette Bildersets verarbeiten ohne Fehler.
Da ich mit C# eine GUI dazu entwerfen wollte, habe ich das ganez als unmanaged DLL Exportiert.

extern "C" { __declspec(dllexport)
void Bilder_verarbeiten(char* open_Path, char* save_Path);

Importiert unter C# habe ich es wie folgt:

 [DllImport("Bilder.dll", EntryPoint = "Bilder_verarbeiten", ExactSpelling = false, SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
        static extern void Bilder_verarbeiten(string open_Path, string save_Path);

//Aufruf
Bilder_verarbeiten(file, savetext);

Wenn ich nun in C# ein komplettes Bilderset bearbeiten will steigt der Arbeitsspeicherverbrauch immer weiter an und es sieht so aus, als ob von der DLL genutzte Ressourcen nicht wieder richtig freigegeben werden. Nachdem die Anwendung etwa 1,5GB RAM belegt erhalte ich eine SEHException. Leider weiß ich nicht wie ich an dieser Stelle debuggen kann, da der Aufruf der DLL Funktion die Exception wirft. Die Funktion tut bis zu diesem Punkt genau das was sie auch tun sollte. Ich kann die gespeicherten Ergebnisse bis zum Absturzpunkt ansehen.
In meiner Debugbaren C++ Konsolenumgebung tritt dieses Problem nicht auf.

Gibt es Möglichkeiten alle genutzten Ressourcen einer Importierten DLL manuel wieder freizugeben? Für passende Stichworte oder Artikel wäre ich dankebar, da ich so ein Problem noch nie hatte.

Grüße
Toxo

Wenn du nur die Unterschiede zwischen 2 Tabellen brauchst und diese gleich aufgebaut sind schau dir mal MINUS an.
SQL MINUS

Du iterierst mit einem for each durch alle deine Controls(Ich nehme an, dass du mit Formen Controls meinst) und fragst dann ab ob das jeweilige Steuerelement deines gesuchten Typs entspricht. Wenn dem so ist hast du nur noch Position.X -=10 als Einzeiler in deiner Abfrage.

Nein er meint wohl ein Farbband wie beim HSV Farbraum wie im folgenden Bild.
HueScale.svg
Im Beispielbild ist Blau(Min) 240 und Rot(Max) 360 und der Lila(Value) 300.

Ich würde dir Vorschlagen, dass du für so etwas nur mit dem H Kanal im HSV Farbraum arbeitest und die Sättigung auf maximum hälst.
MSDN GetHue()

Danke das war genau das richtige Stichwort
😁 👍

Hallo,

ich suche nach einer Möglichkeit ein struct zu Visualisieren, welches unter anderem aus anderen struct besteht.
Im Prinzip eine Art TreeView für den Datentyp struct indem ich Werte einsehen und manipulieren kann.
Kennt jemand ein geeignetes Steuerelement oder kann mir einen Hinweis geben wie man so etwas bauen kann?

Gruß
David

Hab es gelöst. Es gab einfach auch noch Textboxelemente, welche nichts mit der Datenbank zu tun hatten und da hat dann die Spaltensuche immer sehr lange gedauert hat bis es zu einer exception kam die ich bisher ignoriert hatte. Habe es rausgefunden indem ich mal alles was in der Schleife passiert mal Schrittweise auseinandergenommen habe und einen Try-Catch Block entfernt habe.

Dim Typ = GetType(TextBox)
 Dim TB As TextBox

            For Each ctrl As Control In F.Controls
                If ctrl.GetType() Is Typ Then
                    TB = ctrl
                    If Not TB.Text = "" And Not TB.Text = "Fehler" And Not TB.Tag = "" Then
                        newData(TB.Tag) = TB.Text

                    End If
                End If
            Next

In Zukunft muss ich genau drauf achten wo irgendwelche try-Ctach Blöcke stehen und ausserdem auch auf entsprechende Rückmeldungen reagieren.

Was bei deiner Vorgehensweise so lspürbar ange dauert geht da nicht genau hervor, denn du schreibst nicht wie genau du das machst.

 Sub MessdateninDatenbakn()
            Dim newData As DataRow
            newData = tbltempMOC.NewRow() 

           For Each ctrl As Control In F.Controls
                If ctrl.GetType Is GetType(TextBox) Then                 

                        newData(ctrl.Tag) = ctrl.Text   
               
                End If
            Next

            tbltempMOC.Rows.Add(newData)

            Dim Commandbuilder As New SqlCommandBuilder(MOCTabelle)
            MOCTabelle.Update(DataSetMOC, "MESSDATEN")
            MsgBox("Datenbank aktualisiert")

    End Sub

Muss momentan in VB.Net an dem Prgramm arbeiten hoffe es stört nicht. Die Syntax ist ja C# sehr ähnlich. tbltempMOC ist meine Datatable, welche die Spalteninformationen aus der Datenbank bereits besitzt.
Die for each Schleife ist der zeitaufwändige Part. Bei etwa 40 Textboxen/Spalten vergehen in dem Block ca. 3 Sekunden und das empfindet der Nutzer als unschön wenn er bei "so wenig Werten" 3 Sekunden warten muss bis diese in der Datenbank ankommen.

Zum Thema Databindings. Damit habe ich bisher nur bei GridViews gearbeitet und kam mir hier erstmal nicht in den Sinn. Lese jetzt erstmal einen Artikel auf CodePrject dazu vielleicht ist die Sache damit auch fix gelöst. Danke erstmal für das Stichwort.

Hallo,

folgender Sachverhalt. Gefordert ist eine dynamische Schnittstelle zu einer Datenbank. Inhalte aus Textfeldern sollen direkt in eine Datenbank übertragen werden. Bezeichnungen der Steuerelemente stimmen mit den Spaltennamen der DB überein. Wenn etwas an den Textboxen geändert wird(neue hinzufügen/alte entfernen) möchte man nur noch die entsprechenden Datenbankspalten ändern der Schnittstelle selber soll das nichts ausmachen.

Mein vorgehen besteht hier aus einem DataAdapter und einem DataSet entsprechende Informationen wie eine DataTable dazu aufgebaut ist hol ich mir direkt aus der DB. Es wird eine leere neue DataRow erzeugt und anschließend befüllt.

Alle Textboxen werden nacheinander durchlaufen und Der Name der Textbox entspricht nun auch einem Spaltennamen in meiner DataTable und der Inhalt wird nun angefügt.
Dieser Vorgang dauert auffällig lange Im vergleich zum Rest. Ich vermute es liegt am Vergleich der Der Textboxnamen zu den Spaltennamen der DataTable untereinander. Wieso frisst das so viel zeit und gibt es bei den Anforderungen alternativen?

Gut dann habe ich jetzt mal einen Grund das Betriebssystem zu wechseln und den Rechner aufzuräumen 😁
Hatte nur vermutet, dass es Sachen gibt die anders interpretiert werden. Fehler die im Programm enthalten sind und durch XP nicht zu Tage gefördert werden kamen mir nicht in den Sinn aber da weiß ich wo ich ansetzen muss.

Danke für den Hinweis

Guten Morgen,

ich habe folgendes Problem. Unter Windows XP habe ich eine Windows Forms Anwendung erstellt und dort läuft auch alles wie es sein sollte. Nun wollte ien Kollege diese unter Windows 7 nutzen aber dort treten nun eingie merkwürdige Phänomene auf die ich mir so nicht erklären kann.

• Fehlerhafte Farbdarstellung:
  Weißter Hintergrund wird in Win 7 schwarz dargestellt und weiße Schrift ist Dunkelgrau

• ignorierte Rasterung
  Während der Laufzeit werden Controls generiert die sich in eine Rasterung einordnen. Unter Win 7 sieht es aber so aus, als ob die Controls in der Y-Richtung die Rasterung umkehren.

-Probleme beim markieren von Controls
Der Nutzer kann Controls markieren und diese verschieben. Unter Win 7 scheint es da aber wieder Probleme mit dem auswerten der Y-Koordinaten vom "markierrechteck" zu geben.

Auf allen Rechnern ist das aktuelle Framework installiert.

Kennt jemand eventuell einen Artikel, welcher zeigt was man beachten sollte wenn man Anwendungen für Windows 7 unter XP erstellt? Wüsste gerne wo da die Grundlegenden Probleme liegen, bzw. Was Windows 7 anders interpretiert.

Gruß
David

Danke euch.

Ich hatte wirklich angenommen, dass ich mit dem Tooltip ein neues eigenes Steuerelement anhänge aber eure Erklärungen haben das richtig gestellt und nun ist die Sache viel klarer.

Hallo

Ich iteriere in meiner Anwendung durch alle meine Benutzerdefinierten Steuerelemente. In solch einem Steuerelement befinden sich unter anderem 2 Labels. Eins für eine Bezeichnung und ein weiteres für einen Wert. Die Werte werden nun mit einer hinterlegten Datenquelle abgeglichen und wenn etwas nicht übereinstimmt wird das jeweilige Label eingefärbt und über Code füge ich einen Tooltip mit einem Hinweis ein.

ToolTip Fehlertt = new ToolTip();
Fehlertt.setToolTip(eigenes_Steuerelement,"Fehler weil.......");

Wenn ich nun erneut durch meine eigenen Steuerelemente iteriere um die ToolTips später wieder zu entfernen finde ich diese nirgends. Weder in this.Controls noch in eigenes_Steuerelement.Controls
Angezeigt werden sie aber weiterhin.
Woran kann das liegen, bzw. wo befinden sich diese Tooltips und wie entfernt man diese wieder?

Hallo,

das Problem ist ja bereits in der Überschrift geschildert.

Ich versuche Daten in eine Datenbank zu übertragen die ich nur als String erhalte.

Folgende bisherige vorgehensweise

messTabelle.GetType().GetProperty(Messwert.Spalte).SetValue(messtabelle, Messwert.Wert, null );
DbConnection.Messwerte.InsertOnSubmit(messTabelle);

messTabelle ist eine Tabelle aus meiner DBML, in Messwert.Spalte steht der Spaltenname drin wie er in der Datenbank vorkommt und Messwert.Wert ist der zu überführende Wert.
Nun müsste ich aber Messwert.Wert noch in den entsprechenden Datentyp konvertieren, da er ja momentan nur als stringg vorliegt.

Nur wie komm ich an den entsprechenden Datentyp dieser Spalte. Bin bis zu folgendem String gekommen
"System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]"
mit folgender Anweisung.

messTabelle.GetType().GetProperty(Messwert.Spalte).PropertyType.FullName

Sicherlich könnte ich jetzt mit dem String weiterarbeiten aber meine Frage wäre ob sich das auch irgendwie eleganter lösen lässt.

Guten Morgen,

ich stehe momentan vor einem Problem in dem ich ein Diagramm in Teilbereiche einteilen will und gerne wissen würde ob sich das mit einem Chart lösen lässt.

Der Bereich in dem Diagramm der interessant ist liegt zwischen 0,02 und -0,12 Meine Werte können aber zwischen 10 und -10 liegen.
Der interessante Bereich sollte etwa 80% des Diagrammbereichs einnehmen und alles was drüber oder drutner ist jeweils 10%, da man Ausreisser sehen will es aber uninteressant ist wo diese genau liegen.

Meine ersten Versuchen bestanden darin mit der AxisScaleBreakStyle Klasse zu arbeiten. Da habe ich aber das Problem, dass ich bei dieser nur mit prozentualen Abweichungen arbeiten kann udn keine festen Werte definieren kann.
Gibt es Mögleichketien diese Klasse zu erweitern oder ist die Aufgabe mit einem Chart-Objekt nicht lösbar und ich muss mit 3 arbeiten und diese mit entsprechenden Datenquellen versorgen?

Gruß David

Ja aber genau das war doch meine Frage 🙁
Ob es möglich ist diese Art der Abfrage einfach anzupassen ohne das ich die Datenmenge "von Hand" durchfiltern muss.
Ja ich kenne die Unterschiede zwischen den Datentypen und im Prinzip wollte ich nur wissen ob die Art der Abfrage so Anwendbar ist oder ob man es Grundlegend ändern muss.

Ich strapaziere ein wenig unabsichtlich deine Geduld. Entschuldigung dafür.

// Edit 2:
Ich glaub deine gesamte Rechnung ist falsch, wieso ist 1 / 5 * 5 und 3 / 5 * 5 gleich 0? Da stimmt doch irgendetwas hinten und vorne nicht.

1/5 laut eigentlich 0,2 da die Werte aus einer Tabellenspalte kommt mit Datentyp smallInt ist 1/5 =0 und 0*5 =0
daher (1/5)*5 =0

Ich sag mal da musst du etwas mehr investieren. du kannst aus den Daten 1,3,3,3,5,5 nicht die Zeilen 1,2,3,4,5 erzeugen. Dazu müsstest du dir erst eine (temporäre?) Tabelle mit der richtigen Schrittweite erzeugen und dann deine Daten per LEFT JOIN anhängen.

folgende Daten 1,3,5,7

(1/5)*5 = 0
(1/5+1)*5 = 5
+1 in Datenatz zwischen 0-5

(3/5)*5 = 0
(3/5+1)*5 = 5
+1 in Datensatz zwischen 0-5

(5/5)*5 = 5
(5/5+1)*5 = 10
+1 in Datensatz zwischen 5-10

(7/5)*5 = 5
(7/5+1)*5 = 10
+1 in Datensatz zwischen 5-10

resultat

untereGrenze|obereGrenze| Daten
0| 5|2
5|10|2

Was ist an dieser Überlegung falsch?

SELECT  
 ((IOut/0.2)*0.2) AS untereGrenze,   
((IOut/0.2+1)*0.2) AS obereGrenze  
 FROM PE   

Diese Berechnung ergibt doch nichts anderes aus als dieser gekürzte Code:

SELECT  
 IOut AS untereGrenze,   
 IOut+0.2 AS obereGrenze  
 FROM PE   

Wahrscheinlich hast du vergessen zu runden, bzw. die Nachkommastellen abzuschneiden.

Christian

Stimmt du hast recht. Mein Problem ist das ich eine Abfrage wollte die Funktioniert ohne das ich die Tabelle kenne oder weiß auf welchen Datentyp ich überhaupt zugreife. Das ist dann wohl doch noch nicht der richtige Weg.

Hi Toxo,

Das eigentliche Problem tritt nun bei Fließkommazahlen auf. Wird im nächsten Post genauer erläutert, da nur 1 Bild pro Post gestatttet ist.

Hat evtl. jemand eine Idee wo der Fehler liegen könnte?

Wenn du jetzt auch noch dein Problem erklären würdest, könnte dir evtl. jemand weiterhelfen...

Christian

ja irgendwie hab ich das vergessen. Verzeihung.

im 2. Post ist eine Schrittweite für das Histogramm von 0,2 angegeben.

Ich erwarte also nur alle Vielfache von 0,2 einen Wert. In der Datatable tauchen aber Werte 36,5, 36,6, 36,7, 36,8......
erwarten tue ich aber 36,4, 36,6, 36,8, 37....

Die Abstände zwischen obergrenze und untergrenze sind Korrekt mit 0,2 nur die Schrittweite ist eifnach nicht Korrekt.
wenn ich nun eine Schrittweite von 1 angebe sieht es zum Beispiel so aus

untereGrenze | obereGrenze| Anzahl gefundener Datensätze

34,8 | 35,8 | 38
35,4 | 36,4 | 18
35,7 | 36,7 | 3
36 | 37 | 12

usw...

erwünschte ausgabe wär:

34| 35 | 20
35 | 36 | 24
36 | 37 | 18

usw.

Ich hoffe es ist nun etwas klarer wo das Problem liegt.

Ich versteh noch nicht ganz das Problem. Meinst du die Sprünge in der ersten Spalte also z.B. 40.0, 40.1, 40.7? Diese Sprünge hast du in der anderen Tabelle auch, das liegt aber wohl einfach daran, dass du im Bereich 40.2 bis 40.6 keine Daten hast.

Schon mal überprüft?

Edit: ich bin mir auch nicht ganz sicher, ob dein Statement überhaupt einen Sinn hat. Im Endeffekt lieferst du nur die Anzahl jeder Ausprägung von IOut, wobei die Ausprägung die erste Spalte darstellt und die 2. spalte nur die erste spalte + 0.2 ist. Im Grunde kannst du eigentlich auch die ganze Rumrechnerei weglassen, weil du ja sowieso nur IOut und IOut + 0.2, und die dazugehörige Anzahl lieferst.

Die Sprünge machen kein Problem da die Datatable so wie sie ist an ein Diagramm übergeben wird und es nur um das finden de Gausskurve geht.
die unregelmäßge Schrittweite bei double Werten zerstückelt mir aber meine Gausskurve und ist so nicht zur Auswertung geeignet.

Die Rechnerei ist notwendig damit ich Werte in Bereiche gruppieren kann die eben durch meine Schrittweite angegeben wird. Diese ist im 1. Fall 5 und im 2. fall 0,2

Beispielabfrage über eine Tabelle mit Fließkommawerten:

SELECT
 ((IOut/0.2)*0.2) AS untereGrenze, 
((IOut/0.2+1)*0.2) AS obereGrenze,
 Count(IOut) AS Daten
 FROM PE 
GROUP BY (( IOut/0.2)*0.2) , ((IOut/0.2+1)*0.2)  
 HAVING  ((IOut/0.2)*0.2)>20 AND  ((IOut/0.2+1)*0.2)<80

hier wird zwar in 0,2 Abständen Gruppiert doch die Schrittweite ist sehr variabel.

Als Anhang ein Ausschnitt des Ergebnisses

Hat evtl. jemand eine Idee wo der Fehler liegen könnte? Ich drehe mich nur im Kreis und bräuchte ein paar Anregungen wo dei Fehlerquelle liegen könnte.

Danke und Gruß
David

verwendetes Datenbanksystem: MSS SQL 2008

Hallo,

Ich habe mir eine Abfrage gebastelt, welche mir Messdaten so auffbereitet, dass sie in einer Form zurückkommen die als Histogramm auswertbar sind.

Beispielabfrage:

SELECT 
((Sin/5)*5) AS untereGrenze, 
((Sin/5+1)*5) AS obereGrenze, 
Count(Sin) AS Daten 
FROM PE 
GROUP BY (( Sin/5)*5) , ((Sin/5+1)*5)   
HAVING  ((Sin/5)*5)>0 AND  ((Sin/5+1)*5)<5000

Ergebniss bei ganzzahligen Werten sind als Bild angehängt.

Das eigentliche Problem tritt nun bei Fließkommazahlen auf. Wird im nächsten Post genauer erläutert, da nur 1 Bild pro Post gestatttet ist.

Gut wenn du MoonTaxi schon kennst dann hier nochmal ein Beispiel was vielleicht eher auf deine Bedürfnisse zugeschnitten ist.
Starter Kit Platformer

In dem Artikel werden ein paar Worte zu Physik und scrollbaren levels gesagt. Ich denke das trifft so ziemlich was du suchst 😁
zum Thema engines kann ich dir leider nicht viel sagen da ich da selber auch noch keine Erfahrungen habe.

Wie viel hast du schon mit XNA gearbeitet? Bevor du dich an ein größeres Projekt wagst würde ich allgemein erstmal empfehlen ein bisschen mit XNA zu probieren einzelne Problemstellungen im kleinen zu testen.

Vor allem in Sachen Level laden, Tiles und Sprites oder allgemein Grafiken lohnt es sich Begriffe wie Content Pipeline nachzuschlagen.
Je nachdem wie du Content in dein Spiel lädst wird dieser unterschiedlich gehandhabt. Die Möglichkeiten sind da sehr vielfältig.
Probierbeispiel für XNA wäre zum Beispiel einfach mal einen Ball zu programmieren, der sich linear über das Bild bewegt und an den Wänden "abprallt".

Das probieren ist wichtig, da sich Spieleprogrammierung anders verhält als Ereignisgesteuerte Programmierung.

Wahlweise kannst du auch die vielzähligen Tutorials in Netz durchgehen. Ein erwähnenswertes für 2D wäre Moon Taxi

Thema Veröffentlichung:

Steam liefert die XNA redistributable darum musst du dich nicht kümmern aber exotsiche dll solltest du so in den Code packen das diese mitinstalliert werden.
Näheres dazu: Steam SDK FAQ

Danke, das bringt erstmal etwas mehr Klarheit in die Angelegenheit.

Entschuldigung für meinen laxen Umgang mit dem Begriff LINQ. Ich habe es schon mehrfach verwendet um mit XML Dateien zu arbeiten oder große Datenmengen zu bearbeiten und bin daher auch auf die Verwendung Datenbanken gestoßen. Das ORM fällt mir hier aber etwas auf die Füße. Vom XML teil von LINQ war ich große flexibilität gewöhnt und habe das nun in linq2sql vermisst.
Das zeigt mir mal wieder das es schlecht ist das erstbeste zu nehmen in der Hoffnung das es fix fertig wird.
Ich werde mich jetzt noch durch ein paar Artikel und Bücher arbeiten bevor ich weiter irgendwelchen Code schreibe. Da is doch noch ein bisschen Theorie nachzuholen. =)

Danke nochmal für deine Zeit und Erklärungen.

Ich brauch bitte noch weitere Beratung für den richtigen Zugriff auf die Datenbank.

Mein Problem liegt jetzt in der Vielfalt der Möglichkeiten und ich bin mir nicht mehr sicher was nun das sicherste,perfomanteste bzw. in Sachen Erweiterbarkeit und auf zukünftige Sicht das Beste ist.
Ich bin etwas erschlagen von den ganzen Technologien ala OLEDB, SqlConnection, Entityframework, LINQ mit Erweiterungsmethoden und Lambdaausdrücken....

ist die Auswahl dieser Technologien rein subjektiv? Also man nimmt das womit man am besten arbeiten kann oder gibt evtl. irgendwo eine Auflistung mit Datanbankschnittstellen und derenangedachten Anwendung?
Falls es jetzt zu sehr in Grundlagen rutscht tut es mir leid aber ich bin etwas überfordert und unsicher was nun der weitere richtige Weg wäre.

Ich muss dir recht geben der Ansatz scheint hier wirklich der falsche zu sein. LINQ to SQL war für mich erstmal eine gute Sache für den Einstieg in Datenbankarbeit mit C# und ich war begeistert von Geschwindigkeit, Stabilität und einfacher Bedienung. Solange das Datenbankmodell immer gleich ist und sich nichts ändert ist eine typisierte Sprache ideal.
Da ich aber in einer Entwicklungsumgebung arbeite wo sich schnell mal Messarten verworfen werden, Testreihen gebildet werden oder alte Abläufe umstrukturiert werden in der Datenbank. Ist eine OR Abbildung keine ideale Lösung wenn man die Änderungen auch noch schnell visualisieren möchte.

Ja das ist wohl wahr. Exotisch sind die Anforderungen keinesfalls, mir geht es eher um den Lerneffekt und etwas Festigung im Umgang mit Datenbanken.
Ich habe mit einer Access Datenbank als Grundlage angefangen und da mal ein paar VBA Geschichten zur Auswertung gebastelt. Doch dies ist mittlerweile einfach nicht mehr performant genug und stürzt gerne mal ohne irgendwelche Rückmeldung ab.

Deswegen ist die Datenbank auf einen Microsoft SQL Server migriert und habe dort dann LINQ als gute alternative entdeckt. Das Projekt wächst nun doch immer weiter, so das es noch eine Spur dynamischer werden muss und durch die festgelegte Struktur durch die DBML erscheint LINQ da wieder etwas zu starr.
Bin zufällig auf Dynamic LINQ gestoßen und das bringt mich erstmal ein ganzes Stück weiter.

Eine weitere Frage wäre, ob es möglich ist die DBML während der Laufzeit zu ändern aber das lässt sich mit probieren und weiteren Recherchen rausfinden.

Ich bin dir trotzdem dankebar für deine Zeit winSharp93