Language Interoperability and Destructors
Open visual studio à go to file new Project
à choose console application à name it as accessDeemo1 and name the solution as MySolution , by default we get a class in the project as program,
write
following code in it making the class as public :
|
public class Program
{
private void Test1()
{
Console.WriteLine("Private Method");
}
internal void Test2()
{
Console.WriteLine("Internal Method");
}
protected void Test3()
{
Console.WriteLine("Protected Method");
}
protected internal void Test4()
{
Console.WriteLine("Protected Internal Method");
}
public void Test5()
{
Console.WriteLine("Public Method");
}
static void
{
Program
p = new Program();
p.Test1(); p.Test2(); p.Test3();
p.Test4(); p.Test5();
Console.ReadLine();
}
}
|
- Add a
new class Two.cs in the project and write the following:
|
class Two : Program
{
static void
{
Two
obj = new Two();
obj.Test2(); obj.Test3();
obj.Test4(); obj.Test5();
Console.ReadLine();
}
}
|
- Add a
new class Three.cs in the project and write the following:
|
class Three
{
static void
{
Program
p = new Program();
p.Test2(); p.Test4(); p.Test5();
Console.ReadLine();
}
}
|
- Add a new project under the solution of type
console application à name it as AccessDemo2 and rename the default
file Program.cs as Four.cs , so that
class name also changes as Four à add the reference of AccessDemo1 assembly from its physical
location to the current project & then write the following code :
|
class Four : AccessDemo1.Program
{
static void
{
Four
obj = new Four();
obj.Test3(); obj.Test4();
obj.Test5();
Console.ReadLine();
}
}
|
- Add a
new class under the Project AccessDemo2 names it as Five.cs and write the
following:
|
using AccessDemo1;
using System;
namespace AccessDemo2
{
class Five
{
static void
{
Program
p = new Program();
p.Test5();
Console.ReadLine();
}
}
}
|
Language Interoperability
As discussed earlier the code written in 1 .net language
can be consumed from other , to test this add a new project under the
MySolution by choosing the language as
VB and template as class library which is collection of types that can only be
consumed but not executed .
|
Public Class Class1
Public Sub Add(ByVal x As Integer, ByVal y As Integer)
Console.WriteLine(x
+ y)
End Sub
Public Function Say(ByVal name As String) As String
Return "Hello" & " " & name
End Function
End Class
|
- Now to compile the project open solution
explorer à right click on the VBproject à and select Built which compiles and
generates an assembly.
- Now add a new class under AccessDemo2
project as TestVb.cs , add the reference of VBProject’s assembly from its
physical location and write the following code:
|
using VBDemo;
using System;
namespace AccessDemo2
{
class TestVB
{
static void
{
Class1
obj = new Class1();
obj.Add(100,50);
Console.WriteLine(obj.Say("Prabhu"));
Console.ReadLine();
}
}
}
|
Members Of a Class
As we are aware a class is a collection of members which can be
of various types like –
<!--[if
!supportLists]-->1. <!--[endif]-->Fields (variables)
<!--[if
!supportLists]-->2. <!--[endif]-->Methods
<!--[if
!supportLists]-->3. <!--[endif]-->Constructor
<!--[if
!supportLists]-->4. <!--[endif]-->Destructor
<!--[if
!supportLists]-->5. <!--[endif]-->Properties
<!--[if
!supportLists]-->6. <!--[endif]-->Indexers
<!--[if
!supportLists]-->7. <!--[endif]-->Events
<!--[if !supportLists]-->8.
Delegates
<!--[if
!supportLists]-->9. <!--[endif]-->Ename
Destructors
These are also special methods, avilabel in a class similar to
a constructor, whereas a constructor method gets executed whenever the object
of the class is created and destructor method gets executed whenever the object
of class is destroyed.
|
class Test
{
Test()
{
//Constructor
}
~Test()
{
//Destructor
}
}
|
- A constructor method can have modifiers as
well as parameters also, whereas, a Destructor cannot have it.
-Add a
class TestDemo.cs under OOPSProject and write the following:
|
using System;
namespace oopsProject
{
class DestDemo
{
public
DestDemo()
{
Console.WriteLine(" object 1 created");
}
~DestDemo()
{
Console.WriteLine("object 1 distroyed");
}
}
class DestDemo2 : DestDemo
{
public
DestDemo2()
{
Console.WriteLine(" object 2 created");
}
~DestDemo2()
{
Console.WriteLine("object 2 distroyed");
}
static
void
{
DestDemo2
obj = new DestDemo2();
//obj = null ;
GC.Collect();
//Console.ReadLine();
}
}
}
|
- As we are aware Garbage Collector is
responsible for memory management i.e. allocation and dislocation, so it is
only responsible to create an object and allocate the memory and destroy the
object and de-allocates the memory.
-
Garbage Collector comes into the picture for destroying the object of a class
in different case like:
<!--[if
!supportLists]-->1. <!--[endif]-->In
the end of a programs execution, when the program gets executed successfully
without any shortage of memory.
<!--[if
!supportLists]-->2. <!--[endif]-->Sometimes
it can also come into picture in the middle of a programs execution provided
there is a memory shortage, which identifies all unused object to destroy them.
<!--[if
!supportLists]-->3. <!--[endif]-->We
can also explicitly call the Garbage Collector in to a program in the middle to
perform the de-allocation process , but this is not advised because, whenever
Garbage Collector comes into picture for performing de-allocation it suspends
the execution of program for an unpredictable laps of time.
-Execute the above program using ctrl F5 and
check the result. In this case we find both constructor and destructor getting
called one after the other because the main method contains only single
statement in it i.e. is creating object of class, so when object is created
constructor is called and because that is end of execution of program object
get destroyed and destructor gets called.
Note – When constructors are
called in case of inheritance they adopt top to bottom approach, whereas in
case of destructor it will be bottom to top approach.
- Now
uncomment the ReadLine statement in main and execute the program again using
ctrl + F5, now we can see only constructor getting called but not destructor
because the program is still under execution at ReadLine statement , press
enter which will end the program and invokes the destructors.
- Now
uncomment the second statement also in Main and execute the program again ,
where we can see destructor getting called before program execution is
completed only because we are explicitly calling the Garbage collector in to
the program to destroyed unused object.
0 Comments