Sorry, it's been a hectic day... I didn't finish my post, but somehow
managed to send it anyway....

In the strings, I there are always random numbers, and I want them ignored.
I only want matches on the measurements which can be written about a million
different ways.  This is for pulling data out of a legacy inventory
application.

Any thoughts or suggestions would be very, very much appreciated.  Right
now, my app uses this expression, and removes matches to the empty groups,
but this is just not how it should work.

Thanks,
Trevor_B

One easy suggestion is that you can write "{0,1}" more succinctly as
"?", e.g., "a{0,1}" and "a?" are equivalent.

If you want to insist that one of the groups matches, then say what
you mean.  Remember that the ? and * quantifiers *always* succeed
because they can match nothing.

For complex patterns, I like to use IgnorePatternWhitespace

Your subpatterns are inconsistent, e.g., some included the unit and
some didn't, and even with your followup, I may not be clear on what
you're trying to capture.

Take a look at the code below.  Note how the pattern requires one of
the alternatives to match non-empty strings.

   static void Main(string[] args)
   {
     Regex measurements = new Regex(
       @"
       (?<Fraction>    (\d+\s+)?\d+/\d+"" ) |
       (?<Decimal>     \d+\.\d+""         ) |
       (?<Feet>        \d+'               ) |
       (?<WholeInches> \d+(?![/\w])       )
       ",
       RegexOptions.IgnorePatternWhitespace |
       RegexOptions.ExplicitCapture);

     string[] inputs = {
       "1/4\" x 2\" Flat 44W x 20'",
       "1 1/4\" x 2\" Flat 44W x 20'",
       "1/4\" x 2.5\" Flat 44W x 20'",
       "1/4\" x 2\" Flat 44W x 20' 3\"",
       "1/4\" x 2\" Flat 44W x 20' 3.5\"",
       "1/4\" x 2\" Flat 44W x 20' 1/2\"",
       "1/8\" x 4\" C-1018 flat x 14' 5-1/4\"",
     };

     string[] groups = {
       "Feet", "WholeInches", "Fraction", "Decimal",
     };

     foreach (string input in inputs)
     {
       Console.WriteLine("[" + input + "]:");

       int count = 1;
       foreach (Match m in measurements.Matches(input))
       {
         Console.WriteLine("  - {0}:", count++);

         foreach (string group in groups)
           Console.WriteLine("    - {0}: [{1}]",
             group, m.Groups[group].Value);
       }
     }
   }

Is it at least a start in the right direction?  Should an input such
as [20' 3"] produce one match or two (one for the feet component and
one for the inches component)?  What else needs fixing?

I agree with Mark Noon: regular expressions are fun, so I look forward
to hearing back from you.

Hope this helps,
Greg