To reproduce:
  protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            InitializeComponent();

            radChartView1 = new RadChartView();
            this.Controls.Add(radChartView1);

            DateTimeContinuousAxis asseX = new DateTimeContinuousAxis();
            LinearAxis asseY = new LinearAxis();

            asseY.AxisType = AxisType.Second;
            asseY.Minimum = 0;
            asseY.Maximum = 200;
            asseY.HorizontalLocation = Telerik.Charting.AxisHorizontalLocation.Right;
            asseY.LabelFormat = "{0} °C";

            LineSeries serie = new LineSeries();

            serie.DataPoints.Add(new CategoricalDataPoint(150, DateTime.Now));
            serie.VerticalAxis = asseY;
            serie.HorizontalAxis = asseX;

            radChartView1.Series.Add(serie);
        }

Workaround is available in the attached project.

To reproduce:

SteplineSeries stepLineSeries = new SteplineSeries();
stepLineSeries.DataPoints.Add(new CategoricalDataPoint(12, "Jan"));
stepLineSeries.DataPoints.Add(new CategoricalDataPoint(42, "Apr"));
stepLineSeries.DataPoints.Add(new CategoricalDataPoint(28, "Jul"));
stepLineSeries.DataPoints.Add(new CategoricalDataPoint(12, "Oct"));
this.radChartView1.Series.Add(stepLineSeries);  

CartesianArea area = this.radChartView1.Area as CartesianArea ;
area.Orientation = Orientation.Horizontal;

Please refer to the attached screenshots.

Workaround: use LineSeries with custom CartesianRenderer:

public Form1()
{
    InitializeComponent();

    this.radChartView1.CreateRenderer += radChartView1_CreateRenderer;

    LineSeries lineSeries = new LineSeries();
    lineSeries.DataPoints.Add(new CategoricalDataPoint(12, "Jan"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(42, "Apr"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(28, "Jul"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(12, "Oct"));
    this.radChartView1.Series.Add(lineSeries);
    
    CartesianArea area = this.radChartView1.Area as CartesianArea ;
    area.Orientation = Orientation.Horizontal;
}

private void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
{
    e.Renderer = new CustomCartesianRenderer((CartesianArea)e.Area);
}

public class CustomCartesianRenderer : CartesianRenderer
{
    public CustomCartesianRenderer(CartesianArea area) : base(area)
    {
    }

    protected override void Initialize()
    {
        base.Initialize();

        for (int i = 0; i < this.DrawParts.Count; i++)
        {
            LineSeriesDrawPart drawPart = this.DrawParts[i] as LineSeriesDrawPart;
            if (drawPart != null)
            {
                this.DrawParts[i] = new CustomLineDrawPart((LineSeries)drawPart.Element, this);
            }
        }
    }
}

public class CustomLineDrawPart : LineSeriesDrawPart
{
    public CustomLineDrawPart(LineSeriesBase series, IChartRenderer renderer) : base(series, renderer)
    {
    }

    protected override GraphicsPath GetLinePaths(PointF[] points)
    {
        GraphicsPath path = new GraphicsPath();
        PointF x;
        PointF y;
        List<PointF> pointsList = points.ToList();

        CartesianArea area = this.Element.Parent as CartesianArea;
        if (area != null && area.Orientation == Orientation.Horizontal)
        {
            pointsList = pointsList.OrderBy(p => p.Y).ThenBy(p => p.X).ToList();
        }
        
        if (pointsList.Count > 1)
        {
            for (int i = 1; i < pointsList.Count; i++)
            {
                x = pointsList[i - 1];
                y = pointsList[i];
                path.AddLine(x.X, x.Y, y.X, x.Y);
                path.AddLine(y.X, x.Y, y.X, y.Y);
            }
        }
        else
        {
            return null;
        }

        return path;
    }
}

To reproduce:
BarSeries barSeries = new BarSeries("Performance", "RepresentativeName");
barSeries.Name = "Q1";
barSeries.DataPoints.Add(new CategoricalDataPoint(1000000, "Harley Harley Harley Harley Smith"));
barSeries.DataPoints.Add(new CategoricalDataPoint(2000000, "White"));
barSeries.DataPoints.Add(new CategoricalDataPoint(3000000, "Smith Smith Smith Smith Smith mith Smith Harley"));
barSeries.DataPoints.Add(new CategoricalDataPoint(4000000, "Jones"));
barSeries.DataPoints.Add(new CategoricalDataPoint(5000000, "Marshall"));
this.radChartView1.Series.Add(barSeries);

this.radChartView1.GetArea<CartesianArea>().Orientation = Orientation.Horizontal;

LinearAxis horizontalAxis = radChartView1.Axes.Get<LinearAxis>(1);
horizontalAxis.ClipLabels = false;


Workaround:
void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
{
    e.Renderer = new CustomCartesianRenderer(e.Area as CartesianArea);
}
//
public class CustomCartesianRenderer : CartesianRenderer
{
    public CustomCartesianRenderer(CartesianArea area)
        : base(area)
    { }

    protected override void Initialize()
    {
        base.Initialize();

        for (int i = 0; i < this.DrawParts.Count; i++)
        {
            AxisLabelDrawPart part = this.DrawParts[i] as AxisLabelDrawPart;
            if (part != null)
            {
                this.DrawParts[i] = new CustomDrawPart((Axis)part.Element, this);
            }
        }
    }
}
public class CustomDrawPart : AxisLabelDrawPart
{
    public CustomDrawPart(Axis axis, IChartRenderer renderer) :base( axis,  renderer)
    {}
    protected override void DrawNoneAndMultiLineLabelElements()
    {
        //base.DrawNoneAndMultiLineLabelElements();
        if (!this.Element.ShowLabels || this.Element.Children.Count == 0)
        {
            return;
        }

        Graphics graphics = this.Renderer.Surface as Graphics;
        RadGdiGraphics radGraphics = new RadGdiGraphics(graphics);

        RadRect plotRect = this.Element.Model.LayoutSlot;
        plotRect.X += this.ViewportOffsetX;
        plotRect.Y += this.ViewportOffsetY;

        CartesianAxis axis = this.Element as CartesianAxis;
        SizeF offset = SizeF.Empty;

        if (axis != null)
        {
            offset = ((CartesianRenderer)this.Renderer).GetAxisOffset(axis);

            if (axis.ClipLabels)
            {
                SizeF size = graphics.MeasureString("W", this.Element.Font);

                RectangleF clipRect = ChartRenderer.ToRectangleF(plotRect);
                clipRect.Y -= size.Height / 2f;
                clipRect.Height += size.Height;
                clipRect.X -= size.Width;
                clipRect.Width += size.Width * 2f;
                clipRect.Offset(offset.ToPointF());

                graphics.SetClip(clipRect);
            }
        }

        using (SolidBrush brush = new SolidBrush(Color.Empty))
        {
            foreach (UIChartElement element in this.Element.Children)
            {
                AxisLabelElement labelElement = element as AxisLabelElement;

                if (labelElement == null || !labelElement.IsVisible)
                {
                    continue;
                }

                string text = labelElement.Text;

                if (string.IsNullOrEmpty(text))
                {
                    continue;
                }

                labelElement.OnAxisLabelFormatting(new ChartAxisLabelFormattingEventArgs(labelElement));
                RadRect slot = labelElement.GetLayoutSlot();

                if (this.Element is CartesianAxis)
                {
                    slot.X += this.ViewportOffsetX;
                    slot.Y += this.ViewportOffsetY;
                }

                if (this.Element.AxisType == AxisType.First)
                {
                    slot.X += (float)((IChartView)this.Element.View).PlotOriginX;
                }
                else
                {
                    slot.Y += (float)((IChartView)this.Element.View).PlotOriginY;
                }

                RectangleF rect = ChartRenderer.ToRectangleF(slot);

                if (axis != null)
                {
                    rect.Offset(offset.ToPointF());
                }

                if (labelElement.BackgroundShape != null)
                {
                    labelElement.BackgroundShape.Paint((Graphics)radGraphics.UnderlayGraphics, rect);
                }

                FillPrimitiveImpl fill = new FillPrimitiveImpl(labelElement, null);
                fill.PaintFill(radGraphics, 0, Size.Empty, rect);

                BorderPrimitiveImpl border = new BorderPrimitiveImpl(labelElement, null);
                border.PaintBorder(radGraphics, 0, Size.Empty, rect);

                if (brush.Color != labelElement.ForeColor)
                {
                    brush.Color = labelElement.ForeColor;
                }

                StringFormat sf = StringFormat.GenericTypographic;
                sf.Alignment = StringAlignment.Near;

                graphics.DrawString(text, labelElement.Font, Brushes.Black, rect.Location, sf);
            }
        }
    }
}

Steps to reproduce:

1. Add a chart to a form.

2. Add and remove series continuously.

3. The memory of the project will only raise and memory will not be freed.

WORKAROUND*:

Clear the data points of the series that is/are removed from the chart.

*Although this will significantly reduce the memory consumption it will not eliminate the memory leak. There will still be a small portion of retained memory.

To reproduce:
LineSeries dailySeries = new LineSeries();
dailySeries.BorderColor = Color.DarkBlue;
dailySeries.BorderWidth = 1;
dailySeries.PointSize = new SizeF(5, 5);
dailySeries.ShowLabels = true;

for (int i = 0; i < 100; i++)
{
    dailySeries.DataPoints.Add(new CategoricalDataPoint(rnd.Next(100), DateTime.Now.AddMonths(i)) { Label = "old" });
}

DateTimeCategoricalAxis categoricalAxis = new DateTimeCategoricalAxis();
categoricalAxis.DateTimeComponent = DateTimeComponent.Date;

categoricalAxis.MajorTickInterval = 10;

categoricalAxis.PlotMode = AxisPlotMode.OnTicks;
categoricalAxis.LabelFormat = "{0:MMM-yy}";
categoricalAxis.ClipLabels = false;
categoricalAxis.LastLabelVisibility = AxisLastLabelVisibility.Visible;

CartesianArea area = this.radChart.GetArea<CartesianArea>();
area.ShowGrid = true;
CartesianGrid grid = area.GetGrid<CartesianGrid>();
grid.DrawHorizontalFills = true;
grid.BorderDashStyle = System.Drawing.Drawing2D.DashStyle.DashDot;

//First assign the axis to the VerticalAxis property and then add the series to the chart
dailySeries.HorizontalAxis = categoricalAxis;

this.radChart.Series.Add(dailySeries);

Workaround: 
Use different value for the MajorTickInterval.

Add Range series similar to those provided by WPF/SL

http://demos.telerik.com/silverlight/#ChartView/Gallery/Range

Steps to reproduce:

1. Add a RadChartView to a form.

2. Add a LassoZoomController to the chart 

3. Run the project and start scrolling the mouse wheel. 

You will see that the chart is not zoomed in our out. If you click on the chart the mouse wheel zooms as expected.



WORKAROUND:

Set the focus to the chart element:

this.radChartView1.Behavior.ItemCapture = this.radChartView1.ChartElement;
this.radChartView1.ChartElement.Focus();

public Form1()
{
    InitializeComponent();

    AreaSeries areaSeries = new AreaSeries();
    areaSeries.DataPoints.Add(new CategoricalDataPoint(13, "Jan"));
    areaSeries.DataPoints.Add(new CategoricalDataPoint(20, "Apr"));
    areaSeries.DataPoints.Add(new CategoricalDataPoint(15, "Jul"));
    areaSeries.DataPoints.Add(new CategoricalDataPoint(16, "Oct"));
    this.radChartView1.Series.Add(areaSeries);

    AreaSeries areaSeries2 = new AreaSeries(); 
    areaSeries2.DataPoints.Add(new CategoricalDataPoint(15, "Jan"));
    areaSeries2.DataPoints.Add(new CategoricalDataPoint(25, "Apr"));
    areaSeries2.DataPoints.Add(new CategoricalDataPoint(27, "Jul"));
    areaSeries2.DataPoints.Add(new CategoricalDataPoint(18, "Oct"));
    this.radChartView1.Series.Add(areaSeries2);

    this.radChartView1.ShowTrackBall = true;
    this.radChartView1.Series.First().IsVisible = false;
}

Please refer to the attached sample video.

Workaround 1: remove the series instead of hiding it.

Workaround 2:

private void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
{
     e.Renderer = new CustomCartesianRenderer(e.Area as CartesianArea);
}

public class CustomCartesianRenderer : CartesianRenderer
{
    public CustomCartesianRenderer(CartesianArea area) : base(area)
    {
    }

    private int renderPass = 0;

    public override void Draw(object context)
    {
        if (renderPass < 2)
        {
            if (this.Area.View.Owner.Control.Site == null)
            {
                for (int i = 0; i < this.Area.Series.Count; i++)
                {
                    if (this.Area.Series[i].IsVisible && !this.Area.Series[i].Model.IsArrangeValid)
                    {
                        this.Area.View.Layout();
                        renderPass++;
                        return;
                    }
                }
            }
        }
        FieldInfo fi = typeof(ChartRenderer).GetField("surface", BindingFlags.Instance | BindingFlags.NonPublic);
        if (context != null)
        {
            fi.SetValue(this, context);
        }
        Initialize();

        for (int i = 0; i < this.DrawParts.Count; i++)
        {
            this.DrawParts[i].Draw();
        }
    }
}

To reproduce:
- Enable the Trackball.
- Add 2 series to the chart.
- Remove and add back the first one.
- Move the mouse over the chart.

Workaround:
class MyChartTrackballController : ChartTrackballController
{
    protected override string GetPointText(DataPoint point)
    {
        if (point.Presenter != null)
        {
            return base.GetPointText(point);
        }
        else
        {
            CategoricalDataPoint p = point as CategoricalDataPoint;
            if (p!= null)
            {
                return p.Value.ToString();
            }
        }
        return "";
    }
} 

To reproduce:
public RadForm1()
{
    InitializeComponent();

    LineSeries lineSeries = new LineSeries();
    lineSeries.DataPoints.Add(new CategoricalDataPoint(40, "Jan"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(22, "Apr"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(12, "Jul"));
    lineSeries.DataPoints.Add(new CategoricalDataPoint(19, "Oct"));
    lineSeries.ShowLabels = true;
    this.radChartView1.Series.Add(lineSeries);

    LineSeries lineSeries2 = new LineSeries();
    lineSeries2.DataPoints.Add(new CategoricalDataPoint(13, "Jan"));
    lineSeries2.DataPoints.Add(new CategoricalDataPoint(15, "Apr"));
    lineSeries2.DataPoints.Add(new CategoricalDataPoint(17, "Jul"));
    lineSeries2.DataPoints.Add(new CategoricalDataPoint(22, "Oct"));
    lineSeries2.ShowLabels = true;
    this.radChartView1.Series.Add(lineSeries2);

    ((CartesianArea)this.radChartView1.View.Area).ShowGrid = true;

    int i = 1;
    foreach (DataPointElement dpe in this.radChartView1.Series[0].Children)
    {
        dpe.IsVisible = false; AnimatedPropertySetting setting = new AnimatedPropertySetting();
        setting.StartValue = false;
        setting.EndValue = true;
        setting.Property = UIChartElement.IsVisibleProperty;
        setting.ApplyDelay = 40 + 40 * i;
        setting.NumFrames = 2;
        setting.ApplyValue(dpe); i++;
    }i = 1;
    foreach (DataPointElement dpe in this.radChartView1.Series[1].Children)
    {
        dpe.IsVisible = false; AnimatedPropertySetting setting = new AnimatedPropertySetting();
        setting.StartValue = false; setting.EndValue = true;
        setting.Property = UIChartElement.IsVisibleProperty;
        setting.ApplyDelay = 60 + 60 * i;
        setting.NumFrames = 2;
        setting.ApplyValue(dpe); i++;
    }
}

Workaround:
Perform the animation in the Shown event.

The lasso controller should zoom vertically as well.

To reproduce:
 protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            radChartView1 = new RadChartView();
            radChartView1.Parent = this;

            this.radChartView1.AreaType = ChartAreaType.Pie;
            PieSeries series = new PieSeries();
            series.DataPoints.Add(new PieDataPoint(50, "Germany"));
            series.DataPoints.Add(new PieDataPoint(70, "United States"));
            series.DataPoints.Add(new PieDataPoint(40, "France"));
            series.DataPoints.Add(new PieDataPoint(25, "United Kingdom"));
            series.ShowLabels = true;
            this.radChartView1.Series.Add(series);

            (series.Children[0] as PiePointElement).RadiusAspectRatio = 1.2f;
      }

Workaround:

  protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            radChartView1 = new RadChartView();
            radChartView1.Parent = this;

            this.radChartView1.AreaType = ChartAreaType.Pie;
            PieSeries series = new PieSeries();
            series.DataPoints.Add(new PieDataPoint(50, "Germany"));
            series.DataPoints.Add(new PieDataPoint(70, "United States"));
            series.DataPoints.Add(new PieDataPoint(40, "France"));
            series.DataPoints.Add(new PieDataPoint(25, "United Kingdom"));
            series.ShowLabels = true;
            this.radChartView1.Series.Add(series);

            (series.Children[0] as PiePointElement).RadiusAspectRatio = 1.2f;

            this.radChartView1.CreateRenderer += new ChartViewCreateRendererEventHandler(radChartView1_CreateRenderer);
        }

        void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
        {
            e.Renderer = new CustomPieRenderer(e.Area as PieArea);
        }

        public class CustomPieRenderer : PieRenderer
        {
            public CustomPieRenderer(PieArea area)
                : base(area)
            { }

            protected override void Initialize()
            {
                base.Initialize();

                for (int i = 0; i < this.DrawParts.Count; i++)
                {
                    PieSeriesDrawPart piePart = this.DrawParts[i] as PieSeriesDrawPart;
                    if (piePart != null)
                    {
                        this.DrawParts[i] = new CustomPieSeriesDrawPart((PieSeries)piePart.Element, this);
                    }
                }
            }

        }

        class CustomPieSeriesDrawPart : PieSeriesDrawPart
        {
            public CustomPieSeriesDrawPart(PieSeries series, IChartRenderer renderer)
                : base(series, renderer)
            {

            }

            public override void DrawSeriesParts()
            {
                //base.DrawSeriesParts();

                PieSeriesModel model = this.Element.Model as PieSeriesModel;
                float diameter = CalculateDiameter();

                if (diameter > 0)
                {
                    DrawPieSegments(model, diameter);
                }
            }

            private float CalculateDiameter()
            {
                PieSeriesModel model = this.Element.Model as PieSeriesModel;
                double diameter = Math.Min((float)model.LayoutSlot.Width, (float)model.LayoutSlot.Height) * ((PieSeries)Element).RadiusFactor;

                return (float)diameter;
            }

            private void DrawPieSegments(PieSeriesModel model, float diameter)
            {
                Graphics gr = ((PieRenderer)this.Renderer).Graphics;
                RadGdiGraphics radGraphics = new RadGdiGraphics(gr);

                for (int i = 0; i < model.DataPoints.Count; i++)
                {
                    PiePointElement childElement = (PiePointElement)this.Element.Children[i];
                    PieDataPoint piePoint = (PieDataPoint)childElement.DataPoint;

                    float finalDiameter = diameter * childElement.RadiusAspectRatio;
                    GraphicsPath path = ConstructGraphicsPath(piePoint, model.LayoutSlot, finalDiameter);
                    UpdatePointPaths(piePoint, path);
                    System.Drawing.RectangleF rect = GetPieSectionRect(piePoint, model.LayoutSlot, finalDiameter);

                    childElement.GradientAngle = (float)(piePoint.StartAngle + piePoint.SweepAngle / 2);
                    FillPrimitiveImpl fill = new FillPrimitiveImpl(childElement, null);
                    fill.PaintFill(radGraphics, path, rect);

                    BorderPrimitiveImpl border = new BorderPrimitiveImpl(childElement, null);
                    border.PaintBorder(radGraphics, null, path, rect);
                }
            }

            protected System.Drawing.RectangleF GetPieSectionRect(PieDataPoint point, RadRect modelLayoutSlot, float diameter)
            {
                System.Drawing.RectangleF result;

                float x = (float)(modelLayoutSlot.X + (modelLayoutSlot.Width - diameter) / 2);
                float y = (float)(modelLayoutSlot.Y + (modelLayoutSlot.Height - diameter) / 2);

                result = new System.Drawing.RectangleF(x, y, Math.Max(diameter, 1f), Math.Max(diameter, 1f));

                if (point.OffsetFromCenter > 0)
                {
                    System.Drawing.PointF offset = GetOffset(point.StartAngle + (point.SweepAngle / 2), (diameter / 2) * (point.OffsetFromCenter));
                    result.X += offset.X;
                    result.Y += offset.Y;
                }

                return result;
            }

            private System.Drawing.PointF GetOffset(double angle, double radius)
            {
                double angleInRad = angle * RadMath.DegToRadFactor;

                double x = (Math.Cos(angleInRad) * radius);
                double y = (Math.Sin(angleInRad) * radius);

                return new System.Drawing.PointF((float)x, (float)y);
            }
        }

To reproduce:
Enable the smart labels and export the chart using custom size:
 this.radChartView1.ExportToImage(@"C:\df.png", new Size(1100,1100), System.Drawing.Imaging.ImageFormat.Png);

Workaround:
class MyPieRenderer : PieRenderer
{
    
    public MyPieRenderer(PieArea area) : base(area)
    {
    }

    protected override void Initialize()
    {
        base.Initialize();

        var area = this.View;

        SmartLabelsController smartController = null;
        for (int i = 0; i < area.View.Controllers.Count; i++)
        {
            smartController = area.View.Controllers[i] as SmartLabelsController;

            if (smartController != null)
            {
                RadRect viewport = area.View.Viewport;
                viewport.X -= area.View.Margin.Left;
                viewport.Y -= area.View.Margin.Top;
                viewport.Width += area.View.Margin.Horizontal;
                viewport.Height += area.View.Margin.Vertical;

                Rectangle plotArea = new Rectangle((int)viewport.X, (int)viewport.Y, (int)viewport.Width, (int)viewport.Height);
                smartController.CalculateLabelsPositions(area.View.Series, plotArea);

                break;
            }
        }
    }
}
// change like this 
void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
{
    e.Renderer = new MyPieRenderer((PieArea)e.Area);
}

To reproduce
- Add step-line series with two data points.

Workaround:
public class CustomCartesianRenderer : CartesianRenderer
{
    public CustomCartesianRenderer(CartesianArea area) : base(area)
    {
    }

    protected override void Initialize()
    {
        base.Initialize();

        for (int i = 0; i < this.DrawParts.Count; i++)
        {
            SteplineDrawPart linePart = this.DrawParts[i] as SteplineDrawPart;
            if (linePart != null)
            {
                this.DrawParts[i] = new CustomDrawPart((SteplineSeries)linePart.Element, this);
            }
        }
    }
}

public class CustomDrawPart : SteplineDrawPart
{
    public CustomDrawPart(LineSeriesBase series, IChartRenderer renderer)
        : base(series, renderer)
    {
    }
    protected override System.Drawing.Drawing2D.GraphicsPath GetLinePaths(PointF[] points)
    {
        //return base.GetLinePaths(points);
        GraphicsPath path = new GraphicsPath();

         if (points.Length > 1)
        {
            if (this.Element is LineSeries && ((LineSeries)this.Element).Spline)
            {
                path.AddCurve(points, ((LineSeries)this.Element).SplineTension);
            }
            else
            {
                bool isVertical = this.Element.View.GetArea<CartesianArea>().Orientation == System.Windows.Forms.Orientation.Vertical;

                for (int i = 1; i < points.Length; i++)
                {
                    PointF x = points[i - 1];
                    PointF y = points[i];

                    if (isVertical)
                    {
                        path.AddLine(x.X, x.Y, y.X, x.Y);
                        path.AddLine(y.X, x.Y, y.X, y.Y);
                    }
                    else
                    {
                        path.AddLine(x.X, x.Y, x.X, y.Y);
                        path.AddLine(x.X, y.Y, y.X, y.Y);
                    }
                }
            }
        }
        else
        {
            return null;
        }

        return path;
    }
}
//change like this
void radChartView1_CreateRenderer(object sender, ChartViewCreateRendererEventArgs e)
{
    e.Renderer = new CustomCartesianRenderer((CartesianArea)e.Area);
}
 

To reproduce:
- Add line series with large point size and null points.
- Hover a near a point which is close to null point (the line break).

Workaround:
public class MyChartTooltipController : ChartTooltipController
{
    protected override ActionResult OnMouseMove(MouseEventArgs e)
    {
        for (int i = 0; i < this.Area.Series.Count; i++)
        {
            DataPoint point = this.Area.Series[i].HitTest(e.X, e.Y);
            DataPoint hoveredPoint = typeof(ChartTooltipController).GetField("hoveredPoint", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(this) as DataPoint;
            ToolTip toolTip = typeof(ChartTooltipController).GetField("toolTip", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(this) as ToolTip;
            if (point != null && hoveredPoint != point)
            {
                hoveredPoint = point;
                var result = typeof(CategoricalDataPoint).GetMethod("GetTooltipValue", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Invoke(hoveredPoint, null);
                
                if (result == null)
                {
                    return new ChartRefreshResult();
                }
            }
        }
        return base.OnMouseMove(e);
    }
}



 

Having issues withVS2013 & 2015 Q1 Winforms RadChartView control

1. WYSIWYG in design time does not refresh properly after changing axis collection parameters, unless close and reopen the parent winform or custom control
2. by changing an axis collection parameter , seem to end up with multiple extra axes series (originally had axisX, AxisY, and after a minor param change ended up with axis 0 thru 5 (6 in total) and all series where now using axis4 & axis5 not my original axis?
3. I can't see to toggle display on/off of series in winforms via the legend, yet in wpf web it is possible? will this feature be added later?

attached is example of WYSIWYG not working

improvement Suggestions:
I would love to have a major and minor grid (similar to ref: http://thumbs.dreamstime.com/z/screen-digital-oscilloscope-two-types-signal-33269502.jpg)  as most of my work is measurement and scientific in nature. 

I would like to ensure the ratio of X-Y is fixed so that on resize of the control the grid does not skew or stretch  and I loose 1:1 aspect ratio

I look forward to your feedback ;)

By making IsVisibleInLegend = false at design time, get exception during compile (see attached) and also exceptions at run time

Aim:
I need to be able to hide certain chart text from legend

 

RadChartView Control: corrupts legend when set Series IsVisibleInLegend = False in Properties at design time

Simply added a few extra series , and then tried to turn them off in the legend 

screen shot shows too many legent items for the series in the properties window