Forenbeiträge von panicJonny Ingesamt 64 Beiträge
Mein Klasse kann schon ein wenig mehr.
Sie kann auch Enums(Flags), Point(f), Size(f) und so weiter konvertieren. Den Vorteil habe ich oben schon beschrieben, dass ich mit Reflection den Zieldatentyp "auslesen" kann und dann entsprechend Konvertieren.
Grüße,
Klar kann ich die verwenden und mache ich auch im Hintergrund. Meine Klasse macht das ganze ein wenig praktischer, da ich ein einheitliches Interface habe.
Was ich nicht geschrieben habe ist, dass man den Typen auch als Parameter übergeben kann und nicht unbedingt als generic type parameter angeben muss.
Es gibt also auch eine StringConverter.ConvertTo(type,string). Das ist auch der ursprüngliche Grund für die Klasse, da ich damit über Reflection Datenklassen aus Dateien heraus befüllen kann. Vornehmlich gehts dabei um Grenzwerte die in Konfigdateien stehen.
Da ich dann die Klasse nun mal schon hatte, habe ich sie ein wenig erweitert und nutze sie nun als allgemeine Konverterklasse.
Hallo zusammen,
ich habe mir eine Klasse gebaut, mit der ich strings in so ziemlich jeden Datentyp umwandeln kann, den ich möchte.
So weit so gut.
Die Hauptmethode wird so aufgerufen. StringConverter.ConvertTo<T>(string).
Jetzt ist mir beim Benutzen aufgefallen, dass der Aufruf relativ schwer zu lesen ist. Gerade weil ich den halt oft hintereinander benutze. Also in mehreren Zeilen, wenn ich mal wieder einen String zerlege und die Bestandteile in die entsprechenen Properties packe.
Da hab ich mir gedacht, ich mache für häufige Datentype spezielle Methoden.
Zum Beispiel StringConverter.ToInt(string).
Wäre das eigentlich zu viel des Guten und fallen euch andere Lösungen ein?
Viele Grüße.
Moin moin,
für die Grobeinteilung kannst du ausmessen und zusammen mit der dpi vom Drucker die Koordinaten ausrechnen.
Für die genaue Einstellung hilft trial & error.
Moin moin,
ich mache mir das Einfach. So lange es nicht unbedingt sein muss, liefere ich meine Anwendungen als "portable" aus. Das ist natürlich sehr bequem und einfach. (einfach das release Verzeichnis 😉
Wenn ich noch zusätzliche Sachen installieren muss, dann nehme ich NSIS her. Das ist ganz nett und bietet viele Möglichkeiten.
Mach mal deinen Virenscanner aus. Der hatte bei mir die Dateien genau dann zum scannen blockiert, als der Installer sie gebraucht hat.
Ich hab mir aus "Verzweiflung" noch mal deine erste Antwort langsam durchgelesen und bin auf diesen Satz gestoßen.
Das "besser" war aus dem Auge als Software Architekt.
Du kannst eben auf ein Generic Einschränkungen setzen, die eben bei einfacher Parametrisierung nicht möglich sind.
Dein Aufruf startet quasi mit einer Whitelist und schränkt diese dann nachträglich ein (bildlich gesprochen).
Das Interface als Parameter anzugeben schränkt hingegen gleich maximal ein. Was ja an der Stelle für mich Sinnvoll zu sein scheint.
Das enzige, was mir an der Stelle dazu einfällt ist Erweiterbarkeit, falls ich mal ein weiteres Interface supporten soll. Allerdings soll man ja seine Software auch nicht auf absolut jeden möglichen Fall auslegen (overengineering).
Sorry, kantische Lehrmethoden funktionieren bei mir heute nicht.
Was ist der Benefit davon, dass ich den Aufruf über ein Generic mache? Und bitte nicht wieder auf den Artikel mit den contstaints verweisen. Der hat mit meiner Frage irgend wie nichts zu tun.
Grüße
hm,
die brauche ich aber auch nicht, wenn ich den Parameter vom Typ IIrgendwas mache.
Welchen Vorteil bekomme ich davon statt
void foo(IIrgendwas param)
void foo<T>(T param) where t: class, IIrgendwas
zu machen?
Das ist, für mich gesehen, der gleiche Aufruf nur komplizierter
Huhu, das ist keine ketzerische Frage sondern ernst gemeint. Warum das als generic übergeben?
Hallo,
bitte die Code tags benutzen. Das macht die Sache deutlich lesbarer.
Zu deiner Frage. Schmeiß das ref aus der Methode raus. Das hat dort nix zu suchen. Du willst ja eine Kopie der Zahl übergeben und keine Referenz drauf.
int fac(int x){
return x<2 ? 1: x * fac(x-1)
}
Macht es Sinn ein Factory Design Pattern zu implementieren, obwohl man nur eine konkrete Klasse hat?
Der Sinn von Interfaces ist primär die Modularisierung und die Trennung von Schnittstelle und Implementierung.
Der Nutzer einer Schnittstelle soll nichts von der konkreten Implementierung wissen.
Ist das nicht ein Relit aus alten C Zeiten? Sogar modernes C++ geht davon weg (siehe modules). Und nur weil es kein IFoo gibt hat Bar nicht gleich kein definiertes Interface nach außen. Selbst das .NET Framework packt nicht alles in Interfaces ( z.Bsp.: File, Exception, EventArgs )
Quatsch. Bitte so nicht machen!
Interfaces sind keine unnötigen Strukturen!
Das widerspricht aber schön dem KISS prinzip. Für eine Klasse, von der es keine weitere Variante gibt brauche ich kein extra Interface und auch keinen Factory. Der Code lässt sich aber trozdem leicht erweitern, falls es doch mal nötig wird, weil sich eine Interface Struktur ( ich weiß grad nicht, wie ich ein Interface als solches selber von dem Interface, wie in IDisposable, sprachlich unterscheiden soll) sehr leicht drüber stülpen lässt.
Wenn ich jeden Code immer so anlegen würde, bekäme ich jedes mal ganz schnell einen unübersichtlichen Moloch durch den sich man ziemlich schlecht navigieren kann. Ein Interface zwischegeschaltet sorgt leider auch dafür, dass sich die Implementierung zum teil nicht so leicht finden lässt.
PS: Mir fällt gerade auf, dass es OT ist und vor allem deine absoluten Aussagen betrifft. für den TO ist es unerheblich. Seine Klasse gehört in ein Interface und ein Factory.
@Abt
Der Link hat schon mal ziemlich weiter geholfen. Ich sag nur Filterblase. Ich hab imm er nur Anleitungen gefunden, wie man den Käse halb Hand erstellt. Ich wusste zum Beispiel gar nicht, dass ich nuget spec auch auf das Projektfile loslassen kann. Ich hab das immer auf die dll selber gemacht.
Bei deinem Link muss ich nur das nuspec einmal von Hand erzeugen und den Rest kann ich mit ein wenig Post-Build events machen. Auf jeden Fall eine deutliche Erleichterung zum bisherigen Vorgehen.
@codesoldier
Wenn ich anfange einen eigenen GitLab Server in einer VM aufzusetzen bekomme ich tüchtig Haue von unserer IT (und das Zurecht). Manche Sachen muss man einfach nehmen, wie sie sind.
Nö.
Gut, ich spezifiziere es mal genauer. vom VS Studio das NuGet Package erstellen lassen geht nur bei .Net Core Anwendungen. Falls ich falsch liege, dann bitte her mit der Anleitung, ich finde nämlich nichts.
dann ist die Software Architektur Käse.
Ich gebe ja gerne zu, dass ich was falsch mache. Kompiliere ich meine Biblioteken als .Net Core, kommen alle benutzen Referenzen von .Net Core mit ins Ausgabeverzeichnis.
man muss nichts per Hand ändern - noch nie.
Egal ob .NET Framework, .NET Core oder .NET Standard.
Die Version wird im .nuspec beim compilieren automatisch angepasst? Bei mir leider nicht.
totale Käse, von Vorn bis hinten.
Meine Rede
Ich bin leider an SVN und VS ohne TFS gebunden und das lässt sich auch nicht ändern.
Wie mein Workflow mit Nuget ist, hab ich ja hin geschrieben.
Git ist nicht und TFS auch nicht.
Hallo zusammen,
bei meiner Arbeit, fallen viele kleinere Projekte an, die in Teilen gemeinsamen Code haben. Da hat sich im Laufe der Zeit einiges angesammelt.
hier mal eine logging Klasse, da mal ein paar Klassen zum ansteuern von managed Switches u.s.w
Das ist mittlerweile eine schöne Ansammlung von code geworden. Nur langsam wirds ein wenig unübersichtlich. Ich weiß nicht mehr wo was in welcher Version aktuell ist.
Ich habe da ein paar Sachen ausprobiert:
-> bauen von Nuget Packages: da finde ich den Workflow ziemlich doof bei bugfixes und Erweiterungen. Packages automatisch erstellen lassen geht ja nur bei .Net Core anwendungen und das erzeugt bei mir immer einen Wust an dlls. Von Hand ist das ziemlich mühsam. nuspec Datei ändern, binary umkopieren, nuget package erzeugen und dann ins Repository Verzeichnis kopieren und dann im Zielprojekt updaten.
Vorteil ist, dass Unittests in einem eigenem Projekt leichter möglich sind (wenn machbar)
-> als SVN external einbinden: Eigentlich eine ziemlich runde Sache. Nur leider kann man gemeinsame Abhängigkeiten nicht gut auflösen. Man hat dann am Ende im Zielprojekt teilweise zig mal die gleichen Klassen
-> Sourcen kopieren: So mache ich das gerade. Nur leider verschwindet der Überblick, was denn jetzt die letze Version mit den letzten Bugfixes und den neuesten Features ist.
Wie macht ihr das. Hat da wer einen Tip für mich?
Zu bedenken ist, dass ich nicht der einzige bin, der diese Klassen benutzt, aber der einzige, der dran rumschraubt.
Grüße,
Moin,
sind alle Rechner in eine Domöne eingebunden? Vielleicht kann das hier weiter helfen.
Ich habs zugegebenermaßen nur überflogen und kann es nicht ausprobieren (mangels admin)
Einen Versuch ist es wert.
Nur mal so aus der Hüfte geschossen^^.
ListA.AddRange(ListB)
pappt beide Listen zusammen.
var combined = ListA.Distinct();
sucht dann die Einzigartigen raus, wobei du noch GetHashCode und Equals in deiner Bestellungen Klasse überladen musst.
Grüße
Hallo,
das einzige, was bei mir geholfen hat.
VS deinstallieren. Auf der Microsoft Webseite einloggen und dort die Sprache auf Englisch umstellen (in deinen Accounteinstellungen). Dann den Installer herunterladen und wieder installieren.
Ich hpffe aber, es gibt noch einen anderen Weg.
Moin,
ich gebe zu, ich habe keine Ahnung, was du meinst. Ich versuchs trozdem mal 😃
Ein Event hat gewöhnlich immer die gleiche Signatur
void EventName(EventArgs e, object sender)
wobei EventArgs die Basisklasse ist und davon abgelitten wird.
Wenn du eins erstellen willst, kanns du dir das mit dem Delegaten auch sparen. Das geht mittlerweile einfacher.
public EventHandler<EventArgs> MyEvent = new EventHandler<EventArgs>();
private void RaiseMyEvent(EventArgs e){
MyEvent?.Invoke(e,this);
}
Wenn du dann das Event feuern willst, rufst du einfach RaiseMyEvent an der Stelle auf, wo du es loswerden willst.
Grüße
Moin,
schmeiß doch einfach alle Buttons in ein Dictionary<string,Button>. Da kannst du mit den Namen auf sie zugreifen.
@panicJonny:
Er parst jedesmal den Puffer:ReceiveCommando = parser.ParseCommandoReceive( buffer );Das führt aber im Endeffekt zum gleichen Ergebnis wie bei meiner Aussage oben.
Nein, tut er nicht. Wenn nicht genügend Daten ankommen, springt er vorher aus der Methode mit return raus.
Wo schmeiße ich denn den Inhalt weg?
*/
byte[] buffer = new byte[ 50 ];
/* Empfangene Daten abholen
*/
length += Client.Read(buffer, 0, buffer.Length);
/* Ist die mindest Anzahl an Bytes empfangen worden?
*/
if ( length < (int)cmd.Answer_Byte_Position_enum.CMD_ANSWER_DATA_BYTE_BEGINN )
{
return;
}
Du legst den Buffer in der Methode an. Beim Verlassen dieser, werden die Daten weggeschmissen. Du speicherst die nirgends.
Erstaunlich, dass das überhaupt funktioniert.
Du schmeißt nämlich so den Inhalt deines Buffers weg, wenn nicht genug daten eingetroffen sind.
Moin,
du willst, dass dein Log von oben nach unten "wächst". Das halte ich erst mal für eine schlechte Idee. Das frist absolut unnötig performance, weil du ja immer die Datei neu schreiben musst und der Lohn dafür ist...überschaubar. Außerdem sollte man in einem Log nichts löschen. Dann kann man später nachschauen, was früher passiert ist.
(wie oft mich schon der ringbuffer vom syslog hat hängen lassen)
Falls du eine separate Darstellung von deinem Log hast, dann lasse lieber die anders herum anzeigen. Das sind nur Operationen im Ram statt auf der Platte.
Edit: ansonsten kannst du mit Skip oder Take arbeiten.
int displayLines =3 ;
var FileContent = new List<string>(File.ReadAllLines(fileName));
var toDisplay = FileContent.Skip(FileContent.Count - displayLines ).ToList();
toDisplay.Reverse();
bla.toDisplay (x => Console.WriteLine(x));
Kein Anspruch auf Vollständigkeit oder Funktion. Ist nur runter getippelt. Sollte aus einer Datei alle Daten einlesen und nur die letzten 3 anzeigen beginnend mit der letzten. In deinem Fall sollten die Daten natürlich aus dem Ram kommen und nicht aus der gerade geschriebenen Datei.
PS: 5 Edits--- neuer Rekord. Ich geh Kaffee holen.
Ihhh, deutsche Version installiert?
Ja, das ist der Leistungsprofiler. Und dann den Performance Wizard verwenden (keine Ahnung, wie der auf deutsch heißt).
Dann kannst du dein Programm starten und nach dem Beenden so ziemlich alles analysieren, was du brauchst. In deinem Fall werden wohl die Methodenaufrufe interssnt sein.
Entweder Fuchst du dich da durch oder schaust mal hier für eine kleine Einführung
Einführung in die Leistungsprofilerstellung
Hier noch mal ausführlich (englisch)
Profiling in Visual Studio
Moin,
zu erst mal... Code aufräumen. Das ist ja ein Graus.
Kleiner Tip, wenn du immer nur jede zweite Spalte haben möchtest in deiner for Schleife, kannst du den Schleifenzähler auch gleich um 2 erhöhen statt im Code das abzufragen.
for (int cols = 6; cols < colCount; cols+=2)
Zu deinem Problem: Du benutzt warscheinlich das falsche Event. CellFormatting ist nicht wirklich dafür geeignet. Das ist nur für eine einzelne Zelle gedacht.
Wann willst du denn das aufrufen? Immer wenn ein neuer Preis eingegeben wird? Dann nimm lieber was wie CellEndEdit oder CellLeave
Nachtrag. Was für eine Version vom Visual Studio benutzt du denn? Bei der Community Edition vom VS2017 ist der Profiler mit an Board. Damit kannst du gut messen, wo es hängt.
Hiho,
lade doch mal aus dem NuGet Browser das HtmlAgilityPack. Ich habe es zwar noch nicht selbst benutzt, denke aber, dass es was für dich ist.
Grüße.
Ob das der richtige Weg ist? Scheint mir ein fragwürdiger Ansatz zu sein.
Speichere deine save.txt lieber an einem Ort ab, der für die Benutzer unterschiedlich ist ist. Zum Bsp im %Appdata%. Dort gehören solche Sachen auch hin.
Moin
du kannst auch einfach LINQ benutzen. Dann schrumpft das ganze zu einem Einzeiler
var count = kevin.where( x => x>=15 ).Count();
viel Text
EDIT: Zu lange geschrieben^^
Ich glaube du missverstehst den TE ein wenig. Er hatte wohl eher Fragen wofür der Typ "interface" gut sein soll.
Interfaces sind erst mal eine Vereinbarung, wie die Schnittstelle auszusehen hat. Funktionalität gibts dahinter keine.
Ich hab z.Bsp ein Interface um meine verschiedenen Netzteile anzusteuern
internal interface IPowerSupply{
void setVoltage(double value);
void setMaxCurrent(double value)
double getCurrent();
}
Damit kannst du deinem Programm garantieren, dass diese Methoden einer Klasse vorhanden sind. Wenn nicht, meckert der Compiler. Nun musst du das auch noch mit Leben füllen:
internal class Manson : IPowerSupply{
public void setVoltage(double value) => // was auch zu tun ist;
public void setMaxCurrent(double value) => // hier ist was anderes zu tun;
public double getCurrent() => return current;
}
nun kannst du in in deinem Programm das Netzteil von Manson ansprechen
IPowerSupply myPower = new Manson();
myPower.setVoltage(5.0);
Auf einmal geht dein Netzteil kaputt. Das ist aber kein Thema, du hast ja noch eins von Voltcraft da. Also wird das Interface erneut mit Leben gefüllt
internal class Manson : IPowerSupply{
public void setVoltage(double value) => // Voltcraft zeugs;
public void setMaxCurrent(double value) => // hier anderes Voltcraft zeugs;
public double getCurrent() => return current;
}
jetzt kannst du einfach in einer Zeile das Netzteil austauschen
IPowerSupply myPower = new Voltcraft();
Dadurch, dass du vorher ein Interface vereinbart hast, kannst du dir sicher sein, dass alle Methoden auch implementiert sind und du bekommst Compilerfehler wenn nicht.
Dabei ist IPowerSupply vom Typ erst mal nur eine abstrakte Vereinbarung. Also eher ohne genauen Typ. Du kannst auch keine direkte Instanz von IPowerSupply erstellen.
Hallo,
dazu habe ich zwei Fragen.
zeichnest du asschließlich in der OnPaint() und hast du die DoubleBuffered Eigenschaft gesetzt?
Grüße,
Ich bleibe auch mal bei einem gepflegtem..HÄ?
Die .Image Property deiner PictureBox enthält das Bild. Das kannst du dann separat abspeichern.
var ImageData = PictureBox1.Image;
ImageData.Save("mein_pfad_auf_der_Festplatte");
Hallo,
Über das .Image Property kommst du nicht an die Grafik ran?
Moin,
wenn du das wirklich so "game.exe < maze.dat" starten sollst, landen die Daten auf dem stdin stream.
von dort aus kannst du sie im Programm einfach mit
string fieldData = Console.In.ReadToEnd();
in deiner Variable speichern.
Klugscheißer 😉
Aber du hast ja recht. Mir ist beim schreiben schon aufgefallen, dass das Ganze ein wenig unglücklich formuliert ist. Mir ist nur nicht eingefallen, wie ichs besser schreiben kann.
Mein Fehler war überall das gleiche Event aufzurufen, denke mal das das den kompiler verwirrt hat.
Ja und nein. Der Compiler ist grundsätzlich nicht verwirrt.
du list ja in deinem Event den seriellen Port erst aus. Das machst du bei jedem Aufruf. Also ist der Buffer vom Port beim zweiten Aufruf des Events bereits leer und nichts kann gelesen werden.
SerialDataReceived += func1
SerialDataReceived += func2
ruft das Event zwei mal auf
Ist warscheinlich ein wenig spät aber ich muss es trozdem los werden^^
Lass einfach den Inhalt neu zeichnen und zwar ohne Tooltip "Fenster"
Grüße
Blödes Thema mit der Lokalisierung. Das klappt bei mir auch immer nicht.
Was bei mir geholfen hat war:
sich bei MS mit dem Account einloggen, dort die Sprache auf Englisch umstellen und dann den Installer herunter laden. Der installiert dann alles auf Englisch.
Vorher natürlich das VS komplett deinstallieren.
Guten Morgen,
Du erzeugtst eine Liste mit deinen Zellen.
also:
List<Cell> cellList = new List<CommonCell>();
und dann kannst du die Liste befüllen mit:
cellList.Add(new Zelle1);
cellList.Add(new Zelle2);
cellList.Add(new Zelle3);
cellList.Add(new Zelle4);
Dann kannst du mit foreach durch die Liste iterieren.
Moin, falls das irgend wen interessieren sollte^^
ich hab das jetzt über ein manuelles #define useDrawing gelöst. Das auszukommentieren geht immer noch schneller als die blöde referenz zum aus der Liste zu suchen und dem Projekt hintzuzufügen.
Vielen Dank für die vielen Anregungen.
#if Direktiven beziehen sich aber auf Code-Inhalte, nicht auf Assemblies.
Man kann mit Direktiven auch nur deklarieren, was kompiliert werden soll, nicht wie.
genau das hat mir ja auch vorgeschwebt. Den Kram einfach nicht kompilieren, wenn das Assembly nicht eingebunden ist 😃
Schade,
ich hatte gehooft, das man mit #if was machen könnte oder irgend eine andere Variante davon.
Nun gut. Dann werd ich die Klasse doch als zusätzliches Assembly bereitstellen.
Danke für die Infos
Klingt ziemlich abgefahren.
Kannst du kurz mal den Anwendungsfall schildern?
Sehe ich mal als Kompliment an 😃
Ich habe ein XML Dokument, welches mir etwas zum Ausdrucken beschreibt.
Das sieht z.Bsp. so aus
<object type="text" position="40,106" >
<font name="Calibri" size="5.9" style="Bold" />
<text>Hallo Welt</text>
</object>
Das wird geparst und dann über DrawString gezeichnet. Die Zeichenketten müssen natürlich in den entsprechenden Datentyp gewandelt werden. Das ist ja auch nicht mein Problem.
Die Klasse, welche die Daten parst ist über die Zeit gewachsen und ich möchte sie auch nur in einer Version weiter pflegen.
Ich habe aber nicht in jedem Project "System.Drawing" dabei und will das auch nicht unnötigerweise jedes mal hinzu fügen müssen. Daher will ich den Kram, der "Point" benutzt ohne Compilerfehler weghaben ohne tätig werden zu müssen.
@Cat
die Klasse wird über svn:externals eingebunden. Ich bin kein Fan von zu vielen Dlls in meinen bin Verzeichnissen
Hallo zusammen,
ich habe da eine Klasse die mir Strings in (fast) beliebige Datentypen umwandelt.
Das klappt erst mal wunderbar mit allen Typen, die eine Parse Methode mitbringen und zusätzlich mit Enums sowie Size und Point ( + die Floatvarianten).
So weit so geht.
Jetzt ist es aber so, dass Point und Size natürlich nach System.Draw verlangen. Das wird ja bei Konsolenanwendungen nicht automatisch als Refezenz eingebunden. Da ich aber keine Lust habe, das jedes mal von Hand zu machen und das dann eh nicht brauche.
Also lange Rede kurze Frage. Hat jemand eine Idee, wie ich dem Compiler beibringe, den entsprechenden Teil zu ignorieren, wenn das Assembly nicht geladen ist?
PS: Falls Code benötigt wird, kann ich ihn gerne reinstellen.
Moin,
LINQ sieht zwar schön aus (keinen falschen Eindruck gewinnen, ich benutze es gerne und häfig. Wie konnte ich früher nur ohne leben) dürfte in dem Fall aber nicht schneller sein, weil es ja auch über alle Daten iterieren muss. Warscheinlich liefert es auch nicht die letzten Dateien nach Datum sondern irgend was. Die Reichenfolge ist nicht bestimmt. Du müsstes die Dateien erst mal nach Datum sortieren.
Da hilft nur Profiling. Schau dir mal an, was da so lange dauert.
Eigentlich sollte GetFiles der Zeitfresser sein und nicht das Iterieren. 400.000 Dateien sind halt kein Pappenstiel. Das kann schnon mal eine Weile dauern.
Bei so einer großem Anzahl an Dateien solltest du dir ein paar gedanken über Indexing machen. Du kannst dir ja zum Beispiel einen kleinen Dienst schreiben, der die benötigten Daten in einer Datenbank ablegt (name, datum, seriennummer). Dieser Dienst kann ja immer im Hintergrund laufen und die Datenbank ständig aktualisieren.
Mit deinem Programm fragst du dann nur noch die Datenbank ab. Das geht dann schnell.
Auf der anderen Seite kannst du dir Überlegen, ob du wirklich alle 400.000 Dateien in einem Ordner haben musst. Ich hatte auch mal viele Daten in einem Ordner (so ca 6000 Verzeichnisse). Da hat dann schon der Explorer beim Anzeigen abgekackt. Ich habe dann angefangen, die Daten in "Jahresordner" zu verschieben. Damit kann man auch schon viel Übersicht erzeugen und die Suchmenge deutlich eingranzen.
Grüße,
EDIT: Schau mal bei DirectoryInfo nach EnumerateFiles. Da kannst du schon anfangen zu durchsuchen, bevor er fertig ist, das Array zu füllen. bei GetFiles musst du warten, bis es komplett ist.
https://msdn.microsoft.com/de-de/library/dd413232(v=vs.110).aspx
Schau mal bei den Hinweisen.
Moin wieder.
Das ist jetzt schon etwas OT.
Ich würde an deiner Stelle die Spielzeit separat handeln.
Zuzeit verwurschtelst du den Timer für das Bilderwechseln mit dem Timer für die Spielzeit.
Wenn du das vernünftig trennst, brauchst du keine Seiteneffekt befürchten, wenn du z.Bsp. möchtest, das die Zeit in der die Bilder wechseln immer kürzer wird (Schwierigkeitsgrad erhöhen und so^^).
Oh, okay
gib doch mal eine Statusmeldung aus, wenn in eine Box geklickt wird. Dann weißt du auch, dass das geht.
Ach, was passiert denn, wenn dein IntCount 15 erreicht (sollte der nicht eigentlich 45 sein).
Moin,
also erst einmal, dein Text erzeugt Chaos im Kopf.
Nur damit wir vom Gleichen schreiben.
Du hast deine 4 Picture Boxen und mit einem Klick in die Box willst du den Zeit verändern, mit dem die Bilder neu ausgewürfelt werden?
Du erzeugst das Timer Object local in einer Funktion. Es wird daher eigentlich nach Verlassen der Funktion glöscht. Bist du dir sicher, dass es mehr als einmal den Tick aufruft?
Wenn du die Zeit ändern willst musst du natürlich Timer.Intervall ändern.
Was macht eigentlich dein IntCount? Den Teil vom Code hast du nicht gepostet.
Hast du mal mit dem Debugger nachgeschaut (oder eine Ausgabe in deiner Textbox gesetzt), ob die Callback aufgerufen wird?
Kleiner Tip. Du kannst die PictureBoxen auch in ein Array packen. Dann kannst du dir deine If Orgie sparen
if (RndPos == 1)
{
pbSlot01.Image = (Image)Properties.Resources.ResourceManager.GetObject(iconName);
}
und gleich über den Index drauf zugreifen.
allPictureBoxes[RndPos].Image = blalblalbla
Hab bei mir z.B. einfach die Datenbank gelöscht (die unter ProgramData lag) und ein Fehler dieser eben mit Ende des Nutzungszeitraums quittiert - da hilft auch ein Zurückstellen der Uhr nicht mehr.
Schlechte Idee, wenn man jemanden dazu bringen will, das Programm nach Ende der Probephase zu kaufen 😃