First of all, this is rather odd code... I'm not sure why you'd use an
enum value as an array size. Regardless, you would go about this in a
very different way in C#.
For the size, you can quite handily declare a constant:
public const int liffeSizeAutoMarketRef = 15;
As for array sizes, C#, unlike C, knows the size of every array. This
is why I always used typedefs in C: so that I could remember how big
the array was, and relate the array back to a length constant. If I had
declared everything as simply char[] or char * in C, I wouldn't know
how big it was and how much I could store in it.
This isn't a problem in C# for three reasons.
First, because you don't usually declare character arrays the way that
you demonstrated. You more usually use the "string" type, which
provides a variable-length string. No more overrun checking.
Second, because every array in C# (including strings) know their
length, so it's no longer necessary to use clever naming conventions
(like typedefs) to keep track of how big the array is. In C# you just
ask it:
if (index >= liffeAutMarketReference.Length)
{ ... }
Third, because unlike C, C# encourages you to create arrays at run time
rather than at compile time. You can still declare them as constant
length, but even in C that was often not what you wanted. The length
was usually a guess at how much information would need to be stored. C#
provides a plethora of array-like memory structures that you can
create, add items to, and remove items from on the fly, and the array
always knows how many items it's holding. Even real, hard-and-fast
arrays in C# can be allocated at run time and given dimensions that are
known only at run time. Because arrays always know how big they are,
there is no need for the meticulous accounting that was required in C
(and that includes typedefs).
Finally, you may want your array to exhibit special behaviour. For
example, you may want a string that is never longer than 15 characters,
or you may want an array of 15 characters indexed by enumerated values.
In these cases you should create a whole new class that defines this
new behaviour and allows callers to perform only valid operations on
the array and its contents. You then instantiate a new instance of that
class as your "array" and work with it.
In summary, C# doesn't have typedefs because it has different solutions
to the problems that typedefs addressed in C. I would claim that you
shouldn't use typedefs in C#, and you shouldn't try to emulate them,
because if you are, then your way of solving programming problems is
going against the grain of the C# language, and as a result you're
misusing the tool. Spitting into the wind, so to speak.
