The statements of Listing 8.9 will produce the following output:
They’re equal
They’re equal
The two variables are initially equal. No surprise. After modifying one of the obj2variable’s prop-
erties, however, they’re still equal, because obj2points to obj1. Every time we change obj2, obj1also
changes. That’s because we’ve made obj1point to obj2. They both point to the same object (or
instance of the class), and you can access this object through either class.
Comment out the line that sets obj2equal to obj1. Now, they’re not equal, even if you set all their
fields to the same values. They don’t reference the same object, and it’s possible to set their proper-
ties differently.
In the following section, we’ll add an Equals method that checks for value equality(as opposed to
reference equality) by comparing the values of the properties of the two instances.
Customizing Default Members
As you recall, when you created the Minimal class for the first time, before adding any code, the
class already exposed a few members—the default members, such as the ToString method (which
returns the name of the class) and the Equals method (which compares two objects for reference
equality). You can provide your custom implementation for these members; this is what we’re going
to do in this section. You already know how to do this. Your custom ToString method must be
implemented as a public function, and it must override the default implementation. The implemen-
tation of a custom ToString method is shown next:
Public Overrides Function ToString() As String
Return “The infamous Minimal class”
End Function
It’s that simple. The Overrides keyword tells the compiler that this implementation overwrites
the default implementation of the class. Ours is a very simple method, but you can return any string
you can build in the function. For example, you can incorporate the value of the BDate property in
the string:
Return(“MINIMAL: “ & tBDate.ToString)
tBDateis a local variable in the class’s module, and you can use its value in any way you see fit in your
code. The value of the local variable tBDateis the current value of the BDate property of the current
instance of the class.
When called through different variables, the ToString method will report different values. Let’s
say you’ve created and initialized two instances of the Minimal class with the following statements:
Dim obj1 As New Minimal()
Obj1.Bdate = #1/1/1963#
Dim obj2 As New Minimal()
Obj2.Bdate = #12/31/1950#
Console.WriteLine(obj1.ToString)
Console.WriteLine(obj2.ToString)
Chapter 8 BUILDING CUSTOM CLASSES
340
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Convert multiple page pdf to tiff - Convert PDF to tiff images in C#.net, ASP.NET MVC, Ajax, WinForms, WPF
Online C# Tutorial for How to Convert PDF File to Tiff Image File
pdf to tiff multipage; pdf to tiff converter without watermark
Convert multiple page pdf to tiff - VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.net, ASP.NET MVC, Ajax, WinForms, WPF
Free VB.NET Guide to Render and Convert PDF Document to TIFF
pdf to tiff conversion using; how to convert pdf file to tiff format
The last two statements will print the following lines on the Output window:
MINIMAL: 1963-01-01 00:00:00
MINIMAL: 1950-12-31 00:00:00
The Equals method exposed by most of the built-in objects, however, can compare values, not
references. Two Rectangle objects, for example, are equal if their dimensions and origins are the
same. The following two rectangles are equal:
Dim R1 As New Rectangle(0, 0, 30, 60)
Dim R2 As New Rectangle
R2.X = 0
R2.Y = 0
R2.Width = 30
R2.Height = 60
If R1.Equals(R2) Then
MsgBox(“The Two rectangles are equal”)
End If
If you execute these statements, a message box will pop up. The two variables point to different
objects (i.e., different instances of the same class), but the two objects are equal. The Rectangle class
provides its own Equals method, which knows how to compare two Rectangle objects. If your class
doesn’t provide a custom Equals method, all the compiler can do is compare the objects referenced
by the two variables. In the case of our Minimal class, the Equals method returns True if the two vari-
ables point to the same object (which is the same instance of the class). If the two variables point to
two different objects, the default Equals method will return False, even if the two objects are equal.
You’re probably wondering what makes two objects equal. Is it all of their properties, or perhaps
some of them? Two objects are equal if the Equals method says so. You should compare the objects
in a way that makes sense, but you’re in no way limited as to how you do this. You may even com-
pare internal variables that are not exposed as properties to decide about the equality. In the Minimal
class, for example, you may decide to compare the birth dates and return True if they’re equal. List-
ing 8.10 is the implementation of a possible custom Equals method for the Minimal class.
Listing 8.10: A Custom Equals Method
Public Overloads Function Equals(ByVal obj As Object) As Boolean
Dim O As Minimal = CType(obj, Minimal)
If O.BDate = tBDate Then
Equals = True
Else
Equals = False
End If
End Function
Notice that the Equals method is prefixed with the Overloads keyword, not the Overrides key-
word. To test the new Equals method, place a new button on the form and insert the statements of
Listing 8.11 in its Click event handler.
341
BUILDING THE MINIMAL CLASS
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
C# Create PDF from Tiff Library to convert tif images to PDF in C#
Similarly, Tiff image with single page or multiple pages is supported. Description: Convert to PDF/TIFF with specified zoom value and save it on the disk.
pdf to tiff conversion online; how to save pdf to tiff
C# PDF File Split Library: Split, seperate PDF into multiple files
to two files //File 0: page 0
pdf to tiff open source; pdf to multipage tiff converter
Listing 8.11: Testing the Custom Equals Method
Dim O1 As New Minimal()
Dim O2 As New Minimal()
O1.BDate = #3/1/1960#
O2.BDate = #3/1/1960#
O1.property1 = “object1”
O2.property1 = “OBJECT2”
If O1.Equals(O2) Then
MsgBox(“They’re equal”)
End If
If you run the application, you’ll see the message confirming that the two objects are equal,
despite the fact that their property1properties were set to different values. The BDate property is the
same, and this is the only setting the Equals method examines.
So, it’s up to you to decide which properties fully and uniquely identify an object and to use
these properties in determining when two objects are equal. It’s customary to compare the values 
of all the properties of the two objects in the Equals function and return True if they’re all the
same. You can modify the code of the custom Equals function to take into consideration the other
properties.
Know What You’re Comparing
The Equals method shown in Listing 8.10 assumes that the object you’re trying to compare to the
current instance of the class is of the same type. Since you can’t rely on developers to catch all their
mistakes, you should know what you’re comparing before you actually do the comparison. A more
robust implementation of the Equals method is shown in Listing 8.12.
Listing 8.12: A More Robust Equals Method
Public Overloads Function Equals(ByVal obj As Object) As Boolean
Dim O As New Minimal()
Try
O = CType(obj, Minimal)
Catch typeExc As InvalidCastException
Throw typeExc
Exit Function
End Try
If O.BDate = tBDate Then
Equals = True
Else
Equals = False
End If
End Function
Chapter 8 BUILDING CUSTOM CLASSES
342
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Separate source PDF document file by defined page range in VB.NET class application. Divide PDF file into multiple files by outputting PDF file size.
convert pdf to 300 dpi tiff; pdf to tiff
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
class. Support of converting from any single one PDF page and multiple pages. Change program. Able to convert password protected PDF document.
convert pdf to tiff high quality; converting pdf to tiff
Note Note that the custom Equals method throws the same exception it receives from the CType() function. This is a
little different from creating and throwing a new custom exception, as we did in the Age property’s code.
Custom Enumerations
Let’s add a little more complexity to our class. Since we’re storing dates of birth to our class, we can
classify persons according to their age. Instead of using literals to describe the various age groups,
we’ll use an enumeration, with the following group names:
Public Enum AgeGroup
Baby
Child
Teenager
Adult
Senior
Overaged
End Enum
These statements must appear outside any procedure in the class, and we usually place them at
the beginning of the file, right after the declaration of the Class. The enumeration is a list of integer
values, each one mapped to a name. In our example, the name Babycorresponds to 0, the name Child
corresponds to 1, and so on. You don’t really care about the actual values of the names, because the
very reason for using enumerations is to replace numeric constants with more meaningful names.
You’ll see shortly how enumerations are used both in the class and the calling application.
Now add to the class the GetAgeGroup method (Listing 8.13), which returns the name of the
group to which the person represented by an instance of the Minimal class belongs. The name of 
the group is a member of the AgeGroup enumeration.
Listing 8.13: Using an Enumeration
Public Function GetAgeGroup() As AgeGroup
Dim group As AgeGroup
Select Case tAge
Case Is < 5 : Return (group.Baby)
Case Is < 12 : Return (group.Child)
Case Is < 21 : Return (group.Teenager)
Case Is < 65 : Return (group.Adult)
Case Is < 100 : Return (group.Senior)
Case Else : Return (group.Overaged)
End Select
End Function
First, we declare a variable of the AgeGroup type. As you can see, the members of the AgeGroup
enumeration become properties of the groupvariable. The advantage of using enumerations is that
you can manipulate meaningful names instead of numeric constants. This makes your code less
prone to errors and far easier to understand.
343
BUILDING THE MINIMAL CLASS
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
C# PDF Page Insert Library: insert pages into PDF file in C#.net
Support adding and inserting one or multiple pages to of adding and inserting (empty) PDF page or pages various file formats, such as PDF, Tiff, Word, Excel
convert pdf to tiff; online convert pdf to tiff
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Professional .NET PDF control for inserting PDF page in Visual Basic .NET class application. Able to add and insert one or multiple pages to existing adobe PDF
how to convert pdf to tiff using; convert pdf to tiff 300 dpi online
Tip The members of an enumeration are not variables. They’re constants, and you can only access them through a vari-
able of the AgeGroup enumeration.
Because the AgeGroup enumeration was declared as Public, it’s exposed to any application that
uses the Minimal class. Let’s see how we can use the same enumeration in our application. Switch to
the form’s code window, add a new button, and enter the statements from Listing 8.14 in its event
handler.
Listing 8.14: Using the Enumeration Exposed by the Class
Protected Sub Button3_Click(ByVal sender As Object, _
ByVal e As System.EventArgs)
Dim obj As Minimal
obj = New Minimal()
obj.BDate = #2/9/1932#
Console.WriteLine(obj.Age)
Dim discount As Single
If obj.GetAgeGroup = Minimal.AgeGroup.Baby Or _
obj.GetAgeGroup = Minimal.AgeGroup.Child Then discount = 0.4
If obj.GetAgeGroup = Minimal.AgeGroup.Senior Then discount = 0.5
If obj.GetAgeGroup = Minimal.AgeGroup.Teenager Then discount = 0.25
Console.WriteLine(discount)
End Sub
This routine calculates discounts based on the person’s age. Notice that we don’t use numeric
constants in our code, just descriptive names. Moreover, the possible values of the enumeration are
displayed in a drop-down list by the IntelliSense feature of the IDE as needed (Figure 8.4), and you
don’t have to memorize them, or look them up, as you would with constants.
Using the SimpleClass in Other Projects
The project you’ve built in this section is a Windowsapplication that contains a Class module. The
class is contained within the project, and it’s used by the project’s main form. What if you wanted to
use this class in another project?
Figure 8.4
The members of 
an enumeration are
displayed automati-
cally in the IDE as
you type.
Chapter 8 BUILDING CUSTOM CLASSES
344
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
C# Create PDF from images Library to convert Jpeg, png images to
Batch convert PDF documents from multiple image formats, including Jpg image formats into one or multiple PDF file in able to be cropped and pasted to PDF page.
convert pdf to tiff online; pdf to multi page tiff
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
NET library to batch convert PDF files to Turn multiple pages PDF into single jpg files respectively of converting from any single one PDF page and multiple
convert pdf to single page tiff; c# convert pdf to tiff
First, you must change the type of the project. A Windowsproject can’t be used as a component
in another project. Right-click the SimpleClass project and select Properties. On the project’s Prop-
erties dialog box, locate the Output drop-down list and change the project’s type from
WindowsApplication to Class Library, as shown in Figure 8.5. Then close the dialog box. When
you return to the project, right-click the TestForm and select Exclude From Project. A class doesn’t
have a visible interface, and there’s no reason to include the test form in your project.
Now open the Build menu and select Configuration Manager. The current configuration is
Debug. Change it to Release, as shown in Figure 8.6. The Debug configuration should be used in
testing and debugging the project. When you’re ready to distribute the application (be it a
Windowsapplication, a class library, or a control library), you must change the current configura-
tion to Release. When you compile a project in Debug configuration, the compiler inserts additional
information in the executable to ease the debugging process.
From the main menu, select Build 
Build SimpleClass. This command will compile the Simple-
Class project (which is a class) and will create a DLL file. This is the file that contains the class’s
code and is the file you must use in any project that needs the functionality of the SimpleClass class.
The DLL file will be created in the 
\Obj\Release
folder under the project’s folder.
Figure 8.6
Changing the config-
uration of a project
Figure 8.5
Setting a project’s
properties through
the Property Pages
dialog box
345
BUILDING THE MINIMAL CLASS
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
able to perform image extraction from multiple page adobe PDF Extract multiple types of image from PDF file in Scan high quality image to PDF, tiff and various
online pdf to tiff; pdf to tiff conversion c#
Let’s use the 
SimpleClass.dll
file in another project. Start a new Windowsapplication, open the
Project menu, and add a reference to the SimpleClass. Select Project 
Add Reference and, in the
dialog box that appears, switch to the Projects tab. Click the Browse button and locate the 
Simple-
Class.dll
file. Select the name of the file and click OK to close the dialog box.
The SimpleClass component will be added to the project. You can now declare a variable of the
SimpleClass type and call its properties and methods:
Dim obj As New SimpleClass
obj.Age = 45
obj.property2 = 5544
MsgBox(obj.Negate())
If you want to keep testing the SimpleClass project, add the TestForm to the project (right-click
the project’s name, select Add 
Add Existing Item, and select the TestForm in the project’s
folder). Then change the project’s type back to Windowsapplication, and finally change its configu-
ration from Release to Debug.
Firing Events
Methods and properties are easy to implement, and you have seen how to implement them. Classes
can also fire events. It’s possible to raise events from within your classes, although not quite as com-
mon. Controls have many events, because they expose a visible interface and the user interacts
through this interface (clicks, drags and drops, and so on). But classes can also raise events. Class
events can come from three different sources:
The class itself A class may raise an event to indicate the progress of a lengthy process, or that
an internal variable or property has changed value. The PercentDone event is a typical example. A
process that takes a while to complete reports its progress to the calling application with this
event, which is fired periodically. These are called progress events,and they’re the most common type
of class events.
Time events These events are based on a timer. They’re not very common, but you can imple-
ment alarms, job schedulers, and similar applications. You can set an alarm for a specific time or
an alarm that will go off after a specified interval.
External events External events, like the completion of an asynchronous operation, can also fire
events. A class may initiate a file download and notify the application when the file arrives.
Notice that the class can’t intercept events initiated by the user under any circumstances, because
it doesn’t have a visible user interface.
Time Events
Let’s look at an example of a simple event, one that’s raised at a specific time. We’ll implement an
event in our Minimal class that fires at five o’clock in the afternoon—that is, if an application is
using the class at the time. Classes can’t be instantiated at specific times. Even if they could, the
events would go unnoticed. Classes must be instantiated by an application. In addition, the applica-
tion must be executing when the event is fired, so that it can process it. If the application doesn’t
Chapter 8 BUILDING CUSTOM CLASSES
346
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
provide a handler for the event, the event will go unnoticed—just like the DragEnter and Enter
events of most controls, which are not handled in a typical Windowsapplication.
The first problem we face is that the class’s code isn’t running constantly to check the time peri-
odically. It executes when a member of the class is called and then returns control to your applica-
tion. To make your class check the time periodically, you must embed a Timer control in your class.
But the class doesn’t have a visible interface, so you can’t place a Timer control on it. The solution is
to instantiate a Timer control from within the class’s code and program its Elapsed event so that it
fires every so often. In our example, we’ll implement an event that’s fired every day at five o’clock.
This is a reminder for the end of a shift, so it need not be extremely precise. We’ll set the Timer
control to fire a Tick event every 10 seconds. If this were a real-time application, you’d have to fire
Tick events more often. The following line creates an instance of the Timer control:
Dim WithEvents tmr As System.Timers.Timer
This declaration must appear outside any procedure. The WithEvents keyword is crucial here.
Controls and classes that raise events must be declared with the WithEvents keyword, or else the
application won’t see the events. Controls will fire them, but the class won’t be watching out for
events. While methods and properties are an integral part of the class and you don’t have to request
that these members be exposed, the events are not exposed by default. Moreover, the statements that
declare object variables with the WithEvents keyword must appear outside any procedure.
The Timer control is disabled by default, and we must enable it. A good place to insert the Timer’s
initialization code is the class’s New() procedure, which is called when the class is instantiated:
Public Sub New()
tmr = New WinForms.Timer()
tmr.Interval = 10000
tmr.Enabled = True
End Sub
Our timer is ready to go and will fire an event every 10,000 milliseconds, or 10 seconds. The
shorter the interval, the more time spent in processing the Timer’s Elapsed event.
The Timer’s Elapsed event will be fired every 10 seconds, and you must now program this event.
What do we want to do in this event? Check the time and, if it’s five o’clock, raise the TeaTime
event. Before a class can raise an event, you must declare it with a statement like the following:
Public Event TeaTime()
This declaration must also appear outside any procedure in your class’s code. Now you can pro-
gram the Elapsed event handler (Listing 8.15) and raise the event when appropriate. Because we
can’t be sure that the Timer will fire its event at five o’clock precisely, we check the time and, if it’s
after 1700 hours and no later than 120 seconds after that time, we fire the event.
Listing 8.15: The Timer’s Tick Event Handler
Private Sub tmr_Elapsed(ByVal sender As Object, _
ByVal e As System.Timers.ElapsedEventArgs) Handles tmr.Elapsed
‘Console.WriteLine(DateDiff(DateInterval.Second, Now(), _
DateAdd(DateInterval.Hour, 17, System.DateTime.Today)))
347
BUILDING THE MINIMAL CLASS
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
If DateDiff(DateInterval.Second, Now(), DateAdd( _
DateInterval.Hour, 17, System.DateTime.Today)) < 120 Then
tmr.Enabled = False
RaiseEvent TeaTime(Me)
End If
End Sub
Notice that once the event is raised, we disable the timer, or else the same event would fire again
and again (Figure 8.7). The long statement I’ve commented out displays the number of seconds
from the moment it’s executed to five o’clock. Use this value to adjust the second statement, and
make the class fire the event at any time.
The code uses the DateDiff() function, which calculates the difference between the current time
and 1700 hours in seconds. If this difference is less than two minutes, the class raises the TeaTime
event. The syntax of the DateDiff() function is complicated, but here’s an explanation of its argu-
ments. The first argument is a constant value that tells the DateDiff() function what time unit to use
in reporting the difference. In our example, we want to express the difference in seconds. The fol-
lowing two arguments are the two date (or time) values to be subtracted. The first of the two argu-
ments is the current date and time: the second is a date/time value that represents the current date at
five o’clock. This value is constructed with the following expression:
DateAdd(DateInterval.Hour, 17, System.DateTime.Today)
This statement returns the current date with a time value of 17:00.00 (something like 2001-08-13
17:00:00). This value is then compared to the current date and time.
Programming the Class’s Event
How do we intercept the event in our main application? As you may have guessed, we’ll instantiate
the class with the WithEvents keyword. Declare a second variable of the Minimal type in the test
form with the WithEvents keyword:
Dim WithEvents TimerObj As Minimal
Figure 8.7
Declaring and rais-
ing an event in the
class’s code
Chapter 8 BUILDING CUSTOM CLASSES
348
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
After this declaration, the TimerObj variable will appear in the list of objects of the editor window,
and its TeaTime event will appear in the list of events, as you see in Figure 8.8. You can now pro-
gram the event in your application and use it any way you see fit.
The events raised by a class may pass additional arguments to the program that handles the event.
The senderargument is passed by default and contains information about the object that raised the
event—so that you can write an event handler for multiple events. Place a new button on the form,
name it Initialize Timer, and enter the following code in its Click event handler (this is the code
behind the button of that name on the test form):
Private Sub bttnInitTimer_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles bttnInitTimer.Click
TimerObj = New Minimal()
End Sub
This subroutine creates a new instance of the TimerObjvariable. This variable was declared outside
the procedure, but it wasn’t instantiated. Before this statement is executed, no events will take place.
I’ve inserted the statement that prints the time difference (seconds left until five o’clock) in the
Timer’s Tick event so that you can see what’s going on.
Let’s see how the application uses the class. Start the application and wait for 10 seconds. You
might expect to see something in the Output window, but nothing will appear. The 
Console.Write-
Line
statement in the Timer control’s Tick event handler isn’t executed, because the TimerObjvari-
able hasn’t been instantiated yet.
Click one of the buttons on the form other than the Initialize Timer button. Every 10 seconds, a
new double value will appear in the Output window. This is the number of seconds left until (or
passed since) five o’clock. The event, however, isn’t raised. An instance (or more) of the Minimal
class has been created, so the class’s code is executing, and it prints the number of seconds left until
the next TeaTime event in the Output window. However, the TimerObjvariable (the one declared
with the WithEvents keyword) has not been instantiated yet, so even if the class fires the event, your
application won’t handle it. Since none of the variables of the Minimal type was declared with the
WithEvents keyword, the application isn’t receiving notifications about the event—should it hap-
pen. The class’s code, however, is running, and it prints a value every 10 seconds.
Now click the Initialize Timer button, wait for a few seconds, and the message will pop up—
provided you’re testing the application around five o’clock. Only the TimerObjvariable was declared
with the WithEvents keyword, and this is the only one that can intercept the event.
Figure 8.8
Programming a
class’s event
349
BUILDING THE MINIMAL CLASS
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Documents you may be interested
Documents you may be interested