get
After the (very simple) selection of version, the first action should be to obtain the assets and
unpackage them to a working area. In this case, it is a matter of creating the working area and
then grabbing and unzipping the archive into it:
<target name="get" description="Grab the correct assets.">
<delete dir="${core.deploy}" failonerror="false"/>
<mkdir dir="${core.deploy}\${sys.version}\"/>
<copy 
file="${core.publish}\Transformer-Build-${sys.version}.zip"
todir="${core.deploy}"/>
<unzip 
zipfile="${core.deploy}\Transformer-Build-${sys.version}.zip"
todir="${core.deploy}\${sys.version}\"/>
</target>
selectenvironments
As discussed earlier, we are not considering at this point the differing environment possibili-
ties, and so there is no work in this target:
<target name="selectenvironments" description="Select environments">
<!--Enter tasks for selectenvironments target-->
</target>
createenvironments
Creating the environment is as simple as creating the directory as specified at the top of the
script. We also append the specific version of the application as in this example we can have
multiple side-by-side instances of the software:
<target name="createenvironments" description="Create the environments required">
<delete dir="${core.environment}\${sys.version}\" failonerror="false"/>
<mkdir dir="${core.environment}\${sys.version}\"/>
</target>
position
With the environment created, we can perform a copy of the assets into the environment. In
this case there are very few assets of course.
<target name="position" description="Place required assets">
<copy todir="${core.environment}\${sys.version}\">
<fileset basedir="${core.deploy}\${sys.version}">
<include name="**"/>
</fileset>
</copy>
</target>
CHAPTER 4 A SIMPLE CASE STUDY
130
Convert multiple 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
reader convert pdf to jpg; c# convert pdf to jpg
Convert multiple 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 photo to jpg; convert pdf to gif or jpg
configure
Under most scenarios we would expect to have to alter configuration in some way, but in this
simple application there is nothing to do:
<target name="configure" description="Amend configuration settings as necessary">
<!--Enter tasks for configure target-->
</target>
notify
Once again, a straightforward message is sufficient:
<target name="notify" description="Tell everyone of the success or failure.">
<echo message="Notifying you of the deploy process success."/>
</target>
fail
This target will also make do with a simple message:
<target name="fail">
<echo message="Notifying you of a failure in the deploy process."/>
</target>
help
We have added notes to the help target to assist with the execution of the script:
<target name="help">
<echo message="The skeleton file for the deploy process is designed ➥
to execute the following targets in turn:"/>
<echo message="-- selectversion"/>
<echo message="-- get"/>
<echo message="-- selectenvironments"/>
<echo message="-- createenvironments"/>
<echo message="-- position"/>
<echo message="-- configure"/>
<echo message="-- notify"/>
<echo message="This file should be run with a Boolean value for 'debug'."/>
<echo message="-- True indicates that no versioning be set (0.0.0.0)."/>
<echo message="-- False indicates that a regular version be set(1.0.x.0)."/>
<echo message="Example: -D:debug=true"/>
<echo message="This file should be run with a version number for ➥
'sys.version'."/>
<echo message="-- If debug=true then the default will be used (0.0.0.0)."/>
<echo message="Example: -D:sys.version=1.0.7.0"/>
</target>
CHAPTER 4 A SIMPLE CASE STUDY
131
C# Create PDF from images Library to convert Jpeg, png images to
Batch convert PDF documents from multiple image formats, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage.
convert pdf to jpeg; convert pdf to jpg for online
VB.NET Create PDF from images Library to convert Jpeg, png images
Components to batch convert PDF documents in Visual Basic .NET class. Support create PDF from multiple image formats in VB.NET, including Jpg, Png, Bmp, Gif
change pdf file to jpg; convert pdf to jpg 300 dpi
Examining the Output
So the current deployment script is not too complicated, we can execute the script with the
following:
nant -f:Transformer.Deploy.xml -D:debug=true go
or with this:
nant -f:Transformer.Deploy.xml -D:debug=false -D:sys.version=1.0.2.0 go
Based on a debug run, we can see the following output:
---------- NAnt ----------
NAnt 0.85 
Copyright (C) 2001-2004 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///Transformer.Deploy.xml
Target(s) specified: go 
selectversion:
get:
[delete] Deleting directory 'D:\dotNetDelivery\TempDeploy\'.
[mkdir] Creating directory 'D:\dotNetDelivery\TempDeploy\0.0.0.0\'.
[copy] Copying 1 file to 'D:\dotNetdelivery\TempDeploy\'.
[unzip] Unzipping ➥
'D:\dotNetDelivery\TempDeploy\Transformer-Build-0.0.0.0.zip' ➥
to 'D:\TempDeploy\0.0.0.0\' (10379 bytes).
selectenvironments:
createenvironments:
[delete] Deleting directory ➥
'D:\dotNetDelivery\Program Files\Transformer\0.0.0.0\'.
[mkdir] Creating directory ➥
'D:\dotNetDelivery\Program Files\Transformer\0.0.0.0\'.
position:
[copy] Copying 2 files to ➥
'D:\dotNetDelivery\Program Files\Transformer\0.0.0.0\'.
CHAPTER 4 A SIMPLE CASE STUDY
132
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
Free online C#.NET source code for combining multiple PDF pages together in .NET framework. Combine scanned images to PDF, such as tiff, jpg, png, gif, bmp
convert pdf file to jpg on; change pdf file to jpg online
C# WPF PDF Viewer SDK to convert and export PDF document to other
Create multiple pages Tiff file from PDF document. Convert PDF to image file formats with high quality, support converting PDF to PNG, JPG, BMP and GIF.
convert online pdf to jpg; convert pdf image to jpg image
configure:
notify:
[echo] Notifying you of the deploy process success.
go:
BUILD SUCCEEDED
Total time: 5.6 seconds.
Output completed (30 sec consumed) - Normal Termination
Broadly speaking, not much happened. All we have really done here is unzip some assets
to a directory. However, even with this limited interaction, you should be able to see that
deployment could quickly become a problem once we have moved beyond pure .NET Win-
dows applications. Once interaction with other systems, databases, multiple configurations,
and the like are taken into account, we will have a tricky problem to solve. 
With that said, bear in mind that for simple utilities or tools, this deployment script might
be perfectly adequate.
Note
We will look at techniques for handling deployment complexity in the next chapter to some extent,
and also in the advanced chapters toward the end of the book.
Summary
We have walked through the creation of a build and deployment script in some depth. Although
we have concentrated on a simple application, the same issues that arise for complex applica-
tions have appeared here in one form or another.
We have refactored the original script to a small extent and considered where other gains
through refactoring may be obtained as we progress.
In addition, we have linked groups of tasks together to achieve our ends, and we discov-
ered some of the limitations that we may need to tackle.
In the next chapter we will complicate the scenario further, which will lead to refactoring
of the code itself and a refactoring of the build files to gain further efficiencies.
Further Reading
For a great practical guide to unit testing (and other types of testing), a good read is Test-Driven
Development in Microsoft .NET,by James Newkirk (Microsoft Press, 2004).
CHAPTER 4 A SIMPLE CASE STUDY
133
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
An advanced .NET control able to batch convert PDF documents to image formats in C#.NET. Support exporting PDF to multiple image forms, including Jpg, Png, Bmp
.net convert pdf to jpg; convert pdf file into jpg format
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
Combine multiple specified PDF pages in into single one file. VB.NET Components to combine various scanned images to PDF, such as tiff, jpg, png, gif, bmp
.pdf to .jpg online; convert multi page pdf to single jpg
Process Standards
W
e have successfully created build and deploy scripts for a simple candidate application.
Additionally, we identified a few areas for improvement and made useful changes to improve
the flexibility of the resulting scripts.
In accordance with the Design to Deliver initiative, the next challenge is to provide scripts
across multiple systems to ensure the viability of the initial work. We can also take advantage
of refactoring and standardization to assist the large-scale integration of all systems under our
control.
At the end of this chapter we should be broadly satisfied with the delivery process that
isin place for a couple of systems, and be aware of outstanding issues that remain to be
addressed.
Another Case Study
Those bright sparks at Etomic have done it again. Following the immeasurable success of the
Transformer application, someone suggested it might be a great idea to have a web version of
the application. 
Implementing a web version is quite simple because the interface and application logic
for the Transformer application are cleanly separated. Therefore, a new user interface (UI)—in
this case a web interface—can easily be coded using the same application logic. It is not as
feature-rich as the Windows version, but it utilizes the same engine assembly, so in principle,
it could be. Bear in mind that permitting HTML input via the Web could be a security con-
cern—something the Etomic team may have missed!
The web application looks like the screen shown in Figure 5-1.
135
CHAPTER 5
■ ■ ■
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, etc. Create writable PDF from text (.txt) file.
convert pdf file to jpg online; .pdf to .jpg converter online
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
PDF. Convert PDF documents to multiple image formats, including Jpg, Png, Bmp, Gif, Tiff, Bitmap, .NET Graphics, and REImage. Turn
batch pdf to jpg converter; convert pdf file to jpg
CHAPTER 5 ■ PROCESS STANDARDS
136
Figure 5-1.Transformer web application
Considering the Delivery Scenario
We now have two simple applications with their own interfaces, sharing a common set of
application logic. The application logic is controlled through the use of unit tests. Although I
have not used it in this instance, the Microsoft User Interface Application Block (available
from the MSDN web site at http://msdn.microsoft.com/library/default.asp?url=/library/
en-us/dnbda/html/uip.asp) is a useful framework for providing separation of interface and
application logic.
It would be quite straightforward to have these four projects (the two UI projects, the
oach would proba-
bly not provide the desired delivery scenario.
Beated each
time a change is made to one or the other, or to the application engine. This may not be what
the teams who are developing and maintaining the systems are looking for. 
For example, if a new feature is placed in the application logic, then the team handling
the web UI implementation may not want to use this feature at this time. They may be happy
with the existing engine or not have the time in the project schedule to consider testing. The
point is that they should be able to decide when they want to use a new engine. Similarly,
changes to one interface impact on the other since both interfaces have to be built at the
same time. In this case, the implementations are separate and no real justification exists for
coupling the two.
Note
Perhaps one justification is that the applications are considered a suite and so coupling the activi-
ties is perceived as a good idea.Clearly contexts will differ from system to system.
Seemingly then, the best idea is to have three independent processes for delivery of the
subsystems and systems. The independence is only theoretical, of course, since the interfaces
ultimately rely on the engine subsystem for delivery, but we can provide more choices.
The Solutions
The solutions can be found in the Visual SourceSafe (VSS) database as follows:
Etomic.Library.Transformer.This solution contains the application logic engine assembly
and the corresponding unit-testing assembly.
Etomic.Transformer.Win.This solution references the Etomic.Library.Transformer.Engine
assembly and contains a project representing the Windows interface.
Etomic.Transformer.Web.This solution references the Etomic.Library.Transformer.Engine
assembly and contains a project representing the web interface.
We will discuss the naming and organization of the solutions in the next section, where
we will also consider other useful standards.
The Build Process
The build process for the three solutions is the same for the most part. The main difference in
terms of the defined process is that there are no unit tests in either of the user interface solu-
tions. The only unit testing implemented is in the Etomic.Library.Transformer solution.
Therefore, this activity is curtailed in the scripts for the other two solutions, though we can
include the FxCop analysis as before.
The Deploy Process
The deployment process is a different story. All three solutions have different specifics, although
overall the process matches the use case described in the previous chapter. The differences
relate to the delivery of different kinds of system: a web application, a Windows application,
and an assembly. There are other possibilities, too, such as Windows services and web serv-
ices, but these are probably the most common and therefore represent a good starting point.
The main differences are as follows:
CHAPTER 5 ■ PROCESS STANDARDS
137
Etomic.Library.Transformer. Because this is an assembly that is to be used by other sys-
tems, it is likely that the deployment itself will be simple. However, the assembly needs to
be published in a certain way to ensure that the systems that utilize it can see it and use it
during their own builds. We will therefore also need to publish multiple versions of the
assembly in a standard way so that the other systems can select the correct version.
Etomic.Transformer.Win.Windows applications are simpler to deploy than web applica-
tions since they require no infrastructure such as a web site or virtual directory. There
may be need for configuration and so on, but otherwise an XCOPY deployment to a spe-
cific folder is probably enough.
Etomic.Transformer.Web.The deployment of the web application is more complex
because it will require applying the same configuration settings as the Windows applica-
tion and also the additional step during environment creation of creating a virtual
directory for the site to run in.
Once again, because we are considering applications with no real deployment complex-
ity, we will see only a limited amount of deployment script. That is not to say that our script
will not do the job, but we will not have to focus on standardizing and refactoring the deploy
scripts in the same way we will the build scripts.
Consideration of Standards
If we were just to move on and produce a build script for these components and systems, we
would no doubt be successful since NAnt would easily accommodate our requirements. But at
this point we should consider our goal: the implementation of a standard set of scripts and/or
processes that are quick and that ease the integration of new systems.
If we imagine for a moment that the Transformer applications are more complex than
thecode presented here, then the scenario itself is one that is quite common: multiple inter-
faces/systems utilizing shared common code. This gives us the opportunity to consider
broader standards for the way in which the team should organize the environment and the
solutions they have in order to successfully and efficiently deliver the resulting products. This
sounds a little like Design to Deliver.
The following are some areas worth considering for standardization. We will discuss them
here and then see how they impact on the scripts later.
Naming Conventions
The use of sensible naming conventions standardized across solutions can facilitate the creation
of build scripts as well as help team members understand the systems they will work with.
One common standard uses the company name, followed by the system name, the sub-
system name, and so on—for example, Etomic.Transformer.Engine.
In particular, there are specific types of project that, if named the same thing, become a
lot easier to handle in the scripts than those with more “individuality.” Candidates for naming
standards are
CHAPTER 5 ■ PROCESS STANDARDS
138
The solution file.The solution file is referred to in the <solution>task. The file also repre-
sents the discrete “unit” that a build script is prepared for. Therefore, the name of the file
is important. 
The test project.If a solution has an assembly specifically for unit testing, then naming it
“Tests” aids with identification during the delivery process.
The UI project.Again, it may be advantageous to provide a standard UI name, particu-
larly when a web application is involved and additional information needs to be provided
to the <solution>task.
This convention is valuable because it allows for easy matching of assemblies related to
the company or the subsystem. If assemblies are named in this way, then it is a great idea to
name solution and project files in a way that dovetails with this policy. For instance, for the
Transformer engine project, I would name the solution file “Etomic.Library.Transformer”
(Iadded the library name because we intend to share the project contents), and then name
the individual projects a single name such as “Engine” or “Tests”. I would then set the output
assembly names to be “Etomic.Library.Transformer.Engine.dll” and “Etomic.Library.Trans-
former.Tests.dll” respectively.
If it is possible to standardize on naming of projects and solutions, then you should do so
as there will undoubtedly be some efficiency gained through the ability to remove awkward
parameters and properties and maintain only standard scripting functions. Consider the fol-
lowing properties that appear in the build files for this chapter:
<property name="company.name" value="Etomic"/>
<property name="solution.name" value="${company.name}.Library.Transformer"/>
<property name="project.name.1" value="${solution.name}.Engine" />
Here we have ensured that the solution names and content are defined at the top of the
build file. As we explained, having standards to allow properties such as this aids the construc-
tion of filters and the like for the provision of documentation, distribution packages, and so on.
In a best case, it may be possible to reuse a build script only through changes to these
properties.
Source Control Organization
Although organizing VSS is straightforward, it is also very easy to get it wrong, or to let the
standards slip since VSS is often perceived as quite static once the source control system is
created. Deciding how to organize your source control system and manage it is an important
part of a configuration management policy for the development team. It should not be
entered into lightly since it is difficult to alter structures later on—at least without losing the
history of the systems held under the source control system. You may not agree with the
approach presented here, and that is fine. What isimportant is that your own development
team reaches an agreement at the outset of introducing these processes.
In the VSS database included with the book code, you’ll find a project/folder called
Solutions; all solutions are then held a level below this, as Figure 5-2 shows.
CHAPTER 5 ■ PROCESS STANDARDS
139
Figure 5-2.Source control organization
In a real situation, it is likely—given the limitations of VSS—that there will be multiple VSS
databases. Organizing them in the same way, with the same builderuser account, is efficient
because it means that all VSS access becomes the same, with the exception of the solution
name. Therefore, by using the naming standards we described earlier, along with this organi-
zation, this approach can easily be parameterized to standard targets that could lead to
efficiency through refactoring.
VS .NET Settings
We saw several settings in the last chapter that are worth employing. Let us recap those here:
CommonAssemblyInfo.cs.The shared “versioning” file is very useful. All projects should
implement this shared information in the same way. Versioning should then become a
standard activity; the common file will always contain the same information and will be
held in the same place relative to the solution root. This technique can also be used to
link to a common SNK file to be used for strong naming (for example).
CHAPTER 5 ■ PROCESS STANDARDS
140
Documents you may be interested
Documents you may be interested