C#

public static class MoreTryParse {
	public static bool TryParse(this RectangleF dummy, string s, out RectangleF rect) {
		float x=0;
		float y=0;
		float w=0;
		float h=0;
		if (s.StartsWith("(") && s.EndsWith(")")) s=s.Substring(1, s.Length-2);
		string[] sa=s.Split(',');
		if (sa.Length==4 && float.TryParse(sa[0], out x) && float.TryParse(sa[1], out y) &&
			float.TryParse(sa[2], out w)&& float.TryParse(sa[3], out h)) {
			rect=new RectangleF(x, y, w, h);
			return true;
		} else {
			rect=new RectangleF(0, 0, 0, 0);
			return false;
		}
	}
}

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

string s = "0.0,0.0,1.0,1.0";
RectangleF rect = RectangleF.Parse(s);

Chesnokov Yuriy wrote:

add public static methods

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