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);
    }
}



 

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:
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:
 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);
            }
        }

How to reproduce: create a drill down chart with different area types on the different levels. 
The issue seems to be related to some series not implementing the ILegendInfoProvider interface.

Workaround:
A similar result as having a drill-down chart with series having different area types can be achieved manually using the ChartSelectionController. Please check the attached project and video file.

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.

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 Form1()
{
    InitializeComponent();

    Random rand = new Random();
    for (int i = 0; i < 3; i++)
    {
        LineSeries lineSeries = new LineSeries();    
        lineSeries.DataPoints.Add(new CategoricalDataPoint(rand.Next(-50, 50), "Jan"));
        lineSeries.DataPoints.Add(new CategoricalDataPoint(rand.Next(-50, 50), "Apr"));
        lineSeries.DataPoints.Add(new CategoricalDataPoint(rand.Next(-50, 50), "Jul"));
        lineSeries.DataPoints.Add(new CategoricalDataPoint(rand.Next(-50, 50), "Oct"));
        this.radChartView1.Series.Add(lineSeries);
    }

    this.radChartView1.ShowLegend = true;
    this.radChartView1.ChartElement.LegendPosition = LegendPosition.Bottom;

    ((LineSeries)this.radChartView1.Series[0]).LegendTitle = "S&P 500";
    ((LineSeries)this.radChartView1.Series[1]).LegendTitle = "MSCI Emerging Markets TR Index";
    ((LineSeries)this.radChartView1.Series[2]).LegendTitle = "Great ETF";
}


Workaround:

Font f = new Font("Times New Roman", 10f, FontStyle.Regular);

private void Form1_Load(object sender, EventArgs e)
{
    foreach (LegendItemElement item in this.radChartView1.ChartElement.LegendElement.StackElement.Children)
    {
        item.Font = f;
    }
}

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:

public Form1()
{
    InitializeComponent();
    this.radChartView1.AreaType = ChartAreaType.Polar;
    Random rand = new Random();
    for (int i = 0; i < 80; i++)
    {
        RadarLineSeries s = new RadarLineSeries();
        s.ShowLabels = true;
        for (int j = 0; j < 8; j++)
        {
            s.DataPoints.Add(new CategoricalDataPoint(rand.Next(1, 100), "X" + j));
        }
       
        this.radChartView1.Series.Add(s);
    }
    this.radChartView1.ShowSmartLabels = true;
}

To reproduce:

public Form1()
{
    InitializeComponent();

    this.radChartView1.ShowPanZoom = true;
    Random rand = new Random();
    this.radChartView1.AreaType = ChartAreaType.Polar;
    for (int i = 0; i < 85; i++)
    {
        RadarLineSeries radarPointSeries = new RadarLineSeries();
        for (int j = 0; j < 8; j++)
        {
            radarPointSeries.DataPoints.Add(new CategoricalDataPoint(rand.Next(1, 100), "X" + j));
        }
        this.radChartView1.Series.Add(radarPointSeries);
    }
}

Workaround: set the ShowPanZoom property after the chart is populated with data.

To reproduce:
this.radChartView1.AreaType = Telerik.WinControls.UI.ChartAreaType.Polar;
RadarLineSeries series = new RadarLineSeries(new SizeF(8f, 8f));
series.DataPoints.Add(new CategoricalDataPoint(0.0, "Coding"));
series.LegendTitle = String.Format("Coding");
series.BorderWidth = 2;
radChartView1.Series.Add(series);
series.PolarAxis.Minimum = 0d;
series.PolarAxis.Maximum = 0.0;
series.PolarAxis.TickLength = 4;

Workaround: 
public Form1()
        {
            InitializeComponent();
         
           StringFormat.GenericTypographic.Alignment = StringAlignment.Near;
        }

To reproduce: 
Add horizontal bar series bind to the following data:

myList = new BindingList<MyCustomObject>();
myList.Add(new MyCustomObject(1, "Outdoor"));
myList.Add(new MyCustomObject(0, "Hardware"));
myList.Add(new MyCustomObject(0, "Tools"));
myList.Add(new MyCustomObject(1, "Books"));
myList.Add(new MyCustomObject(1, "Appliances"));

Workaround:
LinearAxis verticalAxis = new LinearAxis();
verticalAxis.LabelFitMode = AxisLabelFitMode.Rotate;
verticalAxis.LabelRotationAngle = 0.1;
verticalAxis.Minimum = 0;
verticalAxis.Maximum = 2;

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.

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:
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);
            }
        }
    }
}

Workaround:

public class CustomLassoZoomController : LassoZoomController
{
    protected override ActionResult OnMouseUp(MouseEventArgs e)
    {
        if (this.MouseDownLocation == Point.Empty || this.MouseMoveLocation == Point.Empty)
        {
            return Controller.Empty;
        }

        return base.OnMouseUp(e);
    }
}

public Form1()
{
    InitializeComponent();

    BarSeries barSeries = new BarSeries("Performance", "RepresentativeName");
    barSeries.Name = "Q1";
    barSeries.DataPoints.Add(new CategoricalDataPoint(177, "Harley"));
    barSeries.DataPoints.Add(new CategoricalDataPoint(128, "White"));
    barSeries.DataPoints.Add(new CategoricalDataPoint(143, "Smith"));
    barSeries.DataPoints.Add(new CategoricalDataPoint(111, "Jones"));
    barSeries.DataPoints.Add(new CategoricalDataPoint(118, "Marshall")); 
    this.radChartView1.Series.Add(barSeries);

    BarSeries barSeries2 = new BarSeries("Performance", "RepresentativeName");
    barSeries2.Name = "Q2";
    barSeries2.DataPoints.Add(new CategoricalDataPoint(153, "Harley"));
    barSeries2.DataPoints.Add(new CategoricalDataPoint(141, "White"));
    barSeries2.DataPoints.Add(new CategoricalDataPoint(130, "Smith"));
    barSeries2.DataPoints.Add(new CategoricalDataPoint(88, "Jones"));
    barSeries2.DataPoints.Add(new CategoricalDataPoint(109, "Marshall"));
    this.radChartView1.Series.Add(barSeries2);

    CustomLassoZoomController lassoZoomController = new CustomLassoZoomController();
    radChartView1.Controllers.Add(lassoZoomController);
}

If one adds a RadChartView to a form and set its Visibility property to false or creates a chart in memory and tries to export it to an image the result would not look as expected.

Steps to reproduce:

1. Add a chart with bar series to a form

2. Set the border of the bars to be larger than 2px

You will see that bars are taller/longer with the border applied than they are without a border.