What really make difference between structures and classes?

I will enumerate through this article some differences between classes and structures

There is an important question that several people ask in forums and the question is "so what's the difference between structure and class? "Or "In what could be the structure useful as we have already the class that can do perfectly the job?" Those questions could particularly be posed by a java programmer who wants to emigrate from Java to .Net. For this reason I will enumerate through this article some of those differences to make clear the issue.

1. The structures are value types and the classes are reference types. Before stepping to the next point let explain the difference between the two types. Imagine this is the memory within the machine
   
   
   
   
   Figure 1
   
   The value types are stocked in the stack but the reference type no. In fact, what could be really stocked in the stack for the reference types is a pointer that targets an address at the heap level.
   
   Then type of structure objects are stocked in the stack exactly like any value type say an Integer, a double or a float. Meanwhile, memory emplacements could be reserved for the reference types in the heap. Defining heap and stack and the difference between them is beyond the scope of this article but nevertheless I propose this excellent Matthew article to understand the memory mechanism.
   
   http://www.c-sharpcorner.com/UploadFile/rmcochran/csharp_memory01122006130034PM/csharp_memory.aspx?ArticleID=9adb0e3c-b3f6-40b5-98b5-413b6d348b91
   
2. Classes are usually used for large amounts of data, whereas structs are usually used for smaller amount of data
3. Classes could be inherited whereas structures no
4. A structure couldn't be Null like a class
5. A structure couldn't have a destructor such as class
6. A structure can't be abstract, a class can
7. You cannot override any methods within a structure except those belong to type of object
    
   • Equals()
   • GetHashCode()
   • GetType()
   • ToString()
   
   And the other polymorphism technique used for structures is implementing interfaces
    
8. Declared events within a class are automatically locked and then they are Thread safe, at the contrast of the structure type where event couldn't be locked.
9. A structure must have always the default parameter less constructor be defined as public but a class might have one, so you can't define a private parameter less constructor
   
   struct Me
       {
           private Me() // compile-time error
           {
           }
       }
       
   class Me
            {
               private Me() // runs Ok{
            }
    
10. A static constructor is trigged in case of class but not in case of structure
    
    struct myStructure
        {
            static myStructure()
            {
                Console.WriteLine("This is me a structure");
            }
        }
        class myClass

        {
            static myClass()
            {
                Console.WriteLine("This is me a class");
            }
        }

        class Program
        {
            static void Main(string[] args)
            {
               myStructure s = new myStructure();//Nothing happen
               myClass c = new myClass();//Will out put This is me a class
               Console.Read();
            }
        }
     

11. The strucutre can't conatain a volatile field wheatheas the class does
12. You can't use sizeof with classes but you can with structures
13. Fields are automatically initialized with classes to 0/false/null wheatheras in strucutres no
14. Fields couldn't directley instanciated within structures but classes allow such operations
    
    struct myStructure
        {
            public string x = 2;//Not allowed
        }
        class myClass
        {
            public string x = 2; //Allowed
        }
     
15. Structure and class don't adopt the same aproach taward the System.Object.Equals() method
    
    Suppose those Strucutre and class
    
    struct StructurePerson
        {
            public string FirstName;
            public string LastName;
        }
        class ClassPerson
        {
            public string FirstName;
            public string LastName;
        }

    Now, try this code
    
    class Program
        {
            static void Main(string[] args)
            {
                StructurePerson strX = new StructurePerson();
                strX.LastName = "Bejaoui";
                strX.FirstName = "Bechir";
                StructurePerson strY = new StructurePerson();
                strY.LastName = "Bejaoui";
                strY.FirstName = "Bechir";

                if (strX.Equals(strY))
                {
                    Console.WriteLine("strX = strY");
                }
                else
                {
                    Console.WriteLine("strX != strY");
                }//This code displays strX = strY

                ClassPerson clsX = new ClassPerson();
                clsX.LastName = "Bejaoui";
                clsX.FirstName = "Bechir";
                ClassPerson clsY = new ClassPerson();
                clsY.LastName = "Bejaoui";
                clsY.FirstName = "Bechir";

                if (clsX.Equals(clsY))
                {
                    Console.WriteLine("clsX = clsY");
                }
                else
                {
                    Console.WriteLine("clsX != clsY");
                }//This code displays clsX != clsY
                Console.Read();
            }
        }
    
    In the first strucutre case the two objects are value types, they are compared according to their values like int I = 5 and int J = 5 so I=J because they have the same value. At the contrast, in the class case two different and distinct reference are created so to make clsX = clsY you should use this code.
    
                ClassPerson clsX = new ClassPerson();
                clsX.LastName = "Bejaoui";
                clsX.FirstName = "Bechir";
                ClassPerson clsY = clsX;
                if (clsX.Equals(clsY))
                {
                    Console.WriteLine("clsX = clsY");
                }
                else
                {
                    Console.WriteLine("clsX != clsY");

                }//This code displays clsX = clsY
    

That's it

Good Dotneting!!!