open pdf file in asp.net using c# : How to insert text into a pdf Library control component .net azure wpf mvc 01311770521-part65

x
C
ONTENTS
Other Techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
Moving Forward  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
After Extract Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268
Chapter 21: I’m Changing the Same Code All Over the Place . . . . . . . . . .  269
First Steps   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272
Chapter 22: I Need to Change a Monster Method 
and I Can’t Write Tests for It . . . . . . . . . . . . . . . . . . . . . . . . .  289
Varieties of Monsters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290
Tackling Monsters with Automated Refactoring Support   . . . . . . .294
The Manual Refactoring Challenge  . . . . . . . . . . . . . . . . . . . . . . . .297
Strategy  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304
Chapter 23: How Do I Know That I’m Not Breaking Anything?. . . . . . . .  309
Hyperaware Editing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310
Single-Goal Editing  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311
Preserve Signatures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312
Lean on the Compiler   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315
Chapter 24: We Feel Overwhelmed. It Isn’t Going to Get Any Better. . . . . .319
PART III: Dependency-Breaking Techniques 
. . . . . . . . . . . . . . . . . . . .323
Chapter 25: Dependency-Breaking Techniques . . . . . . . . . . . . . . . . . . . . .  325
Adapt Parameter  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326
Break Out Method Object  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330
Definition Completion  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .337
Encapsulate Global References . . . . . . . . . . . . . . . . . . . . . . . . . . . .339
Expose Static Method  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345
Extract and Override Call  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348
Extract and Override Factory Method  . . . . . . . . . . . . . . . . . . . . . .350
Extract and Override Getter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .352
Extract Implementer  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356
Extract Interface   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362
Introduce Instance Delegator  . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369
Introduce Static Setter  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .372
Link Substitution  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377
Parameterize Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379
Parameterize Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .383
How to insert text into a pdf - insert text into PDF content in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
XDoc.PDF for .NET, providing C# demo code for inserting text to PDF file
adding text pdf files; adding text to pdf in reader
How to insert text into a pdf - VB.NET PDF insert text library: insert text into PDF content in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Providing Demo Code for Adding and Inserting Text to PDF File Page in VB.NET Program
add text field to pdf; add text to pdf in preview
C
ONTENTS
xi
Primitivize Parameter  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
Pull Up Feature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Push Down Dependency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
Replace Function with Function Pointer . . . . . . . . . . . . . . . . . . . . 396
Replace Global Reference with Getter  . . . . . . . . . . . . . . . . . . . . . 399
Subclass and Override Method . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Supersede Instance Variable  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Template Redefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Text Redefinition  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Appendix: Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Extract Method  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
C# PDF Page Insert Library: insert pages into PDF file in C#.net
editor library control, RasterEdge XDoc.PDF, offers easy & mature APIs for developers to add & insert an (empty) page into an existing PDF document file.
adding text to pdf in acrobat; how to add text to a pdf file in reader
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
of PDF page adding in C# class, we suggest you go to C# Imaging - how to insert a new empty page to PDF file. DLLs for Adding Page into PDF Document in VB.NET
adding text fields to a pdf; add text pdf reader
This page intentionally left blank 
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Merge several images into PDF. Insert images into PDF form field. Access to freeware download and online C#.NET class source code.
add text to pdf document online; add text to pdf online
VB.NET PDF insert image library: insert images into PDF in vb.net
Insert images into PDF form field in VB.NET. Insert Image to PDF Page Using VB. Dim doc As PDFDocument = New PDFDocument(inputFilePath) ' Get a text manager from
how to insert pdf into email text; add text pdf acrobat
F
OREWORD
xiii
Foreword 
“…then it began…”
In  his  introduction  to  this  book,  Michael  Feathers  uses  that  phrase  to
describe the start of his passion for software.
“…then it began…”
Do you know that feeling? Can you point to a single moment in your life and
say: “…then it began…”? Was there a single event that changed the course of
your life and eventually led you to pick up this book and start reading this fore-
word?
I was in sixth grade when it happened to me. I was interested in science and
space and all things technical. My mother found a plastic computer in a catalog
and ordered it for me. It was called Digi-Comp I. Forty years later that little
plastic computer holds a place of honor on my bookshelf. It was the catalyst
that sparked my enduring passion for software. It gave me my first inkling of
how joyful it is to write programs that solve problems for people. It was just
three  plastic S-R flip-flops and  six plastic  and-gates, but  it  was enough—it
served. Then… for me… it began…
But the joy I felt soon became tempered by the realization that software sys-
tems almost always  degrade into a mess.  What starts as  a  clean  crystalline
design in the minds of the programmers rots, over time, like a piece of bad
meat. The nice little system we built last year turns into a horrible morass of
tangled functions and variables next year.
Why does this happen? Why do systems rot? Why can’t they stay clean?
Sometimes we blame our customers. Sometimes we accuse them of changing
the requirements. We comfort ourselves with the belief that if the customers had
just been happy with what they said they needed, the design would have been
fine. It’s the customer’s fault for changing the requirements on us.
Well, here’s a news flash: Requirements change. Designs that cannot tolerate
changing requirements are poor designs to begin with. It is the goal of every
competent software developer to create designs that tolerate change.
This seems to be an intractably hard problem to solve. So hard, in fact, that
nearly every system ever produced suffers from slow, debilitating rot. The rot is
so pervasive that we’ve come up with a special name for rotten programs. We
call them: Legacy Code.
C# PDF File Split Library: Split, seperate PDF into multiple files
Divide PDF File into Two Using C#. This is an C# example of splitting a PDF to two new PDF files. Split PDF Document into Multiple PDF Files in C#.
add text block to pdf; add text box in pdf document
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Split PDF file into two or multiple files in ASP.NET webpage online. Split PDF Document into Multiple PDF Files Demo Code in VB.NET.
adding text to pdf form; adding text to a pdf form
xiv
F
OREWORD
Legacy code. The phrase strikes disgust in the hearts of programmers. It con-
jures images of slogging through a murky swamp of tangled undergrowth with
leaches beneath and stinging flies above. It conjures odors of murk, slime, stag-
nancy, and offal. Although our first joy of programming may have been intense,
the misery of  dealing with legacy code is often sufficient to extinguish  that
flame.
Many of us have tried to discover ways to prevent code from becoming leg-
acy. We’ve written books on principles, patterns, and practices that can help
programmers keep their systems clean. But Michael Feathers had an insight that
many of the rest of us missed. Prevention is imperfect. Even the most disciplined
development team, knowing the best principles, using the best patterns, and fol-
lowing the best practices will create messes from time to time. The rot still accu-
mulates. It’s not  enough  to  try to  prevent the rot—you  have  to  be  able  to
reverse it.
That’s what this book is about. It’s about reversing the rot. It’s about taking
a tangled, opaque, convoluted system and slowly, gradually, piece by piece, step
by step, turning it into a simple, nicely structured, well-designed system. It’s
about reversing entropy. 
Before you get too excited, I warn you; reversing rot is not easy, and it’s not
quick. The techniques, patterns, and tools that Michael presents in this book
are effective, but they take work, time, endurance, and care. This book is not a
magic bullet. It won’t tell you how to eliminate all the accumulated rot in your
systems overnight. Rather, this book describes a set of disciplines, concepts, and
attitudes that you will carry with you for the rest of your career and that will
help you to turn systems that gradually degrade into systems that gradually
improve.
Robert C. Martin
29 June, 2004
VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net
Among all the DLL components, there is a PDF processing library which enables developers to convert PDF document into text file using Visual Basic .NET
add text box in pdf; adding text to a pdf file
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
PDF document splitting, PDF page reordering and PDF page image and text extraction. Description: Combine the source PDF streams into one PDF file and save
how to insert text into a pdf file; adding text to a pdf document
P
REFACE
xv
Preface
Do you remember the first program you wrote? I remember mine. It was a little
graphics program I wrote on an early PC. I started programming later than
most of my friends. Sure, I’d seen computers when I was a kid. I remember
being really impressed by a minicomputer I once saw in an office, but for years
I never had a chance to even sit at a computer. Later, when I was a teenager,
some friends of mine bought a couple of the first TRS-80s. I was interested, but
I was actually a bit apprehensive, too. I knew that if I started to play with com-
puters, I’d get sucked into it. It just looked too cool. I don’t know why I knew
myself so well, but I held back. Later, in college, a roommate of mine had a
computer, and I bought a C compiler so that I could teach myself programming.
Then it began. I stayed up night after night trying things out, poring through
the source code of the emacs editor that came with the compiler. It was addic-
tive, it was challenging, and I loved it.
I hope you’ve had experiences like this—just the raw joy of making things
work on a computer. Nearly every programmer I ask has. That joy is part of
what got us into this work, but where is it day to day? 
A few years ago, I gave my friend Erik Meade a call after I’d finished work
one night. I knew that Erik had just started a consulting gig with a new team, so
I asked him, “How are they doing?” He said, “They’re writing legacy code,
man.” That was one of the few times in my life when I was sucker-punched by
a coworker’s statement. I felt it right in my gut. Erik had given words to the pre-
cise feeling that I often get when I visit teams for the first time. They are trying
very hard, but at the end of the day, because of schedule pressure, the weight of
history, or a lack of any better code to compare their efforts to, many people
are writing legacy code.
What is legacy code? I’ve used the term without defining it. Let’s look at the
strict definition:  Legacy code is  code  that we’ve gotten from  someone  else.
Maybe our company acquired code from another company; maybe people on
the original team moved on to other projects. Legacy code is somebody else’s
code. But in programmer-speak, the term means much more than that. The
term legacy code has taken on more shades of meaning and more weight over
time.
xvi
P
REFACE
What do you think about when you hear the term legacy code? If you are at
all like me, you think of tangled, unintelligible structure, code that you have to
change but don’t really understand. You think of sleepless nights trying to add
in features that should be easy to add, and you think of demoralization, the
sense that everyone on the team is so sick of a code base that it seems beyond
care, the sort of code that you just wish would die. Part of you feels bad for
even thinking about making it better. It seems unworthy of your efforts. That
definition  of  legacy  code  has  nothing  to do  with  who  wrote  it.  Code  can
degrade in many ways, and many of them have nothing to do with whether the
code came from another team. 
In the industry, legacy code is often used as a slang term for difficult-to-change
code that we don’t understand. But over years of working with teams, helping
them get past serious code problems, I’ve arrived at a different definition. 
To me, legacy code is simply code without tests. I’ve gotten some grief for
this definition. What do tests have to do with whether code is bad? To me, the
answer is straightforward, and it is a point  that  I elaborate  throughout the
book:
You might think that this is severe. What about clean code? If a code base is
very clean and well structured, isn’t that enough? Well, make no mistake. I love
clean code. I love it more than most people I know, but while clean code is
good, it’s not enough. Teams take serious chances when they try to make large
changes  without  tests.  It  is  like  doing  aerial  gymnastics  without  a  net.  It
requires incredible skill and a clear understanding of what can happen at every
step. Knowing precisely what will happen if you change a couple of variables is
often like knowing whether another gymnast is going to catch your arms after
you come out of a somersault. If you are on a team with code that clear, you are
in a  better position than most programmers. In my work, I’ve noticed  that
teams with that degree of clarity in all of their code are rare. They seem like a
statistical anomaly. And, you know what? If they don’t have supporting tests,
their code changes still appear to be slower than those of teams that do. 
Yes, teams do get better and start to write clearer code, but it takes a long
time for older code to get clearer. In many cases, it will never happen com-
pletely. Because of this, I have no problem defining legacy code as code without
tests. It is a good working definition, and it points to a solution.
I’ve been talking about tests quite a bit so far, but this book is not about test-
ing. This book is about being able to confidently make changes in any code
Code without tests is bad code. It doesn’t matter how well written it is; it doesn’t mat-
ter how pretty or object-oriented or well-encapsulated it is. With tests, we can change
the behavior of our code quickly and verifiably. Without them, we really don’t know
if our code is getting better or worse. 
P
REFACE
xvii
base. In the following chapters, I describe techniques that you can use to under-
stand code, get it under test, refactor it, and add features.
One thing that you will notice as you read this book is that it is not a book
about pretty code. The examples that I use in the book are fabricated because I
work under nondisclosure agreements with clients. But in many of the exam-
ples, I’ve tried to preserve the spirit of code that I’ve seen in the field. I won’t
say that the examples are always representative. There certainly are oases of
great code out there, but, frankly, there are also pieces of code that are far
worse than anything I can use as an example in this book. Aside from client
confidentiality, I simply couldn’t put code like that in this book without boring
you to tears and burying important points in a morass of detail. As a result,
many of the examples are relatively brief. If you look at one of them and think
“No, he doesn’t understand—my methods are much larger than that and much
worse,” please look at the advice that I am giving at face value and see if it
applies, even if the example seems simpler. 
The techniques here have been tested on substantially large pieces of code. It
is just a limitation of the book format that makes examples smaller. In particu-
lar, when you see ellipses (…) in a code fragment like this, you can read them as
“insert 500 lines of ugly code here”:
m_pDispatcher->register(listener);
...
m_nMargins++;
If this book is not about pretty code, it is even less about pretty design. Good
design should be a goal for all of us, but in legacy code, it is something that we
arrive at in discrete steps. In some of the chapters, I describe ways of adding
new code to existing code bases and show how to add it with good design prin-
ciples in mind. You can start to grow areas of very good high-quality code in
legacy code bases, but don’t be surprised if some of the steps you take to make
changes involve making some code slightly uglier. This work is like surgery. We
have to make incisions, and we have to move through the guts and suspend
some aesthetic judgment. Could this patient’s major organs and viscera be bet-
ter than they are? Yes. So do we just forget about his immediate problem, sew
him up again, and tell him to eat right and train for a marathon? We could, but
what we really need to do is take the patient as he is, fix what’s wrong, and
move him to a healthier state. He might never become an Olympic athlete, but
we can’t let “best” be the enemy of “better.” Code bases can become healthier
and easier to work in. When a patient feels a little better, often that is the time
when you can help him make commitments to a healthier life style. That is
what we are shooting for with legacy code. We are trying to get to the point at
xviii
P
REFACE
which we are used to ease; we expect it and actively attempt to make code
change easier. When we can sustain that sense on a team, design gets better.
The  techniques  I describe are ones that I’ve discovered and learned with
coworkers and clients over the course of years working with clients to try to
establish control over unruly code bases. I got into this legacy code emphasis
accidentally. When I first started working with Object Mentor, the bulk of my
work involved  helping teams with serious problems develop their skills and
interactions to the point that they could regularly deliver quality code. We often
used Extreme Programming practices to help teams take control of their work,
collaborate intensively, and deliver. I often feel that Extreme Programming is
less a way to develop software than it is a way to make a well-jelled work team
that just happens to deliver great software every two weeks.
From the beginning, though, there was a problem. Many of the first XP
projects were “greenfield” projects. The clients I was seeing had significantly
large code bases, and they were in trouble. They needed some way to get con-
trol of their work and start to deliver. Over time, I found that I was doing the
same things over and over again with clients. This sense culminated in some
work I was doing  with a team in the financial  industry. Before I’d arrived,
they’d realized that unit testing was a great thing, but the tests that they were
executing were full scenario tests that made multiple trips to a database and
exercised large chunks of code. The tests were hard to write, and the team
didn’t run them very often because they took so long to run. As I sat down with
them to break dependencies and get smaller chunks of code under test, I had a
terrible sense of déjà vu. It seemed that I was doing this sort of work with every
team I met, and it was the sort of thing that no one really wanted to think
about. It was just the grunge work that you do when you want to start working
with your code in a controlled way, if you know how to do it. I decided then
that it was worth really reflecting on how we were solving these problems and
writing them down so that teams could get a leg up and start to make their code
bases easier to live in.
A note about the examples: I’ve used examples in several different program-
ming languages. The bulk of the examples are written in Java, C++, and C. I
picked Java because it is a very common language, and I included C++ because it
presents some special challenges in a legacy environment. I picked C because it
highlights many of the problems that come up in procedural legacy code. Among
them, these languages cover much of the spectrum of concerns that arise in leg-
acy code. However, if the languages you use are not covered in the examples,
take a look at them anyway. Many of the techniques that I cover can be used in
other languages, such as Delphi, Visual Basic, COBOL, and FORTRAN. 
P
REFACE
xix
I hope that you find the techniques in this book helpful and that they allow
you to get back to what is fun about programming. Programming can be very
rewarding and enjoyable work. If you don’t feel that in your day-to-day work, I
hope that the techniques I offer you in this book help you find it and grow it on
your team.
Acknowledgments
First of all, I owe a serious debt to my wife, Ann, and my children, Deborah
and Ryan. Their love and support made this book and all of the learning that
preceded it possible. I’d also like to thank “Uncle Bob” Martin, president and
founder of Object Mentor. His rigorous pragmatic approach to development
and design, separating the critical from the inconsequential, gave me something
to latch upon about 10 years ago, back when it seemed that I was about to
drown in a wave of unrealistic advice. And thanks, Bob, for giving me the
opportunity to see more code and work with more people over the past five
years than I ever imagined possible.
I also have to thank Kent Beck, Martin Fowler, Ron Jeffries, and Ward Cun-
ningham for offering me advice at times and teaching me a great deal about
team work, design, and programming. Special thanks to all of the people who
reviewed the drafts. The official reviewers were Sven Gorts, Robert C. Martin,
Erik Meade, and Bill  Wake; the unofficial reviewers  were  Dr.  Robert Koss,
James Grenning, Lowell Lindstrom, Micah Martin, Russ Rufer and the Silicon
Valley Patterns Group, and James Newkirk.
Thanks also to reviewers of the very early drafts I placed on the Internet.
Their feedback significantly affected the direction of the book after I reorga-
nized its format. I apologize in advance to any of you I may have left out. The
early  reviewers were:  Darren  Hobbs, Martin Lippert,  Keith Nicholas,  Phlip
Plumlee, C. Keith Ray, Robert Blum, Bill Burris, William Caputo, Brian Mar-
ick,  Steve  Freeman,  David  Putman,  Emily  Bache, Dave  Astels, Russel  Hill,
Christian Sepulveda, and Brian Christopher Robinson.
Thanks also to Joshua Kerievsky who gave a key early review and Jeff Langr
who helped with advice and spot reviews all through the process. 
The reviewers helped me polish the draft considerably, but if there are errors
remaining, they are solely mine.
Thanks to Martin Fowler, Ralph Johnson, Bill Opdyke, Don Roberts, and
John Brant for their work in the area of refactoring. It has been inspirational.
Documents you may be interested
Documents you may be interested