Struct cannot have an explicit parameterless constructor, only the implicit one, that initializes all members to their default. Struct won't allow destructor in .Net.

Although the CLR allows it, C# does not allow structs to have a default parameterless constructor. The reason is that, for a value type, compilers by default neither generate a default constructor, nor do they generate a call to the default constructor. So, even if you happened to define a default constructor, it will not be called and that will only confuse you. To avoid such problems, the C# compiler disallows definition of a default constructor by the user. And because it doesn't generate a default constructor, you can't initialize fields when defining them.

The default constructor is implicitly defined by C# and you can't implement the default constructor yourself.  The default constructor initializes all struct fields to default values. i.e. integrals are 0, floating points are 0.0, and booleans are false. If you need custom constructor overloads, you can add new constructors, as long as they have one or more parameters.

Listing 1-1 shows the Rectangle struct that includes a constructor overload.

Listing 1-1: Overloading a struct Constructor

/// <summary> 
/// Custom struct type, representing a rectangular shape 
/// </summary> 
struct Rectangle 
{ 
/// <summary> 
/// Backing Store for Width 
/// </summary> 
private int m_width; 
/// <summary> 
/// Width of rectangle 
/// </summary> 
public int Width 
{ 
get 
{ 
return m_width; 
} 
set 
{ 
m_width = value; 
} 
} 
/// <summary> 
/// Backing store for Height 
/// </summary> 
private int m_height; 
/// <summary> 
/// Height of rectangle 
/// </summary> 
public int Height 
{ 
get 
{ 
return m_height; 
} 
set 
{ 
m_height = value; 
} 
} 
/// <summary> 
/// Instantiate rectangle struct with dimensions 
/// </summary> 
/// <param name="width">Width to make new rectangle</param> 
/// <param name="height">Height to make new rectangle</param> 
public Rectangle(int width, int height) 
{ 
m_width = width; 
m_height = height; 
} 
}

The highlighted portion of code in Listing 1-1 is a constructor overload. Constructors are named the same as their containing class, which is Rectangle in this case. This Rectangle constructor overload has two parameters, which it assigns to backing stores that are encapsulated by properties for calling code. Listing 1-2 shows an example of how you would use the constructor overload in Listing 1-1 to instantiate a new Rectangle.

Listing 1-2: Instantiating a struct Through a Constructor Overload

using System; 
/// <summary> 
/// Example of declaring and using a struct 
/// </summary> 
class StructExample 
{ 
/// <summary> 
/// Entry point: execution starts here 
/// </summary> 
static void Main() 
{ 
// instantiate a new Rectangle struct 
// where Width is set to 5 and Height is set to 7 
    Rectangle rect2 = new Rectangle(5, 7); 
// show the value of Width and Height for rect2 
Console.WriteLine("rect2: {0}:{1}", rect2.Width, rect2.Height); 
Console.ReadKey(); 
} 
}

The code in the Main method of Listing 1-1 instantiates a Rectangle struct and displays the values set via the constructor overload. When instantiating rect2, the code passes the values 5 and 7 as arguments. From Listing 1-1, you can see that the Width of rect2 will be set to 5 and the Height of rect2 will be set to 7. Here's the output from Listing 12-4:

rect2: 5:7