Funktioniert leider nicht.

Ich glaube auch nicht daran, dass es sich um ein Problem handelt, den SQL Server zu finden. Ich hab weil ich mir da nicht mehr sicher war mal aus dem Backslash einen Forwardslash gemacht, da kommt der Fehler, dass er den SQL Server nicht finden kann. Mit dem G63W26 sollte auch kein Problem darstellen, das ist der Netzwerkname des Servers, unter dem man den i.e. im Explorer auch findet.

Kann es vorkommen, dass es an mangelnden Rechten liegt? Ich hab bisher nicht die Gelegenheit bekommen die ganze Sache als Administrator zu testen, und das fertige Programm sollte ja auch keine Administratorberechtigungen brauchen nur um eine Datenbankverbindung herzustellen, aber ich sag mal, damit kenne ich mich am wenigsten aus und vermute deswegen, dass es irgendwas in die Richtung ist.

Ping hab ich nicht probiert, aber die Verbindung vom Management Studio klappt ja.

Der verwendete Connectionstring ist "Data Source=G63W26\SQLSERVER;Initial Catalog=Dokumentation;Integrated Security=True" und ist mit dem ConnectionStringBuilder zusammengebaut, sollte also keine grammatischen Fehlerchen wie vergessenes Semikolon oder so aufweisen.

verwendetes Datenbanksystem: MS SQL Server 2005 Express

Hallo zusammen,

ich bekomme ein Problem bei einer Verbindung zum SQL Server Express. Timeout sei abgelaufen. Das an sich wäre ja noch nicht komisch, aber die Verbindung vom Management Studio aus klappt einwandfrei, während die Verbindung vom eigenen Programm immer am Timeout scheitert.

Das System befindet sich in einem Firmennetzwerk hinter einer Firewall, wobei auf jedem Rechner nochmal eine Client-Firewall drauf ist, die aber per Richtlinie auf Durchzug geschalten ist (Ports sind offen), beim Server selbst sind die Ports 1433 und 1434 auch auf. Wobei, wenn es wirklich an der Firewall liegen würde, dann würde ja erst gar keine TCP/IP-Verbindung zustande kommen?!?

Der Server ist Windows 7, der Client ist XP, falls das jemandem was nützt.

Vielen Dank schonmal

Georg

Hallo impact,

GPL bedeutet, du darfst dein programm selbst auch nur unter die GPL-Lizenz stellen (also schon auch verkaufen, aber die Käufer dürfen das weiterverkaufen oder verschenken, Lizenzgebühren sind nicht erlaubt), während du bei Bibliotheken unter LGPL deine eigene Lizenz behalten darfst, wenn du die Bibliothek nur benutzt (wie zB SharpZipLib). Wenn du aber zB SharpZipLib anpasst, dann musst du die angepasste Version unter LGPL veröffentlichen und kannst sie dann erst in deinem Programm verwenden.

Sprich die freie Komponente muss unter LGPL stehen, GPL geht nicht.

Viele Grüße

Georg

Hallo zusammen,

ich habe eine Gui, die vom Prizip her so aufgebaut ist oben Menüleiste, in der Mitte der Hauptcontent, unten ein Expander, der nach Wunsch Zusatzinformationen anzeigt. Nun will ich, dass man die Höhe des Bereichs mit Zusatzinformationen frei einstellen kann, ansonsten soll die verfügbare Höhe halt mit dem Hauptcontent voll ausgeschöpft werden.

Schön und gut, wäre das da unten kein Expander, sondern ein Element, dessen Höhe nicht von seinem Zustand abhängt, dann würde man einfach ein Grid benutzen können, so hab ich im Moment den Inhalt des Expanders auf eine konstante Höhe gesetzt und benutz ein DockPanel.

<DockPanel>
  <Menu DockPanel.Dock="Top" />
  <Expander DockPanel.Dock="Bottom">
     <TabControl Height="100">
  </Expander>
  <!-- Main Content -->
  <Grid />
</DockPanel>

Was mir jetzt aber an der Lösung nicht gefällt, ist das die Höhe des Expanders, wenn er ausgeklappt ist, nicht mehr vom Benutzer eingestellt werden kann. Ich will schon, dass die Höhe des Expanders "von außen" festgelegt wird (also nicht durch den Platzbedarf der darin enthaltenen Elemente), aber dieser Platz soll durch eine Art GridSplitter einstellbar sein können.

Wie kann man das am besten machen?

Viele Grüße und Danke im Voraus

Georg

Hm, wenn schon xkcd, dann darf Faust 2.0 nicht fehlen:

Also ich gehöre auch zu der Fraktion, die mit VS 2010 arbeiten, und bis jetzt ist mir das so gut wie nie abgestürzt. Ich benutze es aber komplett ohne jedwedes Plugin, insbesondere ohne Resharper. Aber es ist im Vergleich zu VS 2008 (was parallel auch noch drauf ist) schon langsamer, gerade der Programmstart.

Und es gibt einen lustigen Bug, weil der Tooltip indem der Pfad der zu ladenden Solution erst ewig spät und auch nicht bei Umschalten auf andere Programme verschwindet.

OK, hab die Lösung: Man kommt wie's aussieht wohl nicht darum herum den DataTemplateSelector neu zu setzen, das ist dann aber mit

DataTemplateSelector s = ctrl.ContentTemplateSelector;
ctrl.ContentTemplateSelector = null;
ctrl.ContentTemplateSelector = s;

auch recht schnell getan 😃

Wenn du jetzt aber tatsächlich unterschiedliche Templates benutzen willst, die sich in mehr als nur der Farbe unterscheiden: Du kannst als Key der DataTemplates auch ein Type-Objekt angeben:

<DataTemplate Key="{x:Type local:RealtimeMessage}">
...
</DataTemplate>

und dann sieht der TemplateSelector ziemlich einfach aus:

public override System.Windows.DataTemplate SelectTemplate(object item, System.Windows.DependencyObject container)
        {
            if (item == null) return null;
            return resources[item.GetType()] as DataTemplate;
        }

Funktioniert prima.

Georg

Hallo,

ich habe einen TemplateSelector, der in Abhängigkeit der Anwendungseinstellungen aus verschiedenen ResourceDictionarys die DataTemplates rausholt. Das funktioniert an sich auch ziemlich gut, das Problem dabei ist, wenn die Anwendungseinstellungen zur Laufzeit geändert werden, so dass der TemplateSelector eigentlich ein anderes Template nutzen würde, dann aktualisieren sich deswegen die Steuerelemente (in meinem Fall ist das nur eins), die die alten Templates geladen haben, halt nicht.

Ich habe jetzt schonmal versucht, ApplyTemplate aufzurufen oder den DataContext vorrübergehend auf null zu setzen, leider führt das aber nicht zum Erfolg. Sobald ich aber einen komplett anderen DataContext festlege wird bereits das richtige Template genutzt, auch wenn ich danach dann wieder den richtigen Context setze funktioniert es auch, nur will ich halt eigentlich eine Möglichkeit ihm sofort sagen zu können, dass das Template, was er sich da vom TemplateSelector geholt hat, nicht mehr aktuell ist und er sich ein neues holen soll.

Schonmal Danke

Georg

RowsRemoved tritt erst auf, nachdem die Row entfernt wurde, probier mal den Editiermodus zu verlassen bevor die Row entfernt wird, beispielsweise mit UserDeletingRow.

Hallo zusammen,

ich hab ein Problem beim Binden einer GridViewColumn. Ich hab die GridViewColumn per DisplayMemberBinding an diesen einen Teil des ViewModels gebunden und will diesen Inhalt jetzt per TemplateSelector anzeigen lassen. Bis auf das "per TemplateSelector anzeigen lassen" funktioniert das auch ganz gut, aber irgendwie finde ich die Stelle nicht, wo ich den TemplateSelector eintragen muss, weil CellTemplateSelector in der Spalte selbst oder ItemTemplateSelector in der ListView sind es nicht.

Bei mir kommt noch dazu, dass ich nicht mit XAML arbeiten kann, weil die Spalte erst zur Laufzeit erzeugt werden kann. Oder hat jemand sonst eine Idee, wie man ein ViewModel mit der Struktur einer DataTable (deren Spalten zur Compilezeit nicht bekannt sind!) an eine ListView binden kann?

Gruß

Georg

Funktioniert. Der TemplateSelector, der einfach nach dem entsprechenden Typ sucht ist auch wirklich sehr kurz (wenn die DataTemplates wie in meinem Beispiel alle in den Anwendungsresourcen lagern):

public override DataTemplate SelectTemplate(object item, System.Windows.DependencyObject container)
        {
            if (item == null) return null;
            return App.Current.Resources[item.GetType()] as DataTemplate;
        }

OK, hatte gedacht/gehofft er würde das Template automatisch anhand der Typen zuordnen können, wenn ich als Key die jeweiligen Typen verwende. Naja. TemplateSelector schreiben ist ja auch nicht so der Aufwand. Aber Danke für den Hinweis

Hallo zusammen,

ich hab leider nichts dazu gefunden, aber ist es möglich ein DataTemplate auch außerhalb eines Selectors oder einer Liste zu benutzen? Also ich bekomme ein (einzelnes) Objekt rein, was einen von mehreren Typen haben kann. Jetzt war mein Plan eben für jeden möglichen Typen ein DataTemplate zu erstellen, die alle mit den entsprechenden Typen als Schlüssel in die Resourcen zu schieben und dann aus den Objekten irgendwie die Visuals nach den Vorlagen der DataTemplates an einer bestimmten Stelle einzufügen. Naiver Weise hab ich's mit einem ContentPresenter versucht in der Hoffnung, dass der wenn es ein passendes DataTemplate gibt, auf dieses auch zurückgreifen würde, aber das hat er leider nicht getan.

Oder gibt es dazu eine bessere Möglichkeit?

Georg

Nagut, dem Räuber könnte man auch einfach entgegnen "Nagut, dann wähle ich Leben". Der Spruch des Räubers müsste ja eigentlich eher so etwas sein wie "Geld her oder ich erschiesse Sie!". Wobei der Räuber erst bei "Entweder Geld her oder ich erschiesse Sie" ernsthaft Probleme kriegen würde. 😃

Hm, die sehr unelegante, aber einfache Lösung ist der new-Operator (Das ist mal eine einigermaßen sinnvolle Einsatzmöglichkeit). Problem daran ist nur, dass der gegen jede OOP-Prinzipien verstößt, aber wenn dich das nicht weiter stört ist das OK. Also mach einfach eine private Eigenschaft drüber, das blendet die Eigenschaft der Oberklasse aus.

Jetzt zu den eleganteren Varianten.
Wenn du Glück hast, dann ist die Eigenschaft virtuell und du kannst sie überschreiben und ihr ein BrowsableAttribut verpassen.
Wenn du kein Glück hast, dann ist es fast noch das beste in der Klasse ICustomTypeDescriptor zu implementieren. Ich persönlich finde diese Lösung aber semantisch unschön, weswegen ich dann schon doch fast die unelegante Variante von oben vorziehen würde, aber diese Lösung wäre zumindest vielleicht noch verträglich mit den OOP-Prinzipien.

Naja, ich würde es weniger von der Größe der Anwendung abhängig machen als vielmehr von der Häufigkeit der zu erwartenden Aktualisierungen. Wenn eine Anwendung nur ein- zweimal im Jahr aktualisiert werden muss, dann darf der Deploymentaufwand auchmal etwas höher sein. Wenn du jetzt was hast, was sich quasi täglich ändern kann dann Webanwendung. Der andere Punkt ist dann noch der mit den Betriebssystemen, wenn du garantieren kannst, dass aus deiner Zielgruppe alle Windows mit installiertem .NET Framework haben dann geht auch mal was clientseitiges.

Für mich gilt die Faustregel wenn nichts gegen Client spricht, dann Clientsoftware (und Deployment zB über ClickOnce), weil Clients i.d.R. einfacher zu programmieren und gleichzeitig mächtiger sind. Ansonsten halt Web.

Ich glaube ich benutze meistens die kleingeschriebene Variante. Ganz sicher bin ich mir da nicht, kommt so ein bisschen auf die Gefühlslage drauf an. Ich seh da kein Problem darin das auch innerhalb eines Quelltextes mal so und mal so zu machen.

Ganz ehrlich gesagt wird mir bei einigen Antworten, die ich hier jetzt gelesen habe schlecht. Ich hab jetzt keinen Bock irgendwelche Zitate rauszusuchen und damit Einzelne runter zu machen, aber Einiges geht in die Richtung zu begründen, warum Menschen, die in irgendeiner Form einen Gottesglauben haben ja schon mal prinzipiell mehr oder weniger behämmert sein müssen, weil sie es ja nicht einsehen, dass das ja gar nicht sein kann.

Das nennt man dann Religionsfreiheit? Na ich weiß ja nicht. Meiner Meinung nach ist das nur wenig besser als das, was die Kirche im Mittelalter im Mittelalter verbrochen hat. Bei der Diskussion ob eine atheistische Buskampagne jetzt gerechtfertigt ist gleich den Sinn der Kirche infrage zu stellen und deren Anhänger teilweise hämisch zu denunzieren, das muss einfach nicht sein.

Ich persönlich finde die Kampagne, naja, auf der einen Seite irgendwo überflüssig, weil ich einfach nicht das Problem sehe, dass man als Atheist in Deutschland auf irgendeine Art von Unverständnis stößt, dafür gibt es in Deutschland einfach zu viele Atheisten, als das da eine Ablehnung noch irgendwie tragbar wäre. Auf der anderen Seite ist es halt einfach eine Missionierungskampagne, nur eben mal für "die andere Seite" (korrekterweise müsste man eigentlich sagen für eine andere Seite). Mich persönlich freut es jetzt nicht unbedingt, wenn ich eine weltanschauliche Sicht auf einem Bus sehe, mit der ich mich nicht idendifizieren kann.

Aber das ist wieder so eine Sache, wie man das sieht. In England war die Kampagne wie ich das verstanden hab so gemeint, dass sie sich zum Ziel gesetzt hat eine öffentliche Debatte auszulösen, um eine öffentliche Akzeptanz des Atheismus zu erreichen und irgendwo einen Gegenpol zu religiös motivierter Werbung zu schaffen. In Deutschland verfehlt das meiner Meinung nach einfach das Ziel, wie gesagt, ich meine Atheismus ist hier einfach allgemein akzeptiert und einen Gegenpol zu religiös motivierter Werbung muss man hier auch nicht schaffen, weil es nicht wirklich welche gibt. Die einzige Werbung der Kirche, die ich in letzter Zeit gesehen hab war für "Brot für die Welt", aber das ist keine weltanschauliche Werbung. Ich meine, wenn sie wollen und Leute finden, die das finanzieren (die scheint es ja zu geben), dann sollen sie es halt tun. Bis zu einem gewissen Grad ist das OK.

Es ist halt irgendwo die Frage, inwieweit Religionsfreiheit es zulässt sich in die Religionsfreiheit anderer einzumischen. Gar nicht ist da zu weit gegriffen, weil das würde eine Tabuisierung von Religion bedeuten und das ist nicht der Sinn der Sache. Es gibt Grenzen, aber die sind für mich bei irgendwelcher Buswerbung noch nicht erreicht. Wenn mich dagegen irgendein Zeuge Jehovas anquatscht oder Hausbesuche macht, dann ist die Grenze dagegen schon leicht überschritten.

Also können Typen in C# niemals privat sein.

Stimmt nicht. Können sie. Macht aber nur bei Nested Classes überhaupt Sinn, dann allerdings hat der Compiler auch nichts dagegen. Folgendes kompiliert bei mir (VS08) auch problemlos:

namespace Test
{
    public class BaseClass
    {

        private SubClass2 sc = new SubClass2();

        private abstract class SubClass1
        {
        }

        private class SubClass2 : SubClass1
        {
        }
    }
}

Also sind private Klassen möglich - auch abstrakte, aber eben nur nested.

Im Gegenteil, auch CodeCompletion freut sich über Namensgebung á la ThumbNailPictureBox, weil man dann unabhängig von nachträglichen Änderungen ist, weil dadurch die Semantik der Steuerelemente ja erhalten bleibt, aber nicht notwendigerweise der Typ ("Nein, NumericUpDownBox geht nicht, da kann man nicht zwischen 0 und NULL unterscheiden, dann halt doch eine (spezielle) TextBox").

Teilweise hab ich es auch schon gesehen, dass man sich auch bei den GUI-Elementen darauf beschränkt zu sagen, dass es überhaupt ein GUI-Element ist, aber nicht exakt welcher Typ (zB NameBox). Meines Erachtens ist das vollkommen ausreichend.

nimm noch lieber IDbConnection und IDbCommand (das wäre dann allerdings die Variante a). Es sei denn du brauchst an einer Stelle wirklich die Methoden von DbConnection bzw. DbCommand.

Wenn du die Klassen auch instanziieren willst, dann empfiehlt es sich außerdem per TypeConstraint einen parameterlosen Konstruktor vorzuschreiben, dann kannst du den auch benutzen.

//edit: Beim Beispielcode sind die Generika wirklich überflüssig, ja

aus performancetechnischen gründen und aus sicht vom handling ist nr.1 vorzuziehen.

Aus performancetechnischen Gründen? Handling hast du ganz klar meine Zustimmung, aber Performance? Ich mein, CodeDOM ist als DOM mit ziemlicher Sicherheit speicherintensiver und muss nicht mehr in irgendeiner Art und Weise kompiliert werden, sollte also imho schneller sein.

Das soll nicht heißen, dass ich auf Reflection.Emit zurückgreifen würde, weil man muss schon sehr genau wissen, was man tut, um IL einfach so runterschreiben zu können.

Zur eingabe ist eine NumericUpDownBox aber viel besser als eine TextBox (ich nimm mal an, dass das mit "edit box" gemeint ist).

auch nur bedingt, nämlich unter der Bedingung, dass definitiv eine Zahl eingegeben wird. Sowas wie <Kein Wert vorhanden> oder NULL kann man mit einer NumericUpDownBox nicht darstellen

Danke für die beiden Links!

Hallo zusammen,

ich habe ein recht eigenartiges Problem. Ich hab jetzt mein Vista gegen Windows Server 2008 ausgetauscht, den ich aber nicht wirklich als Server sondern eben nur als "Vista in schnell" benutzen will. Das Problem ist, dass ich ja normalerweise nicht als Admin arbeiten will, sondern nur als Standarduser. Die dürfen aber bei Windows Server den Rechner nicht herunterfahren. Die Stelle, an der ich den Shutdown-Manager abschalten kann, hab ich schon gefunden, muss also nicht mehr immer den Grund des Herunterfahrens angeben, aber ich muss im Moment noch erstmal abmelden, als Admin anmelden und kann dann erst den Rechner herunterfahren.

Kurz: In welcher Gruppe muss man sein, oder wie lässt sich das einstellen, dass Standarduser auch den Rechner herunterfahren dürfen?

Gruß

Georg

Wenn man wirklich mal eine eigene Collection braucht (weil die zum Beispiel beim registrieren irgendwas machen können muss, oder in diesem Fall halt ein Event feuern), dann sollte man eigentlich sowieso immer von System.Collections.ObjectModel.Collection<T> ableiten, nie von List<T>. Ehrlich gesagt hätt' ich mir bei List<T> ein sealed gewünscht, aber naja.

Der Grund ist genau das, was Jack schon meinte, die Schnittstellenmember sind bei List<T> als nicht überschreibbar gekennzeichnet, weshalb die Aufrufe dann imernoch an die Basis und damit an den Zusatzfunktionen vorbei gehen (Die Schnittstellenimplementierung fehlt natürlich nicht, aber sie wird halt nur von der Basisklasse übernommen).

Hallo pdelvo, Hallo PoWl,

Du musst der Eigenschaft das Attribute Browsable geben

genau falsch, weil true ist der Standardwert für Browsable. Du musst also das Attribut setzen, wenn du die Eigenschaft nicht im Designer angezeigt bekommen willst. Gleichfalls wäre es bei den Eigenschaften noch nett, wenn du ein DescriptionAttribute und ein CategoryAttribute mit angibst, dann steht die Eigenschaft nachher nicht unter Sonstige und ohne Hilfetext da.

Zu dem Problem mit dem von Label oder UserControl ableiten: Ich würde dir dringend davon abraten von Label abzuleiten, weil das fertige Control ist für meine Begriffe kein Label. Es ist eher ein Steuerelement, was eine Fließkommazahl visualisiert. Dann sollte man aber auch nicht die Möglichkeit haben über eine Text-Eigenschaft auf den Text des Labels direkt zugreifen zu können. Ich würde dir schon sehr empfehlen, das ganze zu kapseln, sprich von Control oder der Einfachheit wegen von UserControl ableiten.

Gruß

Georg

So wie ich das verstanden hab dreht es sich darum, dass es eine Eigenschaft AllowDouble gibt, die von der Sache her erstmal bool deklariert ist, und nur wenn das auf true steht, dann soll als "Untereigenschaft" OnlyPositive auftauchen, was dann auch wieder bool ist.

Somit ist die Lösung mit dem enum zwar eine sehr einfache Lösung, die aber das eigentliche Problem nur umschifft. Das geht aber auch nur, weil die Eigenschaften bool sind. Wenn das komplexere Typen sind, die man nicht in enums zusammenfassen kann wird die Sache schon problematischer....

verwendetes Datenbanksystem: EF allgemein

Hallo zusammen,

mal so eine grundsätzliche Frage zum Entity Framework:

Grundprinzip ist ja soweit ich es verstanden hab, dass Daten als Entitäten angesehen werden, die dann irgendwie auf eine oder mehrere Tabellen gemappt werden. Wie ist mir erstmal egal. Welcher Entität ein Objekt angehört bestimmt sich aber rein nur aus dem Typ des Objekts. Jetzt hab ich aber das Problem, dass ich bestimmte Entitäten (ich sag jetzt mal Produkte) an verschiedenen Stellen speichern will, aber nicht zwei Entitäten aufmachen will.

Eigentlich würde ich es aber trotzdem klasse finden, wenn ich, wenn ich sage, ich will alle Produkte haben, dass dann auch an zwei Stellen geschaut wird. Und wenn die Objekte dan persistiert werden sollen, will ich möglichst noch beeinflussen können, an welche Quelle zurückgeschrieben werden soll. Geht das? Nächster Schwierigkeitsgrad wäre dann, dass eine Quelle in Wirklichkeit eine View der anderen Quelle ist, die einfach nur ein paar Daten rausfiltert, also beim Selektieren nicht beachtet werden muss. Ach ja, außerdem kann es natürlich abhängig von den Benutzerrechten passieren, dass eine oder mehrere Quellen nicht erreichbar sind.

Jetzt die eigentliche Frage: Meint ihr das EF kriegt sowas hin? (Wenn ja: Wie?)

Gruß

Georg

Nein. Es geht aber natürlich trotzdem, wenn auch deutlich komplizierter.

"Subproperties" werden von TypeConvertern bereitgestellt, d.h., bau dir am besten deinen eigenen TypeConverter für diese Property und weis diesen per Attribut zu, damit kriegst du's hin. Anders geht es nicht oder nur noch komplizierter.

Georg

Wenn du gerade von Speicherbedarfökonomie redest: Einfach die Koordinaten als structs zu definieren ist nicht wirklich der Weisheit letzter Schluss, dir sollte das volle Ausmaß dieser Vorgehensweise bewusst sein. Auszugsweise:

• Bei einer Übergabe des Objekts (z.B. als Parameter) wird nicht der Zeiger übergeben, sondern das komplette struct (gut, das besteht so wie es jetzt implementiert ist hauptsächlich nur aus drei Zeigern auf die Arrays)
  Das heißt auch, dass du immer nur quasi mit lokalen Kopien arbeitest, die du dann zurückschreiben musst, Aufrufe wie

System.Drawing.Size s = control.Size;
s.Height = 30;

sind deswegen komplett blödsinnig, es sei denn man schreibt das struct-Objekt zurück (control.Size = s in dem Fall)

• Vererbung ist ausgeschlossen, du solltest dir also gut überlegen wie es mit Wiederverwendung aussieht

Übrigens wegen dem NULL und null: Die CLR hat doch keine Ahnung, dass du mit C# arbeitest, du könntest genausogut mit VB.NET programmiert gearbeitet haben, und da heißt die leere Referenz Nothing. Das kann ab und an mal passieren, das die selben Sachen unterschiedliche Namen haben (zB auch int vs Int32 vs Integer (VB.NET), string vs String).

Was ist das Problem, wenn du die DLLs mit zu deinem Code packst, kannst sie ja in einen gesonderten Ordner verbannen. Ansonsten könnte vllt noch über PreBuild-Ereignisse was gehen, aber das wäre die Mühe nicht wert.

Naja, wenn du immer alle deine Dimensionen verfügbar hast, dann mach dir eine Struktur und nimm die als Key. Schon isses mehrdimensional. Wenn du nicht immer alle Dimensionen parat hast, dann nimm halt verschachtelte Dictionarys (Dictionarys sind halt die generischen und damit streng typisierten Hashtabellen, die gegenüber den statischen nur Vorteile haben).

Also wegen der ganzen Diskussion wegen der Sicherheit von Atomkraftwerken Das ist kompletter Blödsinn, moderne Atomkraftwerke überlasten sich nicht. Die Sache mit den Terroranschlägen klappt da auch nicht, alles was man machen kann ist die Reaktorhülle wegsprengen, na dann mal viel Spaß dabei. Aber die Sache mit der Überlastung kann gar nicht gehen, weil moderne AKWs mit Wasser moduliert (=geregelt) werden und wenn das verdampft, dann gibts kein Modulator mehr und das AKW fährt ganz automatisch runter, muss man gar nichts für tun. Tschernobyl wäre mit modernen AKWs nicht möglich.

Viel größer ist da in der Tat das Endlagerproblem.

Die Sache ist halt nur, irgendeinen Tod muss man sterben, fossile Energie schadet der Umwelt/dem Klima, eneuerbare Energien sind teuer und mengenmäßig denk' ich nicht ausreichend vorhanden um damit die Energieversorgung sicher zu stellen, bzw. was zB Windkrafträder angeht auch einfach nicht konstant genug.

Ohne das Endlagerproblem wäre ich sehr klar für Atomkraft, so bin ich da so ein bisschen geteilter Meinung. Aber die AKWs abzuschalten um dann Atomstrom aus anderen Ländern zu importieren ist imho komplett blödsinnig. Am besten wäre für den Moment, wenn sich Kohlebrennstoffzellen durchsetzen würden, die haben schon mal einen wesentlich höheren Wirkungsgrad als wenn man Kohle direkt verbrennt. Nur sind die Teile halt teuer und die Wissenschaft will den Wirkungsgrad erst noch ein bisschen hochschrauben (derzeit technisch 42% bei theoretischem Maximum von 62,5%, wollen wohl noch über 50% schaffen, aber derzeitige klassische Kraftwerke haben vllt max. 15%?).

ASP.NET bzw. Derivate habe ich mir nicht angeguckt. Klingt mir aber in der Realisierung viel komplexer als das ROR Framework. Lieber ein zusammengehöriges Paket mit gleicher Sprache als ein zusammengebasteltes mit 2 verschiedenen Sprachen, gell? Wobei ASP.NET natürlich viel Gemeinsamkeiten mit C# hat.

Jetzt vergleichst du aber Äpfel mit Birnen. C# ist eine (.NET-)Sprache, ASP.NET eine (.NET-)Technologie für Webseiten. Aber man kann in C# Webseiten ohne ASP.NET machen und man kann noch besser ASP.NET ohne C# benutzen. Und das mit den 2 verschiedenen Sprachen, ja klar, du brauchst für ASP.NET zwei Sprachen: eine .NET-Sprache (z.B. C#) und das bisschen Xml. Aber die sind sauber voneinander separiert. Und jetzt erzähl mir nicht, dass du in ROR kein Html benutzt, damit sinds dann auch schon mal zwei, die aber afaik meist irgendwie verwurschtelt werden.

Wegen den Samples auf der Webseite: Man kann in absolut jeder Sprache verdammten Scheiß zusammenschreiben und meistens geht das sogar noch ziemlich einfach, weshalb das doch relativ verbreitet ist. Aber wenn man Code vorstellt, dann sollte man zusehen, dass man da guten, sauberen Code reinstellt.

Die Klasse System_Tester.DataRow ist nicht public, also kannst du keine public Eigenschaft definieren, die diesen Typ hat, also entweder mach die Klasse public oder die Eigenschaft auf den gleichen Zugriffsmodifizierer.

Gruß

Georg

sobald du allerdings dieses struct an eine Funktion übergeben willst, übergibst du meistens einen Pointer

ehrlich gesagt hab ich bislang eher die Erfahrung gemacht, dass Parameter eher selten ref Parameter sind. Und man Strukturen auch als solche erwartet - nicht als Schnittstellenparameter oder noch schlimmer Object. Dann werden gar keine Pointer kopiert, sondern die ganze Struktur. Und da reden wir immernoch von 12Byte, gut, das sind zugegebenermaßen mehr als 4Byte, aber wir wollen ja auch keine Unmengen Funktionsaufrufe machen, sondern die Teile nur vergleichen.

Da ich mich gerade damit beschäftige einen Demonstrator für die Sinnhaftigkeit paralleler Programmierung im Bereich Wegsuche zu bauen geb ich auch mal meinen Senf dazu.

Parallelisierung ist ein spannendes Thema, weil es notgedrungen sehr aktuell ist, aber noch nicht ausreichend erforscht, als das man eine bewährte Herangehensweise hätte, wie man bestehende Applikationen parallelisiert. Auf der anderen Seite muss man genau das aber tun, weil die Clients immer öfter immer mehr Kerne haben und dieser Trend wird sich beim besten Willen nicht aufhalten oder verlangsamen, weil es aus energietechnischen Gründen keinen Sinn mehr macht die Taktraten der einzelnen Kerne noch weiter hoch zu setzen.

Prinzipiell ist schonmal das Problem, was herbivore schon angeschnitten hat, dass ein Thread immer sequentiell abläuft, also nur von maximal einem Prozessor bearbeitet werden kann, also muss man um überhaupt eine Parallelisierung hinzukriegen auf mehrere Threads aufteilen. Dazu gibt es jetzt aber auch gleich mehrere Möglichkeiten, einmal wirklich Threads, aber es ist genausogut möglich, Delegates asyncron auszuführen (BeginInvoke), das ist für kurzlebige Threads sogar oft genug sinnvoller, weil die CLR offenbar optimiert (greift wahrscheinlich automatisch auf den Threadpool zurück). Aber in jedem Fall kostet dieser Overhead Zeit.

Wenn du jetzt mit Mitteln wie Threads oder asyncronen Delegates jede einzelne Schleife parallelisieren willst, dann bringt das in den meisten Fällen ziemlich genau nichts, weil der Overhead viel mehr Zeit frisst als die parallele Abarbeitung wieder rausholt. Wie es aussieht macht Parallelisierung dann am meisten Sinn, wenn sie möglichst grob ist, also wenn du die Threads möglichst lange leben lässt. Interessanterweise ist das bei den Parallel Extensions nicht so tragisch, wenn man die Strukturgröße kleiner wählt, also Schleifen parallelisiert, die einen verhältnismäßig kleinen Schleifenkörper haben, da wurde bei der Optimierung offenbar ganze Arbeit geleistet.

Besser ist es aber im Allgemeinen, die Algorithmen an sich zu parallelisieren und zu schauen, was man parallel machen kann. Bei manchen Algorithmen (u.a. leider klassische Wegsuche-Algorithmen wie Dijkstra oder A*) geht es aber auch einfach nicht oder nicht wirklich, weil immer ein Ergebnis auf dem anderen aufbaut. Im Moment sieht die Situation dann so aus, dass man sich dann was überlegen darf, wie man diese Algorithmen dann doch irgendwie parallelisiert kriegt oder gleich neue parallelisierbare Algorithmen entwickelt. Oder auch überlegen, wo man sonst noch rechenaufwändige Operationen parallelisieren kann.

lag wohl offenbar an einer Datenpanne...
http://www.spiegel.de/netzwelt/web/0,1518,604786,00.html

Immer Strukturen statt Klassen zu verwenden ist mit Sicherheit Blödsinn, auch von der Geschwindigkeit her, keine Frage.

Aber was den Zugriff angeht, sicherlich ist der Unterschied weniger als marginal, aber auf der anderen Seite, selbst die kompletten Strings zu vergleichen brauch, naja, wie lange so ein Rechner so halt braucht um ganze 52Byte zu vergleichen. Wir reden hier also irgendwo schon von extrem geringen Zeiten, da macht das meiner Meinung nach schon einen Unterschied, ob die Variablen dann noch in den Stack kopiert werden müssen, oder nicht.

Aber eigentlich ist es egal, weil wir glaub ich einfach festhalten können, dass Decimals vergleichen auf alle Fälle kürzer dauert als Strings zu vergleichen. Wenn man aber die Zahlen wirklich als String hat und die sonst nicht braucht, dann wird es wirklich wie floste sagt schon schneller sein direkt einen Stringvergleich zu machen (evtl mit Nullen wegtrimmen).

Hm, das BinarySearch im Zweifelsfall das bitweise Komplement liefert ist mir noch nicht aufgefallen. Wieder was dazu gelernt. Ich war davon ausgegangen, dass alle Suchmethoden aus dem Framework immer -1 zurückgeben, wenn sie den gesuchten Wert nicht finden. Weil in dem Fall hätte man es nicht einsetzen können...

Hm, in dem Fall lässt sich die Komplexität wirklich auf O(log n) drücken, während die Implementierung so in O(n) liegt. Wenn du also sehr große Arrays hast, dann wäre es ratsam das noch zu optimieren (sprich eine Art BinarySearch zu implementieren).

Hm, also ich bin der Meinung, die Uni ist für die Theorie da, die Praxis holt man sich im Nebenjob. Wobei du an einer FH sowieso mehr Praxis hast, als an der Uni (das macht sie imho ja gerade aus). Da denk ich doch, dass es dir da beim Abschluss nicht an Praxis mangeln wird.

Was die Sache mit der Treiberentwicklung angeht, naja, um jetzt tiefgehend zu wissen, was welcher Befehl jetzt mit der Elektronik anrichtet, kommt man um das Etec Wissen nicht wirklich herum, insofern kann ein einziges Modul da bei weitem nicht so viel Background geben wie ein Etec Studium. Und es ist nunmal so, dass du im Bereich Treiberentwicklung auch viele Geräte relativ einfach physisch zerstören kannst, wenn du beim Programmieren Fehler machst...

Beim string kommen sogar noch mehr Bytes dazu, der braucht schon mal 4 Byte um überhaupt zu wissen, dass er ein string ist und nochmal vier Byte, um die Länge zu speichern. Ich hab mir sogar sagen lassen, dass string so implementiert ist, dass er nochmal weitere 4 Byte verbrät (vorgehaltenes Array?), macht also summa summorum 52Byte.

Aber eben 52Byte auf dem Heap, bei decimal sind es 12Byte auf dem wesentlich schnelleren Stack (bei strings muss man ja erst an die entsprechende Speicheradresse gehen und da die Sachen nachschlagen, bei decimals sind die Daten schon da, wo man sie braucht), das macht imho den Hauptunterschied.

Bist du auf eine spezielle FH beschränkt? Ansonsten könnte FH gesucht noch ein nützlicher Thread für dich sein.

Ich hab mich auf der anderen Seite aber auch erst vor kurzem mit einem studierten E-Techniker unterhalten, der genau das gemacht hat - Software-/Treiberentwicklung im Embedded-Systems-Bereich, als Consultant. Allerdings hatte der keinen FH-Abschluss, sondern von ner "richtigen" Uni.

Gut, zuggebenermaßen hab ich von Embedded Systems leider nur sehr wenig Ahnung, würde aber meinen wenn du eher zu Treiberentwicklung tendierst, dann lieber Etec, soll's Anwendersoftware sein, die vllt auch auf einem Framework aufbauen darf, dann lieber Informatik.

  
  
/* double[] myList; */  
double tmpResult = DoCalculation();  
double result = myList[0];  
for(int i = 0; i < myList.Length; i++)  
{  
  if(myList[i] > tmpResult && myList[i] < result)  
    result = myList[i];  
}  
  
return result;  
  

funktioniert aber auch nicht, weil du result mit double.MaxValue vorinitialisieren solltest, ansonsten knallt es sofort, wenn myList[0] < tmpResult ist.

for (int i = 0; i <= liste.Length; i++)  
                        {  
                            if (widerstand <= liste[i])  
                            {  
                                nwiderstand = liste[i];  
                                break;  

Hm, der Algorithmus macht mal gänzlich was anderes, er findet nämlich den erstbesten Wert, der größer oder gleich dem angegebenen Startwert ist, aber nicht den kleinsten solchen, es sei denn das Array ist wieder vorsortiert.

Was bringen 2 Prozessoren? Z.B. nutzt die VS-IDE die Leistung, oder würde der eine immer nur pennen?

Naja, ich sag's mal so: Ich glaube starkt daran, dass es über kurz oder lang nichts anderes mehr als Multicores geben wird. Das heißt aber auch, dass dann alle Anwender früher oder später Multicores dastehen haben, was heißt, dass Anwendungen multicorefähig sein sollten, so sie mehr als fast nichts an Rechenzeit benötigen, weil mehrere Kerne sind toll, aber wenn alles in einem Thread passiert, dann nützt das wenig. Aber die Leute werden immer verlangen, dass Programme schnell laufen, die Software wird aber gleichzeitig immer komplexer und damit tendenziell langsamer.

Da die sequentielle Ausführungsgeschwindigkeit aber nicht mehr steigt, heißt das, man muss seine Programme parallelisieren. Wenn du aber an einem Einkerner entwickelst, dann wirst du die gegenteilige Erfahrung machen, weil Parallelisierung immer einen Overhead mit sich bringt, weshalb die ganze Schose langsamer wirkt, was sie aber bei den irgendwann meisten Leuten nicht sein wird. Mit einem Mehrkerner kannst du deinen ganzen Kram aber umgekehrt in einer VM auch in einer Einkerner-Umgebung testen (sollte zumindest möglich sein).

Ist es gänzlich nicht da, oder ist es vielleicht nur nicht da, wo du es vermutest? Normalerweise wird da ja ein Startmenü-Eintrag Programme/[Firma]/[Produkt] angelegt. Schau mal nach, was da bei dir drinsteht...