c# render pdf : Change page order pdf preview Library software component asp.net winforms windows mvc vb_dot_net_developers_guide57-part612

538
Chapter 11 • Optimizing, Debugging, and Testing
Trace
For applications where performance is vital, it would be convenient to be able to
trace their performance as the end users were using them.Visual Studio.NET
provides a mechanism that allows us to do just that.We can place code
throughout our application that can log events and steps of execution to a con-
sole window, log file, or any other available output. For example, we may want to
examine database connectivity in a multiuser environment in order to determine
why some users are experience longer lags then others.
In Figure 11.6, we saw how to define conditional compilation constants.The
dialog box also has two other checkboxes.The first checkbox is where you set
the Debug constant, and the second is where you set the Trace constant.As in
Visual Basic 6.0, we have access to a debug class. In previous versions of Visual
Basic, we had the ability to write to the Immediate window by using lines in our
code, such as debug.print.This class is still available in Visual Basic .NET
(though the method names have changed, the overall functionality is similar).
One difference is that unless the Debug constant is set, all the debugging code
that is written in your application using the Debug class will not be compiled into
the final executable. On the other hand, if you set the Trace option, all the debug-
ging code that is written in your application using the Trace class will be com-
piled into the executable. It is through this mechanism that we can add Trace
functionality to our deployed applications.
The information that you wish to have logged can be written to a few dif-
ferent places.These places are called Trace Listeners. The Listeners collection of the
Trace object keep track of the Trace Listeners.Two other potential Listeners are
the TextWriterTraceListener and the EventLogTraceListener.The EventLogTraceListener,
as you might guess, will write the Trace information to an event log.The
TextWriterTraceListener writes the information to any instance of the TextWriter
class or Stream class. In the upcoming example, we use an instance of the Stream
class to create a text file to track the operations and numbers that our users use.
This information might be useful if they report bugs with the application.
Let’s take a look at using traces in our simple calculator program.Add the 
following Code to the simple calculator window’s form:
1. At the top of the Form class, enter the following declaration:
Private myfile As System.IO.Stream
Private BoolSwitch As BooleanSwitch
www.syngress.com
Change page order pdf preview - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
pdf reverse page order; reorder pages in a pdf
Change page order pdf preview - 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
rearrange pages in pdf file; rearrange pages in pdf reader
Optimizing, Debugging, and Testing • Chapter 11
539
2. Add this initialization code to the bottom of the New() method:
'set up the trace listener
Boolswitch = New BooleanSwitch("General", _
"Simple Calculator")
myfile = system.IO.File.Create("C:\TraceFile.txt")
Trace.Listeners.Add( _
New TextWriterTraceListener(myfile))
boolswitch.Enabled = True
3. Add the following code to the top of the Calculate() method:
'trace operation if trace is enabled.
trace.WriteLineIf(boolswitch.Enabled, _
CType(intleftnumber, String) & _
CType(cbooperation.selecteditem, String) & _
CType(intRightNumber, String))
4. Lastly, select the Finalize method from the method name drop-down
for the form and add this code:
Protected Overrides Sub Finalize()
'close the Trace listener
myfile.close()
End Sub
Now, run the application and do some operations.When you have completed
a few calculations, navigate to where you created the text file and open it.You
will see all the operations that you did logged in the text file. In this case, we are
writing every operation to the text file regardless of any factors.This may not be
optimal for all applications because using the Trace mechanism does come with
some overhead ( as minimal as it may be).The Trace class offers other function-
ality that allows you to categorize your messages into different levels and Trace
them only if that level of tracing is on.You may have noticed in the previous
example that we used the Trace.WritelineIf method.This method will only write
the Trace if the first parameter of the method evaluates to True. It is useful in this
parameter to pass the Switch object to the Trace method in order to allow the
trace method to determine if Trace is on or not.
www.syngress.com
C# Word - Process Word Document in C#
various Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or
rearrange pdf pages online; how to change page order in pdf acrobat
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
reordering pdf pages; reorder pages in pdf online
540
Chapter 11 • Optimizing, Debugging, and Testing
Two Switch classes are available.The first one is called the BooleanSwitch (as we
saw earlier).This switch is used merely to toggle Trace on or off by using the
Enabled property.The other switch class is called the TraceSwitch.This class allows
us to set our Traces to different levels. By setting the level of Trace that applies to
a specific Trace statement, you can limit what items are written to your Trace
Listener.This allows you to decide in your analysis what type of information a
particular Trace is providing.This type of Trace has five settings: Off (no Trace),
Error,Warning, Info, and Verbose.These options allow you more control over
what information is logged and when that information gets logged.
Assertions
When debugging a project, it can sometimes help to narrow down situations
where you know certain criteria must be met or certain expressions must be True
in order for an algorithm to execute correctly. Assertions allow us to test for these
conditions in our applications. In previous versions of Visual Basic, we had access
to the Assert method of the Debug object.This is still the case in Visual Studio
.NET (the Assert method is also available on the Trace object).
Just as before, the Assert method will evaluate an expression that must evaluate
to a Boolean value. If the expression evaluates to False (the assertion fails), execu-
tion of a program will halt.The functionality of the Assert method has been
extended in Visual Studio .NET.The method has three different overrides (all
three result in a message box to the user).The message box gives the user the
option to Abort, Retry, or Ignore.The first parameter in all three overrides is the
expression to evaluate.The first override accepts only one parameter, and if the
expression evaluates to False, it writes the call stack out to a message box.The
next override takes two parameters.The second parameter is a short message.
Here you can provide a short message to be displayed in the message box instead
of the Call Stack.The last override allows up to three parameters. It also allows a
short message as the second parameter, but it also accepts a more detailed message
as the third parameter.This is useful if you would like to provide more detail to
the user.The Method Signatures for Debug.Assert is:
1. debug.Assert(Condition as Boolean)
2. debug.Assert(Condition as Boolean, Message as String)
3. debug.Assert(Condition as Boolean, Message as 
String,detailmessage as String)
www.syngress.com
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
how to reorder pages in pdf; how to reorder pdf pages in
C# Image: View & Operate Web Page Using .NET Doc Image Web Viewer
Support multiple document and image formats, like PDF and TIFF; Thumbnail images will be automatically created once the Change Web Document Page Order.
reorder pages in pdf; how to rearrange pdf pages in preview
Optimizing, Debugging, and Testing • Chapter 11
541
The user of assertions is more beneficial during the debugging process. Using
assertions in conjunction with conditional compilation is a good idea.This would
allow you to leave the code in the project while in Debug mode but also ensure
that it is not compiled into the final executable.
Code Optimization
Given the gigahertz processors and low-priced memory on the market, opti-
mizing code is often overlooked in the applications we develop today. Granted,
optimization may not offer the same noticeable improvements it might have in
days past, but it is still a worthwhile practice. Optimizing our applications can
www.syngress.com
Attach the Debugger to an External Process
A wonderful new feature in Visual Studio .NET is the ability to attach the
debugger  engine  to  an  external  process.  This  can  be any  application
either on the local machine or a remote machine that has been compiled
with debug information or that you have access to the source code for.
You can use the debugger to debug applications that may or may not
have been created in Visual Studio. You can also enable a just-in-time
debugger. The JIT debugger  invokes  as  a program crashes in order to
assist us in finding the faulty code. To attach the debugger to an external
program, follow these simple steps:
1. Choose Processes from the Debug menu.
2. In the Available Processes list box, select the application you
would like to attach the debugger to.
3. Make sure to select the appropriate type of process.
4. Click OK.
Now, if you want to put the application into break mode, all you
have to do is click Break in the dialog box. This is a really nifty feature
in Visual Studio .NET. It will enable us to make our executable files, run
them, and then attach the debugger to them so that we can find any
offending code the first time an error occurs as opposed to having to re-
create the error in the IDE.
Debugging…
C# Excel - Sort Excel Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Excel document pages, or just change the position of certain one Excel page in an
reorder pages of pdf; move pages in pdf file
C# PDF insert text Library: insert text into PDF content in C#.net
Ability to change text font, color, size and location and string to a certain position of PDF document page. In order to run the sample code, the following
reverse pdf page order online; reorder pages pdf
542
Chapter 11 • Optimizing, Debugging, and Testing
provide for a faster, scalable, more maintainable, and robust application.
Nevertheless, issues such as the object model we choose, late binding versus early
binding, and cleaning up at the end of our routines still fall in the hands of the
developer and all influence how optimal our applications are.
Finalization
The Finalize method is comparable to the Class_Terminate method of objects in
Visual Basic 6.0. It gives you a chance to do any additional cleanup tasks that are
required before the object is destroyed (such as release database connections).The
Finalize method is resource intensive and can slow down the performance of the
application.When you implement the Finalize method, the object will take
longer to remove from memory. In addition, objects are not deallocated in any
particular order and there is no guarantee that your object will be Finalized. In
order to optimize performance, override the Close() method and call the Close
method when you are done with the object.To ensure that the Finalize method
does not get invoked (because we are using the Close method, the object does
not need to be finalized), it can be suppressed in the Close method with a call to
GC.SupressFinalize.
Transitions
When we invoke methods on unmanaged code (such as .DLLs or other COM
components) we cause transitions to occur.The transition is what .NET invokes in
order to communicate with the unmanaged code. It is comparable to marshalling
data across process boundaries.When this is done, we take a performance hit.
Every time a transition is invoked it brings with it some overhead (about 10 to
40 extra instructions). In order to optimize code that requires the use of transi-
tions, organize your code such that you can accomplish as much as possible with
as few calls as possible.
Parameter Passing Methods
In Visual Basic 6.0, values were passed by reference by default.What this meant is
that a pointer to the address location in memory of the parameter was passed to
function calls. Unless we explicitly declared the parameter to be passed by value,
it would be passed by reference.When a parameter is passed by value, a copy of
the data is passed into the receiving routine.We still have the two parameter
passing types in Visual Basic .NET (the default when passing arguments is now
by value). Passing the intrinsic datatypes (Integers, Singles, Char) by value does
www.syngress.com
C# PDF: How to Create PDF Document Viewer in C#.NET with
image and outline preview for quick PDF document page navigation; requirement of this C#.NET PDF document viewer that should be installed in order to implement
how to move pages in pdf converter professional; pdf change page order online
C# PowerPoint - How to Process PowerPoint
For developers who want to delete unnecessary page from PowerPoint document, this C#.NET PowerPoint processing control is quite C# Codes to Sort Slides Order.
how to rearrange pdf pages reader; move pages in pdf online
Optimizing, Debugging, and Testing • Chapter 11
543
have some performance advantages.This is because the Value types such as these
are allocated on the stack where they are accessed and removed quickly with very
little overhead. Objects passed by reference are allocated on the heap, which
requires interaction with the Garbage Collector and in turn generates greater
overhead.
Strings
Strings in Visual Basic .NET are objects. But the difference is that you cannot
modify a String object.That is to say they are immutable.Traditionally, if you
modified a string, you actually modified the specific string. Now, when you
modify a string (perhaps replace the middle character with something else), what
is actually happening behind the scenes is a new String object is being created,
and the old one is discarded.This can mean a lot of overhead for intense string
operations. Instead of working with Strings directly, we can use the StringBuilder
object (System.Text.StringBuilder).This object eliminates the overhead of creating
new strings when modifying the value of a String object. For example, let’s take a
look at some code:
Dim strTemp1 as String
Dim strTemp2 as String  
strTemp1 = "Hello"
strTemp2 = " Out There"
strTemp1 = strTemp1 & strTemp2
In this code example, even though we declared only two String objects, three
will be created.The first one is created for strTemp1.The second is created for
strTemp2.The third String object is created when we perform the concatenation
of the strTemp1 and strTemp2. Internally, a new String object is created and
assigned the result of the concatenation.The pointer to the third String object is
then assigned to strTemp1. If we had a large amount of String operations, we can
see how the overhead would add up quickly. Now take a look at this segment:
Dim strTemp1 As String
Dim y As New StringBuilder("Hello")
strTemp2 = " Out There"
y.Append(strTemp2)
In this code, we can see that we are still creating two objects. One is our
String; the other is the StringBuilder.What is different here is that the StringBuilder
www.syngress.com
544
Chapter 11 • Optimizing, Debugging, and Testing
will concatenate the strings using its Append method without creating the third
object. If we had a lot of string manipulations, we can see how we would save a
lot of overhead by using the StringBuilder object.
Garbage Collection
When you are developing in a distributed architecture, the Garbage Collector
works differently than how it was described in the earlier chapters.When objects
are created from a remote class, they will acquire a lease time.The Garbage
Collector will decide whether or not it is time to clean up the object based on
this lease time.The benefit of this is that distributed objects also used to be
destroyed with reference counting in the same way that reference counting was
used in the desktop application..This can carry high overhead with respect to
network traffic pinging back and forth in order to keep count of the references.
However, in .NET, the Garbage Collector will respond when the lease time
expires. So, when the lease time expires, the Garbage Collector now knows that it
is safe to clean up the object and does so. It is still good practice to explicitly
destroy your objects when you are done with them when you are using a 
distributed architecture by making them equal to nothing.
Compiler Options
Compiler options have long been a way of optimizing code.The compiler
options we choose can help reduce the size or our applications and increase per-
formance if done in the right circumstances.Visual Basic .NET has a plethora of
compiler options. Most of these options are available only from the command
line.The following sections explore some of the more significant options.
Optimization Options
The /optimize compiler option deals with optimization of your compiled applica-
tion. It makes your application file smaller, faster, and more efficient.This option
is on by default. In order to toggle this feature on and off, you use /optimize+ and
/optimize- where the + turns it on and the - turns it off.
Output File Options
The /out option allows you to specify the name of the output file that is gener-
ated by the compiler.The /target option lets you specify the type of application to
create. By setting /target:exe, you generate an .exe console application, which is
www.syngress.com
Optimizing, Debugging, and Testing • Chapter 11
545
the default setting. In addition, you can set this to /target:module, /target:library,
and /target:winexe.These create a code module, a code library, and a Windows
application respectively.
.NET Assembly Options
All of the options in this category allow you to modify assemblies.The 
/keycontainer option allows you to specify the originator of an assembly.The 
/keyfile option enables you to specify a file with a key pair to make a shareable
component.Another option, /nostdlib, tells the compiler not to include the two
standard libraries: Microsft.VisualBasic.dll and Mscorlib.dll.These two files define
the entire system namespace. If you were to create your own namespaces, you
would want to use this option so as to not include the System namespace with
your package.The /reference option allows you to import metadata from a file that
contains an assembly. Finally, the /version option lets you create an assembly and
modify the version.
www.syngress.com
Error-Checking Options
The  debugging and  error-checking  options  that we have seen  in  pre-
vious versions of  Visual Basic included Favor  Pentium Pro and  disable
array bounds checks. In Visual Studio .NET, the options have changed,
with  four options  available.  First  is the  /bugreport option,  which  will
generate a bug  report  consisting of items such as the files that  were
included in the compile, all the compiler options that were being used,
and (but not limited to) the version information of the compiler. Next,
we have the /cls option. This is used to turn off (/cls-) or turn on (/cls+)
whether the compiler checks for the Common Language Runtime spec-
ification. Also, we have the /debug option. Use this option to generate
builds  that  can  be  debugged.  This will  include  the  extra  information
required  by  the debugger  in  order  to  debug an executable program.
Finally,  we  can  use  the  /removeintchecks option.  This  option  can  be
turned on, again, by using the + or – after the option. By turning this
option on, you tell the compiler to ignore overflow checks and division-
by-zero type errors. Turn this on only if your application has been tested
thoroughly, and you know you will not encounter any of these bugs.
Debugging…
Optimizing, Debugging, and Testing • Chapter 11
547
Nevertheless, by having a thorough and stringent testing strategy, you can still
uncover and correct many of the bugs in a software project.The following 
sections outline the different phases of testing.
Unit Testing
Unit testing is the most basic of all the testing phases.When a developer receives a
specification to complete an aspect of the system, the developer also has an idea
as to how this aspect should function. Before the task is determined by the pro-
grammer to be completed, they will usually perform some tests on it to ensure
that the application does indeed generate the desired results. Unit testing is 
considered the lowest level of testing.
Integration Testing
Integration testing becomes important on large teams or teams of subteams
where different individuals or different groups of people are each responsible for
different functional aspects of a system. For example, in an accounting system,
one group may be responsible for user interface design, another for the ledger
system, and yet another for the report generation. In this case, each group would
be responsible for certifying that their components work properly when they are
standing alone. But, will they work when they are integrated into the package?
This is the purpose of integration testing.You determine how the independently
developed components behave when they are all integrated together.
Beta Testing
After a package is put together, and the application is certified by the internal
departments to be fully functional and behave correctly, beta testing takes place.
Beta testing is where the product is put out in a prerelease format for users to use
in actual live production.This environment is where the unthinkable usually hap-
pens.This is where a user will inevitably attempt to accomplish a task by doing
the entire process backward and upside down.The fresh eyes of people outside
the development and testing teams often are able to catch even the most minor
things that have been overlooked.The purpose of beta testing is not to give your
customers a product and for them to let you know whether or not it actually
works. Beta software is usually distributed free in some form of a demo mode or
time-limited evaluation copy so that your product has the opportunity to be fully
tested in a live environment before customers spend their hard earned dollars.
www.syngress.com
Documents you may be interested
Documents you may be interested