ich habe gerade eine kleine Animation geschrieben, da wollte ich verständlicherweise beim Storyboard die TargetProperty-Eigenschafft setzen, als InteliSense(heißt doch so, oder?) das nicht anzeigen wollte. Empfand ich als Merkwürdig - als ich es zu Ende tippte funktionierte alles. Weiß jemand woran es liegen kann? Wahrscheinlich ist es ein ganz einfacher und peinlicher Grund, aber sonst merke ich mir diese Namen für C# in der Regel recht langsam, und wenn ich was brauche öffne ich InteliSense und suche nach Dingen, die brauchbar klingen.

edit:spellcheck
edit: mir fällt gerade auf, das würdeInfrastrukturforum passen. Entschuldige mich- zur Not verschieben. Habe gedacht, wenn schon WPF und XAML im InteliSense...

Jetzt ist das Teil komplett abgestürzt(diese Relaces auch). Ich galub, ich mach´s mit Open Office, bis ich mir ein neues kaufe. Danke jedenfalls für die Hilfe.

alternative: man holt sich den Reader zum drucken. Funktioniert.

Hallo zusammen,
Ich habe vor kurzem einen neuen Drucker installiert, und über Wi-Fi angeschlossen. Der Drucker ist an, und kann drucken. Es geht auch... Mein Notenprogramm zb. kann drucken, aber da kommt meine Ur-Version von Word (97), und wenn die über Wi-Fi drucken soll, dann kommt diese Warteschlange, der Status bleibt eine Weile auf "In Warteschlange" und dann stürzt das ganze ding irgendwann einfach ab. Ihr werdet sagen, "kauf dir ein neues Office" (ich hatte das alte irgendwann mal in einer verstaubten Kiste gefunden), mach ich irgendwann auch, aber bei anderen Druckern hat es doch auch geklappt! Wie kann es sein, dass Word nicht über Wi-Fi drucken kann? Ist das einem von euch auch schon passiert?
Wäre dankbar für Hilfe.

wäre echt interessant seinen code zu sehen, finde ich(auch wenn ich die Sprache nicht kann). Leider veröffentlicht das natürlich niemand.
Aber von den Chinesen hätte ich mindestens einen 7-jährigen erwartet. 9- nicht so besonnders, finde ich.
edit: hab mir grad die Sprache auf Wikipedia angesehen. Bin ich froh, C# genommen zu haben. C++ war schon schlimm genug... (man wird es auch schön finden können, schon klar, Geschmackssache)

Respekt, wirklich. Das sieht schon nach was aus...
wie lange habt ihr gebraucht?

müsste das nicht ein TemplateBinding sein? Kann mich irren.
probier mal {TemplateBinding Format}
oder habe ich was übersehen?

dann habe ich das sogar kappiert. Klasse.
Jetzt kommt noch die Physik (wie kann man etwas "nach" etwas differenzieren?)
und der Fundamentalsatz, wobei ich den dann wahrscheinlich nicht kappieren werde. Wist je ein sehr schöner und interessanter Satz, aber wie leitet man den her?

aber die Steigung der Parabel ist doch überall unterschiedlich! Ist die Ableitung f'(x) der Funktion f(x)dann eine Funktion von x, die die Steigung am Punkt P(x|f(x)) berechnet?
Angenommen
f(x)=X² F'(x)=2x
f(5)=25
f'(5)=10
ist die Steigung am Punkt (5|25) gleich 10?

ich verstehe die Berechnung der Steigung an einem bestimmten Punkt, aber die Zusammenfassung der Steigungen an allen Stellen müsste doch eigentlich wieder dieselbe Funktion ergeben(translation weggedacht), oder habe ich das falsch verstanden, oder was wird bei der Ableitung einer Funktion gemacht?

ich verstehe das so, dass an beliebiger Stelle von X² die Steigung dann 2 sein soll, was ja nciht der Fall ist. Was tut man bei der Berechnung der Ableitung? Durchscnittssteigung ausrechnen?

jetzt verstehe ich immerhin den Rechenweg, aber immernoch nicht die Bedeutung des Ergebnises

den Fundamentalsatz verstehe ich auch nicht ganz, vor allem wie man darauf Kommt.

@MasterMax der Link ist ungültig.
tja, dann muss ich damit wohl noch warten. Schade.
Ärgert mich: Integralrechnung war ja nicht mal so schwer, und jetzt kommen da umgedrehte delta-Zeichen...

edit: ich glaub, so leicht geb ich noch nicht auf. Mal sehen was eine Ableitung ist, vielleicht kappiere ich das ja zumindest.

so wie ich das verstehe ist es eine Methode, die Steigung einer Funktion an einem bestimmten Punkt zu ermitteln.

welche Bedeutung hat in der Einführung vom Wikipediaartikel(Link die variable x0?(0 als Index?)
einfach frei gewählt?

warum ist die Ableitung von x² an jeder Stelle 2x?

gut, jetzt verstehe ich fast nichts mehr. Die Differentialrechnung erst recht nicht(scheint schwerer zu sein).

in der Physink wird meißt über die Zeit integriert oder? kann mir jemad ein anders Beispiel nennen?

jetzt glaube ich zum dritten Mal, dass ich´s kappiert habe... mich hat offenbar verwirrt, dass die die Funktion gleich ins Integrale geschrieben haben. v(t), ja... Wirklich großer Dank für eure Geduld.

soll man sich dabei etwa "intigriere einfach nochmal" dazudenken? Ist das bei allen intergalen so?

@Jelly das habe ich nicht kappiert.

übrigens ist mir das von Vorhin offenbar immernoch nicht klar.

Wenn Du die Beschleunigung (g*t) (m/s^2) integrierst, hast du erst die Geschwindigkeit (m/s), wenn Du diese dann nochmals integrierst, hast Du die Strecke (m).

moment... da wird aber nur einmal integriert...
Also: Im Endefekt ist das Ergebnis der einen Integralen die Fläche unter dem Graphen(begrurck x achse und Grenzen) in einem a(g ist eine Beschleunigung)-t Diagramm.
ASCII Art:

a in m/s²
|
|
|-g__________________________
|ggggggggggggggggggggg|
|ggggggggggggggggggggg|
|ggggggggggggggggggggg|
|ggggggggggggggggggggg|
|_____________________|________ t in s
0                     |  
                     T

die untere Zeile konnte ich nicht vollmachen, wegen den Unterstrichen.
Die g-Fläche müsste das Ergebnis sein, errechnet sich zu T*g und ha die Einheit m/s - Größe v.
Wo ist da eine nochmalige Integration?

@Toem99
ich meinte damit eigentlich die Stralung, die vom Kraftwerk aus auf die in Kernkraftwerksnähe angesiedelten Menschen wirkt, nicht den Müll.

stimmt. Ich habe da vorhin irgendwas verwechselt. Jetzt verstehe ichs. Vielen Dank (an euch beide)

Ich wollte mich nicht extra in einem anderen Forum anmelden, um das zu fragen. Ich könnt mir das doch sicher auch etwas erklären.
Ich bin erst 8-klässler, und habe diese Sachen eigentlich nicht nötig, aber an vielen Stellen, zb. in Wikipedia, kommen diese Dinger einfach vor.

Was ich weiß: eie Intergral beginnt mit diesem Schnörkelzeichen, bei dem oben und unten die Grenzen stehen. dann kommt aus mir unerklärlichen Gründen ein d, und die Variable gefolgt von der Funktion, die diese benutzt. Das Beschreibt die durch die Grenzen, die Funktion und die X-Achse definierte Fläche. Der Kram mit den vielen unbekannten, und Volumina interessiert mich jetzt erstmal nicht.

Alles schön und gut, ich kann mir auch vorstellen, wozu man es braucht. Jetzt kommts: das Beispiel im Wikipediaartikel:Beispiel für den Integralbegriff in der Physik (Wikipedialink)

Das verstehe ich beim besten Willen nicht - na ja, man kann auch ohne diesen konkreten Fall leben, ich wundere mich nur etwas, dass die Strecke, die ein fallender Körper in der Zeit T zurücklegt gleich der Integration der Funktion gt(FallbeschleunigungZeit) über die Zeit ist.

g ist eine Beschleunigung, also Einheit m/s²; Einheit der Zeit ist s
die Integrierte Fläche müsste meiner Ansicht nach demnach die Einheit m/s haben, oder habe ich das falsch verstanden?

Kann mir das jemand erklären? Wäre euch sehr dankbar.

also wie das aussieht, einfach nur eine Methode überladen.
also im Projekt:

public override void MessageReceived(object sender, MessageReceivedEventArgs eventArgs)
{

}

hier bin ich, und habe diese Diskussion immer mit Spannung verfolgt. Dass ich nichts mehr geschrieben habe, lag daran, dass ich zu dem nicht mehr viel hinzuzufügen hatte.
Solarzellen in der Wüste halte ich ebenfalls für unmachbar. Würde sich auch, wenn man keine anderen Herstellungsmethoden entwickelt, wahrscheinlich niemals lohnen.
Strom aus schwarzen löchern ist für mich in deiser Zeit auch das Abwegigste was mir einfällt. Science Fiction-Visionen.
Die Supraleitung dürfte aber interessant sein.
Übrigens: den Normadenvölkern wird ihr Land jetzt schon weggenommen, und sie werden gezwungen sesshaft zu werden, weil das "modern" ist.

ich habe gerade festgestellt, dass es so einen Thread nicht gibt(kaum zu glauben), also ...
Schweden, das ja vor kurzem gegen diese Energiegewinnung war, hat ja vor kurzem beschlossen, alte Atomkraftwerke zu erneuern, statt sie zu schließen. Auch andere europäische Länder setzen weiter auf Kernkraft. Was haltet ihr von der Entscheidung Deutschlands, nach und nach alle Kraftwerke einfach zu schließen? Ich kenne mich nicht so genau mit den Nach - und Vorteilen der Stromgewinnung aus, aber der CO2 Ausstoß ist soweit ich weiß sehr gering. Das Problem "Sicherheit" müsste man eigentlich auch lösen können.
Den Müll hat man bisher eigentlich auch immer entsorgen können, obwohl es damit natürlich Probleme gibt, wie zb. Versenkung im Wasser, was die ehemal. Sovietische Union soweit ich weiß getan hat, führt zu Mutation von Kleinstlebewesen im Wasser. Die Strahlung, und die damit verbundene (soweit ich weiß geringe) krebserregende Wirkung ist soweit ich weiß auch noch ein Problem - gibt es dafür sinnvolle Lösungen?

Ich persönlich bin für Atomkraft, auch in Deutschland. Für den Klimaschutz ist das, finde ich, ein wichtiger Bereich. Es ist nicht so ohne weiteres möglich, alle Energie aus Erneuerbaren Trägern zu gewinnen, und als Umschtiegslösung eignet es sich, finde ich relativ gut.

Auch wenn man findet, die Nachteile überwägen, ist das Vorhaben Deutschlands, aus der Atomkraft auszusteigen, mit Nachteilen verbunden, wie zum Beispiel die Tatsache, dass wenn nicht genügend Strom produziert wird, er eingekauft werden muss, und die Exportierenden Länder werden endsprechend mehr produzieren, mit Atomkraft.
Wie auch immer, ich hoffe, es gibt kvalifiziertere Meinungen, als meine. Wollte nur mal eine Disskussion anregen.

hab mal nach mikrofon boost gesucht, und auch was gefunden, aber wenn ich das Häkchen ancklicke kommt ein Rauschen aus dem Lautsprecher. merkwürdig.
am Anfang was es besser(trotz rauschen), dann wurde es trotzdem wieder leise.
edit:

Das Problem scheint zu sein, dass er nicht das Mikro nimmt, sondern das eingebaute im Notebook, bzw. das von der Kamera, aber ich sehen nirgens in der Hardweare einen Eintrag für meines-

hallo zusammen,
Ich habe mir mal ein Mikrofon gekauft. Von Sped Link, aber das tut wahrscheinlich gar nichts zur Sache. Modellnummer und so finde ich nicht. Das es so leise war hat mich immer schon genervt, aber jetzt möchte ich das ändern.
Gibt es irgendwelche Möglichkeiten das lauter zu machen? Ich habe in der Systemsteuerung schon lange wirklich alle Regler, wo etwas von Spracheingabe oder Mikrofon, etc. steht ganz nach oben, aber es reicht trotzdem nicht. Gibt es vielleicht noch andere Möglichkeiten? Sonst werde ich mir ein neues Mikro kaufen müssen, wenn das dann so ist, worauf muss man dann beim Kauf achten, damit das nicht wieder passiert? Wäre sehr dankbar für ein paar Tipps

habe jetzt Firefox neuinstalliert. Geht wieder. Danke für die Hilfe.

Ich habe jetzt länger Youtube nicht benutzt, und mir fällt auf, dass ich keine Filme mehr sehen kann, da kommen gleich die Bewertungen und Komentare, kein Flash-Fenster mit Film. Wie kriegt man den Film zu sehen? Wahrscheinlich muss man nur irgendwo draufdrücken, aber ich finde seit einer halben Stunde nichts.
Das Problem tritt auch nur bei Firefox (zur Info: Firefox 3.0.5) auf, aber anstatt dass irgendeine Meldung kommt, wie aktualisieren sie Flash Player, etc. passiert einfach nichts. Das Video ist einfach nicht da. Weiß jemand woran es liegen könne?

hier noch ein Beispiel mit LamdaExpression:

        static void Main(string[] args)
        {
            double d = 100;
            Console.WriteLine(Funktion(d, someval => 2 * someval));
        }
        static double Funktion(double x, Func<double, double> f)
        {
            return f(x);
        }

mein PC ist abgeschmiert, also erst heute: (nicht ganz so gut geworden, wie ich wollte. Beachtet: Man kann die häufigkeit der Striche verändern und sie auch ausschalten

Hallo zusammen!
Ich kann es mir gar nicht erklären, dass diese Sache sich so plötzlich einer derart großen Beachtung erfreut. Nach 2 Tagen, eine sehr angenehme Überraschung 😁

Ich werde heute ncoh einen Screenshot posten (der von Seesharp war schon gut, stellt aber nicht den vollen Funktionsummfang dar. Den Tip mit ActualWith etc. habe ich sofort umgesetzt. -peinlich peinlich, dass ich sowas mache 👅

den code mit den Beziersegmenten auch in den Beitrag übernommen - meine Ausrede : damals hatte ich das 2D Kapittel in meinem Buch noch nicht gelesen, und diese ganzen Geometries, Drawings, Segmente usw. hatten mich niedergeschmettert. Wer sich wundert: die Lines-option ist zb. sinnvoll, wenn man einen Aktienkurs darstellen möchte.

Vielen Dank

ich wollte schnell ein paar Sachen aus meinem WPF-Buch ausprobieren, und habe dazu einfach mal schnell in einem neuen Projekt die OnRender-Methode des Windows überschrieben, aber obwohl sie aufgerufen wird, zeigen alle Zeichenvorgänge darauf keine Wirkung! Ich habe das von Anfang an enthaltene Grid entfernt, trotzdem nichts. Warum kann man im überschriebenem OnRender eines Windows nichts zeichnen?
code(auch wenn wahrscheinlich nicht nötig)

protected override void OnRender(DrawingContext drawingContext)
{
      base.OnRender(drawingContext);

      drawingContext.DrawLine(new Pen(Brushes.Red, 11), new Point(0, 50), new Point(50, 50));
      drawingContext.DrawLine(new Pen(Brushes.DarkBlue, 12), new Point(0, 60), new Point(50, 60));

}

einfach in die Codebehind Datei eingefügt. Das Window ist 300x300 groß.
Ergebnis: leeres, weißes Fenster
Ich muss da natürlich nicht unbedingt was zeichnen, kann auch einfach ein eigenes Control basteln, und dann geht es, aber nur aus neugierde: warum passiert nichts???
Wäre euch sehr verbunden.

entweder bin ich jetzt auch verwirrt, oder kannst du auch einfach ein Spezieles EventArgs übergeben, dh. das was du willst, und in den endsprechenden Methoden einfach casten?

edit:spellcheck

Ich arbeite jetzt schon länger an einem Control für WPF, das Funktionen, aber auch graphen allgemein abbilden kann. Es geht um eine Property Points, eine PointCollection (ich habe auch soweit alle Properties als Dependenca Props implementiert), welche relativ zum koordinatenursprung angegeben werden soll, und dann endsprechend vom Programm transformiert wird. Dann werden sie gezeichnet - entweder als winziger Punkt an jeder Position, oder als Polyline. Da gibt es Möglichkeiten (jeder Achse einzeln) andere Maßstäbe zuzuweisen (das Programm unterstützt auch beschriftung der Achsen, die sich auch an die Maßstäbe anpasst, Mit festlegbaren Strichabständen in Absoluten Maßen (natürlich alle Beschriftungen ausschaltbar). Bin sehr froh, wenn ihr mir etwas bei meinen misratenen engl. Kommentaren helft.

Übrigens möchte ich mich an dieser Stelle (auch wenn es nicht dazupasst, in der Hoffnung das hier liest überhaupt jemand) für eine Möglichkeit aussprechen, Text im Beitrag so zu markieren (zb den code), dass er eingeklappt werden kann. Wäre sehr übersichtlich.

Beachtet, ich bin Anfänger mit WPF, und bei allgemein C# bin ich auch noch nicht so gut, obwohl ich das wohl schon etwas länger mache - Bin immer sehr froh, über Verbesserungsvorschläge oder Anmerkungen zu meinem Programierstil.

Noch eine Anmerkung: bei diesem Control empfehle ich es nicht, an einem Template rumzufummeln. Ich habe das Standarttempate dafür verwendet, wobei ich das setzen des Backgrounds gelöscht habe.
Das Ding ist auch kein ContentControl, was bedeuet, dass kein anderer Innhalt eingefügt werden kann. Bei Bildchen im Hintergrund etc. empfehle ich (in dem Fall ImageBrush) auf andere Möglichkeiten zurückzugreifen, obwohl ich keinen großen Sinn in solchen veränderungen sehe.

für WPF 3

aktuell, Verbesserungsvorschläge umgesetzt
22.1.08 ein Paar zum Teil gravierende Fehler entfernt

CODE:

//Component By: ANSI-code
//Version 1.3.1


using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

namespace WpfApplication1
{
    
    public enum KindsOfDrawing { Points, Lines, Curve }

    public class FunktionPlotter : Control
    {


        public static DependencyProperty LineBrushProperty = DependencyProperty.Register("LineBrush", typeof(Brush), typeof(FunktionPlotter), new FrameworkPropertyMetadata(Brushes.Black, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty XUnitProperty = DependencyProperty.Register("XUnit", typeof(Double), typeof(FunktionPlotter), new FrameworkPropertyMetadata(1d, FrameworkPropertyMetadataOptions.AffectsRender, UntitChanged), IsAxisValue0);
        public static DependencyProperty YUnitProperty = DependencyProperty.Register("YUnit", typeof(Double), typeof(FunktionPlotter), new FrameworkPropertyMetadata(1d, FrameworkPropertyMetadataOptions.AffectsRender, UntitChanged), IsAxisValue0);
        public static DependencyProperty TickFrequencyXProperty = DependencyProperty.Register("TickFrequencyX", typeof(Double), typeof(FunktionPlotter), new FrameworkPropertyMetadata(10d, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty TickFrequencyYProperty = DependencyProperty.Register("TickFrequencyY", typeof(Double), typeof(FunktionPlotter), new FrameworkPropertyMetadata(10d, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty ShowInscriptionsProperty = DependencyProperty.Register("ShowInscriptions", typeof(bool), typeof(FunktionPlotter), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty ShowTicksProperty = DependencyProperty.Register("ShowTicks", typeof(bool), typeof(FunktionPlotter), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty KindOfDrawingProperty = DependencyProperty.Register("KindOfDrawing", typeof(KindsOfDrawing), typeof(FunktionPlotter), new FrameworkPropertyMetadata(KindsOfDrawing.Points, FrameworkPropertyMetadataOptions.AffectsRender));
        public static DependencyProperty InscriptionSizeProperty = DependencyProperty.Register("InscriptionSize", typeof(double), typeof(FunktionPlotter), new FrameworkPropertyMetadata(6d, FrameworkPropertyMetadataOptions.AffectsRender));

        public static DependencyProperty PointsProperty;

        Polyline PLines = new Polyline();
        private PointCollection RealPoints { get; set; }

        /// <summary>
        /// defines the Brush of the Line
        /// </summary>
        public Brush LineBrush { get { return (Brush)this.GetValue(LineBrushProperty); } set { this.SetValue(LineBrushProperty, value); } }
        //gets or sets the Points relative to the Middle of the Control.
        public PointCollection Points { get { return (PointCollection)this.GetValue(PointsProperty); } set { this.SetValue(PointsProperty, value); } }
        /// <summary>
        /// defines how meny logical units "one" is on the X axis. no 0 allowed
        /// </summary>
        public Double XUnit { get { return (Double)this.GetValue(XUnitProperty); } set { this.SetValue(XUnitProperty, value); } }
        /// <summary>
        /// defines how meny logical units "one" is on the X axis. no 0 allowed
        /// </summary>
        public Double YUnit { get { return (Double)this.GetValue(YUnitProperty); } set { this.SetValue(YUnitProperty, value); } }
        /// <summary>
        /// sets the frequency of the Matking of the X-Axis and also the InscriptionFrequency for the x-axis
        /// </summary>
        public Double TickFrequencyX { get { return (Double)this.GetValue(TickFrequencyXProperty); } set { this.SetValue(TickFrequencyXProperty, value); } }
        /// <summary>
        /// sets the frequency of the Matking of the Y-Axis and also the InscriptionFrequency for the Y-axis
        /// </summary>
        public Double TickFrequencyY { get { return (Double)this.GetValue(TickFrequencyXProperty); } set { this.SetValue(TickFrequencyXProperty, value); } }
        /// <summary>
        /// sets the TickFrequencyX and the TickFrequencyY Properties. returns the TickFrequencyX Property.
        /// </summary>
        public Double TickFrequency { get { return (Double)this.GetValue(TickFrequencyXProperty); } set { this.SetValue(TickFrequencyYProperty, value); this.SetValue(TickFrequencyXProperty, value); } }
        /// <summary>
        /// if true, the Inscriptions are drawn next to the ticks. Also if ShowTicks is false.
        /// </summary>
        public bool ShowInscriptions { get { return (bool)this.GetValue(ShowInscriptionsProperty); } set { this.SetValue(ShowInscriptionsProperty, value); } }
        /// <summary>
        /// if true, the ticks are drawn.
        /// </summary>
        public bool ShowTicks { get { return (bool)this.GetValue(ShowTicksProperty); } set { this.SetValue(ShowTicksProperty, value); } }


        public KindsOfDrawing KindOfDrawing { get { return (KindsOfDrawing)this.GetValue(KindOfDrawingProperty); } set { this.SetValue(KindOfDrawingProperty, value); } }
        public Double InscriptionSize { get { return (double)this.GetValue(InscriptionSizeProperty); } set { this.SetValue(InscriptionSizeProperty, value); } }




        static FunktionPlotter()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(FunktionPlotter), new FrameworkPropertyMetadata(typeof(FunktionPlotter)));


            FrameworkPropertyMetadata Meta = new FrameworkPropertyMetadata(new PointCollection(), PropChanged, null);

            PointsProperty=DependencyProperty.Register("Points", typeof(PointCollection), typeof(FunktionPlotter),Meta);
        }




        static bool IsAxisValue0(object o)
        {
            return (Double)o != 0;
        }

        static void PropChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is FunktionPlotter)
            {
                ((FunktionPlotter)d).TransformPoints();
            }
        }

        static void UntitChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is FunktionPlotter)
                ((FunktionPlotter)d).TransformPoints();
        }

        void TransformPoints()
        {
            PointCollection Ps = this.Points.CloneCurrentValue();

            RotateTransform RT = new RotateTransform(180);
            RT.CenterX = this.ActualWidth / 2;
            RT.CenterY = this.ActualHeight / 2;

            for (int i = 0; i < Ps.Count; i++)
            {
                Point temp = new Point(Ps[i].X, Ps[i].Y * -1);
                Ps[i] = new Point(temp.X / this.XUnit + this.ActualWidth / 2, temp.Y / this.YUnit + this.ActualHeight / 2);
            }
            RealPoints = Ps;
            this.RefreshLine();
        }

            

        
        protected override void OnInitialized(EventArgs e)
        {
            base.OnInitialized(e);
            RealPoints = new PointCollection();
        }

        protected void RefreshLine()
        {
            PLines.Points = RealPoints;
            PLines.Measure(new Size(this.ActualWidth, this.ActualHeight));
            PLines.Arrange(new Rect(new Size(this.ActualWidth, this.ActualHeight)));
        }


        protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);

            //Draw Background
            drawingContext.DrawRectangle(this.Background, null, new Rect(RenderSize));

            drawingContext.DrawLine(new Pen(LineBrush, 1), new Point(0, ActualHeight / 2), new Point(ActualWidth, ActualHeight / 2));
            drawingContext.DrawLine(new Pen(LineBrush, 1), new Point(ActualWidth / 2, 0), new Point(Width / 2, ActualHeight));

            
            DrawInscriptions(drawingContext);

            if (KindOfDrawing == KindsOfDrawing.Points && RealPoints.Count > 0)
            {
                foreach (Point P in RealPoints)
                {
                    drawingContext.DrawEllipse(LineBrush, new Pen(LineBrush, 0.4), P, 0.4, 0.4);
                }
            }

            if (KindOfDrawing == KindsOfDrawing.Curve && RealPoints.Count > 0)
            {
                PathSegmentCollection c = new PathSegmentCollection();
                for (int i = 3; i < this.RealPoints.Count; i++)
                    c.Add(new BezierSegment(RealPoints[i - 2], RealPoints[i - 1], RealPoints[i], true));
                drawingContext.DrawGeometry(null, new Pen(LineBrush, 0.4),
                    new PathGeometry(new PathFigure[] { new PathFigure(RealPoints[0], c, false) }));
            }

            if (KindOfDrawing == KindsOfDrawing.Lines && RealPoints.Count > 0)
            {
                RefreshLine();
                drawingContext.DrawGeometry(null, new Pen(LineBrush, 0.8),PLines.RenderedGeometry );
            }

        }

        void DrawInscriptions(DrawingContext drawingContext)
        {
            int overUnder = 0;
            int Counter = 0;
            double valToDraw = 0;
            string ValueToDrawAsString = "";

            #region horizontal
            if (TickFrequencyX != 0)
            {
                //left
                overUnder = 0;
                Counter = 1;//1 to avoid overpainting of other inscriptions
                valToDraw = 0;
                //ValueAsString will be reset automatically

                for (double d = ActualWidth/2; d >= 0; d -= TickFrequencyX)
                {
                    if(ShowTicks)
                    drawingContext.DrawLine(new Pen(Brushes.Black, 2), new Point(d, this.ActualHeight / 2 - 2), new Point(d, this.ActualHeight / 2 + 2));

                    if (ShowInscriptions)
                    {

                        valToDraw = Math.Round((d - ActualHeight / 2) * XUnit, 2);
                        ValueToDrawAsString = valToDraw == 0 ? "" : valToDraw.ToString();

                        overUnder = Counter % 2 == 0 ? (int)(InscriptionSize-5) : (int)(-InscriptionSize - 10 - valToDraw.ToString().Length*2);
                        Counter++;

                        drawingContext.DrawText(new FormattedText(ValueToDrawAsString, new System.Globalization.CultureInfo("DE-de"), FlowDirection.LeftToRight, new Typeface("Areal"), InscriptionSize, Brushes.Black), new Point(d - 5, this.ActualHeight / 2 + overUnder));
                    }
                }
                //right
                overUnder = 0;
                Counter = 0;
                valToDraw = 0;
                ValueToDrawAsString = "";
                for (double d = ActualWidth/2; d <= ActualWidth; d += TickFrequencyX)
                {
                    if (ShowTicks)
                    drawingContext.DrawLine(new Pen(Brushes.Black, 2), new Point(d, this.ActualHeight / 2 - 2), new Point(d, this.ActualHeight / 2 + 2));

                    if (ShowInscriptions)
                    {

                        valToDraw = Math.Round((d-ActualHeight/2)*XUnit, 2);
                        ValueToDrawAsString = valToDraw == 0 ? "" : valToDraw.ToString();

                        overUnder = Counter % 2 == 0 ? (int)(InscriptionSize-5) : (int)(-InscriptionSize - 10 - valToDraw.ToString().Length*2);
                        Counter++;

                        drawingContext.DrawText(new FormattedText(ValueToDrawAsString, new System.Globalization.CultureInfo("DE-de"), FlowDirection.LeftToRight, new Typeface("Areal"), InscriptionSize, Brushes.Black), new Point(d - 5, this.ActualHeight / 2 + overUnder));
                    }
                }
            }
            #endregion
            #region vertical
            if (TickFrequencyY != 0)
            {
                //up
                overUnder = 0;
                Counter = 0;
                valToDraw = 0;
                for (double d = ActualHeight/2; d >=0; d -= TickFrequencyY)
                {
                    drawingContext.DrawLine(new Pen(Brushes.Black, 2), new Point(this.Width / 2 - 2, d), new Point(this.ActualWidth / 2 + 2, d));
                    if (ShowInscriptions)
                    {
                        valToDraw = Math.Round((d - ActualWidth / 2) * YUnit, 2)*-1;
                        ValueToDrawAsString = valToDraw == 0 ? "" : valToDraw.ToString();

                        overUnder = Counter % 2 == 0 ? (int)(InscriptionSize) : (int)(-InscriptionSize - 10 - valToDraw.ToString().Length*2.5);
                        Counter++;

                        drawingContext.DrawText(new FormattedText(ValueToDrawAsString, new System.Globalization.CultureInfo("DE-de"), FlowDirection.LeftToRight, new Typeface("Areal"), InscriptionSize, Brushes.Black), new Point(this.ActualWidth / 2 + overUnder, d - 5));

                    }
                }
                //down
                overUnder = 0;
                Counter = 0;
                valToDraw = 0;
                for (double d = ActualHeight/2; d <= this.ActualHeight; d += TickFrequencyY)
                {
                    drawingContext.DrawLine(new Pen(Brushes.Black, 2), new Point(this.Width / 2 - 2, d), new Point(this.ActualWidth / 2 + 2, d));
                    if (ShowInscriptions)
                    {
                        valToDraw = Math.Round((d - ActualWidth / 2) * YUnit, 2)*-1;
                        ValueToDrawAsString = valToDraw == 0 ? "" : valToDraw.ToString();

                        overUnder = Counter % 2 == 0 ? (int)(InscriptionSize) : (int)(-InscriptionSize - 10 - valToDraw.ToString().Length*3);
                        Counter++;

                        drawingContext.DrawText(new FormattedText(ValueToDrawAsString, new System.Globalization.CultureInfo("DE-de"), FlowDirection.LeftToRight, new Typeface("Areal"), InscriptionSize, Brushes.Black), new Point(this.ActualWidth / 2 + overUnder, d - 5));

                    }
                }
            }
            #endregion
        }
        /// <summary>
        /// calculates the Points from a Funktion
        /// </summary>
        /// <param name="Funcion">Sets the Funktion, which calculates the y value from the X value</param>
        /// <param name="StartVal">sets the x-value to start with.</param>
        /// <param name="EndVal">sets the x-value to end with.</param>
        /// <param name="Accuracy">sets the Interval of Points to Caculate</param>
        public void GetPointsFromFunc(Func<double, double> Funcion, double StartVal, double EndVal, double Interval)
        {
            PointCollection PC = new PointCollection();
            if (Interval == 0)
                throw new InvalidOperationException("The interval must not be 0");

            for (double i = StartVal; i <= EndVal; i += Interval)
            {
                PC.Add(new Point(i, Funcion(i)));
            }
            Points=PC;
        }
    }
}

Schlagwörter: Control Graphen zeichnen

also ich hab´s jetzt so gelöst, dass ich das setzten der Background des Borders im Template verhinder habe, und dann einfach den Hintergrung manuell gezeichnet, und zwar als erstes. Wundert mich aber trotzdem - eigenlich wird das Control doch mein aufruf der base() gezeichnet, das heißt alles was dannach kommt müsste drübergemalt werden.

mein wahrscheinlich relativ durchschnittlicher Desktop: (Doch, es gibt sehr wohl eine Ordnung)

ich bekomme sowas auch immer, aber kann nicht sagen dass das litauisch ist. Ich kann die Sprache nämlich. Versuche mal ein paar Encodings auszuprobieren.
edit:
kriegs auf jeden Fall nicht hin, da was Littauisches rauszukriegen.

ich fänds sehr schön, wenn das Programm Klammern akzeptieren würde.
zb. (x+1)² wirft eine Exception.

darüber hinaus ist zwar zb. f(0.15) bei f(x)=x^9
0.000000038, was zwar in der Wertetabelle als 0 angezeigt werden darf, aber doch nicht als tatsächliche Nullstelle gellten, oder???

also wenn du sie umbenannt hast, muss es funktionieren. Richtig umbenennen, und dann schreiben Namespace.Klassenname, oder, wenn die Klasse im selben Namespace liege, wie die Form, das was du selbst geschrieben hast.

ich habe ein selbsterstelltes Control, das ewas Zeichnet(toll, nicht?). Es ist noch nicht fertig, aber funktioniert soweit. Das Problem: mir ist gerade etwas aufgefallen, dass wenn ich die Background Property setze, der gesammte gezeichnete Innhalt einfach verschwindet. Das ist eigentlich nicht so schlimm - bei dem Control ist es nicht ganz so wichtig, eine BackGroundColor setzen zu können, dennoch wundert es mich. Ich habe win Beispielprojekt gemacht, in dem ich einfach ein UserControl(mein Control leitet aber direkt von Control ab) erstellt habe, dessen OnRender Methode überschrieben, und es mit gesetztem Hintergrund zeichnete. Selbes ergebnis.

        protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);
            drawingContext.DrawLine(new Pen(Brushes.Black, 5), new Point(0, 0), new Point(100, 100));
        }

Ergebnis im Anhang.** Es scheint, die Hintergrundfarbe würde immer oben draufgemalt. Weiß jemand wie man auf den Hintergrund zeichnet. und nicht drunter?**

Das könnte noch helfen: http://msdn.microsoft.com/en-us/library/cc278073(VS.95).aspx

So einfach geht das nicht. Template ist zwar der richtige Weg, aber einfach eine Elipse zuweisen geht natürlich nicht.
Anhaltspunkt:(wenn du´s noch wissen willst)
die Slider-Klasse ist unter anderem mit diesen zwei Attributen gekennzeichnet:

System.Windows.TemplatePartAttribute
Name=PART_SelectionRange
Type=System.Windows.FrameworkElement

System.Windows.TemplatePartAttribute
Name=PART_Track
Type=System.Windows.Controls.Primitives.Track

damit, was man daraus schließen kann müsste man es lösen können. Ich hab´s heute noch nicht geschafft, vielleicht wird´s morgen was. Auf jeden Fall müsste das der richtige Weg sein. Die Track Klasse ist mir noch etwas unklar.

Musste das ValueKonversionAttribute empfehlen. Schadet nicht, oder?

man könnte es doch über die BackGround property, und einen ImageBrush versuchen, oder?

                    <MenuItem Header="hallo">
                        <MenuItem.Background>
                            <ImageBrush ImageSource="Bild.jpg"/>
                        </MenuItem.Background>
                    </MenuItem>

das klappt bei mir soweit ganz gut.

ja tu ich 😁
tut mir leid für den Fehler, ich meinte jeweils 257 und 9.223.372.036.854.775.808
und ich will wie gesagt aus einem string mit dezimalziffern ein byte[] machen,
das heißt in C# :

       static byte[] GetBytesFromDezString(string s)
        {
              byte[] bs;
              //hilfe, mir fällt nichts ein.
              return bs;
        }

[abgeleitet von Projekt]
Ich habe das Problem mit meinem binären Konvertierungsprogramm, dass ich strings, die längere dezimale Ziffernvolgen enthalten, das heißt größer als Int64, nicht in byte[] konvertieren kann.

zb.
string "256"
ergibt

0001 0000 0001

das war das Beispiel für byte, das geht noch mit long, aber was macht man bei
string "9.223.372.036.854.775.807" (Punkte nur zur besseren Lesbarkeit)

0001 0000 0000 0000 0000 0000 0000 0000 0001

(keine Garrantie für richtigkeit)
jedenfalls wisst ihr hoffentlich was ich meine. Möchte möglichst vermeinen eine Lib importieren zu müssen.
Weiß jemand dafür eine Möglichkeit? Mir fällt einfach nichts ein. Das schwierigste ist, dass beim Konvertieren die erste Stelle des Dezimalstrings jede beliebige Stelle des byte[] verändern kann.

using System.Windows.Forms;
using System.Xml.Linq;
using System;
using System.IO; //hat gefehlt.

[assembly: Divine]

class DivineAttribute : Attribute
{
}

namespace ForumsProgramm
{
    class Program
    {
        [STAThread]
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world?");

            if (haveApocalypse())
            {
                string s = "Bye, World!";
                //this.SaySomething(s);
                Program.SaySomething(s);
                //MakePanic(s); Methode nicht vorhanden, Name aktualisiert
                CausePanic(s)
            }
        }

        static void SaySomething(string s)
        {
            MessageBox.Show(s, "Something very important to say");
        }

        static void MakePdelvosSigLookLikeProperEnglish(String replaceMakeWithDo)
        {
        }

        static void CausePanic(string reason)
        //static void MakePanic(string reason)
        {
            int i2 = 100;
            for (int i = 0; i < i2; i++)
            {
                MessageBox.Show("Panic Reason:" + reason, "Incite Panic", MessageBoxButtons.OK);
            }

        }
        static bool haveApocalypse()
        {
            String SFile = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            SFile += "\\settings.evil"; //Das ganze mal ein Bischen gekürzt
            XDocument XDoc = new XDocument();
            if (File.Exists(SFile))
            {
                XDoc = XDocument.Load(SFile);
            }
            //return XDoc != null;
            return XDoc.Root != null;
        }
    }
}

ich warte darauf, dass der code auch mal kompilierbar ist 😉
die methode wurde aktualisiert, aber nicht der aufruf

wie langweilig, du weißt schon, was du zu Weihnachten geschenkt bekommst.

Jedenfalls frohe Weihnachten an alle!

edit 1: offtpiv zu offtopic geändert

Ich habe vor kurzem angefangen, ein Programm (in WPF, da ich einige Bindings verwende habe) zu schreiben, dass zwischen verschiedenen Werttypen, und strings hin-und her konvertiert. Bin auch einigermaßend fertig, allerdings dauert das Bugfix länger als erwartet. Damit ich das Programm vor Weihnachten noch abschließen kann, brauche ich noch kurz Hilfe beim Fehlersuchen.

Das ist der Kern des Programms: eine Klasse, die einen Typ, in und aus dem ich konvertiere darstellt und auch die Konvertierungslogik enthällt:

    public class UsedType
    {

        /// <summary>
        /// wichtig: die String Encodings werden mit ihrer Codepage dargestellt!!!!!!!!!!!
        /// </summary>
        public enum UsedTypes
        {
            int16=-1, int32=-2, int64=-3, float_value=-4, double_value=-5, decimal_value=-6,
            bytes_bin=-7, bytes_hex=-8, bytes_dez=-9
        }

        public UsedTypes TheType { get; set; }
        
        //konstr. etc.

        public static string DoConversion(string input, UsedType InputType, UsedType OutputType)
        {
            string output = "ERROR";
            byte[] convertedInput = new byte[512];
            #region FindConvertedInput
            //if the Input-type s a string Type, Use Encodings.
            if ((int)InputType.TheType > 0)
            {

                Encoding CurrEncoding = Encoding.GetEncoding((int)InputType.TheType);
                convertedInput = CurrEncoding.GetBytes(input);
            }
            else
            {
                switch (InputType.TheType)
                {
                    case (UsedTypes.int16):
                        {
                            convertedInput=BitConverter.GetBytes(Convert.ToInt16(input));
                            break;
                        }
                    case (UsedTypes.int32):
                        {
                            convertedInput = BitConverter.GetBytes(Convert.ToInt32(input));
                            break;
                        }
                    case (UsedTypes.int64):
                        {
                            convertedInput = BitConverter.GetBytes(Convert.ToInt64(input));
                            break;
                        }
                    case (UsedTypes.float_value):
                        {
                            convertedInput = BitConverter.GetBytes(Convert.ToSingle(input));
                            break;
                        }
                    case (UsedTypes.double_value):
                        {
                            convertedInput = BitConverter.GetBytes(Convert.ToDouble(input));
                            break;
                        }
                    case (UsedTypes.decimal_value):
                        {
                            using (MemoryStream stream = new MemoryStream())
                            {
                                using (BinaryWriter writer = new BinaryWriter(stream))
                                {
                                    writer.Write(Convert.ToDecimal(input));
                                    convertedInput = stream.ToArray();
                                }
                            }
                            break;
                        }
                    case (UsedTypes.bytes_bin):
                        {
                            convertedInput = GetBinaryFromBinString(input);
                            break;
                        }
                    case (UsedTypes.bytes_dez):
                        {
                            convertedInput = GetBinaryFromDezString(input);
                            break;
                        }
                    case (UsedTypes.bytes_hex):
                        {
                            convertedInput = GetBinaryFromHexString(input);
                            break;
                        }
                }
            }
            #endregion
            //TODO: Add other If´s to get a convertedInput!!!!!!!!!!!!!!!!!!!!!!!!

            #region FindOutput

            if ((int)OutputType.TheType > 0)
            {

                Encoding CurrEncoding = Encoding.GetEncoding((int)OutputType.TheType);
                output = new string(CurrEncoding.GetChars(convertedInput));
            }
            else
            {
                switch (OutputType.TheType)
                {
                    case (UsedTypes.int16):
                        {
                            output = BitConverter.ToInt16(convertedInput, 0).ToString();
                            break;
                        }
                    case (UsedTypes.int32):
                        {
                            output = BitConverter.ToInt32(convertedInput, 0).ToString(); 
                            break;
                        }
                    case (UsedTypes.int64):
                        {
                            output = BitConverter.ToInt64(convertedInput, 0).ToString();
                            break;
                        }
                    case (UsedTypes.float_value):
                        {
                            output = BitConverter.ToSingle(convertedInput, 0).ToString();
                            break;
                        }
                    case (UsedTypes.double_value):
                        {
                            output = BitConverter.ToDouble(convertedInput, 0).ToString();
                            break;
                        }
                    case (UsedTypes.decimal_value):
                        {
                            
                            using (MemoryStream stream = new MemoryStream())
                            {
                                using (BinaryReader reader = new BinaryReader(stream))
                                {
                                    reader.BaseStream.Write(convertedInput, 0, convertedInput.Length);
                                    output = reader.ReadDecimal().ToString();
                                    
                                }
                            }
                            break;
                        }
                    case (UsedTypes.bytes_bin):
                        {
                            StringBuilder sb = new StringBuilder();
                            string oneByteInBin = "";
                            foreach (byte b in convertedInput)
                            {
                                oneByteInBin=Convert.ToString(b, 2);
                                if (oneByteInBin.Length % 8 != 0)
                                    oneByteInBin = new string('0', oneByteInBin.Length % 8) + oneByteInBin;
                                sb.Append(oneByteInBin);
                            }
                            output = sb.ToString();
                            break;
                        }
                    case (UsedTypes.bytes_dez):
                        {
                            StringBuilder sb = new StringBuilder();
                            foreach (byte b in convertedInput)
                                sb.Append(Convert.ToString(b, 10));
                            output = sb.ToString();
                            break;
                        }
                    case (UsedTypes.bytes_hex):
                        {
                            StringBuilder sb = new StringBuilder();
                            foreach (byte b in convertedInput)
                                sb.Append(Convert.ToString(b, 16));
                            output = sb.ToString();
                            break;
                        }
                }
            }
            #endregion

            return output;
        }

        private static byte[] GetBinaryFromHexString(string input)
        {
            input = input.ToUpper();//accept not only capital letters
            // check if input is valid
            if (!new Regex("^[0-9A-F]*$").IsMatch(input))
                throw new Exception("Die Eigabe ist ungültig");

            //two chars are one byte in hex
            byte[] bytes = new byte[input.Length / 2];

            for (int i = input.Length-1; i >= 0; i-=2)
            {
                bytes[i / 2] = GetByteFromHexString(new string(new char[] { input[i-1], input[i] }));
            }

            return bytes;
        }

        private static byte GetByteFromHexString(string s)
        {
            byte result=0;
            byte b;

            for(int i=1; i>=0;i--)
                if (byte.TryParse(new string(s[i], 1), out b))
                {
                    if (i == 0)
                        result |= (byte)(b * (byte)0x10);
                    else
                        result |= b;
                }
                else
                {
                    byte CaseByte = 0;
                    switch (s[i])
                    {
                        case ('A'): CaseByte = (byte)0xA; break;
                        case ('B'): CaseByte = (byte)0xB; break;
                        case ('C'): CaseByte = (byte)0xC; break;
                        case ('D'): CaseByte = (byte)0xD; break;
                        case ('E'): CaseByte = (byte)0xE; break;
                        case ('F'): CaseByte = (byte)0xF; break;
                    }
                    //wenn i==0, das heißt 2. nibble, multipliziere mit 0x10.
                    if (i == 0)
                        result |= (byte)(CaseByte * (byte)0x10);
                    else
                        result |= CaseByte;
                }

            return result;
            /*byte result = 0;
            byte[] bytes = System.Text.Encoding.GetEncoding(1252).GetBytes(s);
            for (int i = 0; i < bytes.Length; i++)
                result |= (byte)(bytes[i] * ((byte)i) * ((byte)0xF));
            return result;*/
        }

        static byte[] GetBinaryFromBinString(string s)
        {
            // check if input is valid
            if(!new Regex("^[01]*$").IsMatch(s))
                throw new Exception("Die Eigabe ist ungültig");

            byte[] erg = new byte[s.Length / 8];

            for (int j = 0; j < erg.Length; j++)
            {
                byte b = 0;
                for (int i = 7, by = 0; i >= 0; i--, by++)
                {
                    if (s[i+j*8] == '1')
                        b = (byte)(b | ((byte)Math.Pow(2, by)));
                }
                erg[j] = b;
            }

            return erg;
        }
        static byte[] ForOne_GetBinaryFromDezString(string s)
        {

            long erg = Convert.ToInt64(s);

            byte[] arr=BitConverter.GetBytes(erg);
            byte[] temp = (byte[])arr.Clone();
            for (int i = 0; i < temp.Length; i++)
            {
                arr[i] = temp[temp.Length -1 - i];
            }

            return arr;
        }
        static byte[] GetBinaryFromDezString(string s)
        {
            //check, if it´s a valid input
            Regex R = new Regex("^[0-9]*$");
            if (!R.IsMatch(s))
                throw new Exception("Die Eigabe ist ungültig");

            long useless;
            if (Int64.TryParse(s, out useless))
            {
                return ForOne_GetBinaryFromDezString(s);
            }

            throw new NotImplementedException("Die Eingabe ist größer als ein long(Int64). Not implemented.");

            
            return null;
        }
    }

aus der GetBinarryFromDezString werde ich nicht so richtg schlau:
wenn der dezimale string zb heißt:
9.223.372.036.854.775.808

(zur Erinnerung:(long.MaxValue = 9.223.372.036.854.775.807))
muss in bytes binär ja (jetzt zur besseren Übersicht hexadecimal)

1 00 00 00 00 00 00 00 01

was ein long nicht mehr speichern kann, aber wie kommt man denn auf diesen Wert im byte[], wenn man mit der gesammten Zahl gleichzeitig nicht rechnen kann? Da komme ich momentan noch nicht drauf.

Noch die exe als Anhang zum Testen, hoffe mit eurer Hilfe wird es schnell ein manchmal vielleicht ganz nützliches Tool, vor allem für anfänger im bit und byte Bereich. Bin auch völlig aufgeschlossen für beliebig schlimme Beschimpfungen meines Programierstils.
In Höchstem Grade verbunden, ansi_code

Bugs nicht ausgeshlossen, dankbar für Hinweise.

Version 1.1.1

du brauchst auf jeden Fall ein Feld, dann halt ein Privates.
anders geht es meines Erachtens nicht.