To reproduce:
-Add a RadGridView and use the following code snippet:

 public Form1()
 {
     InitializeComponent();

      //add GridViewCheckBoxColumn with DataType to BOOL
     GridViewCheckBoxColumn autoTestingselectColumn = new GridViewCheckBoxColumn();
     autoTestingselectColumn.DataType = typeof(bool);
     autoTestingselectColumn.Name = "AutomatedTestingSelectColumn";
     autoTestingselectColumn.FieldName = "AutomatedTestingSelectColumn";
     autoTestingselectColumn.HeaderText = "Automated Testing Select";
     radGridView1.MasterTemplate.Columns.Add(autoTestingselectColumn);

     //add GridViewCheckBoxColumn with DataType to INT
     GridViewCheckBoxColumn startTestingColumn = new GridViewCheckBoxColumn();
     startTestingColumn.DataType = typeof(int);
     startTestingColumn.Name = "StartTestingColumn";
     startTestingColumn.FieldName = "StartTestingColumn";
     startTestingColumn.HeaderText = "StartTesting";
     radGridView1.MasterTemplate.Columns.Add(startTestingColumn);

     List<Item> items = new List<Item>();
     for (int i = 0; i < 5; i++)
     {
         items.Add(new Item(Guid.NewGuid().ToString(),"Name"+i));
     }

     this.radGridView1.DataSource = items;
      //set the AutoSizeColumnsMode property to Fill
     this.radGridView1.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
 }

 public class Item
 {
     public string UniqueIdentifier { get; set; }
     public string Name { get; set; }
     public Item(string uniqueIdentifier, string name)
     {
         this.UniqueIdentifier = uniqueIdentifier;
         this.Name = name;
     }
 }

-Run the project. As a result 4 columns are displayed: two programmatically added and two coming from the data source.
-Now open the Property Builder at design time and add a GridViewCheckBoxColumn.
-Run the project. As a result, 5 columns are displayed: one added at design time, two programmatically added, two coming from the data source.
-Open the Property Builder again and delete the GridViewCheckBoxColumn.
-Run the project. You will notice that only two columns are displayed. The columns, coming from the data source are not generated.

Workaround: delete columns using the Columns collection at design time, instead of using the property Builder.

To reproduce:
- Subscribe to the following RowsChanged event handler:

void radGridView1_RowsChanged(object sender, GridViewCollectionChangedEventArgs e)
{
    if (e.Action == NotifyCollectionChangedAction.ItemChanged)
    {
        GridViewDataRowInfo updrow = (GridViewDataRowInfo)e.NewItems[0];
        GridViewDataRowInfo oldrow = (GridViewDataRowInfo)e.OldItems[0];

        if (updrow.Cells[2].Value != oldrow.Cells[2].Value)
        {
            Console.WriteLine(updrow.Cells[2].Value);
            Console.WriteLine(oldrow.Cells[2].Value);
        }
    }
}

- You will notice that both values are always equal.

Workaround:
The CellValidating event can be used instead.
 

By design the  MinHeight property is not respected in ColumnGroupsViewDefinition.

The right way to apply MinHeight in the ColumnGroupsViewDefinition is setting the GridViewColumnGroup's RowSpanProperty and GridViewColumnGroupRow's MinHeight property. For example:

            this.columnGroupsView = new ColumnGroupsViewDefinition();
            this.columnGroupsView.ColumnGroups.Add(new GridViewColumnGroup("General") { RowSpan = 40 });
            this.columnGroupsView.ColumnGroups.Add(new GridViewColumnGroup("Details") { RowSpan = 40 });
            this.columnGroupsView.ColumnGroups[1].Groups.Add(new GridViewColumnGroup("Address") { RowSpan = 40 });
            this.columnGroupsView.ColumnGroups[1].Groups.Add(new GridViewColumnGroup("Ime Tam") { RowSpan = 40 });
            this.columnGroupsView.ColumnGroups[0].Rows.Add(new GridViewColumnGroupRow() { MinHeight = 40 });             
            this.columnGroupsView.ColumnGroups[0].Rows.Add(new GridViewColumnGroupRow() { MinHeight = 40 });
            this.radGridView1.Columns["ContactName"].RowSpan = 40;
            this.columnGroupsView.ColumnGroups[0].Rows[0].Columns.Add(this.radGridView1.Columns["CustomerID"]);
            this.columnGroupsView.ColumnGroups[0].Rows[0].Columns.Add(this.radGridView1.Columns["ContactName"]);         
            this.columnGroupsView.ColumnGroups[0].Rows[1].Columns.Add(this.radGridView1.Columns["CompanyName"]);
            this.columnGroupsView.ColumnGroups[1].Groups[0].Rows.Add(new GridViewColumnGroupRow() { MinHeight = 40 });             
            this.columnGroupsView.ColumnGroups[1].Groups[0].Rows[0].Columns.Add(this.radGridView1.Columns["City"]);             
            this.columnGroupsView.ColumnGroups[1].Groups[0].Rows[0].Columns.Add(this.radGridView1.Columns["Country"]);
            this.columnGroupsView.ColumnGroups[1].Groups[1].Rows.Add(new GridViewColumnGroupRow() { MinHeight = 40 });          
            this.columnGroupsView.ColumnGroups[1].Groups[1].Rows[0].Columns.Add(this.radGridView1.Columns["Phone"]);

To reproduce:
Add a RadGridView and fill it with data. Set the first column's IsVisible property to false. Right click over the row to Copy the row content and paste it in Excel. All data is in a single cell. The Clipboard content does not contain the corresponding <TABLE><TR> tags.

Note: if the last columns is hidden, the line-breaks in the copied text are missing.

Workaround: create custom RadGridView and replace the wrong content in the Clipboard:
public class CustomGrid : RadGridView
{
    protected override RadGridViewElement CreateGridViewElement()
    {
        return new CustomRadGridViewElement();
    }
}

public class CustomRadGridViewElement : RadGridViewElement
{
    protected override MasterGridViewTemplate CreateTemplate()
    {
        return new CustomMasterGridViewTemplate();
    }
}

public class CustomMasterGridViewTemplate : MasterGridViewTemplate
{
    public override void Copy()
    {
        base.Copy();
        
        if (Clipboard.ContainsData(DataFormats.Html))
        {
            string data = Clipboard.GetData(DataFormats.Html).ToString();
            StringBuilder sb = new StringBuilder(data);
            if (!data.Contains("<TABLE>"))
            {
                int insertIndex = data.IndexOf("<TD>");
                sb.Insert(insertIndex, "<TABLE><TR>");
            }
            else if (!data.Contains("</TABLE>"))
            {
                int insertIndex = data.LastIndexOf("<TD>");
                sb.Insert(insertIndex, "</TR></TABLE>");
            }
            
            Clipboard.SetData(DataFormats.Html, sb.ToString());
        }
    }
}

To reproduce:
- Open the examples solution in Visual Studio.
- Navigate to hierarchy example.
- Enable the excel like filtering for all templates.
- Start the application and open the hierarchy first look example.
- Add a new row in the second template.
- Add such filter that only the newly added row will remain visible.
- Expand the new added row and try to add new row to it. 

This is not considered an issue, it is how RadGridView works. Here are more details:

In order for a GridDetailViewCellElement  to display a pageview instead of a single table element, either the template of the row holding it has to have more than one child template, or its ShowChildViewCaptions should be true.
Once there is a page view, the tabs in it will be visible at all times, except when some of the templates has no rows and AllowAddNewRow for it is false – if it does not have any rows and the user cannot add row, it is considered that there is no need from it.
If one needs to change the visibility of the tabs, this can be done in the ViewCellFormatting event:
private void RadGridView1_ViewCellFormatting(object sender, CellFormattingEventArgs e)
{
	GridDetailViewCellElement detailCell = e.CellElement as GridDetailViewCellElement;

	if (detailCell != null) {
		foreach (RadPageViewItem item in detailCell.PageViewElement.Items) {
			item.Visibility = Telerik.WinControls.ElementVisibility.Visible;
		}
	}
}

Setting the DataSource is slower (about 1/3 times more)  when ShowColumnHeaders is set to true. Workaround: 

Set the ShowColumnHeaders to false, then set the DataSource and restore the ShowColumnHeaders state:

radGridView1.ShowColumnHeaders = false;
radGridView1.DataSource =  mySource;
radGridView1.ShowColumnHeaders = true;

Workaround - listen for Reset of the rows collection and introduce your modification there:

        radGridView1.Rows.CollectionChanged += Rows_CollectionChanged;

        void Rows_CollectionChanged(object sender, Telerik.WinControls.Data.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == Telerik.WinControls.Data.NotifyCollectionChangedAction.Reset)
            {
                foreach (GridViewRowInfo row in radGridView1.Rows)
                {
                    row.Cells[0].Value = false;
                }
            }
        }

To reproduce:
- Open the hierarchy example in the demo application.
- Select Auto-GenratedDataSet and add a new row in the third level template.
- Select Manually generated for Bound Mode and then re-select Auto-GenratedDataSet
- Try to add new row again. Yo will notice that the new row is not added.

Workaround:
class MyNewRowBehavior : GridNewRowBehavior
{
    protected override bool ProcessEnterKey(KeyEventArgs keys)
    {
        if (this.GridControl.IsInEditMode)
        {
            GridViewSynchronizationService.SuspendEvent(this.GridControl.CurrentRow.ViewTemplate, KnownEvents.CurrentChanged);
            bool result = base.ProcessEnterKey(keys);
            GridViewSynchronizationService.ResumeEvent(this.GridControl.CurrentRow.ViewTemplate, KnownEvents.CurrentChanged);
            return result;
        }
        else
        {
            return base.ProcessEnterKey(keys);
        }
    }
 
    protected override bool ProcessTabKey(KeyEventArgs keys)
    {
        if (this.GridControl.IsInEditMode)
        {
            GridViewSynchronizationService.SuspendEvent(this.GridControl.CurrentRow.ViewTemplate, KnownEvents.CurrentChanged);
            bool result = base.ProcessTabKey(keys);
            GridViewSynchronizationService.ResumeEvent(this.GridControl.CurrentRow.ViewTemplate, KnownEvents.CurrentChanged);
            this.Navigator.SelectNextColumn();
 
            return result;
        }
        else
        {
            return base.ProcessTabKey(keys);
        }
    }
}

The default behavior can be changed as follows:
((BaseGridBehavior)radGridView1.GridBehavior).UnregisterBehavior(typeof(GridViewNewRowInfo));
((BaseGridBehavior)radGridView1.GridBehavior).RegisterBehavior(typeof(GridViewNewRowInfo), new MyNewRowBehavior());

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

    for (int i = 0; i < 10; i++)
    {
        this.radGridView1.Columns.Add("Col" + i);
    }

    for (int i = 0; i < 8000; i++)
    {
        GridViewRowInfo row = radGridView1.Rows.NewRow();
        foreach (GridViewCellInfo cell in row.Cells)
        {
            cell.Value = "Data" + row.Index + "." + cell.ColumnInfo.Index;
        }
        radGridView1.Rows.Add(row);
    }
    GridViewTemplate childTemplate = CreateChildTemplate();
    this.radGridView1.Templates.Add(childTemplate);

    childTemplate.HierarchyDataProvider = new GridViewEventDataProvider(childTemplate);
    this.radGridView1.RowSourceNeeded += radGridView1_RowSourceNeeded;
}

private void radGridView1_RowSourceNeeded(object sender, GridViewRowSourceNeededEventArgs e)
{
    for (int i = 0; i < 10; i++)
    {
        GridViewRowInfo row = e.Template.Rows.NewRow();
        row.Cells["Name"].Value = "Name" + i;
        row.Cells["ProductNumber"].Value = "ProductNumber" + i;

        e.SourceCollection.Add(row);
    }
}

private GridViewTemplate CreateChildTemplate()
{
    GridViewTemplate template = new GridViewTemplate();
    template.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;

    GridViewTextBoxColumn namecolumn = new GridViewTextBoxColumn("Name");
    GridViewTextBoxColumn productNumberColumn = new GridViewTextBoxColumn("ProductNumber");
    template.Columns.AddRange(namecolumn,
        productNumberColumn);

    return template;
}

private void radButton1_Click(object sender, EventArgs e)
{
     this.radGridView1.GridNavigator.SelectLastRow();
}

Workaround: navigate the vertical scrollbar to the last row before calling the SelectLastRow method:

private void radButton1_Click(object sender, EventArgs e)
{
    this.radGridView1.TableElement.RowScroller.Scrollbar.PerformLast();
    this.radGridView1.GridNavigator.SelectLastRow();
}

To reproduce:
Add a RadGridView and use the RowFormatting event for showing rows with errors. Use a timer to change the data. The RowFormatting  event fires when the user does not group rows. But after grouping the rows by any column, the grid is not refreshed according to the applied style in RowFormatting event. In order to reproduce the problem, use the following code:
private readonly BindingList<DataItem> _items = new BindingList<DataItem>();
private readonly Random _rnd = new Random();

public Form1()
{
    InitializeComponent();

    for (var i = 1; i <= 10; i++)
    {
        _items.Add(new DataItem("Text1 = " + i, "Type = None", _rnd.Next(0, 2) == 1));
    }
    radGridView1.DataSource = _items;

    timer1.Start();
}

private void radGridView1_RowFormatting(object sender, Telerik.WinControls.UI.RowFormattingEventArgs e)
{
    var item = e.RowElement.Data.DataBoundItem as DataItem;
    if (item != null && item.IsDataCorrect)
    {
        e.RowElement.ResetValue(VisualElement.ForeColorProperty, ValueResetFlags.Local);
    }
    else
    {
        e.RowElement.ForeColor = Color.Red;
    }
}

private void timer1_Tick(object sender, EventArgs e)
{
    foreach (var item in _items)
    {
        item.IsDataCorrect = _rnd.Next(0, 2) == 1;
    }
}


ic class DataItem : INotifyPropertyChanged

private bool _isDataCorrect;
private string _text;
private string _type;

public DataItem(string text1, string type, bool isOk)
{
    Text = text1;
    Type = type;
    IsDataCorrect = isOk;
}

public event PropertyChangedEventHandler PropertyChanged;

public bool IsDataCorrect
{
    get
    {
        return _isDataCorrect;
    }
    set
    {
        if (_isDataCorrect != value)
        {
            _isDataCorrect = value;
            OnPropertyChanged("IsDataCorrect");
        }
    }
}

public string Text
{
    get
    {
        return _text;
    }
    set
    {
        if (_text != value)
        {
            _text = value;
            OnPropertyChanged("Text1");
        }
    }
}

public string Type
{
    get
    {
        return _type;
    }
    set
    {
        if (_type != value)
        {
            _type = value;
            OnPropertyChanged("Type");
        }
    }
}

protected virtual void OnPropertyChanged(string propertyName)
{
    var handler = PropertyChanged;
    if (handler != null)
    {
        handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

Steps at design time:
1.Add a RadGridView to the from and change its Dock property to Fill.
2.Change its AutoSizeColumnsMode property to Fill.
3.Chage the Form.Size property to Width = 527 and Height = 346.

Use the following code:
public Form1()
{
    InitializeComponent();

    DataTable dt = new DataTable("Items");

    dt.Columns.Add("Id", typeof(int));
    dt.Columns.Add("Description", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("Supplier", typeof(string));

    for (int i = 0; i < 10; i++)
    {
        dt.Rows.Add(i, "Description" + i, i * 0.25, "Supplier" + i);
    }

    radGridView1.DataSource = dt;
}

Workaround: set the AutoSizeColumnsMode property to Fill in the Form.Load event:
private void Form1_Load(object sender, EventArgs e)
{
    radGridView1.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;
}

DECLINED: this happens only when the double click is outside the bounds of the scroll button which is the expected behavior.

To reproduce: When the user clicks too fast on the quite thin area between the grid's scroll-bar arrow button and the row, it fires the CurrentRowChanging event.

Workaround:
private bool cancelChanging = false;

private void radGridView1_CurrentRowChanging(object sender, CurrentRowChangingEventArgs e)
{
if (cancelChanging)
{
e.Cancel = true;
cancelChanging = false;
}
}

private void radGridView1_MouseDoubleClick(object sender, MouseEventArgs e)
{
cancelChanging = false;

RadElement element = this.radGridView1.Behavior.GetHoveredRadElement();

while (element != null)
{
if (element.GetType() == typeof(RadScrollBarElement))
{
cancelChanging = true;
break;
}
element = element.Parent;
}
}

To reproduce:
Add a RadGridView and use the following code. When you expand the first row, the vertical scrollbar is not correct. Scrolling down changes its size. However, if you expand the last row, it takes few seconds to open.

Second scenario:
In addition of the following code, if you change the TableElement.PageViewMode to PageViewMode.ExplorerBar, expanding the first row takes few seconds to load the hierarchical data as well.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        List<Item> items = new List<Item>();
        List<SubItem> subItems = new List<SubItem>();

        for (int i = 1; i <= 3; i++)
        {
            Item item = new Item(i, "Item" + i);
            
            for (int j = 1000; j <= 2010; j++)
            {
                subItems.Add(new SubItem(j, "SubItem" + j, i));
            }

            items.Add(item);
        }

        this.radGridView1.DataSource = items;
        this.radGridView1.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;

        GridViewTemplate template = new GridViewTemplate();
        template.ReadOnly = true;
        template.AutoSizeColumnsMode = GridViewAutoSizeColumnsMode.Fill;

        GridViewRelation relation = new GridViewRelation(this.radGridView1.MasterTemplate, template);
        relation.ParentColumnNames.Add("Id");
        relation.ChildColumnNames.Add("ItemId");
        this.radGridView1.MasterTemplate.Templates.Add(template);
        this.radGridView1.Relations.Add(relation);
        template.DataSource = subItems;
    }
}

public class Item
{
    public int Id { get; set; }

    public string Title { get; set; }

    public Item(int id, string title)
    {
        this.Id = id;
        this.Title = title;
    }
}

public class SubItem
{
    public int Id { get; set; }

    public int ItemId { get; set; }

    public string Name { get; set; }
    
    public SubItem(int id, string name, int itemId)
    {
        this.Id = id;
        this.ItemId = itemId;
        this.Name = name;
    }
}

To reproduce:
1.Add a GridViewCheckBoxColumn and populate the grid with data:
radGridView1.DataSource = Enumerable.Range(1, 100).Select(i => new { Check = i % 2 == 0});
2.Add a RadButton and on its Click event clear the filters:
private void radButton1_Click(object sender, EventArgs e)
{
    radGridView1.MasterTemplate.FilterDescriptors.Clear();
}
3.Run the application and change the filter to show only checked items. Then click the button. The check box in the filtering row for GridViewCheckBoxColumn was not updated properly.

Workaround:
this.radGridView1.BeginUpdate();
radGridView1.MasterTemplate.FilterDescriptors.Clear();
this.radGridView1.EndUpdate();

To reproduce:
1.Use the Self-Referencing Hierarchy help article to fill the grid with data.
2.Subscribe to the ChildViewExpanding event and use the following code snippet:
private void radGridView1_ChildViewExpanding(object sender, ChildViewExpandingEventArgs e)
{
    if (e.ParentRow.ChildRows != null && e.ParentRow.ChildRows.Count > 0)
    {
        e.ParentRow.ChildRows[0].Delete();
    }
}

This issue appears when one clears the relations collection of RadGridView, it appears sporadically and in rare cases

To reproduce:


Create a form and add a timer with interval of 1 second and in tick handler do the following:


void t_Tick(object sender, EventArgs e)
{
    if (this.Controls.Count > 0)
    {
        Control oldGrid = this.Controls[0];
        this.Controls.RemoveAt(0);
        oldGrid.Dispose();




        GC.Collect(3, GCCollectionMode.Forced);
    }




    RadGridView grid = new RadGridView();
    grid.Dock = DockStyle.Fill;
    this.Controls.Add(grid);
}


You will see that the memory consumption will grow.


Workaround:


Use the following custom RadGridView


public class MyRadGridView : RadGridView
{
    protected override RadGridViewElement CreateGridViewElement()
    {
        return new MyElement();
    }
}


public class MyElement : RadGridViewElement
{
    protected override PagingPanelElement CreatePagingPanelElement()
    {
        return new MyPagingPanel();
    }


    protected override Type ThemeEffectiveType
    {
        get
        {
            return typeof(RadGridViewElement);
        }
    }
}


public class MyPagingPanel : PagingPanelElement
{
    protected override void CreateButtonsStripElementChildElements()
    {
        base.CreateButtonsStripElementChildElements();


        this.ButtonsStripElement.Children.Add(this.ButtonsStripElement.Grip);
        this.ButtonsStripElement.Children.Add(this.ButtonsStripElement.OverflowButton);


        this.ButtonsStripElement.Grip.Visibility = this.ButtonsStripElement.OverflowButton.Visibility = ElementVisibility.Collapsed;
    }


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


        this.TextBoxStripElement.Children.Add(this.TextBoxStripElement.Grip);
        this.TextBoxStripElement.Children.Add(this.TextBoxStripElement.OverflowButton);


        this.TextBoxStripElement.Grip.Visibility = this.TextBoxStripElement.OverflowButton.Visibility = ElementVisibility.Collapsed;
    }
}