C#

public static class MoreTryParse {
	public static bool TryParse(static, string s, out RectangleF rect) {
		...
	}
}

public void test(string s) {
	RectangleF rect;
	bool result=RectangleF.TryParse(s, out r1);
	log(s+"  result="+result+"  rect="+rect.ToString());
}

public static bool TryParse(static RectangleF, string s, out RectangleF rect) { ... }

public static bool TryParse(static<T>, string s, out RectangleF rect) where T:RectangleF { ... }

BobJanova wrote:

you never know where they are actually defined.

static class Parser {
    static RectangeF ToRectangeF(string s) {
        ....
    }
}

namespace ParseRectangleF
{
  using System;
  using System.Drawing;

  public static class ParserUtility
  {
    /// <summary>
    /// Parse the input string into a valid RectangleF format.
    /// </summary>
    /// <param name="value">The string to convert into the RectangleF format.</param>
    /// <returns>The parsed rectangle.</returns>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name="value"/> is null or an empty string.</exception>
    /// <exception cref="ArgumentException">Thrown if the input string is not in a valid format.</exception>
    public static RectangleF Parse(string value)
    {
      if (string.IsNullOrEmpty(value))
        throw new ArgumentNullException(value);
      // Remove any { or } characters, as generated by the ToString() method.
      value = value.Replace("{", string.Empty).Replace("}", string.Empty).Replace(" ", string.Empty);
      var rectangle = new RectangleF();
      rectangle.X = GetValue(value, "X=");
      rectangle.Y = GetValue(value, "Y=");
      rectangle.Width = GetValue(value, "Width=");
      rectangle.Height = GetValue(value, "Height=");
      return rectangle;
    }

    /// <summary>
    /// Get the relevant value out of the input text and convert it into
    /// a float.
    /// </summary>
    /// <param name="value">The input string to retrieve the value from.</param>
    /// <param name="key">The key used to retrieve the value.</param>
    /// <returns>The value retrieved from the text.</returns>
    /// <exception cref="ArgumentException">Thrown if the input string is not in a valid format.</exception>
    private static float GetValue(string value, string key)
    {
      if (!key.EndsWith("="))
      {
        key += "=";
      }
      int ordinal = value.IndexOf(key, StringComparison.CurrentCultureIgnoreCase);
      int length = ordinal + key.Length;
      int commaPos = value.IndexOf(",", length);
      if (commaPos < length)
      {
        commaPos = value.Length;
      }
      string text = value.Substring(length, commaPos - length);

      float output;
      if (!float.TryParse(text, out output))
      {
        throw new ArgumentException(
          string.Format("The input {0} is not the right format for Parse. It should be formatted like X=nn, Y=, Width=nn, Height=nn.", value));
      }
      return output;
    }
  }
}

RectangleF rect = ParserUtility.Parse("{x=10,  y=10,   width=100,height=300");

RectangleF rect = (RectangleF)(Rectangle)conv.ConvertFromInvariantString("10,10,100,300");

Chesnokov Yuriy wrote:

the values in RectangleF are fractional

using System;
using System.ComponentModel;
using System.Drawing;
using System.Globalization;

public class RectangleFUtilities
{
    public static bool TryParse(string s, out RectangleF result)
    {
        if (string.IsNullOrEmpty(s))
        {
            result = RectangleF.Empty;
            return false;
        }
        s = s.Trim();
        if (s.Length == 0)
        {
            result = RectangleF.Empty;
            return false;
        }
        CultureInfo culture = CultureInfo.CurrentCulture;
        string[] strArray = s.Split(new char[] { culture.TextInfo.ListSeparator[0] });
        float[] numArray = new float[strArray.Length];
        for (int i = 0; i < numArray.Length; i++)
        {
            if (!float.TryParse(strArray[i], out numArray[i]))
            {
                result = RectangleF.Empty;
                return false;
            }
        }
        if (numArray.Length != 4)
        {
            result = RectangleF.Empty;
            return false;
        }
        result = new RectangleF(numArray[0], numArray[1], numArray[2], numArray[3]);
        return true;
    }

    public static string ToString(RectangleF rectangleF)
    {
        CultureInfo culture = CultureInfo.CurrentCulture;
        string separator = culture.TextInfo.ListSeparator + " ";
        TypeConverter converter = TypeDescriptor.GetConverter(typeof(float));
        string[] strArray = new string[4];
        int num = 0;
        strArray[num++] = converter.ConvertToString(null, culture, rectangleF.X);
        strArray[num++] = converter.ConvertToString(null, culture, rectangleF.Y);
        strArray[num++] = converter.ConvertToString(null, culture, rectangleF.Width);
        strArray[num++] = converter.ConvertToString(null, culture, rectangleF.Height);
        return string.Join(separator, strArray);
    }
}