public class GridHelpers
{
    // This class used the combination of approaches presented in https://rachel53461.wordpress.com/2011/09/17/wpf-grids-rowcolumn-count-properties/
    // and in http://samondotnet.blogspot.ru/2012/03/wpf-grid-layout-simplified-using-rows.html .
    // I decide to drop out the properties that aren't needed for me - StarRows and StarColumns from the first link and Cell from the second one.
    // I introduced a new more generic properties RowsHeightFormat and ColumnsWidthFormat 
    // that allow to set up widths and heights with mixed styles (through numbers, asterisks, "auto" word, and default value) simultaneously.



    #region RowCount property

    /// <summary>
    /// Adds the specified number of rows to RowDefinitions. 
    /// Row's height has its default value like when you add a row like this: <![CDATA[<RowDefinition />]]>.
    /// </summary>
    public static readonly DependencyProperty RowCountProperty =
        DependencyProperty.RegisterAttached(
            "RowCount",
            typeof(int),
            typeof(GridHelpers),
            new PropertyMetadata(-1, RowCountChanged));

    public static int GetRowCount(DependencyObject target)
    {
        return (int)target.GetValue(RowCountProperty);
    }

    public static void SetRowCount(DependencyObject target, int value)
    {
        target.SetValue(RowCountProperty, value);
    }

    /// <summary>
    /// Adds rows.
    /// </summary>
    /// <param name="target"></param>
    /// <param name="e"></param>
    public static void RowCountChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        if (!(target is Grid) || (int)e.NewValue < 0)
            return;

        Grid grid = (Grid)target;

        grid.RowDefinitions.Clear();

        for (int i = 0; i < (int)e.NewValue; i++)
        {
            grid.RowDefinitions.Add(new RowDefinition());
        }
    }

    #endregion RowCount property

    #region ColumnCount property

    /// <summary>
    /// Adds the specified number of columns to ColumnDefinitions. 
    /// Column's width has its default value like when you add a column like this: <![CDATA[<ColumnDefinition />]]>.
    /// </summary>
    public static readonly DependencyProperty ColumnCountProperty =
        DependencyProperty.RegisterAttached(
            "ColumnCount",
            typeof(int),
            typeof(GridHelpers),
            new PropertyMetadata(-1, ColumnCountChanged));

    public static int GetColumnCount(DependencyObject target)
    {
        return (int)target.GetValue(ColumnCountProperty);
    }

    public static void SetColumnCount(DependencyObject target, int value)
    {
        target.SetValue(ColumnCountProperty, value);
    }

    /// <summary>
    /// Adds columns.
    /// </summary>
    /// <param name="target"></param>
    /// <param name="e"></param>
    public static void ColumnCountChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        if (!(target is Grid) || (int)e.NewValue < 0)
            return;

        Grid grid = (Grid)target;

        grid.ColumnDefinitions.Clear();

        for (int i = 0; i < (int)e.NewValue; i++)
        {
            grid.ColumnDefinitions.Add(new ColumnDefinition());
        }
    }

    #endregion ColumnCount property

    #region RowsHeightFormat property

    /// <summary>
    /// Sets the Height property for rows of the grid.
    /// </summary>
    public static readonly DependencyProperty RowsHeightFormatProperty =
        DependencyProperty.RegisterAttached(
            "RowsHeightFormat",
            typeof(string),
            typeof(GridHelpers),
            new PropertyMetadata(string.Empty, RowsHeightFormatChanged));

    public static string GetRowsHeightFormat(DependencyObject target)
    {
        return (string)target.GetValue(RowsHeightFormatProperty);
    }

    public static void SetRowsHeightFormat(DependencyObject target, string value)
    {
        target.SetValue(RowsHeightFormatProperty, value);
    }

    public static void RowsHeightFormatChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        if (!(target is Grid) || string.IsNullOrEmpty(e.NewValue.ToString()))
            return;

        var grid = (Grid)target;
        var oldValue = e.OldValue as string;
        var newValue = e.NewValue as string;

        if (oldValue == null || newValue == null)
            return;

        if (oldValue != newValue)
        {
            grid.RowDefinitions.Clear();

            newValue
                .Split(new[] { ',' }, StringSplitOptions.None)
                .Select(ParseGridLength)
                .Select(gridLength =>
                {
                    if (gridLength.HasValue)
                        return new RowDefinition { Height = gridLength.Value };
                    else
                        return new RowDefinition();
                })
                .ToList()
                .ForEach(grid.RowDefinitions.Add);
        }
    }

    #endregion RowsHeightFormat property

    #region ColumnsWidthFormat property

    /// <summary>
    /// Sets the Width property for columns of the grid.
    /// </summary>
    public static readonly DependencyProperty ColumnsWidthFormatProperty =
        DependencyProperty.RegisterAttached(
            "ColumnsWidthFormat",
            typeof(string),
            typeof(GridHelpers),
            new PropertyMetadata(string.Empty, ColumnsWidthFormatChanged));

    public static string GetColumnsWidthFormat(DependencyObject target)
    {
        return (string)target.GetValue(ColumnsWidthFormatProperty);
    }

    public static void SetColumnsWidthFormat(DependencyObject target, string value)
    {
        target.SetValue(ColumnsWidthFormatProperty, value);
    }

    public static void ColumnsWidthFormatChanged(DependencyObject target, DependencyPropertyChangedEventArgs e)
    {
        if (!(target is Grid) || string.IsNullOrEmpty(e.NewValue.ToString()))
            return;

        var grid = (Grid)target;
        var oldValue = e.OldValue as string;
        var newValue = e.NewValue as string;

        if (oldValue == null || newValue == null)
            return;

        if (oldValue != newValue)
        {
            grid.ColumnDefinitions.Clear();

            newValue
                .Split(new[] { ',' }, StringSplitOptions.None)
                .Select(ParseGridLength)
                .Select(gridLength =>
                {
                    if (gridLength.HasValue)
                        return new ColumnDefinition { Width = gridLength.Value };
                    else
                        return new ColumnDefinition();
                })
                .ToList()
                .ForEach(grid.ColumnDefinitions.Add);
        }
    }

    #endregion ColumnsLengthFormat property


    private static GridLength? ParseGridLength(string text)
    {
        text = text.Trim();

        // "Auto" grid length.
        if (text.ToLower() == "auto")
        {
            return GridLength.Auto;
        }

        // Proportional grid length set by asterisk.
        else if (text.Contains("*"))
        {
            double starNumber;

            // If there is only single "*" without a number then this is equivalent to "1*".
            if (text.Length == 1)
                starNumber = 1;
            else
                starNumber = double.Parse(text.Substring(0, text.IndexOf('*')), CultureInfo.InvariantCulture);

            return new GridLength(starNumber, GridUnitType.Star);
        }

        // This leaves the length for row or column with default value - when you set it in XAML like this: 
        // <RowDefinition /> or <ColumnDefinition /> - without defining the length actually.
        else if (String.IsNullOrEmpty(text))
            return null;

        // Grid length set by pixels.
        else
        {
            var pixelsCount = double.Parse(text, CultureInfo.InvariantCulture);
            return new GridLength(pixelsCount, GridUnitType.Pixel);
        }
    }
}