c# render pdf : Moving pages in pdf Library application class asp.net azure windows ajax vb_dot_net_developers_guide56-part611

528
Chapter 11 • Optimizing, Debugging, and Testing
Debug Menu
The Visual Basic .NET IDE Debug menu provides us with some very useful
tools, which are very helpful for debugging in the runtime environment. Each
provides a unique way to control execution of your code line-by-line.The tools
include Step Into, Step Out, Step Over, and Run To Cursor.We now
examine their functionality. Follow these steps:
1. Open the code view for the designer of the simple calculator. In the
code, place the cursor on the line where the Button1_Click() method
begins.
2. Place a breakpoint there by pressing F9.A breakpoint will halt execution
when the compiler reaches this line of code; we cover it in greater detail
in the “Breakpoints” section.
3. Run the application by selecting Start from the Debug menu.
4. When the simple calculator loads up, put any numeric value in each of
the left and right text boxes. Select the plus sign to indicate addition in
the combo box.
5. Select Calculate.You will notice that the execution of the program
stops and that the current line where execution stands is indicated with
a yellow arrow in the left margin of the code view.This yellow arrow
always indicates the next line that will be executed. By using the com-
mands in the Debug menu, we can control where the execution will go.
6. Go to the Debug menu now and select Step Into.You will see the
yellow arrow move down one line, which means that the previous line
executed successfully.This technique can be very useful. It helps you to
follow your code one line at a time in order to determine where an
error occurs or to see where a value changes.
7. Continue to select the Step Into command until the arrow is on the
same line that calls the Calculate() method.At this point, the execution
will move into another procedure.
We have options here. If we know that the method in question
works and is not the source of any error being investigated, then we may
choose to Step Over the call. By selecting to Step Over the call, the
method will be executed at real time without us seeing the execution
line by line. In order to see the code in the method execute line-by-line,
we must Step Into the method.
www.syngress.com
Moving pages in pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change page order in pdf reader; how to reorder pages in pdf file
Moving pages in pdf - 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
how to move pages around in a pdf document; how to rearrange pages in a pdf reader
Optimizing, Debugging, and Testing • Chapter 11
529
8. Select the Step Into command from the Debug menu.After you are in
a routine, you again have two choices.You can step through the code
line by line, or you can Step Out of the method back to the calling
method.You can do this by using the Step Out command.
9. Select the Step Out command from the Debug menu.You will see the
execution return to the calling method (Button1_Click) one line after
the method you are returning from (the Calculate method).All the
code in Calculate() is executed before returning to the calling method.
In addition to all these tools, you can also use the Run To Cursor option,
which is handy in lengthy methods. It gives you the ability to place the cursor on
a line within the current method and have the code execute up to the line where
the cursor is.
N
OTE
Each of the Debug menu tools has keyboard shortcuts. You can use these
debugging techniques very efficiently by becoming familiar with these
shortcuts:
Step Into F8
Step Over Shift+F8
Step Out Ctrl+Shift+F8
Run To Cursor Ctrl+F8
These features are very useful but are usually used along with the other useful
VB.NET IDE debugging tools, which we discuss in the following sections.
Watches
Watches provide us with a mechanism where we can interact with the actual data
that is stored in our programs at runtime.They allow us to see the values of vari-
ables and the values of properties on objects. In addition to being able to view
these values, you can also assign new values.This can be very handy while step-
ping through your code because you can see what would happen if a variable had
a different value at a specific point in time. Let’s use our practice project to
examine the value of watches:
1. In order to use the Watch window, the application must be in break
mode. So again, let’s set a breakpoint in the Button1_Click event.
www.syngress.com
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
In the following part, you will see a complete C# programming sample for moving the position of Tiff document pages. DLLs: Sort TIFF File Pages Order Using C#.
change page order in pdf online; rearrange pdf pages
C#: How to Edit XDoc.HTML5 Viewer Toolbar Commands
That is to say, if you are in need of moving a tab in front of another one, you may directly use _viewerTopToolbar var _userCmdDemoPdf = new UserCommand("pdf");
how to reorder pages in pdf; reordering pages in pdf document
530
Chapter 11 • Optimizing, Debugging, and Testing
2. Run the application and enter some numbers then press the Calculate
button so that we get to our breakpoint.
3. Place the cursor over the intLeftNumber variable names and select
Add Watch.You now see a new window appear at the bottom of the
IDE called the Watch window (see Figure 11.2). Now, you can see the
value of the variable as it changes for as long as it is in scope.The values of
variables are only visible while they are in scope, which means that private
declarations are only visible in the classes or methods in which they are
declared. Publicly declared variables will be visible throughout the applica-
tion. In addition to being able to watch these values, we can also change
them.Although we have the Watch window available, place the cursor into
the Value field for our watch variable. Change the value to 15 and press
Enter. Now continue execution of the program.You will see that the final
result reflects the change that you made in the Watch window.
www.syngress.com
Figure 11.2
The Watch Window
VB.NET Image: Add Callout Annotation on Document and Image in VB.
annotations on multiple document and image formats, such as PDF, Word, TIFF Support easily moving or resizing generated callout annotation using VB.NET code;
reorder pages in pdf; how to rearrange pdf pages in preview
C#: Online Guide for Text Extraction from Tiff Using OCR SDK
Scan image and output OCR result to PDF document. Scan image and output OCR result to Word document. Before moving onto using C# demo codes below, please firstly
reorder pages in pdf reader; how to move pages around in pdf
Optimizing, Debugging, and Testing • Chapter 11
531
N
OTE
You can also add variables to the Watch window by typing their names
into the Name field. Or, you can also add a variable by highlighting it in
the code view and then dragging it into the Watch window. You can
then change and watch their values. You cannot, however, change the
values of constants in the Watch window.
Breakpoints
We have already seen breakpoints in the earlier examples, but we visit them in
more detail here. As we saw, breakpoints allow you to halt execution of your pro-
gram at a specific line of code.This helps when you have narrowed down the
general area of a problem you might be investigating. Breakpoints gives you the
ability to halt execution just before entering into that section and then walk
through the code as you desire.You can set breakpoints in a variety of ways.You
can click in the left margin of the code view at the line where you want to set
the breakpoint, or you can place the cursor on that line and press F9. In fact, you
can press F9 to toggle the breakpoint on and off.You may also set breakpoints by
selecting New Breakpoint from the Debug menu.
A new feature in VB.NET is the Breakpoints window, which you can bring
up by selecting Windows and then Breakpoints from the Debug menu. From
this window, you can see a list of all the breakpoints currently set in your applica-
tion (see Figure 11.3); you also have the flexibility to jump to any breakpoint in
the application simply by double-clicking on it in the Breakpoints window.You
will also notice that each breakpoint listed in the window has a checkbox beside
it.These give the option of activating or deactivating any breakpoint without
actually having to physically remove the breakpoint from the code view pane.
This can be useful if you want to skip over a breakpoint one time but activate it
again at a later time.
Some more advanced features are also available. Select any one of the break-
points in the Breakpoints window and click Properties. Here you can set a condi-
tion for the breakpoint. Click the Condition button and you will see the dialog
box shown in Figure 11.4. In this dialog box, we can specify any Boolean condition
to determine whether the breakpoint should be enabled or disabled. If you click
the Hit Count button from the Breakpoint properties dialog box, you can specify
how many times the breakpoint must be hit before it is automatically enabled.
www.syngress.com
C# Image: Create C#.NET Windows Document Image Viewer | Online
or image type, please see these pages respectively: C# multiple document & image formats (PDF, MS Word Resizing, burning, deleting and moving are all built in.
rearrange pdf pages in preview; how to reverse page order in pdf
VB.NET Image: Draw Linear RM4SCC Barcode on Document Image Using
item) rePage.MergeItemsToPage() REFile.SaveDocumentFile(doc, "c:/rm4scc.pdf", New PDFEncoder certain API, you can read detailed illustration by moving the mouse
how to move pages in a pdf; how to rearrange pages in pdf document
532
Chapter 11 • Optimizing, Debugging, and Testing
Exceptions Window
The Exceptions window is new in Visual Basic .NET. In previous versions of Visual
Basic, we were able to tell the compiler what to do when it encountered errors.
You might remember the options were Break In Class Module, Break On All
Errors, or Break On Unhandled Errors. In the new Exceptions window, you
can tell the compiler what to do on any specific exception or class of related
exceptions. Let’s take a walk through using our simple calculator application:
1. Remove all breakpoints (remember that you can do this with the key
combination Ctrl+Shift+F9).
www.syngress.com
Figure 11.3
The Breakpoints Window
Figure 11.4
Setting a Breakpoint Condition
C# Excel: View Excel File in Window Document Viewer Control
Resizing, burning, deleting and moving are all built in We are dedicated to provide powerful & profession imaging controls, PDF document, image to pdf files and
move pdf pages in preview; how to move pages in pdf acrobat
Optimizing, Debugging, and Testing • Chapter 11
533
2. Run the application by selecting Start from the Debug menu.
3. Place an alpha character in the first textbox and select to multiply it by
any number in the right text box.
4. Select Calculate.
You will see that an exception is thrown in the Button1_Click() method.This
exception (System.FormatException) occurred because, as we know, we cannot
convert a string with alpha characters into an integer.We have two ways we can
handle this.We can use a Try…Catch…Finally block and handle the exception, or
we can configure how the compiler should handle this exception.This type of
configuration is done in the Exceptions window as shown in Figure 11.5. For the
type of exception we are encountering here, we recommend that you use a
Try…Catch…Finally block and handle the exception appropriately. However, we
examine the functionality of the Exceptions window here. Let’s begin by finding
the exception in the exceptions TreeView:
1. Expand the Common Language Runtime Exceptions node.
2. Expand the SystemException node.
3. Scroll down the list until you see the FormatException and select it.
www.syngress.com
Figure 11.5
The Exceptions Dialog Box
534
Chapter 11 • Optimizing, Debugging, and Testing
The bottom of the Exceptions window has two frames. Each one gives you
an option as to how to handle the exception at different points in time.The top
frame labeled When The Exception Is Thrown tells the compiler what to do
immediately after the exception is thrown but before the code to handle the
exception is executed.The second frame labeled If The Exception Is Not
Handled tells the compiler what to do if the exception is not handled or if the
code to handle the exception fails.
Each of the two frames has three options: Break Into The Debugger,
Continue, and Use Parent Setting. By selecting Break Into The Debugger,
you are telling the compiler to go into break mode as soon as the exception is
thrown.You can set this up so that it will break only on unhandled exceptions by
selecting Continue in the top frame and Break Into The Debugger in the
second frame.The second option is Continue. By selecting this, you are telling
the compiler just to continue execution when an exception is thrown. If you
were to select this in both frames, you would be telling the compiler to ignore
the exception all the time.The final setting is Use Parent Setting, which is the
default setting. It allows for a form of inheritance through the hierarchy of
exceptions. For example, if you change the settings for Common Language
Runtime Exceptions, all exceptions below that node that are set to Use Parent
Setting will inherit those changes.
N
OTE
You can also add your own custom exception classes to the Exceptions
window. The Use Parent setting can be very useful when you develop
your own exception classes. If your exception classes have child classes,
they can inherit the behavior from their parent class with the use of this
setting.
Command Window
When debugging in Visual Basic 6.0, we made extensive use of the Immediate
window.We were able to use the Immediate window in order to determine the
values of variables and to execute commands in the IDE while the program is in
debug mode. Much of this functionality has been retained in Visual Basic .NET
with a tool called the Command window.This window is available in two
modes.The first mode is the immediate mode; you can open the command
window in immediate mode by selecting Immediate from the Windows 
www.syngress.com
Optimizing, Debugging, and Testing • Chapter 11
535
submenu on the Debug menu.The second mode is the Command mode; you
can open the Command mode by selecting the Command Window option
from the Other Windows menu found under the View menu.You can switch
between the two modes by using the immed command in Command mode and
using the >cmd command while in Immediate mode.You can use both of these
modes to execute commands while running in debug mode.
When working in command mode, the window’s title bar will read Command
Window.While in command mode, you can execute commands using the com-
mand line instead of locating them in the menus or executing commands that are
not available in the menus. For example, by typing addproj you can add a new
project to the Solutions Explorer. Most of the options that are available for use in
the Command window also have aliases.The aliases allow you to use a short
form, preventing the tedious act of having to type out the long name every time.
An example of this is bl, which is an alias name for Debug.ToggleBreakPoint.
A full list of aliases is available from MSDN, but the most commonly used ones
are listed in Table 11.2.
Table 11.2
Common Command Window Commands
Alias
Long Name
Description
?
Debug.Print
Writes the value of an expression or 
variable to the output window.
??
Debug.QuickWatch
Adds an expression or variable to the 
Quick Watch.
Alias
Tools.Alias
Creates a custom Alias name for a 
command.
Bl
Debug.Breakpoints
Displays the Breakpoints window.
Bp
Debug.ToggleBreakPoint Toggles a breakpoint on the current 
line.
Callstack
Edit.Callstack
Writes out the callstack.
Clearbook Edit.ClearBookmarks
Clears all the bookmarks.
Code
View.ViewCode
Displays the code pane for the current 
designer view.
Designer
View.ViewDesigner
Displays the designer pane for the 
current code view.
Cmd
View.CommandWindow Display the command mode.
Immed
Tools.ImmediateMode
Display the Command window in 
immediate mode.
www.syngress.com
536
Chapter 11 • Optimizing, Debugging, and Testing
As we can see from just these examples, a very comprehensive list of com-
mands is available for use in the Command window. Mastering the use of these
shortcuts will cut down the cost and time involved in debugging your projects.
Although you can use the Command mode of the Command window for
debugging tasks such as evaluating expressions and validating the values of vari-
ables, we recommend that this be done in the Immediate mode of the Command
window.The Immediate mode functions exactly the way that the Immediate
mode from previous versions of Visual Basic did except for one point.The
Up/Down arrow keys do not move up and down through the lines of the
Command window, but they actually scroll through the list of previously issued
commands on the one line. Just as in previous versions, you determine values
with the ? and evaluate expressions simply by typing them in and pressing Enter.
While in Immediate mode, you can execute all the commands available in the
Command mode by prefixing the command mode commands with a > character.
Conditional Compilation
Oftentimes during development, multiple versions of an application are required.
A common driving factor is regionalization of the application.Also, a large
amount of debugging code often exists throughout the source code for an appli-
cation.This code can add up to quite a few lines and it would be very time con-
suming and tedious if we had to remove this code before compiling the
application and then put it back in so that we could continue development on
other features for the application. Conditional compilation provides a way for us to
leave all this extra code in our source and to easily regionalize our applications.
Any source code that is enclosed with conditional compilation may or may not
be compiled into the executable file.
You can declare variables to be used for conditional compilation in a variety
of ways. Most of the directives for declaring conditional compilation variables are
much the same as they were in previous versions of Visual Basic.The first method
is to set up all conditional compilation variables in the project properties dialog
box (see Figure 11.6):
1. Open the Solution Explorer.
2. Right-click the project for which you would like to set up conditional
compilation constants and select Properties.
3. Select Configuration Properties.
4. Select Build and then add or modify conditional compilation constants.
www.syngress.com
Optimizing, Debugging, and Testing • Chapter 11
537
You can also declare variables in code.You declare the variable as a constant
by using the #Const keyword.This syntax tells the compiler that this variable is
to be used to evaluate conditional compilation expressions.You can also pass in
variable definitions as arguments when compiling from the command line by
using the /define tag.To evaluate the value of conditional compilation variables,
we use the #if…#else…#End if construct. Here are some code examples for
using conditional compilation using these two techniques:
#Const Language = "FRENCH"
#If language = "FRENCH" then
'Do french code
#Else
'Do other language code
#end if
We can also have the exact same #if statement in the code but pass in the
definition of the Language variable using the tag on the command line. For
example, Vbc /define:Language=FRENCH [project]. In addition to the
standard conditional compilation options that we have seen here,Visual Studio
.NET provides some built-in conditional compilation options that enable you to
actually trace the execution of a deployed application.
www.syngress.com
Figure 11.6
Project Properties Dialog Box: Conditional Compilation
Documents you may be interested
Documents you may be interested