instance field of struct

Question

hello friends
i was trying to initialize instance variable of an struct in my coding but i got error that i can not initialize instance member of  struct can any one tell me why cant we initialize instance variable of an struct on other hand we can initialize it in class why it is so.
this is the coding which i was trying hope some will illustrate it to me completely. thank you.
using System; using System.Reflection;
namespace UserDefineConversionExpl {     struct LimitedInt     {         private int _theValue;         private int MaxValue = 50;         private int MinValue = 0;
public int TheValuea         {             get             {                 return _theValue;             }             set             {                 if (value                 {                     _theValue = 0;                 }                 else                 {                     _theValue = value > MaxValue ? MaxValue : value;                 }             }         }         public static implicit operator LimitedInt(int x)         {             LimitedInt li = new LimitedInt();             li.TheValue = x;             return li;         }         public static implicit operator int(LimitedInt li)         {             int x = li.TheValue;             return x;         }         public static LimitedInt operator +(LimitedInt li, int x)         {             LimitedInt liSecond = new LimitedInt();             liSecond.TheValue = li.TheValue + x;             return liSecond;         }     }     class Program     {         static void Main(string[] args)         {             LimitedInt Li;             Li = 8;             Console.WriteLine(Li);             Console.ReadLine();
}     } }

Vulpes · Answer

Well, given that classes do allow field initializers, it would be 'unexpected behavior' if they were set to something different if a default constructor was used than when other instance constructors were used.
So, I think the real question here is why do classes allows field initializers but structs do not?
Although I don't remember ever seeing an 'official' answer to this question, I'm pretty sure the answer is 'efficiency'.
Initializing fields in classes is actually a two stage process. When the memory for an object is allocated, all bytes are set to zero which effectively sets all its fields to their default values. Any field initializers are then executed before the code in the constructor runs.
On the other hand simply declaring a struct is enough to allocate memory for it and, in practice, this memory will be set to zero whether the struct is allocated on the stack or the heap (as part of an object). Even so, the C# compiler still insists that all struct fields are initialized before you can use them - presumably so you don't just use the default values without thinking about it first.
The rationale for having structs in the first place is to have an efficient way of representing small, frequently created/destroyed structures which don't have the overhead of objects or require garbage collection. If structs did allow field intialization, then it would clearly slow down their creation particularly if you were creating a large array of them.
As things stand, the CLR has to do nothing more to initialize a struct than allocate memory for it and I believe the default constructor is actually a mirage - the compiler neither creates nor needs one.
As structs are normally small with only a couple of fields, it's not much extra code to initialize them from a constructor in any case.
So I think it was for these reasons that the C# design team decided not to allow field initializers in structs, even though (quite reasonably) they are allowed in classes.

Prashant Jadhav · Answer

thank you vulpes for your reply but the thing is when we initialize instance variable in class defination even then that class default constructor(parameterless constructor) instatiate its object with those instance variable values which we use for initialization. so my doubt is that why struct cant do this keeping that instance variable values as it is its constructor should intialize other instance variable with their default values and create its object.

Vulpes · Answer

Unlike classes, structs always have an implicit parameterless instance constructor which you're not allowed to override with your own implementation.
This constructor sets all the struct's instance fields to their default values i.e. all bytes zero for value type fields and null for reference type fields.
Consequently,  a struct's instance field declarations are not permitted to include variable initializers as the values might, of course, be different from their default values if the parameterless constructor is used.
However, you can easily get around this restriction here by making MaxValue and MinValue into constants which is perhaps what they should be anyway:
struct LimitedInt     {         private int _theValue;         private const int MaxValue = 50;         private const int MinValue = 0;
public int TheValue         {             get             {                 return _theValue;             }             set             {                 if (value                 {                     _theValue = 0;                 }                 else                 {                     _theValue = value > MaxValue ? MaxValue : value;                 }             }         }         public static implicit operator LimitedInt(int x)         {             LimitedInt li = new LimitedInt();             li.TheValue = x;             return li;         }         public static implicit operator int(LimitedInt li)         {             int x = li.TheValue;             return x;         }         public static LimitedInt operator +(LimitedInt li, int x)         {             LimitedInt liSecond = new LimitedInt();             liSecond.TheValue = li.TheValue + x;             return liSecond;         }     }