Classes are Reference types and Structures are Values types.
When I say Classes are reference types, basically they will contain the address of an instance variables. For example:
Class MyClass
{
Public Int DataMember;
}
In main
method, I can create an instance of this class using new
operator that allocates memory for this class and stores the base address of that into MyClass
type variable.
Static Public void Main (string [] arg)
{
MyClass _myClassObject1 =new MyClass ();
_ myClassObject1.DataMember=10;
MyClass _myClassObject2 =_myClassObject1;
_ myClassObject2.DataMember=20;
}
In the above program, “MyClass _myClassObject2 =_myClassObject1
” instruction indicates that both variables of type MyClass myClassObject1
and myClassObject2
will point to the same memory location. It basically assigns the same memory location into another variable of same type.
So if any changes that we make in any one of the objects type MyClass
will have an effect on another since both are pointing to the same memory location.
“_ myClassObject1.DataMember=10
” at this line both the object’s data members will contain the value of 10
. _ myClassObject2.DataMember=20
at this line both the object’s data member will contains the value of 20
. Eventually, we are accessing datamember
s of an object through pointers.
Unlike classes, structures are value types. For example:
Structure MyStructure
{
Public Int DataMember;
}
Static Public void Main (string [] arg)
{
MyStructure _myStructObject1 =new MyStructure ();
_ myStructObject1.DataMember=10;
MyStructure _ myStructObject2 =_ myStructObject1;
_ myStructObject2.DataMember=20;
}
In the above program, instantiating the object of MyStructure
type using new
operator and storing address into _myStructObject
variable of type MyStructure
and assigning value 10
to data member of the structure using “_ myStructObject1.DataMember=10
”. In the next line, I am declaring another variable_myStructObject2
of type MyStructure
and assigning _myStructObject1
into that. Here .NET C# compiler creates another copy of _myStructureObject1
object and assigns that memory location into MyStructure
variable _myStructObject2
.
So whatever change we make on _myStructObject1
will never have an effect on another variable _myStructObject2
of type MyStructrue
. So that’s why we are saying Structures are value types.
So the immediate Base class for class is Object
and immediate Base class for Structure is ValueType
which inherits from Object
.
Classes will support an Inheritance whereas Structures won’t.
How are we saying that? And what is the reason behind that? The answer is Classes.
It can be abstract
, sealed
, static
, and partial
and can’t be Private
, Protected
and protected internal
.
Why do we want to have class as Abstract?
Abstract
– Abstract
classes are incomplete classes, i.e., they will have combination of implemented and unimplemented methods along with data members, properties, events, delegates and indexers.
The main idea to have class as abstract
is to have only Base
class that can be derivable and that will have basic functionality. As I mentioned above, we can have unimplemented method in abstract
class that gives flexibility to derived classes to implement as required along with basic functionality. And also, we can’t instantiate object of abstract
class. Abstract
class can be with/without abstract
methods. But if methods are declared as abstract
in a class, that class also should be declared as abstract
.
Sealed
– Sealed
classes are classes that are not inheritable. Methods also can be sealed
, that is, those methods declared as sealed
can’t be overridable, i.e., derived classed can’t override those methods. And normal classes can’t have sealed
method. Sealed
keyword should be declared with override
keyword in the derived class' method for which base
class will have virtual
method.
Why do we want to have class and method as Sealed?
The reason to have class and method as sealed is to stop the inheritance at one level.
Where to use sealed?
If you think that class is not to be inherited in your design, you can use class as sealed
. But sealed
class can inherit from interface and class. If you think virtual
method cannot to be inherited in derived class at one stage, we can declare a method with sealed+override combination.
By default structures are sealed
, that is the reason structures are not supporting inheritance.
Why do we want to have class and methods as static?
In your design, if you feel that a class should have a set of methods which operate only on arguments that we pass without initiating object of that class, then we can make that class as static
class (Example: System.Math
). Merely call those instance methods by class name.
How this class will be loaded without creating an object?
If your code accesses any of static
class’s methods, then this is the responsibility of CLR (Common Language Runtime) to load this class into memory once which is the lifetime of your application.
Object of static
class can’t be instantiated. Why? Since static
class can’t have instance constructor. Static
class supports inheritance but other classes can’t inherit from static
class, i.e., static
classes are sealed. Classes can have static
methods but static
classes can’t have instance member and instance methods .if
, should be declared with static
keyword.
Static
class is useful when you implement Singleton Design pattern.
What does partial modifier indicate?
Partial key word is to declare the class as partial meant to say it splits the classes into multiple parts under the same class name in a single namespace.
Why? So that developers can implement the functionally for the same class parallely.
But all combined will give one class. Each split class can have instance variable, instance methods, properties, indexers, events and delegates.
Structures can’t have modifiers like abstract
, sealed
, and static
whereas classes can have.
Both structure and class can have partial modifiers.
As I mentioned earlier, structures can have method declaration but not virtual
and sealed
methods. Why? Since those two are essential for inheritance. Anyhow, the structure won’t support inheritance and declaring methods using those two keywords will throw compile time errors.