Du musst aber die Inkonsistenzen auflösen wenn die Mitarbeiter den ganzen Tag Dateioperationen OHNE Tortoise ausführen.

Hast Du schonmal mit SVN gearbeitet? Dann versuche es mal.

Es ist ungeeignet für deine Zwecke.

@1mannlan
Subversion ist vollkommen ungeeignet für dein Vorhaben.

Du willst doch nicht von den Mitarbeitern verlangen, dass jede Dateioperation über z.B. TortoiseSVN durchgeführt wird, oder?
Wenn Dateien einfach wie gewohnt kopiert, gelöscht und verschoben werden, hast Du bei jedem Commit unzählige Fehler von Hand aufzulösen -> Horror

Hallo

Muster die ich gerne verwende:

-Abstract Factory & Repository: Häufig in der Datenschicht.

-Strategy, State und Bridge: Sehr nützlich und eng verwandt. Eigentlich lässt sich die Idee dahinter ständig einsetzen um Verhalten wegzukapseln. Meine Meinung: Strategy ist das wichtigste aller Muster.

-Observer, Iterator, Mediator: events und IEnumerables, ist klar. Und jede Form ist Mediator ihrer Controls. Verwendet man also unbewusst ständig.

-Template Method: Kürzlich in einer Bildverarbeitungsbibliothek verwendet mit sehr sauberem Ergebnis.

-Visitor: Double-Dispatching ist eine faszinierende Idee um if-else-Kaskaden bei der Bestimmung eines konkreten Subtyps zu vermeiden.

-Facade: Einen Satz von Low-Level Schnittstellen hinter einer sauberen, kleinen Facade zu verstecken ist praktisch.

-Interpreter: Ein Rekursiv-Absteigender Parser eben. Sehr nützlich aber warum es ein Muster ist, ist mir rätselhaft.

-Builder: Bei einem Lexergenerator kürzlich verwendet: Regulärer Ausdruck -> NFA -> DFA. Der schrittweise Konstruktionsprozess von RA -> NFA kann damit schön weggekapselt werden.

-Command: Bei einem minimalistischen 3D-Modeller. Aus einer Mausaktion wird entsprechend irgendwelchen gesetzten Häckchen ein Command erstellt, das später ausgeführt wird. Sehr saubere Sache.

Muster die mich Interessieren aber noch nie in Produktivcode verwendet habe:

-Memento: Mangels friend-Schlüsselwort etwas schwierig zu verwenden in C# aber es geht trotzdem.

-Fliegengewicht: Schwierig zu verwenden weil man schnell den Überblick beim extrinsischen Zustand verliert und Anwendungsgebiete sind rar.

Muster die ich als unsauber oder wenig nützlich empfinde:

-Dekorator: Bei Streams z.B. sehe ich den Nutzen aber insgesamt sind Dekorierer gefährlich und hässlich. Wenn sich der Client-Code darauf verlässt, es mit dem "echten" Objekt zu tun zu haben, knallts.

-Proxy: Siehe Dekorator. Nützlich um auf Remote-Objekte transparent zuzugreifen aber selbst ist mir noch nie eine saubere Proxy-Implementierung gelungen.

-Adapter: Die Idee ist großartig aber in der Praxis ergeben sich mir zu selten Möglichkeiten einen Adapter zu verwenden. Zum Beispiel wenn eine Kamera gegen eine andere ausgetauscht werden soll und man für das neue Gerät einen Adapter entwickeln möchte. Oft hat Hardware solch individuelle Eigenschaften im zeitlichen Verhalten oder der Reihenfolge verschiedener Befehle, dass getrickst werden muss.

-Composite: Die Idee der Teil-Ganzes-Hierarchie ist toll aber in der Praxis habe ich sowas noch nie benötigt. Normale Baumstrukturen brauche ich dagegen oft. Edit: Ich bin gerade am überlegen. Ich habe mal einen Renderer für 3D-Levels (Quake3 und so) geschrieben und die Geometrie in einen Octree gepackt. Hier kommt das Teil-Ganzes-Prinzip schon zum Einsatz gegenüber einem einfachen Baum... Naja.

-Singleton: Ohne Worte.

Ich habe mir sehr schwer getan beim Lernen der Patterns (hab natürlich noch nicht alle drauf)

Patterns sind ja auch ein bockschweres Thema.

Eine große Hürde für mich waren die praxisfernen, konstruierten und teilweise hanebüchenen Beispiele in manchen Büchern. Der Transfer auf reale Probleme fällt damit schwer. Deswegen habe ich mir zu allen schwierigeren Mustern immer mehrere Quellen herangezogen und das Web durchforstet.

Das "Head First - Design Patterns" - Buch hat mir die Augen ein Stück weit geöffnet. Danach ist das GoF-Buch ein idealer Katalog.
Dringend abraten muss ich von "C# - Design Patterns". Das Buch erfasst die Kerngedanken hinter den Mustern nicht und die Beispiele sind fehlerhaft und schlecht implementiert.

Edit: Eine Million Tippfehler beseitigen 😄

Ribbons, Tiles, Webzentrierung, ... ich bin zwar erst 29 aber ich komme mit der Umstellung schon nicht mehr klar. Viel zu sehr bin ich an alte Menüleisten und spartanisches aber funktionales Design gewöhnt.

Nach 1,5 Jahren finde ich mich in Windows 7 immer noch nicht so zurecht wie damals unter WinXP nach wenigen Wochen. Alles wird versteckt und überall liegt ein Schleier darüber der dem Benutzer das Denken und Systemwissen abnehmen soll. Dass alles Quitschbunt ist empfinde ich als störend und schalte es so weit es geht aus.

Tja, ich bin wohl konservativ was Betriebssysteme und GUIs allgemein betrifft und in den 90-ern stecken geblieben.

Hallo.

So auf die schnelle für eine 2D-List von ints. Das kannst Du aber einfach ändern zu Flugzeug_Linie.

            int CollisionDistance = 1;

            List<List<int>> list = new List<List<int>>();
            list.Add(new List<int>());
            list.Add(new List<int>());

            list[0].Add(3);
            list[0].Add(7);
            list[0].Add(8);

            list[1].Add(9);
            list[1].Add(14);
            list[1].Add(15);

            var many = list.SelectMany(item => item);
            var result = from x in many
                         let collision = many.Where(y => x != y && Math.Abs(y - x) <= CollisionDistance)
                         where collision.Any()
                         select new { item = x, collisionset = collision };

            foreach (var r in result)
            {
                Console.Write("Item: " + r.item + " , Kollisionsmenge: ");
                foreach (var collisionCandidate in r.collisionset)
                    Console.Write(" " + collisionCandidate);
                Console.WriteLine();
            }

Zu jedem Item der Liste wird also die Menge der Kollisionskandidaten gefunden. Im Beispiel alle, die eine Entfernung von 1 haben (CollisionDistance = 1)

Ausgabe:

Item: 7 , Kollisionsmenge: 8
Item: 8 , Kollisionsmenge: 7 9
Item: 9 , Kollisionsmenge: 8
Item: 14 , Kollisionsmenge: 15
Item: 15 , Kollisionsmenge: 14

MfG

Schreibt ihr ständig Code, checkt ihn ein und prüft bei jeder Änderung ob das neu implementierte funktioniert? (Continuous Integration)?

Genauso, ja. Das Projekt ist relativ klein und die Übersetzung dauert nicht lange, so dass quasi alles direkt getestet werden kann.

Ich finde es ein wenig "gemein", dass man hier diese Vorgehensmodelle als "akademischen Quatsch" abtut. Mal ehrlich: hat sich hier im Vorhinein noch NIEMAND mal Gedanken über Klassendesign o.ä. gemacht? Sicher kommt das immer auf die Projektgröße an, aber ein wenig geplant habt ihr alle schon - oder programmiert ihr wirklich einfach "drauf los"?

Ich habe selbst Informatik (Uni) studiert also darf ich darüber lästern 😃

Ja ich programmiere einfach drauf los. Ich wäre bei neuen Projekten mit hunderten Klassen garnicht in der Lage es vorher bis auf Klassenebene zu entwerfen. Das entwickelt sich mit der Zeit. Ich muss "erforschen" was eine gute Lösung ist. Das geht einfach nicht im Vorfeld in irgendeinem albernen UML-Tool.
Naja, nicht ganz. Es geht doch: Genau dann, wenn man etwas sehr Ähnliches schon einmal gemacht hat. Wenn man sich zum Beispiel was die Datenschicht betrifft für ein Repository-Pattern entscheidet weiß man vorher genau, wie es aussieht, dass da eine abstrakte Fabrik sein wird u.s.w.. Aber warum sollte ich es dann noch aufmalen?
Umgegekehrt kaufe ich niemandem ab, dass er so etwas Komplexes, beim ersten mal und ohne vorher etwas ähnliches gemacht zu haben, mit UML entwerfen kann ohne zu erleben wie es sich in Code "anfühlt".

Die Aussagen beziehen sich auf kleinere und mittlere Projekte. Und da halte ich Vorgehensmodelle und Entwurfsphasen für Zeitverschwendung. Ja, akademischen Quatsch.

Code ist der eigentliche Entwurf. Das eigentlich wesentliche.
Unterstützung in Form von Code gibt es auch: Unit-Tests, Frameworks, Dependency-Injection-Container, OR-Mapper wie nHibernate.... Das sind Dinge die wirklich Helfen. Aber kein Klassendiagramm.

jannemann13 beschreibt schon sehr schön wie es wohl wirklich in sehr vielen Firmen abläuft.

Wenn ich sehr sauberen Code schreibe, Pattern verwende und penibel darauf achte gegen keine Prinzipien zu verstoßen, brauche ich drei bis viermal so lang wie für hingerotzen Durchschnittscode. Die Konsequenz ist, dass sich Änderungen und Wartungsarbeiten nicht mehr ganz so schnell und elegant durchführen lassen wie beim durchstylten Traumsystem. In der Summe bin ich trotzdem noch schneller wenn ich häufiger mal ein Auge zudrücke und gegen Lehrbuchmeinungen verstoße.

Ich verstehe die Vorgehensmodelle als hochgradig weltfremd was kleinere Projekte betrifft. Bei Monsterprojekten haben sie sicherlich ihre Daseinsberechtigung, das kann ich nicht beurteilen.

Code den ich zu Hause schreibe könnte man ins Museum stellen so sauber ist er. Auf der Arbeit muss es schnell gehen. Das Ergebnis zählt.

Vielleicht fehlt mir aber auch noch Erfahrung. Ich bin erst 1,5 Jahre "Profi".

Ich kann das Problem für Windows 7 bestätigen. Im Setup muss ich die Rechte für einen Unterordner von CommonApplicationData setzten sonst hat die Anwendung keinen Schreibzugriff.

Das dachte ich auch zuerst.
Aber so fügt er dem Dictionary ein neues Element ein.
Ich will ja dem Value des Dictionarys "List<MyClass>" eines neues Element anhängen.

Nein das ist schon korrekt.

Kunden und ihre absurden Wünsche. Ohne wär der Job doch nur halb so lustig 😄

Schreib Dir doch schnell ein kleines Tool, das Alles in eine Datei kopiert. Evtl. vor jeder neu beginnenden Quelldatei einen Kommentar mit Dateiname etc. einfügen.

Durch die Namenskonflikte wird im VS zwar vieles unterstrichen aber das lässt sich imho ausschalten.

Aber der Sinn würde mich auch interessieren.

Haha man muss nichtmal etwas in der Datei ändern.
Projekteigenschaften -> Anwendung -> Startobjekt: Hier wählt man einfach eine andere Klasse mit Main-Methode und kann tun was man will. 😃

Oder so...

        static void Main(string[] args)
        {
            if (args.Length == 0 || args[0] == String.Empty)
            {
                Console.WriteLine("Bitte geben Sie den Namen des Angestellten an, den Sie feuern möchten!");
                return;
            }
        }

    class String
    {
        public static string Empty = "Mein Name";
    }

M.e. der einzige nennenswerte Unterschied ist die mögliche Wiederverwendung des zweiteren Konstrukts.

Je nachdem kann auch das erste Konstrukt besser sein bzgl. Wiederverwendung. Z.b. für Bildverarbeitung wenn die Schleifen gleich bleiben und nur die Filterkerne variieren.
Aber ehrlich gesagt habe ich mich in genau diesem Anwendungsfall bisher nicht getraut die Schleifenrümpfe zu kapseln, weil ich nicht weiß wann und unter welchen Umständen inlining stattfindet.

Nein, wir setzen in der Firma keine Obfuscatoren ein.

In nHibernate sind die SQL-Dialekte für viele gängige Datenbanken wegabstrahiert und es ist in der Lage die Tabellen und Verknüpfungen automatisch zu erstellen.

Es ist ein Objekt-Relationaler-Mapper und weit mehr als das was Du eigentlich suchst. Aber da sowieso empfehlenswert, kannst Du ja mal einen Blick drauf werfen.

Will eigendlich nur wissen, wie bekomme ich die IP-Pakete in eine Variable.

Hier, auf die schnelle etwas zum erweitern und spielen.
Zur Ausführung benötigst Du Admin-Rechte

        static void read_IP_traffic()
        {
            try
            {
                Socket s = new Socket(
                    AddressFamily.InterNetwork,
                    SocketType.Raw,
                    ProtocolType.IP);

		//Die lokale Adresse an der Du lauschen willst
                IPAddress ip = new IPAddress(new byte[] { 192, 168, 1, 95 });
                s.Bind(new IPEndPoint(ip, 0));
                
                s.SetSocketOption(System.Net.Sockets.SocketOptionLevel.IP, System.Net.Sockets.SocketOptionName.HeaderIncluded, 1);
                
                byte[] bout = new byte[4];
                s.IOControl(IOControlCode.ReceiveAll, new byte[] { 1, 0, 0, 0 }, bout);
                
                while (true)
                {
	            //2^15 Byte als Maximalgröße eines IP-Pakets
                    byte[] buffer = new byte[1 << 15];
                    s.Receive(buffer);
                    write(buffer);
                }

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

	//Nur die ersten 20 Bytes ausgeben. Entsprechen dem Header der IP-Pakete.
	//Die restlichen Nutzdaten im Buffer kannst Du entsprechend weiterverarbeiten. Erst den TCP-Header auslesen
	//und die Nutzdaten des TCP-Pakets entsprechen dann der HTTP-Kommunikation.
	//Aber vorsicht: Es schwirren viele Pakete anderer Protokolle herum.
	static void write(byte[] buffer)
        {
            for (int i = 0; i < 20; ++i)
            {
                
                Console.Write("{0} ",buffer[i]);
            }
            Console.WriteLine();
        }

C# 4.0 in a Nutshell gefällt mir sehr gut und ich würde es bedingungslos weiterempfehlen.

Hier sind zwei Probekapitel:
http://www.albahari.com/threading/

Mit Sockets kannst Du alle IP-Pakete belauschen. Oder ist das zu Low-Level?

Nein.

Das ist eine Differentialgleichung und erfordert ganz eigene Lösungsmethoden. -> google

Eher lustig als Horror. Ist mir beim programmieren nicht aufgefallen, erst später 😃

catch(SocketException sex)
{
	if(sex.ErrorCode == ErrorCodes.Disconnected)
	{...}
}

WKOs und Channels stehen ja in keiner direkten Beziehung.

z.B.:

TcpChannel c = new TcpChannel(12345);
ChannelServices.RegisterChannel(c, false);

RemotingConfiguration.RegisterWellKnownServiceType(
                typeof(SimpleRemotingAsm.RemoteMessageObject),
                "RemoteMsgObj.rem",
                WellKnownObjectMode.Singleton);

Kennt der Kanal c das RemoteMessageObject? Nein
Kennt der registrierte Service den Kanal c? Auch nicht.

Es wird einfach ein (oder mehrere) Kanal registriert, aber nicht direkt an bestimmte Typen gebunden. Dass Du das ganze in config-Files erledigt hast, wirkt sich nicht darauf aus.

Ich bin was Remoting betrifft etwas grün hinter den Ohren und hoffe das ist soweit richtig. Aber da ja sonst niemand antwortet....

Hallo herbivore,

danke das macht es schon wesentlich klarer.

Könnte man auch einfach sagen, dass ein MemoryBarrier() den Register- und Cache-Inhalt für den jeweils aufrufenden Thread für ungültig erklärt?
Oder wäre das zu unpräzise?

Hallo gfoidl,

rate aus welchem Buch ich das Beispiel habe.

The simplest kind of memory barrier is a full memory barrier (full fence) which prevents any kind of instruction reordering or caching around that fence.

Mir ist absolut klar wie MemoryBarrier das Reordering unterdrückt an eben der Stelle des Aufrufs. Aber die Auswirkung auf Caching wird nicht 100% klar: "prevent ... caching around that fence" ist schwammig.

Hallo,

in einem Buch geht es gerade um Nichtblockierende Synchronisation.

Folgende Funktion, ein Beispiel aus dem Buch, terminiert nicht (Release-Modus und Codeoptimierung wählen):

private static void forever()
{
	bool complete = false;
	var t = new Thread(() =>
	{
	bool toggle = false;
	while (!complete)
	{
              toggle = !toggle;
	}
	});
            
	t.Start();
            
	Thread.Sleep(1000);
	complete = true;

	t.Join();
}

Der Grund ist einfach, dass die complete-Variable im CPU-Register gecachet wird und der Thread t niemals die Zuweisung =true sieht.

Nun werden zwei Lösungen besprochen: Einmal volatile für die complete-Variable und einmal MemoryBarrier.

Bei letzterem wird vorgeschlagen ein Thread.MemoryBarrier() in die while-Schleife zu packen. Es funktioniert, aber ich verstehe nicht ganz warum.

Ich dachte die MemoryBarrier verhindert nur Neuanordnungen von Instruktionen auf CPU, CLR oder Compiler-Level. In der MSDN (*) heißt es auch:
"Synchronisiert den Speicherzugriff wie folgt: Der Prozessor, der den aktuellen Thread ausführt, kann Anweisungen nicht so neu anordnen, dass Speicherzugriffe vor dem Aufruf von MemoryBarrier nach Speicherzugriffen ausgeführt werden, die nach dem Aufruf MemoryBarrier erfolgen."

Kein Wort über verhinderte Register- und Cache-Optimierungen, was zur Lösung des obigen Problems (ähnlich dem volatile Schlüsselwort) notwendig wäre, oder?

Meine Frage also: Weiß jemand wie sich Thread.MemoryBarrier() auf Cache-Optimierungen auswirkt?

(*) Die MSDN enthält sowieso Fehler zur MemoryBarrier, da der Beispielcode entgegen dem Hinweis auch auf anderen CPUs nicht terminiert

MfG

       private bool IsOneOf(Keys myKeyCode, params Keys[] mylist)
       {
           return mylist.Contains(myKeyCode);
       }

       private void ListDiagnosis_KeyUp(object sender, KeyEventArgs e)
       {
           if(IsOneOf(e.KeyCode, Keys.A, Keys.L, Keys.I, Keys.E, Keys.N))
             return;
       }

Ok, war zu langsam 😃

Beispiel:

Bier1 -> Beginn 18:00
Bier2 -> Beginn 18:30

Jetzt kommt beispielweise ne Trinkpause und es geht erst um 00:00 weiter (bis hier hin sollte der alkohol vom Vorabend abgebaut sein)

Bier3 -> 00:00
Bier4 -> 00:45
usw.

Ist doch kein Problem, wenn du die Sache für alle Getränke einzeln berechnest und dann aufsummierst. Wenn ein Getränk zu einem bestimmten Zeitpunkt entweder noch garnicht getrunken oder bereits vollständig abgebaut wurde, liefert es eben den Wert 0 bei.

Dann kannst Du auch Controls.Find verwenden...

Genau.

Wobei "unsichtbare Form" heißt, dass ich Show für diese Testform einfach nicht aufrufe. Die ganze Skalierungslogik über die Font funktioniert trotzdem.

"is die Form selbst nicht mehr auf den Birldschirm passt (und wie messe ich das?)"

Du überprüfst in der Schleife einfach, wann testform.Width oder testform.Height zu groß werden. Was heißt zu groß? Kommt drauf an: Bei mir sind alle Forms der Anwendung nochmal in eine andere, maximierte Form (ohne Controls, nur mit "schickem" Hintergrund) eingebettet, damit nichts vom Desktop zu sehen ist. In dem Fall bestimmt ClientRectangle.Size dieser Hintergrundform die Maximalgröße.

Wenn es sich um ein nicht eingebettetes (TopLevel) Fenster handelt das hochskaliert werden soll, beziehst Du die entsprechenden Werte aus der System.Windows.Forms.Screen-Klasse. Zum Beispiel System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Size scheint mir sinnvoll zu sein.

Im Testlauf ist die Location egal, es kommt nur auf Width und Height an.

Du kannst auch mit AutoScaleMode=Font arbeiten.

Bei Programmstart wird für eine ansonsten leere und nicht sichtbare Form schrittweise die Schriftgröße erhöht. Irgendwann wird die Form zu groß für den Monitor, der Schritt davor stellt dann die maximale Schriftgröße für die entsprechende Schriftart dar.
Damit das funktioniert muss diese TestForm im Designer die größe der größten Form des restlichen Programms haben. Wäre sie kleiner, würde unter Umständen eben diese größte Form nicht mehr auf den Bildschirm passen.

Das wars. Da alle Forms automatisch mit der Font skalieren muss man nichts weiter tun.

Wenn ein Benutzer das Verhalten nicht will, lässt man ihn einfach die Schriftgröße von Hand wählen (mit Tests natürlich). Damit verhindert man, dass die Controls auf einem extrem großen Monitor zu wuchtig werden.

Die Windows Installer Projekte von VS Studio finde ich nicht gut, da diese wohl nicht scriptfaehig sind?!

Glaube nicht aber Du kannst mit Hilfe einer von "Installer" abgeleiteten Klasse im Setup Projekt C#-Code zu bestimmten Zeitpunkten ausführen lassen. Zum Beispiel am Ende Installation, der Deinstallation oder einem Rollback. Einfach durch überschreiben der entsprechenden Methoden.

Ich benutze das um Ordnerrechte für den Datenordner der Anwendung zu setzen und hinterher wieder vollständig aufzuräumen.

Hallo,

was die Quellcodefenster im Visual Studio betrifft kann man unter Extras->Optionen zwischen Registerkarten und MDI wählen. Ich hätte wegen der Arbeit mit zwei Monitoren aber lieber vollständig unverankerte bzw. freie Fenster. So wie es z.B. mit dem Projektmappenexplorer auch möglich ist.

Habe ich etwas übersehen oder gibt es diese Option nicht?

Gelegentlich ziehe ich mir die Hauptanwendung über zwei Bildschirme und füge eine vertikale Unterteilung in zwei Registerkartengruppen ein. Das ist aber mehr eine Notlösung und kein angenehmes arbeiten.

mfg

Ein Vorschlag:

Ich mach das mal für 1000 weil 10^6 unübersichtlich ist.

Teile erst in zwei Summanden auf. Trivial wäre die Mitte zu wählen: 500+500.
Etwas eleganter ist eine normalverteilte Zufallszahl mit Mittelwert 500 und geeigneter Streuung zu nehmen. Sagen wir diese Zufallszahl wird 470. Um auf die 1000 zu kommen ist der zweite Summand ("Komplementärwert) damit natürlich 530.

Somit hast Du deine ersten beiden Summanden 470 und 530.

Für beide wiederholst Du das Verfahren, mit 470/2 und 530/2 als Mittelwerte der beiden Zufallszahlen. Mit diesen beiden Werten und den jeweiligen "Komplementärwerten" hast Du die 1000 schon in vier Summanden zerlegt.

Die Normalverteilung bringt es mit sich Grenzfälle abzufangen: Kleiner 0 und Größer als die aktuell zu zerlegende Zahl darf es natürlich nicht werden. Diese Grenzen bei einer Überschreitung zu nehmen scheint mir aber sinnvoll zu sein. Außerdem sollte die Streuung kleiner werden mit zunehmenden Iterationen.

Nach 8 Iterationen hast Du maximal 256 Summanden (einige können 0 sein). Oder müssen es exakt 200 sein?

Ich kann das Verhalten bestätigen.

Eine einfache Textbox markiert Text den man im Konstruktor oder Load-Event der Form setzt automatisch, falls die Box den kleinsten Wert in der Tabreihenfolge (Aktivierungsreihenfolge) unter allen Controls in der Form hat.

EDIT: Ich sehe gerade Du sprichst von mehreren gleichzeitig markieren strings und nicht nur von einem. Das ist mir allerdings noch nicht untergekommen. Trotzdem, setze mal ein Steuerelement ohne Fähigkeit zur Textmarkierung an die erste Tabposition, vielleicht hilft es ja auch bei dir.

Wieso scheint manchmal der linke und manchmal der rechte Arm weiter oben?

Ich kappiere es nicht 8o

Hallo,

ich füge die Werte für dynamische Kopf- und Fusszeilen immer über Report-Parameter ein. Eigentlich dachte ich, das sei der einzige Weg. ReportItems sagen mir nichts.

Es funktioniert jedenfalls problemlos.

Technik: Visual Studio 2008, Microsoft-Reporting Services mit lokalen rdlc-Reports und dem ReportViewer

Hallo zusammen.

Sagen wir eine Tabelle beginnt eigentlich in der mitte einer Seite und hat so wenige Einträge, dass sie auf eine einzelne Seite in der Druckvorschau passt: Dann entscheidet sich die Render-Engine leider dazu die Tabelle komplett auf die nächste Seite in meinem Ausdruck zu verschieben. Sind es ZU VIELE Einträge für eine einzelne DIN-A4 Seite bemerkt der Renderer dies und beginnt die Tabelle in der Mitte der anfangs erwähnten Seite zu zeichnen: Seitenumbrüche müssen in dem Fall sowieso akzeptiert werden wegen der Menge der Einträge.

Ich möchte keine Lücken. Es wäre mir sehr willkommen das die Tabelleneinträge über mehrere Seiten im Ausdruck gestreckt werden. Wie also kann ich dem Renderer mitteilen, dass er derartige "Optimierungen" am Layout nicht vornehmen soll?

(Die Einstellungen "Tabelle möglichst auf eine einzelne Seite anpassen" bzw "KeepTogether" sind nicht aktiviert)

Danke und schönes Wochenende

Hallo,
Serialisierung ist schon eine nette sache aber 40MB sind IMHO ein bisschen zu viel des Guten.

Warum?

Hallo

Es gibt ein Addin namens ModelingPowerToys für das Visual-Studio, das auch Assoziationen als Linien im Klassendiagramm darstellen kann:
http://modeling.codeplex.com/

Es sind "13,x" Tage weil nach Mitternacht und in DateTime.Now die Uhrzeit steckt.
Abgerundet -> 13.

Oder ich mach konkrete Strategyklasse, und statte diese mit einem eigenen Attribut aus, welche den Typ anzeigt, auf welchen die Strategy angewendet wird.
Die Factory würde dann per Reflection ermitteln, welche Strategy benutzt werden kann.

Wie seht ihr das?
Habt ihr andere und bessere Vorschläge?

Mir kommen da Kanonen und Spatzen in den Sinn ...

Sorry aber Du willst wegen diesem Schnipsel so einen Aufstand machen? Dann auch noch mit Reflectioning arbeiten?
"Overengineering" vom feinsten...

Den Hinweis auch gelesen?

Ja. Du auch?

Der z-Wert selektiert EINE Farbe aus dem Farbverlauf.

Danke aber wie da ja steht: "Fill with a single solid color".

Der Gradient bildet nur die Farbpalette, aus der eine Farbe mit dem Z-Wert ausgewählt wird.

Leider auch nicht:
"The rectangle, that defines the full area into which all graphics will be rendered".

Nein, die ClientSize bezieht sich ja auf das ganze zedGraph-Control.
Die Höhe der blau gefärbten Fläche wäre zu ermitteln.
Zu dem zedGraph gehört ja auch noch eine Legende, Achsenbeschriftungen u.s.w.

Hallo,

ich habe Messwerte im Bereich 0-100, welche in einem ZedGraph als Säulendiagramm dargestellt werden sollen.

Nun möchte ich gerne einen unskalierten Farbverlauf OHNE Widerholungen verwenden.

Schaut mal auf das Bild im Anhang:

Hier sieht man an dem Balken ganz rechts, dass der LinearGradientBrush irgendwann widerholt wird. Ein Messwert von 100 sollte aber vollem Grün entsprechen.

Erstmal noch der entsprechende Code:

ColorBlend blend = new ColorBlend(3);
blend.Colors = new Color[] { Color.Red, Color.Yellow, Color.Green };
blend.Positions = new float[] { 0.0f, 0.5f, 1f };
            
LinearGradientBrush lg = new LinearGradientBrush(new Point(0, 0), new Point(0, 230), Color.Black, Color.Black);
            
lg.InterpolationColors = blend;
            
myCurve.Bar.Fill = new Fill(lg, AlignH.Left, AlignV.Bottom);

Die 230 im Konstruktorparameter ist der Wert, ab dem die Widerholung beginnt.
Der Wert müsste genau der Höhe der eigentlichen Zeichenfläche für die Säulen entsprechen, so dass es nicht zu einer Widerholung kommen kann, nur habe ich keinen Weg gefunden diesen Wert zu ermitteln. Wegen Skalierung der Winform kommt ein fest einkodierter Wert sowieso nicht in Frage.

Jemand eine Idee, wie man das Problem löst?

Danke

Habe gerade getestet, wie es mit "embedded" Bildern aussieht.
So hätte ich die entsprechend Base64-kodierten Bilder ja dynamisch in die XML-Definition des Reports schreiben können. Aber: Auch bei eingebetteten Bildern wird der Speicher im Anschluß NICHT freigegeben.

Wenn das ein Bug ist, dann ein großer.

Hallo,

in meinen Reports muss ich dynamisch Bilder darstellen. Die sind zum Teil recht groß und nach längerer Verwendung der Software und mehrmaligem Aufrufen des ReportViewers kommt es irgendwann zu einer Out-Of-Memory-Exception.

Folgendes am Ende hilft leider nicht:
reportViewer1.LocalReport.Dispose();
reportViewer1.Dispose();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);

Auf die Bild-Objekte habe ich keinen Zugriff, da ich nur einen URI-kodierten Pfad übergebe und der ReportViewer die Bilder von der HD lädt. Kommt man vielleicht trotzdem irgendwie an die Referenzen, damit ich hinterher aufräumen kann?

Weiß jemand Rat?