mvc open pdf in browser : Convert pdf file to jpg on software application cloud windows html winforms class Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_20058-part1091

Important NAnt Tasks
I
n the previous chapter, we covered what NAnt is and to some extent how it works. We also
saw a considerable number of NAnt scripts that did not really do anything useful but that pre-
pared us for various possibilities. Finally, we saw a proposed outline for our own build file
based on a previously designed process.
In the next chapter, we will apply the process fully to a real project, using the skeleton
scripts we have outlined. Before we do this, it is useful to explore the various built-in tasks of
NAnt and NAntContrib to provide some ideas, and ready-made solutions, to the processes.
Therefore, the purpose of this chapter is to familiarize ourselves with the ways in which
NAnt tackles the various tasks required of it. We will also begin stirring the creative juices
before we start the real work in Chapter 4 as we tackle a real delivery scenario.
NAnt and NAntContrib contain pretty much every task you need to implement a desired
delivery process. Some are more complete than others but largely NAnt and NAntContrib will
not be found wanting. Additionally, there are some catchall tasks that allow some additional
flexibility without the need for code extensions immediately.
In this chapter, I am not intending to discuss every task, for two reasons:
NAnt is constantly changing, and the best reference for current task capabilities lies on
the NAnt homepage rather than in print at this time.
I do not use all of the tasks; many are not appropriate to my needs on a practical level since
they relate to a different set of technologies, such as differing source control systems. 
With that in mind, we narrowed down the tasks from NAnt and NAntContrib and will
present some of them here. We then provide examples of using the tasks with the process and
scripts we are trying to create.
We have organized the tasks into categories covering the general kind of work that the
tasks handle:
Structural.These tasks can be used to manipulate and structure the NAnt build files and
the targets within them in helpful ways to gain efficiencies within scripting structures.
Conditional.Some tasks allow the control of flow within a build file.
File.These “bread and butter” tasks will be used constantly as we manage assets through
delivery.
59
CHAPTER 3
■ ■ ■
Convert pdf file to jpg on - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
convert pdf pages to jpg online; changing pdf to jpg
Convert pdf file to jpg on - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
convert pdf file to jpg format; conversion pdf to jpg
CHAPTER 3 ■ IMPORTANT NANT TASKS
60
Delivery.This collection of usually quite specific tasks are the kind that will be of use for
the specific goals of the delivery processes.
Utility. These tasks are quite specific but not as delivery tasks themselves. They are all
very useful within build files, though.
Source control.This category consists of the available wrapped source control functions.
Interestingly, it is NAntContrib that tends to provide more of the specific tasks for the
build process. NAnt itself supplies the core tasks and framework that give the whole package
its structure and flexibility.
There Is More Than One Way to Do It
If you thought that Chapter 2 demonstrated the significant flexibility available in NAnt, then
be prepared for even more. The number of tasks, and the ways in which they can be organized
and applied, means that you will constantly see multiple ways to solve a problem.
This is great news when you are problem solving, but as in general coding, without a
model to aid the coding process and provide a conceptual framework, it is easy for things to
become confusing.
Tip
Decide on your general approach and outline the way that you will use tasks in your scripts.Then
stick to your approach as long as it is successful.There is no shame in refactoring to a different structure or
implementation later on; on the contrary,it is likely to be a positive thing.But when you are planning and
executing standard scripts across multiple projects,refactoring should not be taken too lightly and too often.
One of the main reasons can be that the solutions themselves require reorganization or refactoring to take
advantage of a new build technique,and this can be quite an effort.
General Task Features
We learned about tasks in the previous chapter when we discussed how to get the most out
ofNAnt. Before we look at the specific tasks we are interested in, let us define in detail what a
task is.
A task is an XML tag inside a NAnt build file that instructs the NAnt executable to perform
a specific action. For example, you may recognize the following:
<echo message="I am an example of a task"/>
This task tells NAnt to echo the message to the listener/logger—a very simple example.
We will look at the internals of task construction when we need to build our own task in
Chapter 7. For now, it is important to recognize the features of a task. First, each task has a
specific tag name rather than an attribute to describe its function (for example, we do not use
<task type="echo"/>). Second, tasks are customized in two ways: by using attributes and by
using nested elements. Let us briefly consider these features.
Online Convert Jpeg to PDF file. Best free online export Jpg image
Convert a JPG to PDF. You can drag and drop your JPG file in the box, and then start immediately to sort the files, try out some settings and then create the
change format from pdf to jpg; change pdf file to jpg file
Online Convert PDF to Jpeg images. Best free online PDF JPEG
Online PDF to JPEG Converter. Download Free Trial. Convert a PDF File to JPG. Drag and drop your PDF in the box above and we'll convert the files for you.
change pdf to jpg image; convert pdf document to jpg
Using Attributes
Most tasks have individual attributes to provide the level of customization necessary for the
specific task. By way of comparison, take a look at the <echo>and<mkiisdir>tasks. Each task
has some standard attributes, which are listed in the individual task documentation. We can
also see what those tasks are by using Reflector to examine the source code of nant.core.dll.
All tasks for NAnt inherit from the Taskabstract class. By reflecting over the Taskclass we can
see the code signatures shown in Figure 3-1.
CHAPTER 3 IMPORTANT NANT TASKS
61
Figure 3-1.Reflecting over the Task class
The important features here are the following properties, which directly translate to
attributes for the task:
FailOnError. The default of this property is true. The property specifies whether NAnt
should halt execution and report a problem if the task fails. This property translates to
thefailonerrorattribute.
IfDefined. The default of this property is true. The property specifies whether the task
should execute if the expression in the ifattribute evaluates to true. This property trans-
lates to the ifattribute.
UnlessDefined. This is the reverse of the IfDefinedproperty; its default value is false.
The property specifies whether the task should execute if the expression in the unless
attribute evaluates to false. This property translates to the unlessattribute.
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
C# sample code for PDF to jpg image conversion. This demo code convert PDF file all pages to jpg images. // Define input and output files path.
reader pdf to jpeg; best convert pdf to jpg
C# Image Convert: How to Convert Dicom Image File to Raster Images
RasterEdge.XDoc.Office.Inner.Office03.dll. RasterEdge.XDoc.PDF.dll. This demo code convert dicom file all pages to jpg images.
convert from pdf to jpg; convert online pdf to jpg
Verbose. The default value of the Verboseproperty is false. This allows us to provide a
more verbose description of task execution if the property evaluates to true. This prop-
erty translates to the verboseattribute.
All of these properties are marked with the attributes TaskAttributeandBooleanValidator.
We will explore these in Chapter 7 in terms of implementation, but for our current purposes
this means that all tasks have these four properties defined and available for use if we apply a
Boolean value to them in the task implementation within a build file.
Apart from the documentation for tasks describing the attributes of the task in question,
it can be very useful to use Reflector (or open the source code) to examine the behaviors and
requirements of task attributes.
Using Nested Elements
A task can also be customized by including support for a variety of nested elements. The set of
NAnt tasks contains many useful examples of this. 
The available set of nested elements are held in the NAnt.Core.Typesnamespace. Using
Reflector, we can see the available types, as shown in Figure 3-2.
CHAPTER 3 ■ IMPORTANT NANT TASKS
62
Figure 3-2.Reflecting over the NAnt.Core.Types namespace
C# Create PDF from images Library to convert Jpeg, png images to
C# Create PDF from Raster Images, .NET Graphics and REImage File with XDoc Batch convert PDF documents from multiple image formats, including Jpg, Png, Bmp
convert pdf pictures to jpg; advanced pdf to jpg converter
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Convert PDF documents to multiple image formats, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage. Turn multipage PDF file into image
convert multi page pdf to jpg; convert pdf images to jpg
Caution
Unfortunately,sometimes the types are named differently according to the context of the task.
This is a positive thing in terms of understanding the purpose of the element,but when you are approaching
the task for the first time,it can be confusing.As a simple example,compare the <copy>task to the <style>
task.<copy>uses the name filesetas the name of its filesetelement,which is very simple,but
<style>uses the name infilesto refer to its filesetelement,which makes it less obvious that the
nested element has the same features and behaviors of a regular filesetelement.
Some tasks contain several structures of this kind. These features are particularly preva-
lent among the specific tasks that have been used to automate core parts of the process, such
as the automation of Visual Studio and the use of NDoc.
Again, we will not go into depth here; the current documentation is a better starting point.
However, we will take a look at the most common of these nested elements: the fileset.
The fileset
Thefilesettype is one of the most common types used as a nested element by the various
NAnt tasks. It has some useful features that are worth bearing in mind. 
First, a filesetis usually composed of includesandexcludesnodes defining which files
we want to include and exclude, respectively, as part of a fileset. Here is a simple example: 
<fileset basedir="D:\MyFolder">
<include name="myfile.txt"/>
<exclude name="somefile.txt"/>
</fileset>
Thisfilesetdescribes the inclusion of one specific file in the folder D:\MyFolder, which
means that the excludesnode is entirely superfluous. The includesandexcludesnodes work
well together when we are describing patterns. Table 3-1 shows pattern possibilities.
Table 3-1.Fileset Pattern Matching
Symbol
Meaning
?
Match any one character
*
Match any number of characters
**
Match a complete directory tree
Let us look at a practical demonstration. The following filesetdescribes a useful set of
excludesto walk a set of web files, filtering out all of the superfluous code to be moved to a
web server. For example, we do not require the C# source code, or the resources files (as they
will be compiled), nor do we require the .csprojfiles or other source control artifacts.
CHAPTER 3 IMPORTANT NANT TASKS
63
C# WPF PDF Viewer SDK to convert and export PDF document to other
Convert PDF to image file formats with high quality, support converting PDF to PNG, JPG, BMP and GIF. C#.NET WPF PDF Viewer Tool: Convert and Export PDF.
change pdf file to jpg; convert pdf to jpeg
C# TIFF: C#.NET Code to Convert JPEG Images to TIFF
demo1.jpg", @"C:\demo2.jpg", @"C:\demo3.jpg" }; // Construct List in imagePaths) { Bitmap tmpBmp = new Bitmap(file); if (null Use C# Code to Convert Png to Tiff.
convert pdf to jpg file; best pdf to jpg converter for
Therefore, to walk a directory tree preserving all other assets such as .aspx,.jpg, and .css
files, then the pattern could be described as follows:
<fileset basedir="D:\DirtyFolder">
<include name="**"/>
<exclude name="**\*.cs"/>
<exclude name="**\*.resx"/>
<exclude name="**\*.csproj"/>
<exclude name="**\*.vspscc"/>
<exclude name="**\*.scc"/>
</fileset>
This has been a brief look at a common structure. Keep in mind that we will come across
others.
The filterchain
Afilterchainis similar in use to a filesetin that it involves file manipulation. Effectively, a
filterchaincan be used to handle such tasks as token replacement during file copying and
moving. filterchains cannot be used with any in-memory file representation and so must be
used as a part of a file-manipulation task. Table 3-2 show some possible uses for a filterchain.
Table 3-2.Filterchain Types
Filter
Summary
expandproperties
Parses NAnt properties and expressions.
replacestring
Replaces all occurrences of a given string with a user-supplied
replacement string
replacetokens
Replaces tokens in the original input with user-supplied values
tabstospaces
Converts tabs to spaces
Thefilterchainconstruct may look like this:
<filterchain>
<replacetokens>
<token key="DRIVELETTER" value="D" />
</replacetokens>
</filterchain>
Thisfilterchainwould replace the token @DRIVELETTER@with the value D when the file
manipulation it was embedded within takes place. The <copy>task example later demon-
strates this.
Structural Tasks
In this section, we examine tasks that can be used to add flexibility and power to the structure
of a build file, thus moving the construction of a build file from a simple linear activity to an
activity more akin to coding. The tasks can be used to handle various requirements:
CHAPTER 3 ■ IMPORTANT NANT TASKS
64
Repeat targets or whole build files with different properties (and therefore outcomes).
Reuse build file solutions and therefore reduce duplication of functionality.
Split build file contents to improve management and understanding through a separation
of concerns.
Improve refactoring possibilities and implementation details through the use of the
above features.
As powerful as these tasks are, approach with caution. NAnt is generally very linear for
two reasons: the way the current engine translates and uses a build file, and the lack of sup-
port for parallel execution that is present in NAnt.
A build file can be made relatively complex on its own through the use of conditionals
and target dependencies and can be difficult to follow even with debug and verbose switches.
Once build files are separated and begin to loop, the flow of the build process becomes even
less obvious. As with collections of VBScripts database-stored procedures, XSLT, and other
similar scripted code dependencies are not always easy to track and going forward it can be
easy to introduce risk and rigidity into the delivery process—which is precisely the situation
we were attempting to avoid.
Tip
Start small and refactor.The positive side of collections of scripts and the following tasks is that they
can be implemented quickly.In my experience,avoiding a “big design”up front will help the implementation
of a delivery process move more quickly,particularly if you are exploring the processes and their possibili-
ties.This is the approach that will be used in the next few chapters.
Now, let us consider the tasks that are helpful structurally and how we are likely to apply
them in our process.
<call> [NAnt]
This task can be used to call a target within a build file at any point in a build file. Efficiencies
can be gained by calling a target multiple times with a different set of properties, as in this
example:
<?xml version="1.0"?>
<project default="repeater">
<target name="repeater">
<property name="myparameter" value="foo" />
<call target="generaltarget"/>
<property name="myparameter" value="bar" />
<call target="generaltarget" />
</target>
CHAPTER 3 IMPORTANT NANT TASKS
65
<target name="generaltarget">
<echo message="Doing clever stuff with parameter $(myparameter}" />
</target>
</project>
In practice, the <call>task can be used to recurse over some set of information. In the
next example, <call>is used to check each folder within a folder by re-calling the original tar-
get until the end of the folder hierarchy is reached.
I would not recommend using this kind of function, but it demonstrates some possibilities:
<?xml version="1.0"?>
<project default="folderchecker">
<property name="foldername" value="D:\dotNetDelivery\Assemblies"/>
<target name="folderchecker">
<foreach item="Folder" in="${foldername}" property="foldername">
<echo message="${foldername}" />
<call target="folderchecker"/>
</foreach>
</target>
</project>
Running this task would produce something like the following output, demonstrating the
recursive call:
---------- NAnt ----------
NAnt 0.85 
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///Folderchecker.build
Target(s) specified: folderchecker 
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\Etomic.Library.Transformer
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\Etomic.Library.Transformer\Deprecated
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\Etomic.Library.Transformer\Latest
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\Etomic.Library.Transformer\Specific
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\log4net
CHAPTER 3 ■ IMPORTANT NANT TASKS
66
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\log4net\Deprectated
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\log4net\Latest
folderchecker:
[echo] D:\dotNetDelivery\Assemblies\log4net\Specific
folderchecker:
BUILD SUCCEEDED
Total time: 0.1 seconds.
Output completed (1 sec consumed) - Normal Termination
<nant> [NAnt]
This task allows the wholesale loading of another build file, and its full execution or the execu-
tion of a target or targets as required. Effectively, this task enables a build file to execute the
NAnt command line itself. 
The advantage of using this task is that the build file which is called can inherit all of the
existing properties from the calling build file. This particular ability means that hierarchies
ofbuild files can be created and called from a common point. The flexibility here cannot be
underestimated.
One practical use for this task is to generate a master NAnt file for a project and use it to
set “master properties” for the project that all aspects of the build process might use. This
master file would be the only build file to be called, and the parameters used to call it would
determine how it would perform from there. 
A further step would be to use a build file to maintain common properties across all proj-
ects. Here is a trimmed-down version of how this master file might look:
<?xml version="1.0" encoding="utf-8" ?> 
<project name="Build.Master" default="help">
<property name="core.basedir" value="D:\@Build\" />
<property name="core.build" value="Build\" />
<property name="core.distribution" value="Distribution\" />
<property name="core.logs" value="Logs\" />
<property name="core.documentation" value="Docs\" />
<property name="core.source" value="Source\" />
<!-- etc. a whole bunch of other properties -->  
<target name="build">
<nant
buildfile="${project.name}\Build.xml"
target="go"
inheritall="true"
CHAPTER 3 IMPORTANT NANT TASKS
67
/>
</target>
<!-- Other targets snipped -->
</project>
From this file, we can now invoke the build file for any of our projects—subject to their
adherence to these standards—using this build file and a project name parameter:
nant -f:build.master.build -D:project.name=project1
This would ensure that the core properties—those used by all builds—are set correctly and
that the correct project build is begun. The main advantage here is that changing the base
directory for all activities requires a single modification to one file: this one.
In the previous example, I have simply used inheritallto pass the properties from the
first script through to the second, but I could also include some other properties since the
<nant>task accepts a set of properties as nested elements.
Note
The called build file inherits the properties of the caller but cannot itself call any of the targets of
the caller.This means that the process is still linear.
<loadtasks> [NAnt]
This task allows a build file to load in an assembly, or set of assemblies, from elsewhere other
than the NAnt bin folder in order to execute contained tasks. 
Therefore, this task does not affect the structure of the build files themselves but instead
affects the structure of the code for NAnt, since different tasks (or versions of tasks) can be
accessed from different locations.
In practice, I do not usually use this task because it adds to the overhead and risk of the
build file itself. In principle, there is nothing wrong with using <loadtasks>to grab tasks from
various locations, but I have a tendency to drop my completed customized assembly into the
NAnt bin location instead.
The two uses I would put this task to are as follows:
When you are creating a new customized task, it is easy to use <loadtasks>to grab the
Visual Studio–generated assembly each time rather than continuously copy the output
tothe NAnt bin folder. This is crucial for testing changes to existing tests too.
If I practice what I preach—and I should—then I will deploy my customized tasks to a
central repository, where I can load them using <loadtasks>when I need them. This
means I can specifically target versions of my customized task as well. 
Using <loadtasks>is quite simple. Let us look at three broad options.
CHAPTER 3 ■ IMPORTANT NANT TASKS
68
Documents you may be interested
Documents you may be interested