class sealed Employee: Person 
public int EmpId 
private double Sal = 0; 
public double Basic; 
public double Allowance; 
public double Deductions; 
public new void DisplayInfo 
string msg; 
msg = Base.DisplayInfo(""); 
msg = msg + "ID : " + EmpId.ToString; 
msg = msg + "Basic : " + Basic.ToString; 
msg = msg + "Allowances : " + Allowance.ToString; 
msg = msg + "Deductions : " + Deductions.ToString; 
msg = msg + "Net Salary : " + Basic.ToString; 
MessageBox.Show(msg); 
public double Salary 
get 
return Sal; 
public void ProcessSalary() 
         
Sal = Basic + Allowance – Deductions; 
}
Following decleration is not posssible, .NET generates error!!!! 
Public Class Staff: Employee  
---- 
} 
6.10 Interfaces 
An interface is like an abstract class which allows the derived class to inherit 
more than one interfaces into it.  
We have already seen an abstract class can have methods with or without 
implementation. But an interface can only have members without 
implementation. So it provides only structure of the objects like abstract class. 
To implement an interface in VB.NET, we use the keyword 
Implements
and we  
must provide implementations for all the methods of the interface we implements. 
Defining an Interface:- Interfaces are declared with the following structure 
Pdf password protect - C# PDF Password Library: add, remove, edit PDF file password in C#.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
change password on pdf file; convert password protected pdf files to word online
Pdf password protect - VB.NET PDF Password Library: add, remove, edit PDF file password in vb.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
add password to pdf without acrobat; pdf user password
Public Interface <Name of the interface> 
<decleration of memebrs of the interface, means methods and properties  
structure> 
End Interface 
Let us take up a example and see how the declaration been done 
Interface IShape 
Sub Draw(ByVal coord() As ArrayList) 
End Interface 
interface IShape 
void Draw(ArrayList coord); 
} 
Implementation of Interface:- Interfaces are implemented using Implements keyword. All the 
members of the interface are implemented with Implements keyword. 
“To implement a interface, we must implement all the methods and properties defined by the 
interface” 
If more than one interface is to be implemented, then interfaces names should separated by 
commas with the implements keyword while defining a class. 
Lets us take an example of implementation:- 
Online Remove password from protected PDF file
hlep protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve this via password.
break password on pdf; open password protected pdf
C# PDF Library SDK to view, edit, convert, process PDF file for C#
XDoc.PDF SDK provides users secure methods to protect PDF document. C# users can set password to PDF and set PDF file permissions to protect PDF document.
advanced pdf password remover; pdf password online
Public Class Drawing 
Implements Ishape 
Public Sub Draw(ByVal parCoord() As ArrayList)         Console.Write("Draw a Circle") 
End Sub 
End Class 
Public Class Drawing: Ishape 
Public void Draw (ArrayList parCoord) 
Console.Write("Draw a Circle"); 
} 
In the example, we are implementing Isahpe interface, which contains Draw method into the 
Drawing Class.  
Difference between Abstract class and Interfaces 
Abstract Class 
Interface 
Only one Abstract class can be 
inherited into the derived class. 
Interfaces enable multiple inheritance 
to the object 
Members of the abstract class can or 
cannot have implemention 
Interfaces contains only the definitions 
for the menbers without implementation
When to use the interfaces in programming? 
Solution:- The situation at which we need to implement the functionalities of two 
or more objects into one derived object. So it makes the derived object to refer to 
the interface methods and properties for syntax verification. 
6.11 Delegates and Events 
Delegates:-
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
document page in ASPX webpage, set and edit PDF password, edit PDF file permissions and redact PDF text, image and page content to protect important information
pdf document password; change password on pdf
VB.NET PDF File Permission Library: add, remove, update PDF file
PDF; C# Protect: Add Password to PDF; C# Form: extract value from fields; C# Annotate: PDF Markup & Drawing. XDoc.PDF for VB.NET▶: VB
copy from protected pdf; create copy protected pdf
The Delegate class is one of the most important classes to know how to use 
when programming .NET. Delegates are often described as the 'backbone of the 
event model' in VB.NET. In this we are going to introduce you to delegates 
(Sytem.Delegate class) and show you how powerful of an event mechanism 
through delegates.  
Delegates are implemented using the delegate class found in the System 
namespace. A delegate is nothing more than a class that derives from 
System.MulticastDelegate. A delegate is defined as a data structure that refers to 
a static method or to a class instance and an instance method of that class. In 
other words, a delegate can be used like a type safe pointer. You can use a 
delegate to point to a method, much like a callback or the 'AddressOf' operator in 
VB.NET. Delegates are often used for asynchronous programming and are the 
ideal method for generically defining events. 
Before you get into the actual delegate class let us see some code which 
simulates the delegate functionality through simple class code for the sake of 
understanding. We have a simple class called 'VBDelegate' with two static 
methods named 'CallDelegate' and 'DisplayMessage' as shown below. When the 
CallDelegate method is called,(when the program is run) to display the message. 
Now normally, if we had a class called 'VBDelegate' with a method named 
'DisplayMessage'  
VB.NET 
Public Class VBDelegate 
'Static method to call displaymessage function 
Public Shared Sub CallDelegate() 
DisplayMessage("Some Text") 
End Sub 
'Static Function to display the message 
Private Shared Function DisplayMessage(ByVal strTextOutput As String
MsgBox(strTextOutput) 
End Function 
End Class 
C#
Public Class CSDelegate 
'Static method to call displaymessage function 
Public 
static void
CallDelegate() 
DisplayMessage("Some Text") 
'Static Function to display the message 
Private 
static void
DisplayMessage(String strTextOutput) 
VB.NET PDF Library SDK to view, edit, convert, process PDF file
imaging SDK to load, create, edit, convert, protect, compress, extract Support adding protection features to PDF file by adding password, digital signatures
pdf password recovery; add password to pdf file with reader
How to C#: Basic SDK Concept of XDoc.PDF for .NET
Document Protect. You may add PDF document protection functionality into your C# program. To be specific, you can edit PDF password and digital signature, and
pdf password protect; add copy protection pdf
{  
MessageBox.Show(strTextOutput) 
} 
There is nothing wrong with this approach at all. In fact, it is probably more 
commonly used than delegates. However, it does not provide much in terms of 
flexibility or a dynamic event model. With delegates, you can pass a method 
along to something else, and let it execute the method instead. Perhaps you do 
not know which method you want to call until runtime, in which case, delegates 
also come in handy. 
Now we will implement the same functionality as before, using a actual delegate 
class of .NET.  
Delegates in VB.NET are declared like: 
Delegate [Function/Sub] methodname(arg1,arg2..argN)  
The declared delegate methodname will have the same method signature as the 
methods they want to be a delegate for. This example is calling a shared 
method.. 
VB.NET 
Class VBDelegate 
'Declaration of delegate variable with arguments 
Delegate Function MyDelegate(ByVal strOutput As String
'Function to call the delegates 
Public Shared Sub CallDelegates() 
'Declare variables of type Mydelegate points to the  
'function MessageDisplay with AddressOf operator 
Dim d1 As New MyDelegate(AddressOf MesssageDisplay) 
Dim d2 As New MyDelegate(AddressOf MesssageDisplay) 
'Pass the arguments to the function through delegates 
d1("First Delegation ") 
d2("Second Delegation ") 
End Sub 
'Function to display the message 
Private Shared Function MesssageDisplay(ByVal strTextOutput As String
MsgBox(strTextOutput) 
End Function 
End Class 
C#
.NET PDF Document Viewing, Annotation, Conversion & Processing
Add, Update, Delete form fields programmatically. Document Protect. Apply password to protect PDF. Allow to create digital signature.
pdf passwords; pdf password security
VB.NET PDF: Basic SDK Concept of XDoc.PDF
Document Protect. You may add PDF document protection functionality into your VB.NET program. To be specific, you can edit PDF password and digital signature
create password protected pdf reader; pdf file password
Class CSDelegate 
{  
'Declaration of delegate variable with arguments 
delegate void MyDelegate(String strOutput); 
'Function to call the delegates 
Public static void CallDelegates() 
'Declare variables of type Mydelegate points to the  
'function MessageDisplay  
MyDelegate d1 = New MyDelegate(MesssageDisplay); 
MyDelegate d2 = New MyDelegate(MesssageDisplay); 
'Pass the arguments to the function through delegates 
d1("First Delegation "); 
d2("Second Delegation "); 
'Function to display the message 
Private static void MesssageDisplay(String strTextOutput) 
    
MessgeBox.Show(strTextOutput); 
} 
The Output to the display window is:  
First Delegation in one message window  
And  
Second Delegation in the second message window 
What has happened in the above code? Let's take a look  
First, we defined a delegate. Remember, when defining a delegate it is very 
similar to stating the signature of a method. We have said we want a delegate 
that can accept a string as an argument so basically, this delegate can work with 
any method that takes the same argument(s). 
In our CallDelagates method, we create two instances of our 'MyDelegate'. Then, 
we pass into MyDelegate's constructor the address of our 'DisplayMessage' 
method. This means that the method we pass into the delegate's constructor (in 
this case it's 'DisplayMessage' method) must have a method signature that 
accepts a string object as an input argument, just like our delegate does. Now, 
you might be thinking, "why are we passing in the address of a method when we 
defined our delegate to accept a string object as it's input argument?" In the code 
above, we are telling the delegate which method to call, not which string we're 
passing in. Carefully understand this concept. 
Then finally we have our 'DisplayMessage' method, which takes the string 
passed in by the delegate and tells it what string is to be displayed. 
The same approach is used while handling the events in the .NET. This topic is 
just to understand how delegates works in .NET.
Events:-
Events are nothing but situations at which the message is sent to an object to 
signal the occurrence of the action. These actions can be caused by the user 
interaction or within the object itself. 
For example the class designer can create an event and raise the same through 
its methods and properties. These events will be captured by the object user and 
perform his/her required operation. 
Let us take a simple example of VB.NET Button class. Button is a class defined 
in System.Controls.FormsControls nameplace. The users create an instance of 
the Button class and select the onclick event related to the button object and 
write an action to be performed on click of the button. 
Actually this event is already defined in button class and will be raised when the 
user clicks the button. The following example shows how the event can be 
defined, raised in the class and used by the object user. 
Declaration:- The event member will be declared with Event keyword. Basically 
the event member should always be public. Because these are the members will 
be used by the external users. 
'Declare a class which operates on the Employee collection database 
'This class is used to find some summarised operation on the Employee  
'collction database, which means finding the relavent employee ‘information, 'getting the 
total no. of employees in the collection and ‘others   -  Its just 'an example to explain how 
event works 
Public Class EmployeeCollection 
'Declare an event which will be raised after finding the data 
'Keyword ‘Event’ is used the declare the events 
Public Event FindResult(ByVal blnFound As Boolean
'This method is to find the data from employee colletion database and 'raise the findresult 
event to return the result 
Public Sub FindData(ByVal Name As String
'find the Employee with name and return the result as boolean, if  
'the data is found then raise FindResult with True else with  
'False 
Dim found As Boolean 
found = FineEmployee(Name) 
If found Then 
'Raise the event with parameter 
RaiseEvent FindResult(True
Else 
'Raise the event with parameter 
RaiseEvent FindResult(False
End If 
End Sub 
End Class 
Usage:- In order to access the events of the objects, the object should be 
declared with withevents clause. This is shown in the following example with form 
load event. 
'Declare the object with WithEvents clause to create an instance 
Dim WithEvents objEmpColl As EmployeeCollection = New EmployeeCollection() 
Public Sub load() 
'Find the Employee with name Rama in the Employee collection 
objEmpColl.FindData("Rama") 
End Sub 
'The following event will be raised after the search operation 
Private Sub objObject_FindResult(ByValue blnFound as BooleanHandles 
objObject.FindResult   
If blnFound Then 
MsgBox("The given Employee is Found in the collection") 
Else 
MsgBox("The given Employee is not Found") 
End If 
End Sub 
6.12 Structures 
Structures are used to create a variable set of different datatypes in VB.NET (In 
earlier versions of VB we use TYPE and END TYPE to define it). Here it is 
defined with STRUCTURE and END STRUCTURE keyword. 
It supports allmost all the features of OOPS, like  
• 
Implementing interfaces  
• 
Constructors, methods, properties, fields, constants and events 
• 
Shared constructors 
Ex: - 
Defining the structure:- 
VB.NET 
Structure Person 
Public FirstName As String 
Public LastName As String 
Public Address As String 
Public Pincode As String 
Public DateOFBirth As DateTime 
Public Sub DisplayInfo() 
Dim msg As String 
msg = FirstName & " " & LastName & vbCrLf 
msg = msg & Address & vbCrLf 
msg = msg & "PIN – " & Pincode 
msg = msg & "Date of Birth : " & DateOFBirth.ToString 
End Sub 
End Structure 
C# 
struct Person 
Public String FirstName;  
Public String LastName ; 
Public String Address ; 
Public String Pincode ; 
Public DateTime DateOFBirth; 
Public void DisplayInfo() 
      
String msg=new String(); 
msg = FirstName + " " + LastName ; 
msg = msg + Address ; 
msg = msg + "PIN – " + Pincode; 
msg = msg + "Date of Birth : " + DateOFBirth.ToString; 
} 
In the example a Person structure is declared to hold the a person’s details like 
name, address, pincode etc., we have already seen this person details in terms 
of a class object. Basically the structures are used to hold the set of values like 
array. Theoritically arrays holds a set of single datatype values, but structures 
holds a set of different datatype values. Due to the OOPS feature of .NET we can 
implement the methods and properties in the structures too. This is shown in the 
person structure. Here the Firstname,Lastname,Address,Pincode,Dateofbirth are 
all the variables of person structure with different datatype declarations, where 
DisplayInfo is a method to disputably the information.  
Variables holds the data and methods operates on the data stored in it as in the 
normal class object. 
Usage of the structure:- 
VB.Net 
'Creating an instance of the structure like a normal class variable 
Dim varPerson As Person = New Person() 
'Setting the structure variables with the values 
varPerson.firstname = “Rama” 
varPerson.lastname = “Lakan” 
varPerson.address = “Mysore” 
varPerson.pincode = “570002” 
varPerson.dateofbirth = “25/06/1977” 
'Calling the strcuture method to manipulate and display the person address 
varPerson.displayinfo() 
C#   
Person varPerson =New Person(); 
'Setting the structure variables with the values 
varPerson.firstname = “Rama”; 
varPerson.lastname = “Lakan”; 
varPerson.address = “Mysore”; 
varPerson.pincode = “570002”; 
varPerson.dateofbirth = “25/06/1977”; 
'Calling the strcuture method to manipulate and display the person address 
varPerson.displayinfo(); 
6.13 Sample Application: OOPS 
Heres a small application created to demonstrate Object Oriented / Component Oriented 
features in .NET using C#.  
Accounts are created & managed by the application for a Bank. There are 2 types of 
account that can be created 
Documents you may be interested
Documents you may be interested