Other than declaring a member named "FIX_VALUE" in the class where you  
want to use it, you don't.

Personally, I think this is a good thing.  I already have mixed feelings  
about the use of the "using" statement to alias types, but to remove the  
type identifier altogether seems antithetical to some basic tenet of OOP.  
Even in C++ where you could have global constants, it seems to me that  
that's mainly a holdover from C as opposed to something that's a good idea  
when you're actually writing real OOP code.

C# requires that your constants go into some class somewhere, and it also  
requires that all references to any member of a class other than the one  
in which the code doing the referencing exists be qualified to that  
class.  And I think this is a good thing.  I know I'd hate to try to read  
through code where I couldn't immediately tell the difference between  
something that's defined within the class I'm looking at and something  
that's defined elsewhere.  That sort of flattening of the data structures  
removes a large part of what makes OOP so useful from a code maintenance  
point of view.

Besides, I think your idea of a class whose sole task is to hold constants  
is a bit misguided.  Every constant presumably has _some_ reason for  
existing, based on some class that already exists.  IMHO, that's where the  
constant should be declared, rather than some catch-all place.

Conversely, if you have a constant that you _really_ believe _must_ be a  
global constant and has _no_ other legitimate home, then if you find  
yourself using that constant often enough that the few extra keystrokes is  
a problem, you're misusing the constant.  Most of your code should not  
rely on constants; the values should be passed in from some early user of  
the actual constant high up on the call stack or represented as some  
property of a class instance.  If you're typing the same constant name  
over and over, that's a good sign that your code is not generalized  
enough.  Again, that's antithetical to the point of writing OO code.

Without seeing the full code and design, it's hard to say for sure.  But  
it sure sounds like you've got some basic design problem here that needs  
fixing.  Flattening your symbol space so you don't have the type the name  
of the class holding a constant is most likely a poor bandaid for what's  
really going wrong, whatever that happens to be.

Pete