display pdf in asp.net page : Rotate individual pages in pdf SDK Library API .net wpf azure sharepoint dmp4-part1839

De
s
i
gn data 
s
tructure
s
carefully
21
Solu
t
ion 1
:
simple hash
The immediately obvious solution is to use a hash in which the keys are years and
the values are the numbers of 
CD
s. In this case, there will be no need for a separate
data munging process, as all of the required munging will be carried out in the
input routine. We might create a first draft script something like this:
my %years;
while (<STDIN>) {
chomp;
my $year = (split /\t/)[3];
$years{$year}++;
}
foreach (sort keys %years) {
print "In $_, $years{$_} CDs were released.\n";
}
This provides a solution to our problem in a reasonably
efficient manner. The data structure that we build is very
simple and is shown in figure 2.3. 
Solu
t
ion 2
:
adding flexibili
t
y
But how often are requirements as fixed as these?1 Sup-
pose later someone decides that, instead of having a list of
the number of 
CD
s released, they also need a list of the
actual 
CD
s. In this case, we will need to go back and
rewrite our script completely to something like this:
my %years;
while (<STDIN>) {
chomp;
my ($artist, $title, $label, $year) = split /\t/;
my $rec = {artist => $artist,
title
=> $title,
label
=> $label};
push @ {$year{$year}}, $rec;
}
foreach my $year (sort keys %years) {
my $count = scalar @{$years{$year}};
print "In $year, $count CDs were released.\n";
print “They were:\n”;
print map { "$_->{title} by $_->{artist}\n" } @{$years{$year}};
}
1
There are, of course, many times when the requirements won’t change—because this is a one-off data load
process or you are proving a concept or building a prototype.
1971
1987
1993
1996
1997
1998
1
1
1
1
1
1
Figur
e
2.3
I
nitial data 
s
tructur
e
d
e
s
ign
Rotate individual pages in pdf - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
how to permanently rotate pdf pages; rotate pdf page and save
Rotate individual pages in pdf - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
change orientation of pdf page; rotate individual pdf pages reader
22
CHAPTER 
General mung
i
ng pract
i
ce
s
As you can see, this change has entailed an almost complete rewrite of the script. In
the new version, we still have a hash where the keys are the years, but each value is
now a reference to an array. Each element of this array is a reference to a hash which
contains the artist, title, and label of the 
CD
. The output section has also grown
more complex as it needs to extract more information from the hash.
Notice that the hash stores the 
CD
’s label even though we don’t use it in the
output from the script. Although the label isn’t required in our current version, it is
quite possible that it will become necessary to add it to the output at some point in
the future. If this happens we will no longer need to make any changes to the input
section of our script as we already have the data available in our hash. This is, in
itself, an important data munging principle—if you’re reading in a data item, you
may as well store it in your data structure. This can be described more succinctly as
“Don’t throw anything away.” This improved data structure is shown in figure 2.4.
Solu
t
ion 3
:
separa
t
ing parsing from munging
What happens, however, if the requirements change completely so that we now
need to display counts by artist for a different report? Our current script is of no use
at all. There is no part of it that is reusable to help us achieve our new goals. Per-
haps we need to rethink our strategy from the start.
In all of the scripts above we were not following the advice of the previous sec-
tion. We were trying to do too much in the input section and left ourselves nothing
to do in the data munging section. Perhaps if we went back to a more decoupled
approach, we would have more success.
This leaves us contemplating our original question again—what structure would
offer the best way to represent our data inside the program? Let’s take another look
at the data. What we have is a list of records, each of which has a well-defined set of
attributes. We could use either a hash or an array to model our list of records and we
have the same choices to model each individual record. In this case we will use an
1971
1987
1993
1996
1997
1998
a
r
r
a
y
r
e
f
a
r
r
a
y
r
e
f
a
r
r
a
y
r
e
f
a
r
r
a
y
r
e
f
a
r
r
a
y
r
e
f
a
r
r
a
y
r
e
f
a
rti
s
t
titl
e
l
a
b
e
l
D
a
vid Bowi
e
Hunky Dory
RCA
0
h
a
s
h
r
e
f
Figur
e
2.4
I
mprov
e
d data 
s
tructur
e
d
e
s
ign
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
doc.Save(outPutFilePath). How to VB.NET: Delete Consecutive Pages from PDF. doc.Save(outPutFilePath). How to VB.NET: Delete Specified Pages from PDF.
pdf rotate single page and save; pdf rotate just one page
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Page: Insert PDF Pages. |. Home ›› XDoc.PDF ›› VB.NET PDF: Insert PDF Page. Add and Insert Multiple PDF Pages to PDF Document Using VB.
how to rotate pdf pages and save permanently; rotate individual pages in pdf
De
s
i
gn data 
s
tructure
s
carefully
23
array of hashes2 to model our data. A good argument could be made for just about
any other combination of arrays and hashes, but the representation that I have cho-
sen seems more natural to me. Our input routine will therefore look like this:
my @CDs;
sub input {
my @attrs = qw(artist title label year);
while (<STDIN>) {
chomp;
my %rec;
@rec{@attrs} = split /\t/;
push @CDs, \%rec;
}
}
This third and final data structure is shown in figure 2.5.
More examples
:
using our flexible da
t
a s
t
ruc
t
ure
Based on this data structure, we can then write any number of data munging rou-
tines to produce specific output reports. For example, to produce our original list of
the 
CD
s released in a year we would write a routine like this:
sub count_cds_by_year {
my %years;
foreach (@CDs) {
$years{$_->{year}}++;
}
return \%years;
}
This routine returns a reference to a hash which is identical in structure to our orig-
inal hash and can therefore be printed out using code identical to the output section
of our original script.
2
Or, more accurately, an array of references to hashes.
0
1
2
3
4
5
h
a
s
h
r
e
f
h
a
s
h
r
e
f
h
a
s
h
r
e
f
h
a
s
h
r
e
f
h
a
s
h
r
e
f
h
a
s
h
r
e
f
a
rti
s
t
titl
e
l
a
b
e
l
D
a
vid Bowi
e
Hunky Dory
RCA
y
e
a
r
1971
Figur
e
2.5
Final data 
s
tructur
e
C# PDF Page Insert Library: insert pages into PDF file in C#.net
how to merge PDF document files by C# code, how to rotate PDF document page, how to delete PDF page using C# .NET, how to reorganize PDF document pages and how
rotate all pages in pdf; pdf rotate one page
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
doc.Save(outPutFilePath); Demo Code: How to Delete Consecutive Pages from PDF in C#.NET. Demo Code: How to Delete Specified Pages from PDF in C#.NET.
rotate pdf page; how to rotate one page in a pdf file
24
CHAPTER 
General mung
i
ng pract
i
ce
s
To produce a list of the number of 
CD
s released by each artist we can write a
similar routine like this:
sub count_cds_by_artist {
my %artists;
foreach (@CDs) {
$artists{$_->{artist}}++;
}
return \%artists;
}
In fact these two routines are so similar, that it is possible to write a generic version
which handles both of these cases (along with the cases where you want to count
CD
s by label or even by title).
sub count_cds_by_attr {
my $attr = shift;
my %counts;
foreach (@CDs) {
$counts{$_->{$attr}}++;
}
return \%counts;
}
A complete program to produce counts of 
CD
s by any attribute which is passed in
on the command line would look like this:
#!/usr/bin/perl -w
use strict;
my @CDs;
sub input {
my @attrs = qw(artist title label year);
while (<STDIN>) {
chomp;
my %rec;
@rec{@attrs} = split /\t/;
push @CDs, \%rec;
}
}
sub count_cds_by_attr {
my $attr = shift;
my %counts;
foreach (@CDs) {
$counts{$_->{$attr}}++;
C# TIFF: How to Rotate TIFF Using C# Code in .NET Imaging
Individual Products. XDoc.SDK for .NET. XImage.SDK for Page. |. Home ›› XDoc.Tiff ›› C# Tiff: Rotate Tiff Page. & pages edit, C#.NET PDF pages extract, copy
rotate all pages in pdf file; how to rotate a single page in a pdf document
VB.NET PDF - WPF PDF Viewer for VB.NET Program
Individual Products. XDoc.SDK for .NET. XImage.SDK for .NET. Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Pages. Page: Rotate a PDF
how to rotate one page in pdf document; pdf rotate single page
Encap
s
ulate bu
s
i
ne
s
s
rule
s
27
2.3.3 Simple module
Assume that we want to model the three business rules mentioned at the start of
this section. We will write a module called 
Customer_Rules.pm
that will contain
the two functions 
get_next_cust_no
and 
save_cust_record
which we sug-
gested above. The following example omits some of the lower level functions.
package Customer_Rules;
use strict;
use Carp;
use vars qw(@EXPORT @ISA);
@EXPORT = qw(get_next_cust_no save_cust_record);
@ISA = qw(Exporter);
require Exporter;
sub get_next_cust_no {
my $prev_cust = get_max_cust_no()
|| croak "Can't allocate new customer reference.\n";
my ($prev_no) = $prev_cust =~ /(\d+)/;
$prev_no++;
return "CUS-$prev_no";
}
sub save_cust_record {
my $cust = shift;
$cust->{cust_no} ||= get_next_cust_no();
is_valid_sales_ref($cust->{salesperson})
|| croak "Invalid salesperson ref: $cust->{salesperson}.";
write_sales_record($cust);
}
How Cus
t
omer_Rules.pm works
In this example we have encapsulated our business rules in functions which, in turn,
make use of other lower level functions. These lower level functions haven’t been
shown, as they would contain implementation-specific details which would only
cloud the picture.
In the 
get_next_cust_no
function we begin by getting the customer number of
the most recently created customer record. This might be stored in a database table
or in a text file or in some other format. In all of these cases there will need to be
some kind of transaction-level locking to ensure that no other process gets the same
value for the previous customer number. This would potentially lead to nonunique
customer numbers in the system, which would break one of our business rules.
28
CHAPTER 
General mung
i
ng pract
i
ce
s
Having retrieved the previous customer number we simply extract the integer
portion, increment it, and return it with the string 
CUS-
prepended to it.
In the 
save_cust_record
function, we assume that the customer record is
stored internally in some complex data structure and that we are passed a reference
to that structure. The first thing that we do is to ensure that we have a customer
number in the record. We then check that the 
$cust->{salesperson}
value rep-
resents a valid salesperson in our system. Again, the list of valid salespeople could be
stored in a number of different forms. It may be possible that more data is required
in order to validate the salesperson code. For example, a salesperson may only deal
with customers in a certain region. In this case the region in which the customer is
based will also need to be passed into the 
is_valid_sales_ref
function.
Eventually, we get a true or false value back from 
is_valid_sales_ref
and can
proceed appropriately. If the salesperson is valid, we can write the customer record to
whatever storage medium we are using; otherwise, we alert the user to the error. In a
real-world system many other similar checks would probably need to be carried out.
Using Cus
t
omer_Rules.pm
Having produced this module, we can make it available to all programmers who are
writing applications by putting it into a project-wide library directory. To make use
of these functions, a programmer only needs to include the line:
use Customer_Rules;
in a program. The program will now have access to the 
get_next_cust_no
and
save_cust_record
functions. Therefore, we can ensure that every program has
the same interpretation of the business rules and, perhaps more importantly, if the
business rules change, we only need to change this module in order to change them
in each program.
2.3.4 Objec
t
class
While the module of the previous section is useful, it still has a number of problems;
not the least of which is the fact that the structure of the customer record is defined
elsewhere in the application. If the module is reused in a number of applications,
then each application will define its own customer record and it is possible that the
definitions will become out of step with each other. The solution to this problem is
to create an object class.
An object defines both the structure of a data record and all of the methods used
to operate on the record. It makes the code far easier to reuse and maintain. A full
discussion of the advantages of object-oriented programming (
OOP
) is beyond the
scope of this book, but two very good places to get the full story are the perltoot
manual page and Damian Conway’s Object Oriented Perl (Manning).
Encap
s
ulate bu
s
i
ne
s
s
rule
s
29
Let’s examine a cut-down customer object which is implemented in a module
called 
Customer.pm
.
package Customer;
use strict;
sub new {
my $thing = shift;
my $self = {};
bless $self, ref($thing) || $thing;
$self->init(@_);
return $self;
}
sub init {
my $self = shift;
# Extract various interesting things from
# @_ and use them to create a data structure
# that represents a customer.
}
sub validate {
my $self = shift;
# Call a number of methods, each of which validates
# one data item in the customer record.
return $self->is_valid_sales_ref
&& $self->is_valid_other_attr
&& $self->is_valid_another_attr;
}
sub save {
my $self = shift;
if ($self->validate) {
$self->{cust_no} ||= $self->get_next_cust_no;
return $self->write;
} else {
return;
}
}
# Various other object methods are omitted here, for example
# code to retrieve a customer object from the database or
# write a customer object to the database.
1; # Because all modules should return a true value.
The advantage that this method has over the previous example is that in addition to
modeling the business rules that apply to a customer record, it defines a standard
30
CHAPTER 
General mung
i
ng pract
i
ce
s
data structure to store customer data and a well defined set of actions that can be
performed on a customer record. The slight downside is that incorporating this
module into a program will take a little more work than simply using the functions
defined in our previous module.
Example
:
using Cus
t
omer.pm
As an example of using this module, let’s look at a simple script for creating a cus-
tomer record. We’ll prompt the user for the information that we require.
use Customer;
my $cust = Customer->new;
print 'Enter new customer name: ';
my $name = <STDIN>;
$cust->name($name);
print 'Enter customer address: ';
my $addr = <STDIN>;
$cust->address($addr);
print 'Enter salesperson code: ';
my $sp_code = <STDIN>;
$cust->salesperson($sp_code);
# Write code similar to that above to get any other
# required data from the user.
if ($cust->save) {
print "New customer saved successfully.\n";
print "New customer code is ", $cust->code, "\n";
} else {
print "Error saving new customer.\n";
}
In this case we create an empty customer object by calling the 
Customer->new
method without any parameters. We then fill in the various data items in our cus-
tomer object with data input by the user. Notice that we assume that each customer
attribute has an access method which can be used to set or get the attribute value.4
4
This is a common practice. For example, the 
name
method counts the number of parameters that have
been sent. If it has received a new value then it sets the customer’s name to that value; if not, it just returns
the previous value.
An alternative practice is to have two separate methods called 
get_name
and 
set_name
. Which approach
you use is a matter of personal preference. In either case, it is generally accepted that using access methods
is better than accessing the attributes directly.
Documents you may be interested
Documents you may be interested