Char data type exposes interesting methods (like IsLetter, IsDigit, IsPunctuation, and so on), you
can use these methods in your code. Let’s say the string variable passwordholds a user’s new password,
and you require that passwords contain at least one special symbol. The code segment of Listing 3.3
scans the password and rejects if it contains letter and digits only.
Listing 3.3: Processing Individual Characters
Dim password As String, ch As Char
Dim i As Integer
Dim valid As Boolean = False
While Not valid
password = InputBox(“Please enter your password”)
For i = 0 To password.Length - 1
ch = password.Chars(i)
If Not System.Char.IsLetterOrDigit(ch) Then
valid = True
Exit For
End If
Next
If valid Then
MsgBox(“You new password will be activated immediately!”)
Else
MsgBox(“Your password must contain at least one special symbol!”)
End If
End While
Note If you are not familiar with the 
If…Then
For…Next
, or 
While…End While
structures, you can read their
description in the “Flow-Control Statements” section of this chapter and then return to check out this example.
The code prompts the user with an input box to enter a password. (Later in the book, you’ll find
out how to create a form that accepts the characters typed but displays asterisks in their place, so
that the password isn’t echoed on the screen.) The validvariable is Boolean, and it’s initialized to
False (you don’t have to initialize a Boolean variable to False, because this is its default initial value,
but it makes the code easier to read). It’s set to True from within the body of the loop, only if the
password contains a character that is not a letter or a digit. We set it to False initially, so that the
While…End While
loop will be executed at least once. This loop will keep prompting the user until a
valid password is entered.
The loop scans the string variable password, one letter at a time. At each iteration, the next letter is
copied into the chvariable. The Chars property of the String data type is an array that holds the indi-
vidual characters in the string (another example of the functionality built into the data types).
Then the program examines the current character. The IsLetterOrDigit method of the Char data
type returns True if a character is either a letter or a digit. If the current character is a symbol, the
program sets the validvariable to True, so that the outer loop won’t be executed again, and it exits
the 
For…Next
loop. Finally, it prints the appropriate message and either prompts for another pass-
word or quits.
99
VARIABLES
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Convert 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 converter without watermark; convert pdf to tiff multiple pages
Convert 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
how to save pdf to tiff; print pdf to tiff
You could write more compact code by using the IsLetterOrDigit method directly on the indi-
vidual characters of the password, instead of storing them first in a Char variable. Listing 3.4 is
another way to code the same program. (I’ve omitted the variable declarations at the beginning of the
code; they’re the same as before.)
Listing 3.4: Requesting a Password with One Special Character
While True
password = InputBox(“Please enter your password”)
For i = 0 To password.Length - 1
If Not System.Char.Chars(i).IsLetterOrDigit(password.Chars(i)) Then
MsgBox(“Your new password will be activated immediately!”)
Exit Sub
End If
Next
MsgBox(“Your password must contain at least one special symbol!”)
End While
It’s shorter and certainly much more real code. There’s nothing wrong with the first implementa-
tion, but the second one is “programmer’s code” as opposed to “beginner’s code.” Don’t worry if
you don’t quite understand how it works; you can come back and explore it after you finish this
chapter.
Tip Notice that neither implementation would be possible without the methods exposed by the Char function. Although
the second implementation doesn’t use a variable of Char type, it relies on the functionality exposed by the Char data type.
The expression 
password.Chars(i)
is actually a character, and that’s why we can apply to it the members of the Char
data type.
Date Variables
Date and time values are stored internally in a special format, but you don’t need to know the exact
format. They are double-precision numbers: the integer part represents the date and the fractional
part represents the time. A variable declared as Date can store both date and time values with a state-
ment like the following:
Dim expiration As Date
The following are all valid assignments:
expiration = #01/01/2004#
expiration = #8/27/2001 6:29:11 PM#
expiration = “July 2, 2002”
expiration = Now()
(The Now() function returns the current date and time). The pound sign tells Visual Basic to
store a date value to the expirationvariable, just as the quotes tell Visual Basic that the value is a string.
You can store a date as string to a Date variable, but it will be converted to the appropriate format.
Chapter 3 VISUAL BASIC: THE LANGUAGE
100
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Online Convert PDF file to Tiff. Best free online PDF Tif
Using this .NET PDF to TIFF conversion control, C# developers can render and convert PDF document to TIFF image file with no loss in original file quality.
convert pdf to tiff online; change pdf to tiff for
Online Convert PDF file to Word. Best free online PDF Conversion
Download Free Trial. Convert a Tiff/Tif File to PDF. Easy converting! We try to make it as easy as possible to convert your Tiff/Tif files to PDF.
how to change pdf to tiff; convert pdf images to tiff
If the Strict option is on, you can’t specify dates using the long date format (as in the third statement
of this example).
Tip The date format is determined by the Regional Settings (found in Control Panel). In the United States, it’s
mm/dd/yy (in other countries, the format is dd/mm/yy). If you assign an invalid date to a date variable, like
23/04/2002, Visual Basic will automatically swap the month and day values to produce a valid date as you type. If
the date is invalid even after the swapping of the month and day values, then an error message will appear in the Task List
window. The description of the error is “Expected expression.”
The Date data type is extremely flexible; Visual Basic knows how to handle date and time values,
so that you won’t have to write complicated code to perform the necessary conversions. To manipu-
late dates and times, use the members of the Date type, which are discussed in detail in Chapter 12,
or the Date and Time functions, which are described in the reference “VB.NET Functions and
Statements” on the book’s companion CD. The difference between two dates is calculated by the
function DateDiff(). This function accepts as argument a constant that determines the units in
which the difference will be expressed (days, hours, and so on) as well as two dates, and it returns the
difference between them in the specified increments. The following statement returns the number of
days in the current millennium:
Dim days As Long
days = DateDiff(DateInterval.Day, #12/31/2000#, Now())
You can also call the Subtract method of the Date class, which accepts a date as argument and
subtracts it from a Date variable. The difference between the two dates is returned as a TimeSpan
object, which includes number of days, hours, minutes, and so on. For more information on the
members of the Date class, see Chapter 12.
VB6 
VB.NET
Previous versions of VB allowed direct numeric calculations with date variables. For example, you used to
be able to calculate the difference between two dates in days with by subtracting two date variables
directly:
days = date1 – date2    ‘ DOESN’T WORK IN VB.NET
VB.NET doesn’t allow the use of date variables with the arithmetic operators, even if the Strict option has
been turned off.
Data Type Identifiers
Finally, you can omit the As clause of the Dim statement, yet create typed variables, with the vari-
able declaration characters, or data type identifiers. These characters are special symbols, which you
append to the variable name to denote the variable’s type. To create a string variable, you can use
the statement:
Dim myText$
101
VARIABLES
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Online Convert Excel to PDF file. Best free online export xlsx
Download Free Trial. Convert a Excel File to PDF. Easy converting! We try to make it as easy as possible to convert your xlsx/xls files to PDF.
convert pdf file to tiff online; how to convert pdf into tiff
C# Create PDF from Tiff Library to convert tif images to PDF in C#
filePath). Description: Convert to PDF/TIFF with specified zoom value and save it on the disk. Parameters: Name, Description, Valid Value.
how to convert pdf file to tiff for; pdf to multi page tiff
The dollar sign signifies a string variable. Notice that the name of the variable includes the dollar
sign—it’s myText$,not myText. To create a variable of a particular type, use one of the data declara-
tion characters in Table 3.2 (not all data types have their own identifier).
Table 3.2:Data Type Definition Characters
Symbol
Data Type
Example
$
String
A$, messageText$
%
Integer (Int32)
counter%, var%
&
Long (Int64)
population&, colorValue&
!
Single
distance!
#
Double
ExactDistance#
@
Decimal
Balance@
Using type identifiers doesn’t help in producing the cleanest and easiest to read code. If you
haven’t used them in the past, there’s no really good reason to start using them now.
The Strict and Explicit Options
Previous versions of Visual Basic didn’t require that variables be declared before they were used.
VB.NET doesn’t requirethat you declare your variables either, but the default behavior is to throw an
exception if you attempt to use a variable that hasn’t been previously declared. If an undeclared vari-
able’s name appears in your code, the editor will underline the variable’s name with a wiggly red line,
indicating that it caught an error. Rest the pointer over the segment of the statement in question to
see the description of the error.
To change the default behavior, you must insert the following statement at the beginning of the
file, above the Imports statements:
Option Explicit Off
The 
Option Explicit
statement must appear at the very beginning of the file. This setting affects
the code in the current module, not in all files of your project or solution.
The sample code in this section assumes that the 
Option Explicit
has been set to Off. For all
other examples in the book, I will assume that this option is set to On. Not only that, but in the first
few chapters I include the declarations of the variables I use in short code samples that demonstrate
an object property or the syntax of a function.
You can also specify the settings of the Strict and Explicit options from the Property Pages dia-
log box of the current project, as shown in Figure 3.1. To open this dialog box, right-click the name
of the project in the Solution Explorer and, from the context menu, select Properties. The settings
you specify here take effect for all the components of the current project.
Chapter 3 VISUAL BASIC: THE LANGUAGE
102
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
convert pdf to tiff high quality; how to convert pdf to tiff format
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
convert multiple page pdf to tiff; how to convert pdf to tiff on
The default value of the 
Option Explicit
statement is On. This is also the recommended value,
and you should not make a habit of changing this setting. Most programmers familiar with previous
versions of VB will not like having to declare their variables, but using variants for all types of vari-
ables has never been a good idea. In the later section “Why Declare Variables?”, you will see an
example of the pitfalls you’ll avoid by declaring your variables. (The truth is that all VB programmers
will miss variants, but this is a very small price to pay for the new features added to the language.)
By setting the Explicit option to Off, you’re telling VB that you intend to use variables without
declaring them. As a consequence, VB can’t make any assumption as to the variable’s type, so it uses
a generic type of variable that can hold any type of information. These variables are called Object
variables, and they’re equivalent to the old variants.
As you work with the 
Option Explicit
set to Off, you can use variables as needed, without
declaring them first. When Visual Basic meets an undeclared variable name, it creates a new variable
on the spot and uses it. The new variable’s type is Object, the generic data type that can accommo-
date all other data types. Using a new variable in your code is equivalent to declaring it without type.
Visual Basic adjusts its type according to the value you assign to it. Create two variables, var1 and
var2, by referencing them in your code with statements like the following ones:
var1 = “Thank you for using Fabulous Software”
var2 = 49.99
The var1variable is a string variable, and var2is a numeric one. You can verify this with the Get-
Type method, which returns a variable’s type. The following statements print the types shown below
each statement, in bold:
Console.WriteLine(“Variable var1 is “ & var1.GetType().ToString)
Variable var1 is System.String
Console.WriteLine(“Variable var2 is “ & var2.GetType().ToString)
Variable var2 is System.Double
Later in the same program you can reverse the assignments:
var1 = 49.99
var2 = “Thank you for using Fabulous Software”
Figure 3.1
Setting the Strict
and Explicit options
on the project’s
Property Pages
103
VARIABLES
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
DocumentType.DOCX DocumentType.TIFF. zoomValue, The magnification of the original PDF page size. Description: Convert to DOCX/TIFF with specified resolution and
batch pdf to tiff converter; how to convert pdf to tiff image
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
PDF from RTF. Create PDF from Text. PDF Export. Convert PDF to Word (.docx). Convert PDF to Tiff. Convert PDF to HTML. Convert PDF to
pdf to tiff quality; create tiff from pdf
If you execute the previous Print statements again, you’ll see that the types of the variables have
changed. The var1variable is now a double, and var2is a string.
Another related option is the Strict option, which is Off by default. The Strict option tells the
compiler whether the variables should be strictly typed. A strictly typed variable can accept values of the
same type as the type it was declared with. With the Strict option set to Off, you can use a string
variable that holds a number in a numeric calculation:
Dim a As String = “25000”
Console.WriteLine(a / 2)
The last statement will print the value 12500 on the Output window. Likewise, you can use
numeric variables in string calculations:
Dim a As Double = 31.03
a = a + “1”
If you turn the Strict option on by inserting the following statement at the beginning of the file,
you won’t be able to mix and match variable types:
Option Strict On
If you attempt to execute any of the last two code segments while the Strict option is On, the
compiler will underline a segment of the statement to indicate an error. If you rest the pointer over
the underlined segment of the code, the following error message will appear in a tip box:
Option strict disallows implicit conversions from String to Double
(or whatever type of conversion is implied by the statement).
When the Strict option is set to On, the compiler doesn’t disallow allimplicit conversions
between data types. For example, it will allow you to assign the value of an Integer to a Long, but
not the opposite. The Long value may exceed the range of values that can be represented by an Inte-
ger variable. You will find more information on implicit conversions in the section “Widening and
Narrowing Conversions,” later in this chapter.
Moreover, with 
Option Strict On
, you can’t late-bind an expression. Late bindingmeans to call a
method or a property of an object, but not be able to resolve this call at design time.
When you declare an object, like a Pen or a Color object, and then you call one of its properties,
the compiler can verify that the member you call exists. Take a look at the following lines:
Dim myPen As Pen
myPen = New Pen(Color.Red)
myPen.Width = 2
These three statements declare a Pen object and initialize it to red color and a width of two pixels.
All the shapes you’ll draw with this pen will be rendered in red, and their outlines will be two pixels wide.
This is early binding,because as soon as the variable is declared, the compiler can verify that the Pen
object has a Width and a Red property.
Now let’s use an Object variable to store our Pen object:
Dim objPen As Object
objPen = New Pen(Color.Red)
objPen.Width = 2
Chapter 3 VISUAL BASIC: THE LANGUAGE
104
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
This is called late binding, and it will work only if the Strict option is turned off. The objPenvari-
able is an Object variable and can store anything. The compiler has no way of knowing what type of
object you’ve stored to the variable, and therefore it can’t verify that the objPenvariable exposes a
Width property. In this short segment, it’s pretty obvious that the objPenvariable holds a Pen object,
but in a larger application the objPenvariable may be set by any statement.
Early binding seems pretty restricting, but you should always use it. You should keep the default
value only when absolutely necessary (which is rare). Notice that you don’t have to turn on the Strict
option to use early binding—just declare your variables with a specific type. Early-bound variables
display their members in a drop-down list when you enter their name, followed by a period. If you
enter myPenand the following period in the editor’s window, you will see a list of all the methods
supported by the Pen object. However, if you enter objPenand the following period, you will see a list
with just four members—the members of any Object variable.
Object Variables
Variants—variables without a fixed data type—were the bread and butter of VB programmers up to
version 6.0. VB.NET supports variants only for compatibility reasons, and you shouldn’t be sur-
prised if they’re dropped altogether from the language in a future version. Variants are the opposite
of strictly typed variables: they can store all types of values, from a single character to an object. If
you’re starting with VB.NET, you should use strictly typed variables. However, variants are a major
part of the history of VB, and most applications out there (the ones you may be called to maintain)
make use of them. So I will discuss variants briefly in this chapter and show you what was so good
(and bad) about them.
VB6 VB.NET
By default, you can’t use variants with VB.NET. In order for variables to handle any value you assign to
them, you can either declare them as Object type or turn off the Strict option. The keyword Variant has dis-
appeared from the language.
Variants were the most flexible data type because they could accommodate all other types. A vari-
able declared as Object (or a variable that hasn’t been declared at all) is handled by Visual Basic
according to the variable’s current contents. If you assign an integer value to an Object variable,
Visual Basic treats it as an integer. If you assign a string to an Object variable, Visual Basic treats it
as a string. Variants can also hold different data types in the course of the same program. Visual
Basic performs the necessary conversions for you.
To declare a variant, you can turn off the Strict option and use the Dim statement without speci-
fying a type, as follows:
Dim myVar
If you don’t want to turn off the Strict option (which isn’t recommended anyway), you can
declare the variable with the Object data type:
Dim myVar As Object
105
VARIABLES
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Every time your code references a new variable, Visual Basic will create an Object variable. For
example, if the variable validKeyhasn’t been declared, when Visual Basic runs into the following line:
validKey = “002-6abbgd”
it will create a new Object variable and assign the value “002-6abbgd” to it.
You can use Object variables in both numeric and string calculations. Suppose the variable modem-
Speedhas been declared as Object with one of the following statements:
Dim modemSpeed                ‘ Option Strict = Off
Dim modemSpeed As Object      ‘ Option Strict = On
and later in your code you assign the following value to it:
modemSpeed = “28.8”
The modemSpeedvariable is a string variable that you can use in statements such as the following:
MsgBox “We suggest a “ & modemSpeed & “ modem.”
This statement displays the following message:
We suggest a 28.8 modem.
You can also treat the modemSpeedvariable as a numeric value with the following statement:
Console.WriteLine “A “ & modemSpeed & “ modem can transfer “ & modemSpeed * _
1000 / 8 & “ bytes per second.”
This statement displays the following message:
A 28.8 modem can transfer 3600 bytes per second.
The first instance of the modemSpeedvariable in the above statement is treated as a string, because
this is the variant’s type according to the assignment statement (we assigned a string to it). The sec-
ond instance, however, is treated as a number (a single-precision number). Visual Basic converts it to
a numeric value because it’s used in a numeric calculation.
Another example of this behavior of variants can be seen in the following statements:
Dim I As Integer, S As String
I = 10
S = “11”
Console.WriteLine(I + S)
Console.WriteLine(I & S)
The first WriteLine statement will display the numeric value 21, while the second statement will
print the string “1011”. The plus operator (
+
) tells VB to add two values. In doing so, VB must
convert the two strings into numeric values, then add them. The concatenation operator (
&
) tells VB
to concatenate the two strings.
Visual Basic knows how to handle variables in a way that makes sense. The result may not be
what you had in mind, but it certainly is dictated by common sense. If you really want to concate-
nate the strings “10” and “11”, you should use the & operator, which would tell Visual Basic exactly
what to do. Quite impressive, but for many programmers this is a strange behavior that can lead to
Chapter 3 VISUAL BASIC: THE LANGUAGE
106
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
subtle errors, and they avoid it. It’s up to you to decide whether to use variants and how far you will
go with them. Sure, you can perform tricks with variants, but you shouldn’t overuse them to the
point that others can’t read your code.
You can also store dates and times in an Object variable. To assign a date or time value to a vari-
ant, surround the value with pound signs, as follows:
date1 = #03/06/1999#
All operations that you can perform on date variables (discussed in the section “Date Variables”)
you can also perform with variants, which hold date and time values.
Converting Variable Types
In some situations, you will need to convert variables from one type into another. Table 3.3 shows
the Visual Basic functions that perform data-type conversions. Actually, you will have to convert
between data types quite often now that VB doesn’t do it for you.
Table 3.3:Data-Type Conversion Functions
Function
Converts Its Argument To
CBool
Boolean
CByte
Byte
CChar
Unicode character
CDate
Date
CDbl
Double
CDec
Decimal
CInt
Integer (4-byte integer, Int32)
CLng
Long (8-byte integer, Int64)
CObj
Object
CShort
Short (2-byte integer, Int16)
CSng
Single
CStr
String
To convert the variable initialized as
Dim A As Integer
to a Double, use the function:
Dim B As Double
B = CDbl(A)
107
VARIABLES
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Suppose you have declared two integers, as follows:
Dim A As Integer, B As Integer
A = 23
B = 7
The result of the operation A/ Bwill be a double value. The following statement:
Console.Write(A / B)
displays the value 3.28571428571429. The result is a double, which provides the greatest possible
accuracy. If you attempt to assign the result to a variable that hasn’t been declared as Double, and the
Strict option is On, then VB.NET will generate an error message. No other data type can accept this
value without loss of accuracy.
As a reminder, the Short data type is equivalent to the old Integer type, and the CShort() func-
tion converts its argument to an Int16 value. The Integer data type is represented by 4 bytes (32
bits), and to convert a value to Int32 type, use the CInt() function. Finally, the CLng() function
converts its argument to an Int64 value.
You can also use the CType() function to convert a variable or expression from one type to
another. Let’s say the variable Ahas been declared as String and holds the value “34.56”. The fol-
lowing statement converts the value of the Avariable to a Decimal value and uses it in a calculation:
Dim A As String = “34.56”
Dim B As Double
B = CType(A, Double) / 1.14
The conversion is necessary only if the Strict option is On, but it’s a good practice to perform
your conversions explicitly. The following section explains what may happen if your code relies to
implicit conversions.
Widening and Narrowing Conversions
In some situations, VB.NET will convert data types automatically, but not always. Let’s say you
have declared and initialized two variables, an integer and a double, with the following statements:
Dim count As Integer = 99
Dim pi As Double = 3.1415926535897931
If the Strict option is On and you attempt to assign the value of the pivariable to the countvari-
able, the compiler will generate an error message to the effect that you can’t convert a double to an
integer. The exact message is:
Option Strict disallows implicit conversions from Double to Integer
VB6 
VB.NET
You will probably see this message many times, especially if you’re a VB6 programmer. In the past, VB
would store the value 3 to the countvariable and proceed. If you weren’t careful, you’d lose significant dec-
imal digits and might not even know it. This implicit conversion results in loss of accuracy, and VB.NET
doesn’t perform it by default. This is a typical example of the pitfalls of turning off the Strict option.
Chapter 3 VISUAL BASIC: THE LANGUAGE
108
Copyright ©2002 SYBEX, Inc., Alameda, CA
www.sybex.com
Documents you may be interested
Documents you may be interested