open pdf file in c# : How to add text field to pdf SDK Library project winforms asp.net azure UWP 01311770522-part66

xx
P
REFACE
I also owe a special debt to Jay Packlick, Jacques Morel, and Kelly Mower of
Sabre Holdings, and Graham Wright of Workshare Technology for their support
and feedback.
Special thanks also to Paul Petralia, Michelle Vincenti, Lori Lyons, Krista
Hansing, and the rest of the team at Prentice-Hall. Thank you, Paul, for all of
the help and encouragement that this first-time author needed.
Special thanks also to Gary and Joan Feathers, April Roberts, Dr. Raimund
Ege, David Lopez de Quintana, Carlos Perez, Carlos M. Rodriguez, and the late
Dr. John C. Comfort for help and encouragement over the years. I also have to
thank Brian Button for the example in Chapter 21, I’m Changing the Same
Code All Over the Place. He wrote that code in about an hour when we were
developing a refactoring course together, and it’s become my favorite piece of
teaching code.
Also, special thanks to Janik Top, whose instrumental De Futura served as
the soundtrack for my last few weeks of work on this book.
Finally, I’d like to thank everyone whom I’ve worked with over the past few
years whose insights and challenges strengthened the material in this book.
Michael Feathers
mfeathers@objectmentor.com
www.objectmentor.com
www.michaelfeathers.com
How to add text field to 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
how to insert text into a pdf with acrobat; add text pdf acrobat
How to add text field to 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
adding text to a pdf in acrobat; adding text pdf
xxi
Introduction
How to Use This Book
I tried several different formats before settling on the current one for this book.
Many of the different techniques and practices that are useful when working
with legacy code are hard to explain in isolation. The simplest changes often go
easier if you can find seams, make fake objects, and break dependencies using a
couple of dependency-breaking techniques. I decided that the easiest way to
make the book approachable and handy would be to organize the bulk of it
(Part  II,  Changing  Software)  in  FAQ  (frequently  asked  questions)  format.
Because specific techniques often require the use of other techniques, the FAQ
chapters are heavily interlinked. In nearly every chapter, you’ll find references,
along with page numbers, for other chapters and sections that describe particu-
lar techniques and  refactorings.  I apologize if  this  causes you to flip  wildly
through  the  book as you attempt to  find  answers  to your  questions,  but  I
assumed that you’d rather do that than read the book cover to cover, trying to
understand how all the techniques operate.
In Changing Software, I’ve  tried  to  address very common  questions that
come up in legacy code work. Each of the chapters is named after a specific
problem. This does make the chapter titles rather long, but hopefully, they will
allow you to quickly find a section that helps you with the particular problems
you are having.
Changing Software is bookended by a set of introductory chapters (Part I,
The Mechanics of Change) and a catalog of refactorings, which are very useful
in legacy code work (Part III, Dependency-Breaking Techniques). Please read
the  introductory  chapters,  particularly  Chapter  4,  The  Seam  Model.  These
chapters provide the context and nomenclature for all the techniques that fol-
low. In addition, if you find a term that isn’t described in context, look for it in
the Glossary.
The refactorings in Dependency-Breaking Techniques are special in that they
are meant to be done without tests, in the service of putting tests in place. I
encourage you to read each of them so that you can see more possibilities as
you start to tame your legacy code.
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Insert images into PDF form field. Access to freeware download and online C#.NET class source code. How to insert and add image, picture, digital photo, scanned
how to add text field to pdf; adding text box to pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
Insert images into PDF form field in VB.NET. with this sample VB.NET code to add an image PDFDocument = New PDFDocument(inputFilePath) ' Get a text manager from
how to add text to a pdf document; add text to pdf acrobat
3
Changing 
Software
Chapter 1
Changing Software
Changing code is great. It’s what we do for a living. But there are ways of
changing code that make life difficult, and there are ways that make it much
easier. In the industry, we haven’t spoken about that much. The closest we’ve
gotten is the literature on refactoring. I think we can broaden the discussion a
bit and talk about how to deal with code in the thorniest of situations. To do
that, we have to dig deeper into the mechanics of change.
Four Reasons to Change Software
For simplicity’s sake, let’s look at four primary reasons to change software. 
1. Adding a feature
2. Fixing a bug
3. Improving the design
4. Optimizing resource usage
Adding Features and Fixing Bugs
Adding a feature seems like the most straightforward type of change to make.
The software behaves one way, and users say that the system needs to do some-
thing else also. 
Suppose that we are working on a web-based application, and a manager
tells us that she wants the company logo moved from the left side of a page to
the right side. We talk to her about it and discover it isn’t quite so simple. She
wants to move the logo, but she wants other changes, too. She’d like to make it
animated for the next release. Is this fixing a bug or adding a new feature? It
depends on your point of view. From the point of view of the customer, she is
definitely asking us to fix a problem. Maybe she saw the site and attended a
VB.NET PDF Text Extract Library: extract text content from PDF
With this advanced PDF Add-On, developers are able to extract target text content from source PDF document and save extracted text to other file formats
how to enter text in pdf file; how to insert pdf into email text
C# PDF Text Extract Library: extract text content from PDF file in
How to C#: Extract Text Content from PDF File. Add necessary references: RasterEdge.Imaging.Basic.dll. RasterEdge.Imaging.Basic.Codec.dll.
how to add text box to pdf; add text to pdf online
4
C
HANGING
S
OFTWARE
Four Reasons
to Change
Software
meeting with people in her department, and they decided to change the logo
placement and ask for a bit more functionality. From a developer’s point of
view,  the  change  could  be  seen  as  a  completely  new  feature.  “If  they  just
stopped changing their minds, we’d be done by now.” But in some organiza-
tions the logo move is seen as just a bug fix, regardless of the fact that the team
is going to have to do a lot of fresh work.
It is tempting to say that all of this is just subjective. You see it as a bug fix,
and I see it as a feature, and that’s the end of it. Sadly, though, in many organi-
zations, bug fixes and features have to be tracked and accounted for separately
because of contracts or quality initiatives. At the people level, we can go back
and forth endlessly about whether we are adding features or fixing bugs, but it
is all just changing code and other artifacts. Unfortunately, this talk about bug-
fixing and feature addition masks something that is much more important to us
technically: behavioral change. There is a big difference between adding new
behavior and changing old behavior. 
In  the  company  logo  example,  are  we  adding  behavior?  Yes.  After  the
change, the system will display a logo on the right side of the page. Are we get-
ting rid of any behavior? Yes, there won’t be a logo on the left side.
Let’s look at a harder case. Suppose that a customer wants to add a logo to
the right side of a page, but there wasn’t one on the left side to start with. Yes,
we are adding behavior, but are we removing any? Was anything rendered in
the place where the logo is about to be rendered? 
Are we changing behavior, adding it, or both?
It turns out that, for us, we can draw a distinction that is more useful to us as
programmers. If we have to modify code (and HTML kind of counts as code),
we could be changing behavior. If we are only adding code and calling it, we are
often adding behavior. Let’s look at another example. Here is a method on a
Java class:
public class CDPlayer
{
public void addTrackListing(Track track) {
...
}
...
}
The  class  has  a method  that  enables  us  to  add track  listings. Let’s  add
another method that lets us replace track listings.
Behavior is the most important thing about software. It is what users depend on.
Users like it when we add behavior (provided it is what they really wanted), but if we
change or remove behavior they depend on (introduce bugs), they stop trusting us.
VB.NET PDF Password Library: add, remove, edit PDF file password
VB: Add Password to PDF with Permission Settings Applied. This VB.NET example shows how to add PDF file password with access permission setting.
adding text to pdf online; how to insert text into a pdf file
C# PDF Password Library: add, remove, edit PDF file password in C#
C# Sample Code: Add Password to PDF with Permission Settings Applied in C#.NET. This example shows how to add PDF file password with access permission setting.
how to add text to a pdf document using acrobat; adding text to a pdf document
F
OUR
R
EASONS
TO
C
HANGE
S
OFTWARE
5
Four Reasons 
to Change 
Software
public class CDPlayer
{
public void addTrackListing(Track track) {
...
}
public void replaceTrackListing(String name, Track track) {
...
}
...
}
When we added that method, did we add new behavior to our application or
change it? The answer is: neither. Adding a method doesn’t change behavior
unless the method is called somehow.
Let’s make another code change. Let’s put a new button on the user interface
for the CD player. The button lets users replace track listings. With that move,
we’re adding the behavior we specified in replaceTrackListing method, but we’re
also subtly changing behavior. The UI will render differently with that new but-
ton. Chances are, the UI will take about a microsecond longer to display. It
seems nearly impossible to add behavior without changing it to some degree. 
Improving Design
Design improvement is a different kind of software change. When we want to
alter software’s structure to make it more maintainable, generally we want to
keep its behavior intact also. When we drop behavior in that process, we often
call that a bug. One of the main reasons why many programmers don’t attempt
to improve design often is because it is relatively easy to lose behavior or create
bad behavior in the process of doing it.
The act of improving design without changing its behavior is called refactor-
ing. The idea behind refactoring is that we can make software more maintain-
able without changing behavior if we write tests to make sure that existing
behavior doesn’t change and take small steps to verify that all along the pro-
cess. People have been cleaning up code in systems for years, but only in the last
few years has refactoring taken off. Refactoring differs from general cleanup in
that we aren’t just doing low-risk things such as reformatting source code, or
invasive and risky things such as rewriting chunks of it. Instead, we are making
a series of small structural modifications, supported by tests to make the code
easier to change. The key thing about refactoring from a change point of view is
that there  aren’t supposed  to be  any functional changes  when you refactor
(although behavior can change somewhat because the structural changes that
you make can alter performance, for better or worse).
VB.NET PDF Field Edit library: insert, delete, update pdf form
By using RaterEdge .NET PDF package, you can add form fields to existing pdf files, delete or remove form field in PDF page and update PDF field in VB.NET
how to add text to pdf; add text to pdf document online
VB.NET PDF Text Add Library: add, delete, edit PDF text in vb.net
Data: Auto Fill-in Field Data. Field: Insert, Delete, Update Field. Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note.
add text to pdf document online; how to add text to a pdf document using reader
6
C
HANGING
S
OFTWARE
Four Reasons
to Change
Software
Optimization
Optimization is like refactoring, but when we do it, we have a different goal.
With both refactoring and optimization, we say, “We’re going to keep function-
ality exactly the same when we make changes, but we  are going to change
something else.” In refactoring, the “something else” is program structure; we
want to make it easier to maintain. In optimization, the “something else” is
some resource used by the program, usually time or memory.
Putting It All Together
It might seem strange that refactoring and optimization are kind of similar.
They seem much closer to each other than adding features or fixing bugs. But is
this really true? The thing that is common between refactoring and optimiza-
tion is that we hold functionality invariant while we let something else change. 
In general, three different things can change when we do work in a system:
structure, functionality, and resource usage.
Let’s look at what usually changes and what stays more or less the same
when we make four different kinds of changes (yes, often all three change, but
let’s look at what is typical):
Superficially, refactoring and optimization do look very similar. They hold
functionality invariant. But what happens when we account for new functional-
ity separately? When we add a feature often we are adding new functionality,
but without changing existing functionality.
Adding a Feature
Fixing a Bug
Refactoring
Optimizing
Structure
Changes
Changes
Changes
Functionality
Changes
Changes
Resource Usage
Changes
Adding a Feature
Fixing a Bug
Refactoring
Optimizing
Structure
Changes
Changes
Changes
New
Functionality
Changes
Functionality
Changes
Resource Usage
Changes
C# PDF Field Edit Library: insert, delete, update pdf form field
Able to add text field to specified PDF file position in C#.NET class. Support to change font size in PDF form. Able to delete form fields from adobe PDF file.
add text pdf professional; adding text to pdf in acrobat
C# PDF Text Add Library: add, delete, edit PDF text in C#.net, ASP
Data: Auto Fill-in Field Data. Field: Insert, Delete, Update Field. Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note.
how to add text boxes to pdf; adding text to pdf online
R
ISKY
C
HANGE
7
Risky Change
Adding features, refactoring, and optimizing all hold existing functionality
invariant. In fact, if we scrutinize bug fixing, yes, it does change functionality,
but the changes are often very small compared to the amount of existing func-
tionality that is not altered. 
Feature addition and bug fixing are very much like refactoring and optimiza-
tion. In all four cases, we want to change some functionality, some behavior,
but we want to preserve much more (see Figure 1.1). 
Figure 1.1  Preserving behavior.
That’s a nice view of what is supposed to happen when we make changes,
but what does it mean for us practically? On the positive side, it seems to tell us
what we have to concentrate on. We have to make sure that the small number
of things that we change are changed correctly. On the negative side, well, that
isn’t the only thing we have to concentrate on. We have to figure out how to
preserve  the rest of the behavior. Unfortunately, preserving  it involves  more
than  just  leaving the code  alone.  We  have  to know  that  the behavior isn’t
changing, and that can be tough. The amount of behavior that we have to pre-
serve is usually very large, but that isn’t the big deal. The big deal is that we
often don’t know how much of that behavior is at risk when we make our
changes. If we knew, we could concentrate on that behavior and not care about
the rest. Understanding is the key thing that we need to make changes safely.
Risky Change
Preserving behavior is a large challenge. When we need to make changes and
preserve behavior, it can involve considerable risk.
Preserving existing behavior is one of the largest challenges in software development.
Even when we are changing primary features, we often have very large areas of
behavior that we have to preserve.
Existing Behavior
New Behavior
8
C
HANGING
S
OFTWARE
Risky Change
To mitigate risk, we have to ask three questions:
1. What changes do we have to make?
2. How will we know that we’ve done them correctly?
3. How will we know that we haven’t broken anything?
How much change can you afford if changes are risky?
Most teams that I’ve worked with have tried to manage risk in a very conser-
vative way. They minimize the number of changes that they make to the code
base. Sometimes this is a team policy: “If it’s not broke, don’t fix it.” At other
times, it isn’t anything that anyone articulates. The developers are just very cau-
tious when they make changes. “What? Create another method for that? No,
I’ll just put the lines of code right here in the method, where I can see them and
the rest of the code. It involves less editing, and it’s safer.” 
It’s tempting to think that we can minimize software problems by avoiding
them, but, unfortunately, it always catches up with us. When we avoid creating
new classes and methods, the existing ones grow larger and harder to under-
stand. When you make changes in any large system, you can expect to take a
little time to get familiar with the area you are working with. The difference
between good systems and bad ones is that, in the good ones, you feel pretty
calm after you’ve done that learning, and you are confident in the change you
are about to make. In poorly structured code, the move from figuring things out
to making changes feels like jumping off a cliff to avoid a tiger. You hesitate and
hesitate. “Am I ready to do it? Well, I guess I have to.” 
Avoiding  change  has  other  bad  consequences.  When  people  don’t  make
changes often they get rusty at it. Breaking down a big class into pieces can be
pretty involved work unless you do it a couple of times a week. When you do, it
becomes routine. You get better at figuring out what can break and what can’t,
and it is much easier to do. 
The last consequence of avoiding change is fear. Unfortunately, many teams
live with incredible fear of change and it gets worse every day. Often they aren’t
aware of how much fear they have until they learn better techniques and the
fear starts to fade away. 
We’ve talked about how avoiding change is a bad thing, but what is our
alternative? One alternative is to just try harder. Maybe we can hire more peo-
ple so that there is enough time for everyone to sit and analyze, to scrutinize all
of the code and make changes the “right” way. Surely more time and scrutiny
will make change safer. Or will it? After all of that scrutiny, will anyone know
that they’ve gotten it right?
29
The Seam 
Model
Chapter 4
The Seam Model
One of the things that nearly everyone notices when they try to write tests for
existing code is just how poorly suited code is to testing. It isn’t just particular
programs or languages. In general, programming languages just don’t seem to
support testing very well. It seems that the only ways to end up with an easily
testable program are to write tests as you develop it or spend a bit of time trying
to “design for testability.” There is a lot of hope for the former approach, but if
much of the code in the field is evidence, the latter hasn’t been very successful.
One thing that  I’ve noticed is that, in trying to get code under  test, I’ve
started to think about code in a rather different way. I could just consider this
some private quirk, but I’ve found that this different way of looking at code
helps me when I work in new and unfamiliar programming languages. Because
I won’t be able to cover every programming language in this book, I’ve decided
to outline this view here in the hope that it helps you as well as it helps me.
A Huge Sheet of Text
When I first started programming, I was lucky that I started late enough to have
a machine of my own and a compiler to run on that machine; many of my
friends starting programming in the punch-card days. When I decided to study
programming in school, I started working on a terminal in a lab. We could
compile our code remotely on a DEC VAX machine. There was a little account-
ing system in place. Each compile cost us money out of our account, and we
had a fixed amount of machine time each term. 
At that point in my life, a program was just a listing. Every couple of hours,
I’d walk from the lab to the printer room, get a printout of my program and
scrutinize it, trying to figure out what was right or wrong. I didn’t know enough
to care much about modularity. We had to write modular code to show that we
could do it, but at that point I really cared more about whether the code was
30
T
HE
S
EAM
M
ODEL
Seams
going to produce the right answers. When I got around to writing object-ori-
ented code, the modularity was rather academic. I wasn’t going to be swapping
in one class for another in the course of a school assignment. When I got out in
the industry, I started to care a lot about those things, but in school, a program
was just a listing to me, a long set of functions that I had to write and under-
stand one by one.
This view of a program as a listing seems accurate, at least if we look at how
people behave in  relation to programs that  they write. If we knew nothing
about what programming was and we saw a room full of programmers work-
ing, we might think that they were scholars inspecting and editing large impor-
tant documents. A program can seem like a large sheet of text. Changing a little
text can cause the meaning of the whole document to change, so people make
those changes carefully to avoid mistakes.
Superficially, that is all true, but what about modularity? We are often told it
is better to write programs that are made of small reusable pieces, but how
often are small pieces reused independently? Not very often. Reuse is tough.
Even when pieces of software look independent, they often depend upon each
other in subtle ways. 
Seams
When you start to try to pull out individual classes for unit testing, often you
have to break a lot of dependencies. Interestingly enough, you often have a lot
of work to do, regardless of how “good” the design is. Pulling classes out of
existing projects for testing really changes your idea of what “good” is with
regard to design. It also leads you to think of software in a completely different
way. The idea of a program as a sheet of text just doesn’t cut it anymore. How
should we look at it? Let’s take a look at an example, a function in C++.
bool CAsyncSslRec::Init()
{
if (m_bSslInitialized) {
return true;
}
m_smutex.Unlock();
m_nSslRefCount++;
m_bSslInitialized = true;
FreeLibrary(m_hSslDll1);
m_hSslDll1=0;
FreeLibrary(m_hSslDll2);
Documents you may be interested
Documents you may be interested