c# render pdf : How to move pages in a pdf document application software utility html winforms asp.net visual studio vb_dot_net_developers_guide5-part604

18
Chapter 1 • New Features in Visual Basic .NET
servers and clients have been blurred. It is no longer safe to assume that the
effects of an application can be analyzed on a single computer, because more
applications now run on and require the resources of multiple machines.And if
you are deploying your application to the general public, it is no longer safe to
assume you can identify all of the users of your application. Because of this,
Microsoft has now introduced a new security tool in .NET to support the devel-
oper: SECUTIL.This tool makes it easier to extract information about the user
identity, after the user has been validated using the Public Key Value (internal
users) or the X.509 certificate (external users).
Because of this, users are accountable for their code. In the past, a developer
could write their own version of an OCX or DLL, copy it into a Windows
system directory and register it, and this would have an impact upon every other
application that was dependent upon that resource.
Although this was a handy way to quickly deploy patches, it also infuriated
developers whose code failed when used with the new DLL due to dependence
upon behavior that was altered in the new versions of the code. By contrast, by
using SECUTIL, it is possible to identify what code was developed by what
developer, which increases accountability.
Type Safety
Although much of VB.NET allows you to eliminate development steps, a few
cases exist where you need to take extra precautions in this new environment,
and type safety is one of those factors. Type safety is the enforcement of variable
compatibility when moving data from one variable to another. In this section, we
examine the new requirements in VB.NET and the approaches to address this
requirement.
Casting
If you have experience with languages such as C++ or Java, then you are prob-
ably experienced with casting. If you are an experienced VB developer, then you
probably have used casting, but the term may be new to you.
Casting is the process of explicitly converting a variable of one type to a vari-
able of another type, and it is used to reduce bugs caused by moving information
into variables using inappropriate data types. For example, observe the following
code:
www.syngress.com
How to move pages in a pdf document - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
move pages in pdf document; how to reorder pages in pdf preview
How to move pages in a pdf document - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
move pdf pages in preview; how to rearrange pdf pages
New Features in Visual Basic .NET • Chapter 1
19
Dim A as integer
Dim B as long
A = 20000
B = CLng(A)
The variable B has been explicitly cast to a Long type, using the CLng func-
tion.A cast function exists for each type of variable. Some examples of this are
provided in Table 1.6. Casting is not new in VB.NET, but it is more important,
for reasons discussed in the next section.
Table 1.6
Cast Functions for Variable Types
Cast Function
Action
CLng
Convert to a “Long”
CStr
Convert to a “String”
CInt
Convert to a “Integer”
CDbl
Convert to a “Double”
Data Conversion
When you convert from one variable type to another, it is called narrowing if
there is a risk of loss of precision, and widening if there is no risk of this loss.
In other languages like C++, the developer explicitly tells the compiler what
to do when you pour data from one variable into another with a risk of data loss.
The reason is to provide informed consent—to make sure that you are aware of
the risk and accept responsibility for the consequences if the data is too large for
the defined container.
Now, in the current version of VB.NET, Microsoft has introduced Option
Strict. If you use this option, you must perform an explicit cast for every nar-
rowing assignment. For example, with Option Strict off, the following line would
successfully compile:
Dim a as integer
Dim b as long
A = 20000
B = a ' Cint excluded
But with Option Strict on, this code would generate a compilation error.
www.syngress.com
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. this C#.NET Tiff image management library, you can easily change and move the position of
how to reorder pages in pdf online; how to reorder pdf pages in
C# Word - Sort Word Pages Order in C#.NET
adjust the order of all or several Word document pages, or just page inserting, Word page deleting and Word document splitting C# DLLs: Move Word Page Position.
pdf reverse page order preview; move pages in a pdf
20
Chapter 1 • New Features in Visual Basic .NET
Bitwise Operations
VB.NET enforces more precise type usage in other ways as well, and some short-
cuts that were used by previous generations of VB programmers are no longer
permitted.
In VB.NET, when writing conditional code, the parameter used for the IF
statement must be of the type Boolean. In previous versions of VB, programmers
could take a shortcut, and implicitly cast the integer 0 to the Boolean False. For
example, the following line of code would work in VB 6.0:
Dim a as integer
A = 0
If (a) then MsgBox "Hello world"
This code would, however, fail in VB.NET.To correct the code, you have to
make the following change in the third line:
Dim a as integer
A = 0
If (CBool(a)) then MsgBox "Hello world"
Note that this situation is similar to the relationship between C++ and Java.
Java supports only Booleans with IF, whereas C++ allowed implicit casting of
other variable types.
New Compiler
Although you will normally use the compiler from within the IDE, you also have
new flexibility in compiling from the command line with VB.NET. In this sec-
tion, we take a look at how you can use the compiler, and then we take a look at
some of the advantages to the executables created by the new compiler.
Compiling an Executable
You can initiate compilation from the command line, invoking the executable
wsc.exe, with the parameters shown in Table 1.7.
www.syngress.com
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
the order of all or several PowerPoint document pages, or just PowerPoint page deleting and PowerPoint document splitting C# DLLs: Move PowerPoint Page Position.
change pdf page order online; how to rearrange pdf pages reader
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
RasterEdge XDoc.PDF allows you to easily move PDF document pages position, including sorting pages and swapping two pages. Copying and Pasting Pages.
reorder pdf page; reorder pages in pdf preview
New Features in Visual Basic .NET • Chapter 1
21
Table 1.7
Parameters for WSC Compiler
Tag
Meaning
/t
The type of output code. For example an EXE means a 
console application, while WINEXE means that it is a 
Windows application.
/r
References to include (all DLLs that are referenced in 
the app).
/version
The version number visible when the properties of the 
executable are viewed (major version, minor version, 
revision, and build).
The last parameter
The VB file to compile.
Architecture
To understand the operation of the new VB compiler, you need to understand
the architecture for the applications that the VB compiler creates.
Previously, the executable created by a language such as C++ would make
direct references to registers, interrupts, and memory locations.Although working
inside the Microsoft foundation classes could reduce the risk of error, eliminating
risk due to inexperience (or malice) was not possible.
That has changed with VB.NET. Now, instead of compiling directly to hard-
ware-specific machine code, the compilation is performed to MSIL (Microsoft
Intermediate Language).The syntax of MSIL is similar to machine code, but any
EXE or DLL containing MSIL will need to be reinterpreted after it is deployed
to the destination machine.
File Management in Previous Versions of VB
In previous versions of VB, each resource that you included in your project would
have its own extension and reside in its own file, with an extension that identified
the type of resource, as shown in Table 1.8.
Table 1.8
Sample File Extensions in VB 6.0
Resource Type
Extension
Form
.frm
Class Module
.cls
Module
.bas
www.syngress.com
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). aChar, font, pageIndex, cursor); // Output the new document. Program.RootPath + "\\" output.pdf"; doc.Save
change pdf page order reader; rearrange pages in pdf online
C# PDF Library SDK to view, edit, convert, process PDF file for C#
load, create, convert and edit PDF document (pages) in C# PDF files; insert, delete, move, rotate, copy and robust APIs for editing PDF document hyperlink (url
how to move pages in a pdf file; how to change page order in pdf acrobat
22
Chapter 1 • New Features in Visual Basic .NET
Although this made it easy to interpret the resource type immediately, it also
made it very difficult to manage projects with large numbers of small classes.
Another challenge was trying to keep filenames reconciled with class names.This
became especially difficult as projects grew and changed in focus.
File Management
In VB.NET, the filename extension restriction has been removed. Now,
regardless of which type of resource you create, it will have the same extension
(see Table 1.9).
Table 1.9
Some of the File Extensions in VB.NET
Resource Type
Extension
Form
.vb
Class Module
.vb
Module
.vb
You can also concatenate as many resources as you want into a single file,
regardless of type.The default behavior (when using the Project | Add Class
menu option) is still to create new files, but you can copy this content into a
single source file. For example, two distinct classes could be represented in the file
MyClasses.vb with the following code:
Public Class Beeper
Public Sub Beep()
MsgBox("Beep")
End Sub
End Class
Public Class Booper
Public Sub Boop()
MsgBox("Boop")
End Sub
End Class
www.syngress.com
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Get image information, such as its location, zonal information, metadata, and so on. Able to edit, add, delete, move, and output PDF document image.
move pdf pages; pdf change page order online
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Rapidly and multiple PDF document (pages) creation and edit PDF files; insert, delete, move, rotate, copy robust APIs for editing PDF document hyperlink (url
pdf reverse page order; rearrange pdf pages reader
New Features in Visual Basic .NET • Chapter 1
23
Changes from Visual Basic 6.0
The following sections detail some options you have to prepare for VB.NET.
First, we look at features in VB 6.0 that are gone in VB.NET.Then we look at
new features in VB.NET. Finally, we observe features that are present in both ver-
sions but with some significant changes.This section doesn’t cover every change,
but it will provide enough context to illustrate the challenges and opportunities
involved with this transition.
Variants
The Variant data type is no longer supported in VB.NET, and it has been merged
into the Object type. More specifically, because all variables are now objects, a
variant is simply defined as an object.
Variable Lower Bounds
To make the language compatible with the other .NET languages, you no longer
can start an array at 1 using the Option Base command.All arrays are now
forced to begin with array element zero.
Fixed Length Strings
You now cannot create strings of fixed length. In previous versions of VB, you
could write the following code to define the string to be exactly 12 characters
long:
Dim sLastName as String * 12
This is no longer supported in VB.NET to ensure compatibility with the
other .NET languages.
NULL Propagation
In previous versions of Visual Basic, any expression that had a NULL in it would
yield a null. For example, 1 + NULL would yield a NULL in VB 6.0. However,
VB.NET does not support NULL propagation. If you are using it to do error
handling, you should rewrite your code and use the IsNull function.
www.syngress.com
24
Chapter 1 • New Features in Visual Basic .NET
N
OTE
Interestingly, this approach to null propagation is not standard for all
Microsoft applications. One major difference between SQL Server 6.5 and
7.0 is that null propagation has been introduced into 7.0 unless you
explicitly disable it. In other words, A + NULL + B would equal AB in SQL
Server 6.5, but NULL in version 7.0. This was done to comply with the
ANSI SQL standard.
Other Items Removed
In addition to those already mentioned, the following features shown in Table 1.10
are no longer supported in VB.NET.
Table 1.10
Language Substitution Strategies
Statement
Old Operation
Approach to Replace
GoSub
Allowed execution of a section  Replace with new 
of code without leaving the 
modules.
existing function or procedure.
Computed GoTo /  Acted like the Switch 
Use Select Case or 
GoSub
statement, but selecting one of  Switch with custom 
many sections of code to 
functions.
execute.
DefInt, DefLong, 
Defined a range of scalar 
Define each of the 
DefStr, and so on
variables of the type specified 
variables explicitly or 
with a certain range.
rewrite code to 
support an array.
Lset
Reassign variables of 
Copy over components 
user-defined types.
of new types 
individually.
Function Values
You now can return a value from a function using the command Return,
instead of needing to assign the value to the name of the function. Not only does
this make it easier to terminate the function (instead of having to use two lines to
set the value and then Exit Function, these two statements can be rolled up into
www.syngress.com
New Features in Visual Basic .NET • Chapter 1
25
a single command), it also means that you can rename the function without
having to change all the references to the function name.
Short Circuits
In many other languages, as soon as an IF statement resolves to False, the other
parts of code do not execute. For example, observe the following piece of code:
If DebitsCorrect("Chase") and CreditsCorrect("Citibank") then 
MsgBox "Transaction processed"
End if
In VB6, both the function DebitsCorrect and the function CreditsCorrect
would always execute. However, in one of the new features proposed for
VB.NET, if DebitsCorrect resolved to False, then CreditsCorrect would never
execute.This behavior is called short circuiting because the code knows that the
expression can never resolve to True if the first half resolves to False; it doesn’t
have to bother to execute the second half of the expression. Unfortunately, this
causes greater incompatibility with legacy code, which is why Microsoft has not
confirmed whether or not they will include this change in the final release of
VB.NET.
Properties and Variables
Of course, many of the day-to-day changes you will notice are evolutionary, not
revolutionary. In this section, we look at the impact of changes in how properties
and variables are stored and manipulated.
Variable Lengths
Unfortunately, in the history of computer science there has been disagreement
over the definition of a byte, which has led to significant confusion for the
modern developer. Many early computers used eight bits (binary digits) to
describe the smallest unit of storage, but when computers became more powerful
and stored data internally in larger structures, some developers still thought that a
byte was eight bits, whereas other developers thought that a byte should still rep-
resent how the processor stored data, even if it used 16 bits, or more. Because of
this situation, the size of the variables in C could change when code was recom-
piled on other hardware platforms, and other languages that came in the future
reflected these incompatibilities. Now, in .NET, the definitions of the variable
types have been standardized, as shown in Table 1.11.
www.syngress.com
26
Chapter 1 • New Features in Visual Basic .NET
Table 1.11
Variable Lengths in Bits
Bit Length
VB 6.0
VB.NET
8 bits
Short
Byte 
16 bits
Integer
Short
32 bits
Long
Integer
64 bits
N/A
Long
These definitions bring the standards in line with those used in the rest of the
.NET suite of application development tools.Although some of these variable
names will be automatically substituted when a VB 6.0 application is imported
into VB.NET, you should still examine the finished code to make sure that the
new code reflects your application needs. (Also be aware that this will also affect
the changes made in the API calls—if it used to be a Long, it should now be an
Integer, and so on.)
Get and Set
Previously, your Get and Let/Set statements had to be coded separately, as two
separate blocks of code residing in a class. Of course, it was possible to have a Get
without a Let/Set for read-only properties (or vice versa, for write-only proper-
ties), but for most properties, this added unnecessarily clumsiness to the organiza-
tion of the class modules. Now, in VB.NET, these are now grouped together in a
single module that is broken down into two sections that support both assigning
and retrieving these values.
Date Type
In earlier versions of Visual Basic, variables of the Date type were stored internally
as Doubles (with the number of days to the left of the decimal point and the
fraction of a day stored to the right).Therefore, many developers chose to store
their dates as Doubles instead of as Dates, even after VB introduced the Date
type.
This approach had many advantages. (For example, when using heterogeneous
databases, it was often more reliable to store data as numbers, and the math was
often much easier as well if you reserved the use of Dates for presentation only.)
However, in VB.NET, Double and Date are no longer equivalent, so you should
use the Date type for date use in VB.NET, or you may get compilation errors.
Although Dates are now represented internally using the .NET DateTime
www.syngress.com
New Features in Visual Basic .NET • Chapter 1
27
format, which supports a greater precision and range of dates, you can still use
the ToOADate VB.NET function to convert this type back into a Double-
compatible format.
Default Properties
Some Visual Basic developers use a shortcut to omit the reference to the default
property of an object. For example, if you wanted to assign a value to a text box,
instead of writing this:
tbFirstName.text = "John"
You could instead write this:
tbFirstName = "John"
Each control had a default property that would be referenced if you omitted
the name of the property, and when you created your own objects you could
define the default property you wanted to use for it.
However, in VB.NET, because all data types are now represented as objects, a
reference to an object that omits any property can be interpreted as the object
itself instead of a default property of an object.Therefore, when developing 
applications in VB.NET, remember to explicitly declare the default properties.
www.syngress.com
Documents you may be interested
Documents you may be interested