mvc open pdf in browser : Convert multiple page pdf to jpg application SDK tool html winforms .net online Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_20054-part1087

New systems should adhere to delivery standards.All new developments must adhere to
set delivery processes. Development teams should begin viewing the constructs for delivery
as something that must be treated as a project in itself, to be maintained and developed
accordingly.
Consequences
Design to Deliver has several consequences:
(+) Speed of delivery is improved.Naturally, if the task is automated it is highly likely to
be a lot faster. Significantly, the measurement of time taken could represent a useful met-
ric for success of the initiative: delivery measured in terms of seconds and minutes rather
than vaguer notions of hours.
(+) Confidence in delivery is improved.The ability to repeat delivery constantly and on
demand is a significant boon to the development and operations teams. New doors are
opened in terms of team capability, such as daily system releases to customers or project
teams.
(+) Scope of manual delivery activities is reduced.This is another obvious consequence of
automating the process. Importantly, it becomes more likely that some of the supporting
processes that do not form a critical path but that are still important, such as the distribu-
tion of documentation, notification of support teams, and so on, are guaranteed to occur.
The process cannot degrade, and occurs in the same way every time.
(+) Mundane tasks are automated.Similarly, these kinds of tasks may be considered
mundane in the first place, and thus the effort required in this area is not valued. Here it
isremoved.
(+) Quality of the software improves. A system must conform to the process, forcing the
developer to consider and implement delivery features up front, forcing delivery higher
up the quality agenda.
(+) Understanding of delivery improves.Because there is a framework and stated benefits
to the automation of delivery, the reasons for considering and implementing successful
delivery on a conceptual basis are clearer to the development team. On a practical basis,
the actual implementation requirements for a system are detailed.
(+/–) Options are limited.It may not be appropriate to use a solution that would ordinarily
be appropriate because of difficulty in implementing the standard process. For example,
a useful third-party component may not be easy to deploy and thus hamper automation
efforts. We need to decide what is a more important system feature: a useful UI widget or
successful delivery. On the other hand, limiting these options may be a good idea with
more “innovative” developers in order to maintain a little control over some of the crazier
ideas.
(–)100% success is not guaranteed.Despite every effort, it is doubtful that all systems
and system features can be fully automated for delivery. Therefore, Design to Deliver does
not represent a panacea for delivery, but a roadmap for improvements to the delivery
process with some significant successes expected along the way.
CHAPTER 1 A CONTEXT FOR DELIVERY
19
Convert multiple page pdf to jpg - 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 to high quality jpg; convert pdf into jpg
Convert multiple page pdf to jpg - 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 to jpg file; change pdf to jpg online
Resulting Context
We are able to confidently deliver software using a standard process. The length of time, and
planning required, for delivery is known and can be predicted. There is no need for rigid devel-
opment environments to host our software because we are able to quickly build and deploy a
required solution. The complexity and risk of delivery is reduced.
The advantages to the implementation of Design to Deliver are as follows:
Developers.The developers have a clear strategy for the delivery of products and a set of
defined standards to work within. They understand what is expected of them and how the
process operates. They can consider the delivery of a product—how and when it will be
done—at the outset of the project rather than toward the point of delivery, a risky activity.
Product delivery can, and does, occur at any point in the project, which is a boon to proj-
ect managers as well. They are freed up to handle true development, which is what they
want to do rather than handle mundane tasks. Removing reluctant developers from mun-
dane tasks improves morale and probably improves the quality of the mundane task in
itself.
Management.To management, the delivery processes are transparent. Risk is reduced
since all systems follow the same overall processes. Standards, and therefore monitoring,
are available for the management team. The delivery process encompasses part of an
overall configuration management strategy for IT and can work within the confines of an
existing process quite easily; it is a practical solution without its own paperwork overhead.
Cost benefits can be described to senior management in simple terms since development
effort for delivery can be calculated beyond just headcount: ordinarily a team can only
speculate effort required to deliver a product and this usually becomes a simple head-
count issue (“We need another Ops member because we have more systems”). With
automated processes, the effort to align a system to the process can be fully estimated,
and the delivery measured. The net effect should be a leveling of headcount required for
these processes. The bonus is the additional quality and reduced risk in the same activi-
tiesbutfor fewer people. Customer response (see the next item) is improved.
Customers. The customer can see the product sooner and almost upon demand since
thedelivery can occur upon demand. The risk of system problems is reduced during
useracceptance testing because defects arising from deployment are less likely and thus
scheduled testing time is more likely to be unaffected by such things (development teams
sometimes forget that testing software disrupts the business as much as customers not
turning up to testing disrupts the development). The support cycle should be reduced;
itbecomes easier for small support teams to deliver small changes once complete. If
deployment is tricky, support teams would tend to “roll up” several bugs into scheduled
releases. If deployment is easy, then change can be effected quickly with confidence. This
virtuous circle then increases time available for actual development and/or support from
the team. Finally, incurred costs from delivery are now transparent; they can be accu-
rately specified and estimated at the project outset. They will also be cheaper as ongoing
delivery costs are met through the automated system.
CHAPTER 1 A CONTEXT FOR DELIVERY
20
C# Create PDF from images Library to convert Jpeg, png images to
Batch convert PDF documents from multiple image formats, including Jpg image formats into one or multiple PDF file in able to be cropped and pasted to PDF page.
batch convert pdf to jpg; convert pdf image to jpg
VB.NET Create PDF from images Library to convert Jpeg, png images
Components to batch convert PDF documents in Visual Basic multiple image formats into one or multiple PDF file. Crop and paste specified image area to PDF page.
reader convert pdf to jpg; .pdf to jpg converter online
A Delivery Process for Etomic
After all of this discussion, our path is clear. We have considered the problems faced by a team
like Etomic. We have defined a set of mechanics and consequences for our automation efforts.
The first step on the road to success is the identification of the build and deployment processes
to address the stated aims of Etomic and the Design to Deliver initiative. 
The Build Process
The first aspect of our delivery process is the build process. In the simplest terms possible, this
process must result in the creation of a compiled solution. However, a number of other func-
tions can be performed as part of this compilation.
Help is at hand from Martin Fowler’s article on continuous integration (CI). In this article,
Fowler describes the principles of CI and the activities that would need to take place as part of
CI. We will cover CI and its impact in Chapter 6; the important thing to understand at this point
is the activities described in CI, which are broadly as follows:
Check out.This involves physically getting the source code from the source control data-
base to ensure that we can carry out the rest of the process. In fact, we probably will not
check out the source code, but will “get” the latest version of it.
Build.This encompasses the compilation steps necessary to build the system successfully.
This could consist of several complex and interdependent steps, but in many cases it may
be a straightforward compilation of the kind achieved through the Visual Studio environ-
ment.
Test.Automated testing is a cornerstone of agile methods and CI is of course no excep-
tion. Just because you can physically compile a solution does not mean it is a success. The
testing step allows the process to report a success or failure on the basis of the application
of unit tests subsequent to compilation.
Publish.The automated publishing of the results and assets is a useful feature of the
automated process. 
We can round out these with a few additional steps that will be useful to us:
Clean.This is alluded to in most commentary on automated delivery. Here we are specific
about ensuring a cleanup of the used environment for delivery to ensure that no prob-
lems occur as a result of using incorrect assets and so on.
Version.Providing some automated versioning is a boon when increasing the number of
deliveries significantly; it is a consequence of the process we are subscribing to. We will note
this as a requirement immediately, since it will undoubtedly cause some consternation.
Document.Apart from testing, we can leverage the process to carry out other useful tasks
such as reporting and documentation. This can be another discrete step.
Notify.This could be implied by the Publish step, but we will again define these steps
discretely. Notification can let the team know of successes and failures, and perhaps dis-
tribute logs and reports.
CHAPTER 1 A CONTEXT FOR DELIVERY
21
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
able to perform image extraction from multiple page adobe PDF Extract multiple types of image from PDF file in Scan high quality image to PDF, tiff and various
convert pdf to jpg converter; .pdf to jpg
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
conversions from PDF document to multiple image forms. can use this sample code to convert PDF file to PDFDocument(inputFilePath); // Get the first page of PDF
convert pdf file to jpg; changing file from pdf to jpg
Bearing in mind all of the steps discussed, the final list and order of activities could therefore
be defined as follows:
Clean.We may also repeat this step at the end of the process if required.
Get.Grab the source code.
Version.Apply some versioning to the source code files.
Build.Compile the application.
Test.Apply the unit tests.
Document.Generate documentation and reports.
Publish.Place the compiled assets, reports, etc., in an agreed location.
Notify.Tell everyone of the success (or failure).
The Deployment Process
Deployment is the second stage of our delivery. This is a little trickier since it will differ depend-
ingon the kind of system to be delivered. For instance, it is quite trivial to deploy a single .NET
component to a network share, though it may be slightly less trivial to ensure that this deploy-
ment operates within the constraints of the team development process. On the other hand,
deploying a web application with a database, third-party components, and other dependen-
cies is altogether more complicated. Furthermore, deployment will usually occur to a number
of different environments.
However, we can establish what kind of application we will be delivering. Broadly, Etomic
concentrates on web applications and so we will concentrate on deploying this kind of server-
based application.
A possible deployment process may be as follows:
Select version.Inform the rest of the process which version of a system is to be deployed.
Our versioning strategy from the build process may be important.
Get assets.Obtain and prepare the required assets from the agreed location. Therefore,
how we organize these assets in the Publish step is important.
Select environments.In a similar decision-making step to selecting the version, consider
which environment is required for the deployment. This may require various tweaks to
the deployed assets.
Create environments.With the knowledge of the prior steps, environments such as data-
bases and web sites can be created.
Position assets.The assets can then be positioned as required within the generated envi-
ronments. Files can be copied, database scripts run, components registered, and so on.
Apply configuration.Configuration changes can then be applied to ensure that the envi-
ronments communicate and operate successfully.
Notify.Notify everyone of success or failure.
CHAPTER 1 A CONTEXT FOR DELIVERY
22
C# WPF PDF Viewer SDK to convert and export PDF document to other
Image: Copy, Paste, Cut Image in Page. Link: Edit Create multiple pages Tiff file from PDF document. Convert PDF to image file formats with high quality, support
convert pdf image to jpg; convert pdf file into jpg format
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
C#.NET extract image from multiple page adobe PDF file Extract various types of image from PDF file, like Get JPG, JPEG and other high quality image files from
bulk pdf to jpg converter; convert multiple page pdf to jpg
This process will be complicated by the addition of decision-making steps regarding the
differing environments and whether existing assets should be overwritten or backed up, or
whether the process should fail if an environment already exists. For now, though, this is a
general representation of a deployment.
A Glossary for Delivery
We have described various terms in this first chapter. Captured in Table 1-2 are some of these
terms and their definitions.
Table 1-2.A Glossary for Delivery
Term
Definition
Build process
This is the process used to compile, analyze, and package a system
ready for deployment.
Deploy process
This refers to the process used to position, and configure for use,
asystem on a specified delivery environment.
Environment
In the context of delivery, an environment is an area for delivery
ofa product, for example, a system-testing environment, a user-
testing environment, or a production/live environment.
Delivery process
This overall process encompasses the build and deploy processes.
Automated xprocess
This refers to using a tool or set of tools to perform the specified
process.
Continuous integration
This is a specific branch of delivery made popular through
agile/extreme programming and methodologies. CI is the notion
that a built system should be available at any time a change occurs
to the system. In other words, the build process is performed
continuously against some trigger, usually a change to the source
code.
Configuration management
This term encompasses processes that minimize the confusion
ofa team project. CM is about identification, organization, and
control of software to maximize productivity by minimizing
mistakes.
Source control
This is the control aspect of CM. Source control is about managing
the software assets. Usually source control in this context means a
source control system such as VSS, Subversion, or CVS.
Design to Deliver
This is the initiative described in this chapter, which provides rea-
soning and mechanics for the introduction of delivery processes to
a team.
Summary
As we end this chapter, we have taken important steps toward improvement of delivery
processes. We have looked at the inside of our fictitious development company, Etomic, and
we have seen some of the issues they have faced and are facing. We have reviewed a list of
aims Etomic has for delivery processes, and discussed the surrounding context for delivery,
looking at the problems posed and hinting at potential solutions or methods for the mitiga-
tion of risk.
CHAPTER 1 A CONTEXT FOR DELIVERY
23
C# Create PDF Library SDK to convert PDF from other file formats
Gratis control for creating PDF from multiple image formats such as tiff, jpg, png, gif, bmp Create and save editable PDF with a blank page, bookmarks, links
pdf to jpeg; convert pdf to jpg 300 dpi
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Convert PDF documents to multiple image formats, including Jpg VB.NET programming sample code to convert PDF file to inputFilePath) ' Get the first page of PDF
convert pdf image to jpg image; convert pdf into jpg online
We have also proposed an initiative known as Design to Deliver, which we will use as the
basis for delivering improved delivery processes.
Finally, we have taken the first step in this initiative by defining a very broad build and
deployment process and have briefly discussed automating these processes.
In the next chapter, we are going to start practical work on the Design to Deliver initiative
with a look at NAnt—the tool we will use for build automation. This tool offers a lot of power,
and so we will spend some time thinking about how it works but, just as importantly, what we
can do with it.
Further Reading
There are a host of worthwhile resources related to a variety of topics touched on in this chapter.
When I am stuck for an argument as to why an initiative is a good idea, it is a good bet
that it is covered in Code Complete:A Practical Handbook of Software Construction by Steve
McConnell (Microsoft Press, 1993). 
For excellent commentary and a succinct read on breeding a successful developer, I recom-
mendCoder to Developer:Tools and Strategies for Delivering Your Software by Mike Gunderloy
(Sybex, 2004). This book also covers a host of tools and topics that I’ve put to practical use
myself, such as virtual environments.
There are quite a lot of places to read about continuous integration. I of course
recommend the original article by Martin Fowler at http://martinfowler.com/articles/
continuousintegration.html.
The following book describes the role of continuous integration in an enlightened soft-
ware process: Domain-Driven Design:Tackling Complexity in the Heart of Softwareby Eric
Evans (Addison-Wesley, 2003).
For a discussion on Technical Debt, refer to Beyond Software Architecture:Creating and
Sustaining Winning Solutions by Luke Hohmann (Addison-Wesley, 2003).
My handbook for any configuration management concern I have is A Guide to Software
Configuration Management by Alexis Leon (Artech House, 2000).
Finally, I find a lot of use in Essential SourceSafeby Ted Roche (Hentzenwerke Publishing,
2001).
CHAPTER 1 A CONTEXT FOR DELIVERY
24
Dissecting NAnt
W
e have defined an outline for our process as described in the Design to Deliver initiative.
The next stated mechanic is that of selecting tools to assist with the automation of the
process.
In this chapter, we will take a look at NAnt. You will see what it is, what it can do, and how
it works. We will examine the key concepts of NAnt and prepare a plan for using NAnt to facili-
tate automated processes.
We will consider why NAnt is chosen for a particular task, but you should be aware that
other options are available. Unfortunately this book will not be able to help you with imple-
mentation specifics for other platforms; since we will be focusing on NAnt, I will not spend
too long discussing the various platform merits.
The core purpose of this chapter is to gain an insight into how you use this tool to auto-
mate our process. NAnt is deceptively simple but has a significant amount of flexibility and
options for use. With this flexibility comes decision making and responsibility for choices
made that may be difficult to undo at a later point in time. It is therefore important that you
understand the tool quite well before imposing standards on development teams. 
At the end of the chapter we will turn the processes we described in the previous chapter
into skeleton “build files” for NAnt. You will find that even without any discussion of the actual
tasks that NAnt can perform—of which there are many—we will have achieved quite a lot, and
your mind may well be bursting with ideas, particularly if you have not explored NAnt previ-
ously.
All About NAnt
NAnt is a .NET port of the Java build tool Ant, though it has quite a different set of characteris-
tics in parts. It is currently being actively developed, but it has been a useful and relatively
stable platform for a significant amount of time.
NAnt allows a process to be defined as an XML file, or as a series of XML files consisting of
sections and specific tasks to be carried out. I use the word “process” rather than “build process”
because while NAnt’s raison d’etre is to assist building and many of the tasks are specifically
designed for this purpose, it can be used for many things.
NAnt is an open source project, with a homepage at http://nant.sourceforge.net. There
are links to many resources from this page. In particular there is a useful wiki containing help
and tips on the use of NAnt and the specific tasks it enables. Additionally, you can sign up or
search the archives of the NAnt user and NAnt developer mailing lists.
25
CHAPTER 2
■ ■ ■
CHAPTER 2 ■ DISSECTING NANT
26
Additionally, there is an adjunct to NAnt called NAntContrib. It has a homepage at
http://nantcontrib.sourceforge.net
.
This project is for task contributions to NAnt that do
not make it into the core NAnt release. Occasionally, tasks in NAntContrib will make the
switch to NAnt. 
Both of these projects are required for our work. If you take a look at Appendix A, “A Fistful
of Tools,” you will find more instructions on obtaining NAnt.
Note
For the remainder of the text,unless there is a reason to be specific,NAnt should be assumed to
mean either NAnt,NAntContrib,or both.
What Does NAnt Do?
In short, NAnt parses XML build files and executes the instructions gained from the file. Gen-
erally, a build file will consist of a set of instructions for the build of a .NET solution. Effectively,
this is a replacement for the VS .NET builder. 
This, however, does not come close to describing the power and flexibility of NAnt. Apart
from building a solution, it may also run unit tests, zip up the output, transform XML with
Extensible Stylesheet Language Transformations (XSLT), access source control, send an email,
and a myriad of other possibilities.
Why Choose NAnt?
To me, NAnt is the tool of choice for the automation of build processes for a few reasons:
First, it can handle things (as described above) that VS .NET simply either cannot handle
or cannot handle especially well: activities that support the build process rather than just
provide the compilation facilities. A user of f VS .NET can make use of postbuild tasks
(available in the configuration of a project) to perform some operations like those that
NAnt would take care of, but in itself this would not constitute a stand-alone build process—
it would be more about a specific project compilation process.
Second, it focuses on handling activities that shouldbe automated—those activities that
cause constant niggles in your team: accessing source control, storing deliverables, apply-
ing version numbers.
Third, the build files are defined as XML, which opens a whole world of flexibility in terms
of transforms and process management. Other tools may have more flexibility in script-
ing languages, but XML is the ideal way to design a flexible process because of these
possibilities. Picking up XML directives may also be easier than using proprietary script-
ing languages or user interfaces (UIs).
Fourth, it is so easily extensible and is a fine piece of source code. If you wish you could
write great code, then dig around in the NAnt source code to pick up some tips.
Finally, it is free! The price is most definitely right.
But what can NAnt actually do for you? Quite a bit, as it happens.
You can wrap up an entire process in a NAnt build file. It is possible to refactor a build file
to handle multiple solutions, and the benefits for your team could be
Producing a repeatable and documented build process
Ensuring new solutions conform to required standards (organizational conventions, unit
testing, etc.)
Increasing confidence and reducing risk in solution deployment
Reducing the amount of effort required for these processes
This sounds very similar to the motivations and consequences of the Design to Deliver
initiative. NAnt is a great match for the things we are trying to achieve.
Additionally, the flexibility of NAnt enables you to define the process itself in such a way
that
The overall process is broken down into steps that can be selected and applied appropri-
ately per project.
It can be branched conditionally depending on inputs and selections.
Finally, NAnt can be programmatically extended as needed to complete specific tasks that
are not included as part of the core NAnt tasks. It is actually quite hard to find specific tasks
that are required given the range of “out-of-the-box” features. We will look at this capability in
Chapter 6.
Maybe you have gathered that I am quite a fan. But I think that we have extolled the
virtues of the product enough and should take a look at the NAnt executable and a build file.
NAnt Nomenclature
Just before we dive in, let us clarify some of the terminology that we will use when discussing
NAnt:
NAnt: The physical executable (and the associated tasks) that form the application.
NAnt script/build script/build file: An XML file describing a project comprised of one or
more targets and zero or more properties.
Project: The root node of a build script. Each script has one project.
Target: A subdivision of a project. A target is a discrete piece of work that can consist of
zero or more tasks. Targets can be dependent on each other.
Task: A task is a defined activity that NAnt will execute; for example, creating a directory
or zipping a file. There are many built-in tasks to NAnt, and we will look at the most valu-
able of these in Chapter 3.
Property: An XML key/value pair that can be used to configure tasks and targets in a
more dynamic fashion. Property values can be overridden from the command line.
We will define these terms in much more detail next.
CHAPTER 2 ■ DISSECTING NANT
27
Basic Anatomy of a Build File
NAnt is not much use on its own. It requires an input “build file.” By convention, these files
tend to be called <name>.build, but in fact the files are just XML files and can be called any-
thing at all.
A “Hello World”Example
Consider the following very simple NAnt script:
<?xml version="1.0" encoding="utf-8" ?> 
<project name="HelloWorld" default="go">
<property name="message" value="Hello World!"/>
<target name="go">
<echo message="${message}"/>
</target>
</project>
Even without knowing precisely how NAnt works, you can tell what the script intends to do:
print “Hello World!” to the console.
Save this script as HelloWorld.buildand then do one of two things. Either navigate to the
directory in which the file is saved and type
nant
or use an explicit path to the file at the command prompt such as
nant -f:D:\BookCode\Chapter2\HelloWorld.build
If the PATH environment variable has been set correctly, then you will see something like the
following output:
---------- NAnt ----------
NAnt 0.85
Copyright (C) 2001-2003 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///HelloWorld.build
Target(s) specified: go 
go:
[echo] Hello World!
BUILD SUCCEEDED
Total time: 0 seconds.
Output completed (0 sec consumed) - Normal Termination
Our first, clearly very trivial, NAnt build file is complete. We will be looking at some much
more useful and realistic examples soon where we will also see many more complicated
actions.
CHAPTER 2 ■ DISSECTING NANT
28
Documents you may be interested
Documents you may be interested