Mcolli

//edit noch was eingefallen

Meiner Meinung nach, wie schon oben gesagt, geht die Aufgabenstellung aber eindeutig davon aus, dass man für ein konkretes n wissen will, wie viele Suchanfragen nötig sind damit die binäre Suche effizienter wird, trotz einmaligen Sortieren. Das hätte nämlich auch einen konkreten praktischen Nutzen beim Programmieren. Wenn man statt die Funktionsscharen mit n zu parametrisieren mit a parametrisiert, also das Problem von der andern Seite betrachtet, kann man Aussagen ala "Ab wievielen Mengenelementen lohnt sich für 10 Suchanfragen die binäre/lineare Suche" beantworten. Ich hab keine Ahnung welche Aussage man treffen möchte wenn man a und n als Variable betrachtet. Naja evtl meldet sich der Thredersteller ja noch mal. Zu min. ist es mal schön über Mathe auf vernünftigen Niveau zu diskutieren ohne dass jemand aus Desintresse auf Durchzug schaltet.

Moin moin, Es gibt 2 Möglichkeiten: 1. Das Debug-Atribut [serializable] der Klassen Deffinition voransetzten [Serializable] public class xxx { } Damit kansnt Du innerhalbt Deines Programm-Codes dieser Anwendung z.B. wie folgt diese Klasse "abspeichern" xxx meinObjekt = new xxx(); using (FileStream fs = File.Open("C:\test.xml", FileMode.OpenOrCreate)) { [INDENT] XmlSerializer ser = new XmlSerializer(typeof(xxx)); ser.Serialize(fs, meinObjekt ); [/INDENT] } und wie folgt wieder deserialisieren: using (FileStream fs = new FileStream("C:\test.xml", FileMode.Open, FileAccess.Read)) { [INDENT] XmlSerializer ser = new XmlSerializer(typeof(xxx)); xxx geladen = (xxx)ser.Deserialize(fs); [/INDENT] } Soweit ich weiss klappt das aber nur innerhalb des selben Projektes. Ich bevorzuge: 2. ISerializable in Deine Klasse Implementieren: Man erstellt ein Klassenbibilothek-Projekt das alle Klassendeffinition beinhaltet die man Serialisieren will enthält. Sowohl bei der Sende-Anwendung als auch der Empfangsanwendung wird die DLL dieses Projektes als Verweis referenziert. Damit ist der Sende- und Empfangsanwendung der Selber Code / Bauplan für alle zu serialisierenden Objekte bekannt. Ich habe schon mal ein Projekt dies bezüglich in dem Forum gepostet. Es dient als Beispiel und ist ---->hier <----- zu finden. Es ist nur eine DEMO d.h. es macht Schwachsinn und ist auch nicht sauber programmiert funktioniert aber wenn Du auf dem Testrechner schreibrechte auf C: hast. Unter Umständen ist bei der Sende-Anwendung ein anderer Dateipfad zum speichern der Objekt hinterlegt als bei der Empfangsanwendung..... ist easys zu finden.

Wenn man zwei funktionen in ein Koordinaten System eintragen will und beide Funktionen von einer Variablen abhängig sind ist das eh wurst. Deshalb habe ich ja auch versucht a und n in der Ungleichung zu trennen. Mal zurück zum Kern: 1. Dem Ersteller des Threads wurde von wem auch immer wie auch immer geholfen. 2. Dein Problem jetzt mit meiner Lösung zur Aufgabe (1.Post) habe ich nicht verstanden. (Statt f(a,n) und g(a,n) sollte man besser fn(a) und gn(a) schreiben da das mathematisch der Darstellung eine Funktionsschar gleicht aber das dauert ewig zu formatieren hier) Meine Idee: den Aufwand von linear mit binär Vergleichen Mein Vogehen: zwei Formeln aufstellen: f(a,n) und g(a,n). f(a,n) beschreibt den linearen Suchaufwand und g(a,n) beschreibt den binären Suchaufwand. Diese Formeln in eine Relationsätzen die zu der Frage passt "Ab welchem a und bei einem Konstanten n ist die binäre Suche besser". f(a,n) < g(a,n) Die daraus Resultierende Ungleichung nach a "umstellen" also a < g '(n). Die Formel kann die Frage aus der Aufgabenstellung für jedes n beantworten: Es dürfen maximal g '(n) Suchanfrage auf eine Menge mit n Elementen gestellt werden damit die lineare Suche effizienter ist. Was meinst Du ist Falsch? 1. Die Formeln zur Auwandsberechnung 2. Das Setzen der Realtion 3. Die Schlussfolgerung Zum Grenzwert: Es wäre sicher auch interessant aus mathematischer Sicht die Funtkionsscharen f(a,n) = a * n und g(a,n) = a * ld(n) + n * ld(n) zu untersuchen. Dies ist für die Aufgabe aber TOTAL irrelevant da sich die Frage der Aufgabenstellung darauf bezieht zwei einzelene Funktionen aus den Funtionsscharen zu vergleichen: In dem Moment in dem man sich die Frage stellt "soll ich so oder so suchen in der Menge M" suchen ist n bekannt und keine Variable mehr. Die Frage ist nicht "Um wieviele Elemente hätte meine Menge M größer sein müssen". Es werden aus beiden Scharen die n-ten Funktionen verglichen und nur a ist Variable. Die Mathematische Untersuchung anders wäre dann: existiert kein a für das gilt: für alle i element {N} gilt: fn(a + i) < gn(a + i) aber damit kannst Du nur sagen "ja/nein, so ein a gibt es (nicht) für dieses n" Meine Lösung gibt auch an wie groß dieses a sein muss. Das ist auch das was gefragt ist. Wenn der rechte Teil meiner umgeformenten Funktionsgleichung für alle n einen Funktionswert hat kann man sogar sagen, dass alle Mengen mit endlich vielen Elementen ab einem a besser binär Durchsucht werden. Besser kann ich das was ich meine jetzt echt nicht mehr erklären.

Beispiel: Es gibt 10000 Suchanfragen auf eine Menge mit 5 Elementen Also a = 10000 und n = 5. Somma jetzt binär oder linear Suchen. Wir nehmen meine Ungleichung a * n < ld(n) * (a+n) links: 10000 * 5 = 50000 rechts: ld(5) * 10005 = 23239,89.... --> linkeSeite > rechte Seite --> ungleichung nicht immer erfüllt. Wir sehen die Ungleichung ist NICHT immer erfüllt Du hast zwarch recht das beide Funktionen (sogar Streng) Monoton steigen aber d.h. NICHT, dass die Steigung wie bei der geraden "a * n" auch imemr Konstant ist. Du gehst schon gut mit dem "ersetzen" bei Ungleichung um. Ich schreib nachher noch mal mehr ich muss jetzt schnell weg. Nur soviel die rechte Seite ist im Kern eine logaritmische Funktion und diese Art von Funktionen steigen immer weniger irgendwann ist die steigung < a und dann wird der 2. Term (a+n) immer kleiner .... rechte Seite ableiten gucken ob streng monoton fallend.... Grenzwert gibts da auch für n -> unendlich

Tue ich nicht. Ich weiss aus der Aufgabenstellung, dass der Gesammtaufwand für EINE EINZIGE Lineare Suche "n" ist. Desweiteren weiss ich, dass der Gesammtaufwand für EINE EINZIGE binären Suche "Suchaufwand + Sortieraufwand" ist. In der Aufgabenstellung steht für die binäre Suche Suchaufwand = ld(n) Sortieraufwand = n * ld(n) -> "Suchaufwand + Sortieraufwand" = ld(n) + n * ld(n) Wenn man mehr als einmal sucht gilt "Mehrfache Suche = Suchanzahl * Gesammtaufwand". also: lineare "Mehrfache Suche" = a * n Für die binäre gehe ich bei 1. davon aus, dass NICHT neusortieren werden muss für jede Sucheanfrage aus a ... Warum ich das mache steht ganz unten: "Die Aufgabe wäre sonst schwachsinnig" --> binäre "Mehrfache Suche" = a * Suchaufwand + Sortieraufwand = a * ld(n) + n * ld(n) Die Frage lautet jetzt wann ist die lineare Mehrfachsuche der binären Mehrfachsuche überlgen. Also mathematisch Ausgedrückt Für welche a element {N}gilt a * n < a * ld(n) + n * ld(n) alles was ich danach mache nennt sich Mathematik.... zugegeben ich bin ein wenig eingerostet was das angeht aber ich habe nach den Regeln der Mathematik umgeformt. Bei deiner Zeile z.B. habe ich "ld(n)" ausgeklammert -> a * ld(n) + n * ld(n) = ld(n) * (a + n) dann immer weiter Umformen bis irgendwann etwas da steht wie a < f(n) mit f(n): {N} -> {R} Wenn man ein n hat kann man den Funktionswert bilden. WEnn die Anzahl der Suchanfragen kleiner ist als der Funktionswert ist die lineare Suche besser.

Hallo: ich habe mal die Lösung ausgerechnet für dich im folgenden gilt das "log2(n)" (<-zur Basis) zwei als "ld(n)" geschrieben wird und mit "log(n)" ist der Logarithmus zur Basis 10 gemeint!!! "a" steht für die Anzahl der Suchanfragen die bei der binären Suche keine Neusortierungen nach einmaliger Sortierung vorraussetzt. "n" steht für die Anzahl an Elementen in der zu durchsunden Menge. a,n sind Element der Natürlichen Zahlen und ungleich 0. Du hast für die Berechnung des Binären - Suchaufwandes ld(n) angegeben und für die Berechnung des Sortieraufwandes n*log(n). Damit hat mein 2 verschiede Logarithmenbases in der Gleichung und man muss transformieren, was die Lösung der gleichung meiner Meinung nich Hausaufgaben gerecht macht. Ich denke daher dass die Berechnung des Sortieraufwandes n*ld(n) Ich habe beides durchgerechnet: 1. Sortieraufwand n*ld(n) a * n < a * ld(n) + n * ld(n) = ld(n) * (a + n) <-> es gilt a + n > 0 (a * n) / (a + n) < ld(n) <-> Umkehren (a + n) / (a * n) > 1 / ld(n) <-> linke Seite in 2 Brüche teilen (a / a * n) + (n / a * n) > 1 / ld(n) <-> Kürzen (1 / n) + (1 / a) > 1 / ld(n) <-> 1 /n abzeiehn 1 / a > 1 / ld(n) - 1 /n <-> Rechte Seite Normieren 1 / a > (n - ld(n)) / ld(n) * n <-> Umkehren a < ld(n) * n / (n - ld(n)) Kosmetische Eingreife auf der rechten Seite evtl noch möglich 2. Sortieraufwand n*log(n) Ich hab eine Office Datei Angehängt in der das mit besserer formatierung gerechnet wird .... ist ein wenig komplexer und ein paar mehr Kniffe und Gefühl ist erforderlich. soviel sei aber gesagt je größer n wird desto besser trifft diese vereinfachung zu: Für a < log(n) ist approximal eine Lineare Suche im Worstcase effektiver. Zu der Frage wir das Nie schneller wenn immer Sortiert wird: a * n < a * (log(n) + n * log(n)) <-> es gilt a != 0 n < log(n) + log(n) * n da 1 <= log(n) für alle n Element N n < 1 + 1 * n < = log(n) + log(n) * n <-> n < n + 1 <= log(n) + log(n) * n also ist die Binäre Suche in dem Fall immer größer als n + 1 => immer einmal Langsamer Man kann a möglichst Großhalten und Gewehrleisten dass immer Sortiert ist wenn man sich merkt "ist n größer geworden" wenn ja vor der nächsten Suchanfrage einmal sortieren. Lösung.doc Lösung.odt

Die überprüfung findet zum COMPILE-Zeitpunkt statt....das ist dann wenn Du nen "Build" machst und ne Exe rauskriegst, zu min. wenn alles glatt geht. Die Überprüfung bezieht sich aber nur auf den Rechner auf dem auch der Build veranlasst wird. Damit ist in keinsterweise Sichergestellt, dass der Anwender-Rechner über die entsprechenden Assemblys verfügt. Du kannst Dir das relativ leicht klar machen, wenn Du versuchst für eine ATI Grafikkarte unter Windows XP das Catalyst Control Center zu installieren und auf dem Rechner gar kein .Net Framework 2.0 oder höher ist. Dann bricht der nämlich die Installation ab. D.h. in dem Fall wird die Tauglichkeit des Zielsystem mehr oder weniger im Installer überprüft. Grundsätzlich wird folgendermaßen vorgegangen wenn zur Laufzeit auf Programm-Externe-Assemblys zugegriffen wird: ES WIRD GANZ GENAU DAS ASSEMBLY GELADEN WAS BESCHRIEBENWORDEN IST. Es gibt keine 2 gleichen Assemblys auch wenn die Semantik die gleiche ist. Bei den Eigenschaften zu den Verweisen in Visual Studio (Verweis auswählen und Eigenschaftsfenster gucken) kann man Einfluss darauf nehmen, dass auch ein Assembly mit ner anderen GUID aber gleicher Namen und ggf. Versionsnummer pi pa po genommen werden darf. Soweit ich das in Erinnerung habe muss kein absoluter Pfad angegeben werden. Dann wird der GAC durchleuchtet, wenn da nix is in der Registry nachgeschaut und wenn da auch nix ist im Zweifel im Startordner der Anwendung was passendes gesucht. So kommen wir zu den Links: Evtl könnte Dir dasbei Deinem Problem weiterhelfen. Alle 3 Methoden da zielen darauf ab, dass das Assembly "vorhanden" sein wird. Die 3 Methode soltle interessant für dich sein. Da kannste mit dem AssemblyResolve-Ereignis praktisch einen Handler hinterlegen der für den CLR dann sicherstellen MUSS dass ein entsprechend gültiges Assembly zurückgegeben wird. Das ist aber als AUSNAHME gedacht, wenn das auf dem Entwicklungsrechner liegende genügende Assemby nicht zwangsläufig auf dem Zielrechner ist sondern evtl nur ein vergelichbares ("Visual Studio" muss ja wissen welche Methode es Dir zu einer Deiner Klassen z.B. nach drücken von "." anbieten kann). Da kannste also nicht Mini Maus zurück geben wenns Pluto nur im Micky Maus Assembly gibt. Und wenn Du Dich weiterbilden willst ist das auch ganz nett.

ne bessere Antwort als Gateways wirst Du nicht bekommen. Das Problem bei dynamischen Verweisen ist, dass ein Teil der typsicherheit flöten geht. Ein als Verweis referenziertes Assembly teilt dem Compiler u.a. mit welche Typen durch das Assambly möglich sind. Wenn Deine DLL z.B. die Klasse "meinNamespace.MeineKlasse" enthält kannst Du fortan Sachen in den Code reinschreiben wie using meinNamspace; ..... MeineKlasse toll = new MeineKlasse(); Ohne die using Direktive ist die Klasse im aktuellen Kontext nicht vorhanden. Ohne den Verweis auf die DLL kannst Du meinNamspace auch nicht in der Using Direktive verwenden .... Du kannst mehr oder weniger das Assembly wie oben beschrieben dynamisch zur Laufzeit und NICHT zum Compilezeitpunkt nachladen. Dann muss man aber auch mittels der Invoke Methode auf Member der zum Compilezeitpunkt unbekannten Klasse zugreifen: Assembly assem = Assembly. LoadFile("pfadAlsString"); Object meneInstanz = assem CreateInstance("MeineKlasse ", false, BindingFlags.ExactBinding, null, new Object[] { }, null, null); // InvokeMember ist statisch und in "Type" deffiniert. String meineKlasseStringProperty = (String) meineInstanz.GetType().InvokeMember("StringProperty", BindingFlags.GetProperty, null, meineInstanz, null); Assembly Klasse MSDN Type Klasse MSDN

Intelligenz-Test, wie die Zahlenreihen oder Katonsfalten oder Zahnraddrehung Ermitteln, kann man LERNEN. Einer der die Test gar nicht gemacht hat schneidet schlechter ab als Ihm es zu steht. Einer 100 Tests dieser Art gemacht hat schneidet besser ab als ihm es zu steht. Blöderweise bringen diese Tests dich nur bei der psychologischen Untersuchung beim Arbeitsamt und bei "Bewerbungstests" weiter. Stell Dir lieber mal die Frage (als Beispiel): wie gehst Du vor wenn ein Freund mit seinem kaputten PC bei Dir vorbei kommt ... Windows bootet nicht mehr. Wenn dein Vorgehen strukturiert ist und Du Fehlerquellen nach und nach ausschließen kannst, siehts schon gar nicht schlecht aus. (Also Einschalten gucken ob Bios den Code für "alles OK", also einen einfachen Beep, ausgibt. Wenn nicht Hardware Komponenten als Fehlerursache durch abschalten/austauschen/Probieren als Fehlerquelle ausschließen. Prüfen ob Bootload läd etc) Oder frage Dich ob , wenn die Aussage "Wenn es regnet ist die Straße nass" imemr zutrifft, im Umkehrschluss gilt "Da die Straße trocken ist hat es nicht geregnet" ... Weiss nicht jeder intuitiv aber man kann da auch Regeln erlernen und die sind sogar einfach. Programmieren ist auch leich zu erlenen .... Bücher find ich pers. ****e da die für Anfänger zu komplex sind .... am besten machste Dir nen Script aus ner 1. Semester Vorlesung von Angew. Informatik o.ä. klar ..... da wird auch davon ausgegangen dass der Student nur den PC anmachen und die Mausbewegen kann

Moin, ich hab auch eine Frage dazu: Meine Situation ist ähnlich, ich bin nur Studienabbrecher und habe schon knapp 3 Jahre als studentische Aushilfe gearbeitet. Die lange Praxiserfahrung und das theoretische Wissen aus der Uni führten dazu dass ich sehr gut Programmieren kann (Objektorientiert) und auch, teils durch meine pers. Neigungen, überhaupt kein Problem mit Mathe, Logik und ICs (Integrated Circuits also FlipFlop logische Schaltungen Transistoren Gatter etc) habe. Auf dem BWL Sektor z.B. habe ich große Schwächen. Meine Frage daher: wie wichtig ist BWL und was wird sonst noch im 1. Lehrjahr unterrichtet (Ich denke da an Betriebsstrukturen, meine Rechte als Azubi / Angestellter etv)

Gerade Noch eingefallen: Du kannst auf dem Server eine "Request.php" Seite erstellen die mittels Post den Ablage PFad der dazustellende Silverlight Seite akzeptiert: <html> <body> <object width="300" height="300" data="data:application/x-silverlight-2," type="application/x-silverlight-2" > <param name="source" value="<?php echo $_POST["XAPDatei"]; ?>"/> </object> </body> </html> Zu der Seite kannste dan Navigieren. Weiss nicht ob das 100% korrekt von der Syntax ich hasse htm und php. Aber sollte klar sein was gemeint is. Ich bin mir aber NICHT sicher ob das Webbrowser Steuerelemnt von Silverlight ÜBERHAUPT <object> Tags interpretiert, da man so ganz tolle Rekursionen rezugen kann.

Du kannst nicht zu einer xaml Page Navigieren. Silverlight musst Du Dir so vorstellen: 1. Benutzer steuert, voller freudiger Erwartung, Deine wunderbare Silverlight Seite an. 2. Server schickt eine art Ziparchiev (XAP-Datein) zum Benutzer. 3. Der Browser des Benutzers läd die XAP Datei runna und übergibt die Kontrolle darüber dem Silverlight Browser Plugin, welches wiederum die abgespeckte Version der CLR (Common Language Runtime) nutzt um den Code auszuführen. Die abgespeckte Version heisst "Core CLR". 4. Benutzer freut sich Das Silverlight Plugin erklärt dem Browser was er machen soll wenn er auf einer Interseite ein solches Tag vorfindet: <object width="300" height="300" data="data:application/x-silverlight-2," type="application/x-silverlight-2" > <param name="source" value="SilverlightApplication1.xap"/> </object> Der Browser macht das was ihm erklärt wurde (Xap runterladen, 300 * 300 Pixel zur Darstellung freiräumen, dem Plugin mitteilen "hier hast Du 300*300 Pixel Freiraum, da hast Du Deine Datei, mach was Du willst"). Du kannst diese XAP Datei auch manuell öffnen mittels Winrar o.ä. Dan wirst Du sehen, dass diese KEINE *.xaml Dateien enthält sondern nur DLLs, ein Manifest und ggf. Resourcen und ne XML-Configurationsdatei. Wenn Du eine XAML Datei auf deiner Interseite darstellen willst solltest Du den XMLViewer nutzen. Der "Code" in der geladenen XAML-Seite wird aber nur angezeigt und weder compliert noch interpretiert und schon mal gar nicht ausgeführt.

Du musst aufpassen dass Du nicht aus dem 64bit long range rausläufst: 1. long a=2^(k-1); 2. long b=2*a-1; der Größtmögliche wert für long ist "(2^63) -1" (s. Unten). --> k darf max. 64 sein Da aber bei 2. noch mit 2 Multipliziert wird darf a maximal "(2^63 - 1) / 2" sein da sonst b überläuft: "Richtig" wäre: k = k > 63 ? 63 : k; //k auf max 63 stellen da ja noch Multipliziert wird um b zu erechnen. // Potenziert darf maximal mit 62 werden da man unten ja noch mit 2 Multipliziert. Stichwort: 2^x * 2 = 2^(x+1) long a = 2^(k - 1) - 1 long b=2*a-1; Richtig in anführungszeichen da Du dann dir deine Random Zahl mit long n = RandomProvider.Next(a, ; holst. Ich schätze mal das a die untere und b die Obere Grenze abstecken sollen. Wenn dem so ist macht das meht Sinn: k = k > 63 ? 63 : k; //k darf jetzt maximal 64 sein da man ja nicht mehr mit 2 Multipliziert für das obere Intervall; long a = 2; long b = 2 *(k - 1) - 1; long n = RandomProvider.Next(a, ; [/code] Um den Aufwand beim folgenden Überprüfen ob Primzahl zu halbieren macht das noch sinn: [code] long n = n % 2 == 0 ? n - 1 : n; // n ungerade machen // n darf nicht kleiner als 2 werden (ja gerade Zahlen sind nicht mehr möglich) while (isCompositeFermat(n) && n > 3) { n=n-2; } return n; Sehr gut ist dass Du den Euklyd zur Prüfung benutzt. Wenn Du Die Primzahl aus dem Longbereich erstellt um einen RSA Schlüsselpaar mit 64 Bit zu bilden bedenke das der 64bit Schlüssel nicht 64 bit heisst weil er aus 2 64Bit Primzahlen zusammengesatzt wurde sondern weil der gemeinsame Teile der Schlüsselpaare, der durch Multiplikation 2er Primzahlen gebildet wird, 64Bit lang ist.... Warum 2 ^ (Stellen -1) - 1 als gröten Wert: Long wird, wie int, in der 2er komplimentär Darstellung ausgedrückt ... das heisst, dass das "höchstwertige" Bit (also das mit dem index 63) als negativ interpretiert wird. Der Rest (also Indizies 0-62) als Positive Zahl interpretiert werden und das zu dem Wert des negativen Anteils addiert werden. Wenn man das mit 4 Bit mal verdeutlicht: Zahl: 1 | 0 | 1 | 0 Index: 3 | 2 | 1 | 0 Bit-Wert: -(1*2^3)= -8 | (0*2^0)=0 | (1*2^1)=2 | (0*2^2)=0 Gesammt: -8 + 0 + 2 + 0 = -6 Größte Zahl Wäre: 0111 --> -0 + 1 + 2 + 4 = 7 = 2 ^3 - 1 Kleinster Wert: 1 000 -->-8 + 0 + 0 + 0 = -8 = -2^3

Moin Moin, du solltest Dir evtl mal den Artikel durchlesen und die Klasse dort runterladen. GlobalKeyHooker Ich bin bei der Freundin und die hat keine IDE (ist "Geiste(r/s)"-Wissenschaftlerin). Ich weiss daher nicht ob die Klasse da auch bei nich aktivem Fenster Loggt.

Wollte an der Stelle mal den Tipp geben für Datenbankverbindungen den Data Access Aplication Block der Microsoft Enterprise Library, eine .Net Erweiterung, zu nutzen. Die Enterprise Library ist KOSTENLOS auch für komerzielle zwecke. Dies bietet die Möglichkeit auf hoher Abstraktionsebene auf Datenbanken aller Art zuzugreifen, dies beinhaltet auch Access, Oracle und co. Zudem lassen sich durch eine Erweiterung der App.config, Connection Strings registrieren und man muss somit bei einer Veränderung der Datenbank-IP / - Version / -Art oder so das Projekt nicht neu Compelieren und Ausrollen. Die Syntax ist zudem sehr intuitiv und einfach. Alle in einem Projekt eingebundenen Enterprise Library DLLs werden ins Ausgabeverzeichnis des Projektes kopiert und somit ist bei der Auslieferung eines Projektes keine zusätzliche Installation der Enterprise Library auf den Client Rechnern nötigt. Des weiteren sind in der Enterprise Library verschiedene Andere Application Block Vorhanden die z.B. ein App.config gesteuertes Logging in allen Möglichen Formen ermöglicht oder die App.config oder andere Programmteile leich Verschlüsselbar machen. Get Startet with the Data Access Application Block

So lasset mich den Umstand eurer Konfusität erleutern oh holder Knappe: DEm Property "QuestItemName" deiner (scheinbar) neuen Instanz "qu" wurde noch NIE etwas zugewiesen ... somit ist das mit Null belegt, was wieder rum dazu führt, dass die von Object geerbte Methode "GetType()" nicht aufgerufen werden kann (sowas wie null.GetType() geht NICHT). Der korrekte Auruf der Methode getVar wäre daher: qu.QuestItemName = (string)getVar("QuestItemName", typeof(string), @"C:\Desktop\safe.xml"); Ich vermute aber einen starkes Design Problem in deiner Anwendung, da ich davon ausgehe, dass "qu" sowas wie eine Quest in einem Rollenspiel darstellt und es somit aber witzig viele Instanzen dafür geben wird. Du würdest mit einer Implementierung von ISerializeable bei der Klasse "Quest" oder so besser fahrn. Ich habe im Mom eh wenig zu tun und bin überaus edel vom Gemüt . Wenn Du magst kannste dein Project mal zippen und bei Rapidshare Uppen, mir den Link und das pw für das archiv dann per PN zu kommen lassen und ich bau Dir deine Klasse so um dass Du ganz Easy Quest laden und speichern kannst, ich würde Dir auch nen Questmanager bauen damit das ganze noch einfacher von der Handhabung ist ..... dauert auch nicht lange

Also fehler gefunden: Wenn der Parameter varValue die Belegung null hat tritt der fehler auf. Die Frage ist in wie fern es sinn voll ist das abzuspeichern. Wenn Du das machen willst dann musst Du Folgendes ändern: Methode: saveVar(...) Nach dem code: // Prüfen ob der Ordner bereits existiert / wenn nicht anlegen if (!System.IO.Directory.Exists(pfadOrdner)) { System.IO.Directory.CreateDirectory(pfadOrdner); } folgendes einfügen: if (varValue == null) { varValue = "@!null!@"; } Methode getVar(...) diesen Teilcode else if (varType == typeof(string)) { return varNode.InnerText; } durch diesen ERSETZEN: else if (varType == typeof(string)) { if (varNode.InnerText.Equals("@!null!@") ) { return null; } return varNode.InnerText; } Ich habe den String "@!null!@" als interpretation für null gewählt, da so ein String mit dem inhalt "null" auch richtig als String wieder zurückgegeben wird und nicht als null im Sinne von nix.

Also der Fehler kann nur vor der try Anweisung oder im catch-block auftreten. Die Belegung der Parameter wäre gut zu wissen. Zum Debuggen: Setz mal ne Halte-Marke an den Anfang der Methode (Dann ist die Zeile Rot Markeirt und ein roter Punkt ist da wo die Zeilen nummer steht). Dann führste das Programm aus drückst Deinen Knopf da und der hält an der halte Marke... mit f10 und f11 kannste dann einzel bzw. Prozedurschritte machen. Und dann schreib mal die Anweisung auf die zum der Exception führt. Zu sätzlich wäre die XML Datei die evtl erzeugt wurde nett.... Ich konnte jetzt kein Szenario nachbauen die zu dem Fehler führt. Einzige Fehler den ich erzuegen konnte war eine ArguementOutOfRange-Exception bei der Angabe eines Dateinamens statt eines Dateipfades für die XML_Datei.

naja aber auch ********ener .... Du musst halt die Variablen in der richtigen reihen folge ablegen und auslesen. mein Code kann dir auch eine bestimmte Variable raus holen egal welchen Typs und an welcher stelle. die readInt Methode da macht auch nix anders als eine Zeile zu lesen und dann nach int zu Convertieren : Text datei: 3 Hallo auslsen Stream reader = new StreamReader(..........) int a = Convert.ToInt32(reader.ReadLine()); string b = reader.ReadLine();

Raus Kopieren und Einfügen hier mal ne Test main Methode: // Variable zum speichern int bubble = 255; // Variable speichern saveVar("Bubble", bubble, @"C:\TestXML\var.xml"); // Wert neu setzen bubble = 0; // Alten wert wieder holen bubble = (int)getVar("Bubble", bubble.GetType(), @"C:\TestXML\var.xml"); // nochmla neu setzten bubble = 5; // neuen wert speichern (hier wird der alte wert überschrieben da ja schon mal gespeichert wurde saveVar("Bubble", bubble, @"C:\TestXML\var.xml"); // speichern einer Variable gleichen namens aber andern Typs String bubbleString = "Inhalt jetzt hier"; saveVar("bubbleString", bubbleString, @"C:\TestXML\var.xml"); bubbleString = ""; bubbleString = (String)getVar("bubbleString", bubbleString.GetType(), @"C:\TestXML\var.xml"); // Expception da Variable nicht vorhanden (case sensitiv) bubbleString = (String)getVar("buBBleString", bubbleString.GetType(), @"C:\TestXML\var.xml"); Schau Dir auch mal die XML Datei an die Du erzeugst (z.b. im Notepad oder Visual Studio oder so). Der Code von mir soltle recht robust sein ....

Also ich schreib hier nochmal passgerecht die beiden Methoden, die ich bereits oben gepostet habe hin. Diese klappen 100% ... Wenn Du einzelene Code Passagen nicht verstehst frag dann bitte konkret nach. Grundsätzlich ist das aber sein triviales Problem was Du hast und die bereits von andern oder auch mir geposteten Lösung sollten alle mal reichen. Nichts desto trotz: /// <summary> /// Speichert die angebene Variable in einer XMLDatei. Ist die XML Datei bereits vorhanden /// wird der Variable dort hinzugefügt bzw. wenn schon vorhanden der Wert ersetzt. /// </summary> /// <param name="varName"></param> /// <param name="varValue"></param> /// <param name="?"></param> private static void saveVar(string varName, object varValue, string pathXML) { String pfadOrdner = pathXML.Substring(0, pathXML.LastIndexOf(@"\")); // Prüfen ob der Ordner bereits existiert / wenn nicht anlegen if (!System.IO.Directory.Exists(pfadOrdner)) { System.IO.Directory.CreateDirectory(pfadOrdner); } System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); try { using (System.IO.FileStream fs = new System.IO.FileStream(pathXML, FileMode.Open, FileAccess.ReadWrite)) { doc.Load(fs); System.Xml.XmlNode root = doc.FirstChild; bool ersetzt = false; // Nachschauen ob eine Variable mit dem Namen schon gespeichert ist. foreach (System.Xml.XmlNode varNode in root.ChildNodes) { if (varNode.Name.Equals(varName)) { // Wenn eine Variable mit dem Namen der abzuspeichernden Variable bereits existiert // muss überprüft werden ob auch der angegebene Typ der Variablen übereinstimmt. foreach (System.Xml.XmlAttribute varType in varNode.Attributes) { if (varType.Name.Equals("Type") && varType.InnerText.Equals(varValue.GetType().ToString())) { // Wenn Typ und Name der in der XML Datei bereits gerspeicherten variablen übereinstimmt // wird der Wert geändert und markiert das eine änderung vorgenommen wurde varNode.InnerText = varValue.ToString(); ersetzt = true; } } } } // Wenn nix in der XML Datei ersetzt wurde wird ein neuer Node erzeugt. if (!ersetzt) { System.Xml.XmlNode node = doc.CreateElement(varName); System.Xml.XmlAttribute type = doc.CreateAttribute("Type"); type.InnerText = varValue.GetType().ToString(); node.Attributes.Append(type); node.InnerText = varValue.ToString(); root.AppendChild(node); } } File.Delete(pathXML); doc.Save(pathXML); } // Wenn der versuch das Document zu öffnen fehlschlug wird ein neues erzeugt. catch { // Erzeugen eines neuen Documentes (öffnen würde an der Stelle auch gehen doc = new System.Xml.XmlDocument(); doc.CreateXmlDeclaration("1.0", "UTF-8", "yes"); System.Xml.XmlNode root = doc.CreateElement("root"); doc.AppendChild(root); System.Xml.XmlNode node = doc.CreateElement(varName); System.Xml.XmlAttribute type = doc.CreateAttribute("Type"); type.InnerText = varValue.GetType().ToString(); node.Attributes.Append(type); node.InnerText = varValue.ToString(); root.AppendChild(node); doc.Save(pathXML); } } /// <summary> /// Sucht in der angegeben XML Datei nach der entsprechenden Variablen. Die Suche ist /// Typ und Namen genau. Wenn nix gefunden wird gibts ne Arguemnt exception /// </summary> /// <param name="varName">Name der Variablen</param> /// <param name="varType">Type der Variablen</param> /// <param name="pathXML">XML Datei wo die Variable mutmaßlich gespeichert ist</param> /// <returns>Die ausgelsene Variable</returns> private static object getVar(string varName, Type varType, string pathXML) { System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); using (System.IO.FileStream fs = new System.IO.FileStream(pathXML, FileMode.Open, FileAccess.Read)) { doc.Load(fs); System.Xml.XmlNode root = doc.FirstChild; // Nachschauen ob eine Variable mit dem Namen gespeichert ist. foreach (System.Xml.XmlNode varNode in root.ChildNodes) { if (varNode.Name.Equals(varName)) { // Wenn eine Variable mit dem Namen existiert // muss überprüft werden ob auch der angegebene Typ der Variablen übereinstimmt. foreach (System.Xml.XmlAttribute typeAttribute in varNode.Attributes) { if (typeAttribute.Name.Equals("Type") && typeAttribute.InnerText.Equals(varType.ToString())) { // Unschön aber einfach man könnte auch mittels der Activator Klasse // an der stelle das ganze dynamisch erzeugen aber da raucht Dir der Kopf ab if (varType == typeof(int)) { return Convert.ToInt32(varNode.InnerText); } else if (varType == typeof(string)) { return varNode.InnerText; } else if (varType == typeof(double)) { return Convert.ToDouble(varNode.InnerText); } else if (varType == typeof(decimal)) { return Convert.ToDecimal(varNode.InnerText); } else if (varType == typeof(DateTime)) { return Convert.ToDateTime(varNode.InnerText); } // Weitere Type Converts musste selber machen Wenn Du eigene Komplexe Klassen // als Variablen hast die du abspeichern willst kommst du um eine // serialisierung nicht drum rum!!!!ELF } } } } } throw new ArgumentException("Variable nicht gefunden"); }

naja eine XML ist eine spezielle Text-Datei..... der Metagehalt meiner Aussage war "nicht in irgendeiner Textdatei". Eine XML Datei mag ja auch z.B. utf-8 Codiert sein, aber dennoch gibt es für XML bestimmte Konventionen die es ermöglichen eine XML-Datei strukturiert auszulesen.

Ich würde dringend empfehlen das nicht in einer Textdatei zu machen sondern in einer XML Datei. Nichts desto trotz habe ich für beide Fälle dir einen Sample Code geschrieben der in form einer txt Datei beiliegt .... ja ich bin zu faul die einrückungen hier zu machen Bei der Methode die das schreiben von Variablen in eine XML Datei verdeutlicht fehlt das Lesen dieser erzeugten Datei .... aber das kriegste schon hin ist voll einfach..... das Lesen der Variablen ist auch der Grund für die Empfehlung das in einer XML Datei zu machen .... Du kannst die XML Tags, die den Namen der Variablen als Namen und den Wert der Variablen als InnerText beinhalten , mit Atributen versehebn die aufschluss über den Typ der Variable geben Wenn Du die Daten Serialisieren willst habe ich unter dem Post hier einen tollen Sample Code gepostet der das verdeutlicht .... Aber Du musst halt eine Sammelklasse erezguen in der Variablen gespeichert wetrden und die dann von ISerializeable erben lassen .... FileOutput.txt

das kannst Du Mittels den Klassen DirectoryInfo und FileInfo machen: Die Methode GetFiles der Klasse DirectoryInfo liefert dir alle FileInfos. Das Property Name "nur" den Namen der Datei. Zur weiteren verarbeitung der FileInfos kannst Du dann zusätzlich mittels des Properties FullName auf den vollqualifizierten Pfad zugreifen.