mvc open pdf in browser : Convert pdf to jpg for online Library application class asp.net windows web page ajax Expert_.NET_Delivery_Using_NAnt_and_CruiseControl_.NET_200518-part1065

So we haven’t had any problems so far. Running the Build.Core.xmlscript with the fol-
lowing command-line call will successfully build the application:
nant -f:Build.Core.xml -D:debug=true -D:solution.stub=VSSManager
While this is seemingly straightforward, we should examine the output to think about
what has occurred. The output from the build process is shown in Figure 5-11.
Figure 5-11.The output from building Etomic.VssManager
M
representing the application, the configuration files, and the referenced log4net assembly.
Additionally, and importantly, there is a wrapper for the VSS library called Interop.Source➥
SafeTypeLib.dll. This means that the <solution>task has handled the generation ofthis
wrapper automatically, which is a very useful feature of the task and of course mirrorsthe
behavior of the VS .NET build process itself.
So in fact, we have had to make no real changes to the build scripts in order to handle
thisscenario. 
The deploy scripts can also handle the deployment of application without much change.
Once again, using the Windows application deploy script from Transformer and applying the
necessary changes will deploy the application to, for instance, the Program Files folder as
usual. Additionally, using the assembly deploy script from the work on Transformer enables us
to deploy the remoting interfaces to the shared assembly area. This means that there are two
steps to the deployment of the application, but these steps could be chained by including the
deployment of the remoting interfaces—the NAnt call to do this—in a nant.onsuccesstarget.
However, despite this successful deployment, we have in fact not handled two of the
issues. The first is the dependency on the VSS API and the second is the installation of the
Windows service.
CHAPTER 5 ■ PROCESS STANDARDS
161
Convert pdf to jpg for online - 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 jpeg on; convert pdf image to jpg image
Convert pdf to jpg for online - 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
best pdf to jpg converter for; batch pdf to jpg converter
The VSS API Dependency
The core issue for this dependency is that it is pointless to deploy the application on a machine
unless the VSS API is present. If in fact we can guarantee that it is present, then no changes are
needed to the script and the application will work because the interop assembly is included as
part of the deployment package. 
However, we should actually provide some assurance to the deployment. This can take
the form of regenerating the interop assembly on the deployment target at the time of deploy-
ment. We can do this with the <tlbimp>task. This task may look like this:
<tlbimp typelib="C:\Program Files\Microsoft Visual Studio\VSS\win32\ssapi.dll"
output="${core.environment}\${sys.version}\Interop.SourceSafeTypeLib.dll"
namespace="SourceSafeTypeLib" />
This code reproduces the interop assembly in a manual way. I have named the output
assembly as VS .NET would, and have also included the namespace as VS .NET would. Without
this, you may find that the manually generated assembly will not work with your application.
We could also have used this technique in the build step if we were using the <csc>task
instead of the <solution>task. The code above presumes that VSS is installed in the specified
location—which may be true, but it also may not. We can do a better job of this task by access-
ing the registry to obtain the actual location of the ssapi.dllassembly. The following code
retrieves this information:
<readregistry property="vss.api" 
key="TypeLib\{783CD4E0-9D54-11CF-B8EE-00608CC9A71F}\5.1\0\win32\"
hive="ClassesRoot" />
This task grabs the value of the specified key and places it in the specified property (in
this case vss.api). We can then use the property in the <tlbimp>task instead of the hard-
coded location. You can find the key required by searching the registry or by checking the
GUID of the required assembly (which is also stored in the relevant .csprojfile).
So, using these manual steps means that we have provided some assurance that VSS is
present on the deployment target machine. If it were not, these tasks, and therefore the
deployment, would fail.
The Windows Service
We have generated a Windows service, so we need to install it, and perhaps set it running as
part of the deployment process. We should also uninstall any existing service.
To install a Windows service, we must write an installer class as part of the code for the
application. This is a requirement whether NAnt, an MSI, or something else is used as the
deployment tool. The code for this can be examined in the solution, but this is not a primary
concern for us. Our concern is to actually perform the installation. This can be done using
installutil—a utility for this purpose that sits in the .NET Framework folder along with the
other .NET utilities, such as ildasm.
Installing the service involves a command-line call such as
installutil Etomic.VssManager.Service.exe
CHAPTER 5 ■ PROCESS STANDARDS
162
Online Convert Jpeg to PDF file. Best free online export Jpg image
Online JPEG to PDF Converter. Download Free Trial. Convert a JPG to PDF. You can drag and drop your JPG file in the box, and then start
convert multi page pdf to single jpg; best pdf to jpg converter
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.
convert pdf file to jpg file; c# pdf to jpg
An uninstall would be performed with the addition of a /uswitch. Unfortunately, there is
no specific NAnt task wrapping this utility but we can of course use an <exec>task appropri-
ately to call the utility.
This would look as follows:
<exec program="${framework::get-framework-directory('net-1.1')}\installutil">
<arg value="${core.environment}\${sys.version}\${solution.name}.Service.exe" 
/>
<arg value="/LogToConsole=false"/>
</exec>
This call finds the framework directory (here presuming we are using the .NET 1.1 Frame-
work in order to call installutil, passing the name of the service and one additional flag to
avoid unnecessary output in order to install the service. 
Finally, we can start the service with the following task:
<servicecontroller action="Start" service="Vss Manager Service" />
So with that, we have taken care of the installation of the service.
There is one more interesting detail. The service uses a configuration file in order to oper-
ate. Ordinarily, this would need to be placed in the Windowsfolder since services use this as
their working folder. To avoid this, the following line of code appears in the OnStartmethod
for the service, which allows the configuration file to be placed alongside the executable in the
same way as, for instance, a Windows application:
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
In this example, I have not addressed configuration file changes that may be necessary
upon deployment. You can find more details of this in Chapter 8, which also includes more
complex deployment scenarios.
Changes to the Deployment Script
The above additions for the COM interop and service installer can be added into the deploy-
ment script for the service in the configurationtarget. This target looks like this when
completed:
<target name="configure" description="Amend configuration settings as necessary">
<readregistry property="vss.api" 
key="TypeLib\{783CD4E0-9D54-11CF-B8EE-00608CC9A71F}\5.1\0\win32\"
hive="ClassesRoot" />
<delete
file="${core.environment}\${sys.version}\Interop.SourceSafeTypeLib.dll"/>
<tlbimp typelib="${vss.api}"
output="${core.environment}\${sys.version}\Interop.SourceSafeTypeLib.dll"
namespace="SourceSafeTypeLib" />
<exec program="${framework::get-framework-directory('net-1.1')}\installutil">
<arg value="/u"/>
CHAPTER 5 ■ PROCESS STANDARDS
163
C# Image Convert: How to Convert Adobe PDF to Jpeg, Png, Bmp, &
This demo code just converts first page to jpeg image. String inputFilePath = @"C:\input.pdf"; String outputFilePath = @"C:\output.jpg"; // Convert PDF to jpg.
change from pdf to jpg; convert pdf file to jpg online
C# Image Convert: How to Convert Tiff Image to Jpeg, Png, Bmp, &
RasterEdge.XDoc.PDF.dll. This demo code will convert first page to jpeg image. C:\input.tif"; String outputFilePath = @"C:\output.jpg"; // Convert tiff to jpg.
convert pdf to jpg 300 dpi; change pdf to jpg
<arg
value="${core.environment}\${old.version}\${solution.name}.Service.exe"/>
<arg value="/LogToConsole=false"/>
</exec>
<exec program="${framework::get-framework-directory('net-1.1')}\installutil">
<arg
value="${core.environment}\${sys.version}\${solution.name}.Service.exe"/>
<arg value="/LogToConsole=false"/>
</exec>
<servicecontroller action="Start" service="Vss Manager Service" />
</target>
So the process is as follows:
Read the registry to obtain the location of the VSS API.
Delete the version of the interop file included with the deployment package.
Create a new version of the interop file.
Uninstall any existing service.
Install the new service.
Start the service.
To uninstall an old version of the service, we need to pass the old version at the command
line. The command line to then move from one version to another might look like this:
nant -D:debug=false -D:sys.version=1.0.1.0 -D:old.version=1.0.0.0
Here is the output of the configuration step:
---------- NAnt ----------
NAnt 0.85
Copyright (C) 2001-2005 Gerry Shaw
http://nant.sourceforge.net
Buildfile: file:///Etomic.VSSManager.Deploy.xml
Target framework: Microsoft .NET Framework 1.1
Target(s) specified: configure 
configure:
[delete] Deleting file Interop.SourceSafeTypeLib.dll.
[exec] Microsoft (R) .NET Framework Installation utility Version 1.1.4322.573
CHAPTER 5 ■ PROCESS STANDARDS
164
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 jpg for; convert pdf file into jpg
VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Resize converted image files in VB.NET. Convert PDF to Jpg, Png, Bmp, Gif, Tiff and Bitmap in ASP.NET. Embed PDF to image converter in viewer.
convert pdf page to jpg; .pdf to jpg converter online
[exec] Copyright (C) Microsoft Corporation 1998-2002. All rights reserved.
[exec] 
[exec] Uninstalling assembly 'etomic.vssmanager.service.exe'.
[exec] Affected parameters are:
[exec]    assemblypath = etomic.vssmanager.service.exe
[exec]    logfile = etomic.vssmanager.service.InstallLog
[exec] Removing EventLog source Vss Manager Service.
[exec] Attempt to stop service Vss Manager Service.
[exec] Service Vss Manager Service is being removed from the system...
[exec] Service Vss Manager Service was successfully removed from the system.
[exec] Microsoft (R) .NET Framework Installation utility Version 1.1.4322.573
[exec] Copyright (C) Microsoft Corporation 1998-2002. All rights reserved.
[exec] 
[exec] Installing assembly 'etomic.vssmanager.service.exe'.
[exec] Affected parameters are:
[exec]    assemblypath = etomic.vssmanager.service.exe
[exec]    logfile = etomic.vssmanager.service.InstallLog
[exec] Installing service Vss Manager Service...
[exec] Service Vss Manager Service has been successfully installed.
[exec] Creating EventLog source Vss Manager Service in log Application...
[exec] Committing assembly 'etomic.vssmanager.service.exe'.
[exec] Affected parameters are:
[exec]    assemblypath = etomic.vssmanager.service.exe
[exec]    logfile = etomic.vssmanager.service.InstallLog
BUILD SUCCEEDED
Total time: 5.7 seconds.
Output completed (6 sec consumed) - Normal Termination
You should notice that some of the tasks used—<tlbimp>,<readregistry>, and 
<servicecontroller>—do not actually produce any output.
Once this has been executed, you should be able to see the installed service, as shown in
Figure 5-12.
Figure 5-12.The installed VSS Manager Service
CHAPTER 5 ■ PROCESS STANDARDS
165
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
Jpeg, VB.NET compress PDF, VB.NET print PDF, VB.NET merge PDF files, VB.NET view PDF online, VB.NET Convert PDF to image formats, such as PNG, JPG, BMP and
convert pdf to high quality jpg; convert pdf to jpg
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
batch pdf to jpg online; change pdf into jpg
Finally, with the service installed and the remoting interfaces assembly deployed to the
shared assembly folder, a developer is free to create a client to test the service. I have included
a simple console client to test connectivity to the service. The build and deploy scripts for the
client are included as part of the source code; it follows the same process as a regular Windows
application. When this application is executed, you should see a screen similar to that shown
in Figure 5-13.
Figure 5-13.The client console running
Summary
We now have several applications of different types running from a few build and deploy
scripts. We have made the script files more efficient and spotted a few problems that we need
to address going forward.
Broadly, we have a functioning process across several applications, and the knowledge to
carry us forward into more complex scenarios. We have a list of useful standards for the devel-
opment teams to work with to ensure that the integration of their projects into the process is
as smooth as possible.
In the next chapter we will look at providing improved processes through the use of con-
tinuous integration with CruiseControl.NET and explore the effects that this has on the
current process.
Subsequent chapters will help us to address some of the remaining issues as we extend
NAnt to create new tasks and handle more complex interactions such as configuration and
database issues. 
Further Reading
For more fun with remoting, check out Advanced .NET Remotingby Ingo Rammer
(Apress,2002).
CHAPTER 5 ■ PROCESS STANDARDS
166
Continuous Integration
T
he previous two chapters have seen us construct a satisfactory build process: simple
enough to achieve on a large scale—involving scores of projects—but intricate enough to per-
form the actions required of the process. In addition, standards have been devised to ensure
that new solutions will be able to comply easily with the delivery processes, Design to Deliver.
The delivery scripts are loosely organized and are available on demand. Their use relies
on the intervention of an operator to ensure that the process is used instead of some other
method.
In this chapter we will consider continuous integration (CI) and how it may develop the
processes further.
What Is Continuous Integration?
I have mentioned the original article on CI by Martin Fowler at the beginning of the book as
we considered the broad processes available for delivery. 
Fowler describes several disciplines needed to ensure that automated builds can work,
including items such as a “single place where all the source code lives,” the automation of
building and testing, and the publishing of the built material.
In fact, as we have discovered, it is a little more involved than that, although this summary
is accurate enough. Since we have already implemented these aspects in order to provide a
general automated build, how much more effort is there to providing CI?
The answer is not all that much, at least on one level: the conceptual one. Under CI, the
same processes are occurring as in the build scripts and process that we have already defined,
but the trigger to kick off the process changes. Additionally, the management of the source
control databases is handed to the CI software (at least in the case of CruiseControl.NET and
more than likely others as well) because the source code forms a key part of the trigger
process. This is shown in Figure 6-1.
167
CHAPTER 6
■ ■ ■
CHAPTER 6 ■ CONTINUOUS INTEGRATION
168
Figure 6-1.Automated build vs.continuous integration
Translating the process of continuous integration into a system consists of several core
features found in most products designed for CI. The clues for these are in the words continu-
ousandintegration.
Continuoustranslates to a process that repeats itself constantly against a trigger of some
description. With most CI products, this trigger is the monitoring of a source control reposi-
tory for available changes, though the monitoring may take slightly differing parameters, and
the monitored repository may actually be more esoteric than simply source control.
Integrationinvolves providing evidence of success of the process. While the onus is on the
user to provide actual integration paths for the solutions under CI, the applications are usu-
ally designed to offer feedback such as unit test results. Generally, CI applications will have
useful logging and feedback mechanisms to ensure that the team is notified as to the success
or failure of a build.
CI then is provided through the use of a suitable trigger. To be truly continuous, that trig-
ger should occur when any source code is freshly committed to the source control database.
We will see that other options are available too—less rigid options—but they are not actually
continuous in the originally intended sense.
Technically, achieving CI is more of a challenge. The constructs needed to provide a solu-
tion consist of a service with something like the following capabilities:
Knowledge of how to trigger the NAnt scripts (or otherwise) to perform the actual build
Knowledge of when to trigger the NAnt scripts: monitoring the source control database
for changes
Reporting and feedback methods
Fortunately, CruiseControl.NET (and other CI applications) provide these capabilities
more or less out-of-the-box, and so we can use one of these applications rather than creating
something from scratch
Now that we have considered the process in a holistic sense, let us examine the oppor-
tunities and threats involved with using CI. Broadly, CI provides practical benefits and
improvements to the defined processes, and these represent its strengths, whereas the
threatslie in the form of cultural issues and perhaps the occasional technical issue.
Opportunities
The CI process is acknowledged as a virtuous one, particularly in an “agile” world where it is
almost prescribed. Yet even outside this arena, there are benefits, both direct and indirect, to
using CI.
Builds are always up to date.Because the process performs a build cycle as soon as
changes are detected to the codebase, there is always a current build. Additionally,
reports (e.g., unit test results) are always up to date, demonstrating the features of the
system construction. In the event of a failed build, alerts will immediately notify the
development team. The net result is a reduction in risk since the chance of failure,
particularly failure through lack of use, is limited. CI is providing confidence through
continuous repeated attempts at the same process.
CHAPTER 6 CONTINUOUS INTEGRATION
169
A managed process.Although there is formality in the definition of the aims of the build
process, there is little structure regarding such issues as when to run the process. CI offers
a managed process, or at least the chosen application to run CI offers a managed process. 
Formality and structure.Similarly, the application chosen to run CI brings structure and
formality to the organization of the assets, scripts, and so on under the umbrella of the
CIsystem. CI gives the build process and its parts a “brand” to operate under. Much as
naming the process efforts Design to Deliver helps to raise awareness and understanding
through the team, CI (and the CI application) provide a focal point to the visible results
ofthe efforts.
Threats
Keep in mind that implementing CI may be a step too far for your process since there are also
some potential threats to the process: 
Process not required.If you operate in an environment with a very long-winded approach
to system delivery and integration work, then it is possible that CI will not help; its philos-
ophy is simply opposed to the available methodology. Equally, if no one is doing anything
with the information, then it may be pointless. In this instance, the threat is that the cul-
tural positioning of the team requires some realignment to use CI effectively.
Lack of discipline.This issue is related to the above point. Agile methods such as CI often
require focus to ensure their success. This focus tends to be the kind of focus a develop-
ment team is happy to apply to a situation and thus the processes succeed—but we must
consider that not all development teams, and not all developers, are dedicated to process
work in the same way. In this case, the developers may not be disciplined enough to cor-
rect failed builds, or to even obtain successful builds in the first place. The appearance of
many failed builds—which are supposed to be a “pick-me-up” to dedicated developers—
may have the reverse effect on a team not able to dedicate itself to the CI process.
Managing problem areas.As usual, once systems become tricky to build and deploy, then
CI may not be so easy to achieve. This could compound the other issues. Of course, the
opportunity to ensure a complex delivery presents itself here, but the threat is that there
are some particular considerations that simply do not fit well in a CI process. An example
of this might be database integration work. We will examine some of the implications for
databases in Chapter 8.
Technical Options
We will be using CruiseControl.NET (CCNet) to achieve CI in the sample applications, but it
isimportant to note that other options are available for use. Furthermore, moving between
platforms might not present a huge problem, since the features of the systems are generally
similar: server and client components, a web presence, XML definition files, and so on. Most
importantly, the applications usually provide the build process by wrapping NAnt, and thus
the core part of the process will be reusable across different build systems with only minimal
changes.
CHAPTER 6 ■ CONTINUOUS INTEGRATION
170
Documents you may be interested
Documents you may be interested