asp.net pdf viewer devexpress : No pdf thumbnails in application control utility html web page asp.net visual studio Team-Foundation-Server-Branching-Guidance-031620070-part2025

Team Foundation Server Branching Guidance 
John Jacob, Mario Rodriguez, and Graham Barry 
Microsoft Corporation 
No pdf thumbnails in - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
pdf thumbnails in; how to create a thumbnail of a pdf document
No pdf thumbnails in - VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
generate pdf thumbnails; pdf thumbnail fix
Contents 
Introduction ............................................................................................................................................................................................ 4
Parallel Development .......................................................................................................................................................................... 4
Branching Defined ............................................................................................................................................................................... 5
Creating Isolation in Team Foundation Server ......................................................................................................................... 5
Isolation at Individual Level ......................................................................................................................................................... 5
Isolation for Collaboration ........................................................................................................................................................... 6
Branching ....................................................................................................................................................................................... 6
Merging........................................................................................................................................................................................... 7
Branching Scenarios ................................................................................................................................................................... 9
General Branching Structure Guidance .................................................................................................................................... 10
Branching Checklist ................................................................................................................................................................. 10
Branching Strategies ........................................................................................................................................................................ 12
Broad Areas of Branching Isolation ............................................................................................................................................ 13
Creating Your Branching Strategy .............................................................................................................................................. 14
Single Release Scenario ......................................................................................................................................................... 14
Multiple Release Scenario ..................................................................................................................................................... 15
Multiple Feature/Team Scenarios: ..................................................................................................................................... 15
Defining Your Code Promotion Model ..................................................................................................................................... 16
Code Promotion Criteria............................................................................................................................................................ 18
Quality Gates .................................................................................................................................................................................. 18
Forward/Reverse Integration ................................................................................................................................................... 18
Code Promotion Best Practices .............................................................................................................................................. 19
Baseless Merges ............................................................................................................................................................................ 19
Feature Crews: How Microsoft Does It ..................................................................................................................................... 21
Feature Crew and Feature Defined........................................................................................................................................ 22
Team Composition & Values: .................................................................................................................................................. 23
End-to-End Branching Implementation: .................................................................................................................................. 24
Step1 – Deciding on a Team Project structure ................................................................................................................. 25
Step2 – Deciding on a branch structure ............................................................................................................................. 25
Step3- Following a release on paper .................................................................................................................................... 27
C# Image: Tutorial for Document Viewing & Displaying in ASP.NET
the Viewer with the Thumbnails, type WebAnnotationViewer1 Add No-Postback Navigation Controls to Viewer. Add & profession imaging controls, PDF document, tiff
enable thumbnail preview for pdf files; how to make a thumbnail from pdf
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
Using this .NET PDF to TIFF conversion control, C# developers can render and convert PDF document to TIFF image file with no loss in original file quality.
pdf first page thumbnail; show pdf thumbnails
Scenario 1: Releasing a Beta for Release 2 .................................................................................................................... 27
Scenario 2: Releasing 1.1 and merging some code fixes to Release 2 ............................................................... 29
Scenario 3: Sustained Engineering: Maintenance Activities on Releases .......................................................... 31
Step 4- Creating the physical structure ............................................................................................................................... 32
Appendix ............................................................................................................................................................................................... 33
Software Configuration Management ................................................................................................................................. 33
Branching and Merging Anti-Patterns ................................................................................................................................. 33
Branching in Team Foundation Server vs. Sharing in Visual SourceSafe ............................................................... 34
Labeling vs. Branching ................................................................................................................................................................ 34
Branching and Compliance ...................................................................................................................................................... 35
Identifying Environments .......................................................................................................................................................... 35
Virtual Build Labs .......................................................................................................................................................................... 36
VB.NET Image: VB Tutorial to View Document Online with Imaging Web
including png, jpeg, gif, tiff, bmp, PDF, Microsoft Word How to add no-postback navigation controls to your Connect your viewer with the thumbnails by setting
html display pdf thumbnail; create pdf thumbnail image
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
File: Compress PDF. Page: Create Thumbnails. Page: Insert PDF Pages. Page: Delete Existing PDF Pages. Export PDF from Excel with cell border or no border.
pdf thumbnail preview; pdf thumbnail generator online
Introduction 
As you adopt Team Foundation Server in your organization, there are some things that you just need to 
dive in and learn by doing, and there are other things that you need to research and plan for because 
decisions that you make in these areas can have a big impact down the road.  This paper is intended to 
provide some advice on one of those areas, branching and merging of software.   
Branching and merging of software is a very large topic, and it’s an area where there is a lot of maturity in 
the software industry.  Established software organizations have been evolving branching and merging 
practices for many years, and there is a lot of wisdom out there that people in our industry have 
shared. Similar to the spirit of design patterns, there are documented branching patterns that cover just 
about any scenario that you could conceive of.  This paper is intended to be a primer of these concepts, 
and is intended to be a practical introduction to branching and merging for organizations adopting or 
thinking about adopting Team Foundation Server.  This is not meant to be a comprehensive source on 
this large and intriguing topic area.  Once you have read this paper and want to get more viewpoints and 
dig deeper, please visit www.cmcrossroads.com
.  This site includes detailed papers which go very deep 
into Software Configuration Management topic areas including branching and merging.  We have also 
included some specific links at the end of this paper.   
There are certain concepts in this paper that are relevant to teams of all sizes, some that will be more 
relevant to smaller teams (around 20 or fewer developers), and some that will be more relevant for larger 
teams (20 to 1,000 developers).  There is additional guidance for extremely large teams (thousands of 
developers) which we will touch on in the appendix (Virtual Build Labs).  We will address some concepts in 
the first couple of chapters that are relevant to teams of all sizes, then we get into advice specific to 
smaller teams, then we cover advice for larger teams, and finally tie it all together with the final section 
intended for all teams.   
Parallel Development  
The desire to enable parallel development is the primary reason that branching and merging was created.  
Parallel development is a practice which enables development teams working on different areas of the 
same software project to work simultaneously while minimizing the chance of conflicting changes, thus 
minimizing wasted effort due to rework or defect resolution.  Here are some examples of parallel 
development: 
Example 1: 
A team of 40 developers is building  an application.  There are four feature teams, each led by a 
development lead. The feature teams vary in size from two developers to fifteen developers.  The 
milestones for each feature area also vary.  There needs to be a mechanism to provide isolation to each of 
the feature teams while allowing for changes to the common areas of the application in a reliable and 
controlled fashion.  Branching is a very good solution here; this is referred to in this document as 
Branching for Feature Team Isolation. 
Example 2: 
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Merge all Excel sheets to one PDF file. Export PDF from Excel with cell border or no border. Free online Excel to PDF converter without email.
pdf thumbnail generator; enable pdf thumbnail preview
C# HTML5 PDF Viewer SDK deployment on IIS in .NET
name”, and set the “Physical path” to the place where you store XDoc.PDF.HTML5 Viewer 2. The site configured in IIS has no sufficient authority to operate
create thumbnail from pdf c#; pdf files thumbnails
A development team has just gone live with the first release of a Web site.  The development team has 
started working on the next version of the site, but a critical bug is found by an important customer on 
the live site.  A strategy needs to be introduced to allow the core development team to continue evolving 
the next version of the site while bug fixes can be made for maintenance of the released site.  There needs 
to be a mechanism to isolate these two work streams.  This is referred to in this document as Branching 
for Maintenance.  
From these examples, it is easy to generalize parallel development as being either: 
Development activity on the same code base, implementing different features or bug fixes 
Development activity on different releases of the same software code base. 
The key necessity for parallel development is a mechanism by which code can be isolated and stabilized 
without the danger of cross-contamination of other ongoing development, and a mechanism by which 
such isolated changes in one branch can be integrated back into other development branches. 
Branching Defined 
Branching enables parallel development by providing each development endeavor (bug fix, feature 
development, stabilization of code, etc.) its own, self contained snapshot of needed sources, tools, 
external dependencies and process automation.  Such a self-contained snapshot effectively enables each 
development activity to proceed at its own pace, without taking any dependency on another. It follows 
that these snapshots are allowed to diverge their respective sources along the particular development 
activity they are involved with – fixing a bug, implementing a feature or stabilizing a breaking change. 
Branching typically involves: 
1.
Taking a snapshot of source code to create isolation – a snapshot may be as of a certain point in 
time, or a stable or known state of source code (such as the last successful build). The resulting 
copy is the child branch, and the source from which it was created is called the parent branch. 
2.
Containing and stabilizing changes within the isolated snapshot in the child branch. 
3.
Bi-directional synchronization of changes with the parent branch – usually referred to as 
integrating or merging.  We will explain why this is important later in this document. 
Creating Isolation in Team Foundation Server 
As noted above, there is a need for an isolation mechanism and a merging mechanism – both of which 
can be addressed by functionality found in Team Foundation Server.  First, let’s discuss some isolation 
mechanisms available in Team Foundation Server. 
Isolation at Individual Level 
In case you need code isolation on an individual basis – that is, as a developer you need to work on 
different states or snapshots of a given source code-base, you can effectively use Team Foundation 
Server’s capabilities for creating multiple workspaces off the same source code. Workspaces are your 
C# Image: Create C#.NET Windows Document Image Viewer | Online
C# Windows Document Image Viewer Features. No need for multiple document & image formats (PDF, MS Word Easy to create high-quality image thumbnails & automatic
print pdf thumbnails; pdf thumbnail creator
VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
name”, and set the “Physical path” to the place where you store XDoc.PDF.HTML5 Viewer 2. The site configured in IIS has no sufficient authority to operate
pdf reader thumbnails; can't see pdf thumbnails
client-side mappings of source code onto your local disk – see Working with Source Control Workspaces
 
You can have several such mappings on your local hard disk, each synchronized to a different state. For 
example, a workspace might be mapped to the label of the last successful build, or the latest versions of 
files on server. Each such workspace provides you the isolation for you to make changes without the 
dangers of cross-contamination between workspaces. This is because Team Foundation Server tracks 
changes (check outs, pending changes, edits, etc.) specific to each of your workspaces, no matter how 
many instances you have created.  And, by virtue of having the workspaces mapped to the server, you 
implicitly have a way to merge your changes onto the server by checking in the pending changes in each 
of the given workspaces. In case you have to switch between workspaces and are not ready to check in 
your pending edits, you can safely put away your changes as a shelveset using Team Foundation Server’s 
Shelving
feature.  
Isolation for Collaboration 
While workspaces provide the necessary isolation for different states or phases of coding on your 
individual local disk space, modern software development is more often than not a team effort. As such, 
we also need to address the need for isolation at a team level – that is, where two or more developers 
need to collaborate on a fix, feature, or breaking change, without risking the stability of source code that 
other developers are actively working on. This is where Team Foundation Server’s rich branching 
functionality comes into play. 
Branching 
Team Foundation Server defines branching as a feature that allows a collection of files to evolve in two or 
more divergent paths. Branching is unique in that it’s the only isolation mechanism that provides for 
collaboration amongst a group of people and versioning of changes within that isolated space.  
Team Foundation Server branches in "path space," which is analogous to copying a folder in Windows 
Explorer.  However, unlike copying, branching maintains the history relating the source to the target to 
allow merging future changes. 
Because branches in Team Foundation Server create new copies, they are easy to navigate; in fact 
branches appear in the Source Control Explorer just like the source items.  It also makes it very easy to 
simultaneously work on as many branches of the same code base as you need - just grab that folder as 
you would any other folder. 
When it comes to maintaining permissions for branches, it's easy to set permissions on any folder in the 
server.  Branches are regular paths and use the same path-based permission access control as any other 
folder in your source tree.  Open Source Control Explorer, navigate to the folder, right click on it, choose 
Properties from the popup menu, and click on the Security tab.  From the command line, you can use the 
permissions
command. 
Creating branches uses very little additional storage space.  The server minimizes the storage required by 
only keeping one copy of identical content no matter how many different files are contained in the folder.  
So, if you have 100 copies of a 1 MB file and all of the files are identical, the server will store only 1 MB, 
not 100 MB.  When you create a new branch and commit, all of the files in the new branch that are 
VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.
this PDF Document reorganizing SDK, you are able to reorder the whole PDF document pages or just adjust position of certain PDF document page. No matter which
view pdf thumbnails; create thumbnail jpeg from pdf
VB.NET Image: Program for Creating Thumbnail from Documents and
document and image formats, such as PDF, TIFF, GIF through simple VB.NET programming and no additional image Thumbnails are resized images that are not only
.pdf printing in thumbnail size; pdf thumbnail
identical to the files in the source branch point to the same content.  The result is that a branch consumes 
very little additional storage space, and that storage space expands only when the branched file becomes 
different than the source. And even when files change, Team Foundation Server employs a differencing 
engine to analyze changes between files and once again optimize storage space. 
To create a branch, you can choose to branch by date, label, workspace version (i.e., the versions you last 
retrieved into your workspace), or the latest server version.  Furthermore, you can mix and match as 
needed.  For example, you can branch one folder based on a date and another folder based on the latest 
version of its items. 
Here is how to create a branch of the latest version of the source code: 
For more detailed documentation on branching with Team Foundation Server see: Branching and Merging 
Team Foundation Source Control
Merging 
Merging is the logical corollary to branching in Team Foundation Server. Merging in version control is the 
process of combining changes that have transpired in two distinct branches. A merge operation takes 
changes that have occurred in the source branch and integrates them into the target branch. Merging 
integrates all types of changes in the source branch including name changes, file edits, file additions, file 
deletions, and undeletions. The merge engine is able to do this because Team Foundation Server keeps a 
record of all changes including the relationships of a child branch to the parent branch. 
If items are modified in both the source and target branches, a version conflict will be filed and you will be 
prompted to resolve those conflicts.  
Once you have created a branch, moving changes from the source branch to the target branch or from 
the target branch back to the source branch is very easy.  Team Foundation Server maintains the 
relationships of branched items and the merge history. 
When merging across branches, all of the changes that have been made in the source and target 
branches are merged. This includes additions, deletions, undeletions, and moves (which is effectively a 
rename operation).  For example, if an item in the source branch has been renamed from A.TXT to B.TXT, 
when performing a merge that change will also rename the corresponding item in the target branch. 
For files where you have made changes to both the source and the target, merging the changes will result 
in conflicts.  These conflicts are maintained by the server, and the client provides a dialog (both from the 
command line and Visual Studio) that shows the conflicts and leads you through the process of resolving 
them.  For each conflict, you need to choose whether to accept the source or target changes or a 
combination of them.  If there are edits to the file, you can choose to have the changes merged for you 
automatically.  If the changes cannot be merged automatically or you would like to manually merge the 
files, the conflict resolution dialog will launch a graphical three-way merge tool. 
As mentioned with branching, your merge becomes a set of pending changes that are contained within 
your workspace.  You can make additional changes to the result of the merge, such as changing or 
moving files or fixing build issues, before committing the merged changes.  The entire set of merged 
changes is committed atomically as a single changeset. 
Once a merge has been committed to the server, it becomes part of the merge history of the items 
involved.  The next time you need to merge a set of changes, Team Foundation Server will indicate which 
changes have not yet been merged.  You don't have to keep track of the merges - the system takes care 
of this for you.  At any time, you can get this information from either the command line or from the 
Source Control Explorer in Team Explorer. 
You can also choose what changesets you want to merge.  You may want to choose to merge only a 
subset of the changesets so that you can merge a single bug fix without merging all of the changes that 
occurred before it.  Knowing what change fixed a particular bug becomes simple with the integrated Work 
Item Tracking.  When a developer checks in a changeset, he or she can link that changeset to a relevant 
work item which might represent a bug or a feature.  So finding what changesets need to be merged to 
propagate a bug fix simply requires clicking on the Links tab of the work item to find the appropriate 
changeset or changesets to merge. 
Merging is a painless process within Team Explorer.  The Merge Wizard leads you through the steps of 
choosing which changes to merge, allowing you to merge every change since the last merge or to pick 
only particular changes.  In the Source Control Explorer, simply right-click on the folder from which you 
want to merge changes (the source of a branch).  Clicking the Merge item on the popup menu will bring 
up the Merge Wizard.  The Merge Wizard already knows what the possible targets are, so you simply 
select the target from a list (there's only one entry if you've only branched the folder once).  You can elect 
to merge all changes or just selected changes.  If you choose selected changes, you will be presented with 
changes that haven't yet been merged.  After selecting the changes to merge, click Finish, and you will 
have merges pending for each file involved.  Check in the merge when you are satisfied that it builds 
correctly.  That's all it takes to merge changes. 
It is worth noting that if you are merging only a subset of the available changesets the Merge Wizard will 
require that you select a consecutive range of changesets. If you wish to merge a non-consecutive subset 
of changesets you can do so by re-launching the Merge Wizard for each individual range of changesets. 
Branching Scenarios 
We’ve just been introduced to Team Foundation Server’s branching feature as an isolation mechanism for 
group collaboration in software development. Let’s now look at typical ways development activity can be 
grouped together to provide isolation: 
Release Isolation: If you need to work on multiple releases in parallel, you will probably want 
source code for those releases to be isolated in their own branch – hence release isolation.  This 
is the most common need that causes organizations to start branching their sources.  Keep in 
mind that the term ―release‖ here does not necessarily refer to a new version of your product.  It 
may be appropriate to release your application to your test team from a dedicated branch so that 
you can work through issues with that release independently from the new development that is 
continuing on your development branch. 
Feature Isolation: It is common for teams to embark on new functionality that is either 
considered experimental or is considered risky enough to merit that work being performed in its 
own branch.  In such cases, feature isolation allows the people working on a given feature to 
collaborate without exposing the rest of the application to any instability that may result. 
Team Isolation:  It is also common that organizations elect to have sub-teams work in isolation 
from each other.  Team isolation provides the ability for these teams to collaborate without 
being subjected to the potentially breaking changes that other teams are working on.  Some 
organizations go so far as to create a dedicated branch for every developer on the team. This is 
not required with Team Foundation Server because of the nature of client-side workspaces 
discussed earlier. 
Integration Isolation: Merging changes between branches is often a very destabilizing event.  It 
is sometimes beneficial to maintain an integration branch where active development does not 
take place but rather serves as a staging area for merges.  Changes from other branches can be 
merged into this branch and then stabilized.  Once stable, the changes can be merged back into 
the other branches. In some organization, the term ―breaking changes‖ refers to the potential 
destabilization bug fixes or merges can introduce – accordingly they provide for a ―breaking 
changes branch‖ to accommodate the need for integration isolation. 
The scenarios above are common to most software development organizations – the various levels of 
isolation requirements for each of these are capably addressed by Team Foundation Server’s rich and 
robust branching functionality.  On the other hand, we should also note that a common mistake that 
some organizations make is to over-branch.  The benefits of isolation, therefore, should be weighed with 
their costs so that you can make an appropriate decision about the amount of process overhead you’re 
willing to incur in your development.  The costs of branching can be broken down as follows: 
Merging:  Despite the benefits offered by isolation, the process of merging still involves a fair 
amount of effort to resolve potential conflicts and fix any new bugs which may arise from the 
merge operation. During a merge operation, you often require one or more people from your 
team to reconcile a set of conflicting changes that have been made in different branches.   
Latency: It takes time to move changes between branches.  A typical merge operation involves 
stabilizing the source branch (if it’s not already stable), executing the merge, resolving conflicting 
changes, and then stabilizing the target branch.  For small source bases, this can be done in 
minutes, but for large source bases it can take days.  If moving changes between isolation areas 
involves merging through multiple branches, it can begin to take weeks to move changes through 
the system. 
We will discuss many of these isolation mechanisms together with their costs in order to provide a 
balanced set of guidance for you to consider.. 
General Branching Structure Guidance 
So far we have seen how Team Foundation Server enables parallel development through its rich 
collaborative isolation mechanism – branching and merging. But in order to best leverage these 
capabilities we also need to establish a strategry for branching and merging operations. Just as you would 
organize a team of people based on activities, shared goals and outcomes, it helps to put some 
forethought and planning into the structure and organization of your branches in Team Foundation 
Server. 
Branching Checklist 
We recommend the following checklist for branch creation: 
1.
Choose an isolation model – which could be informed by the need for one or more of the 
following: 
i.
Consolidating common workflows with respect to your software development activities. 
This might include feature development, quality assurance, stabilization, release 
readiness, and sustained engineering. 
ii.
Features that are tightly coupled – have code that is inter-dependent and needs to be 
compiled together (sharing common headers, libraries, for example) and/or require 
binaries that have dependencies on each other at runtime. 
iii.
Providing well-demarcated areas of responsibility for development activity 
iv.
Ensuring strict inviolability, accountability and auditing of source code 
v.
Representing different phases of your development lifecycle 
2.
Define a code promotion path for development activity which defines how your parallel 
development activity eventually get integrated into the mainline branch. 
3.
Define a set of quality criteria that need to be met before code can be merged for promotion 
between branches. 
4.
Define the key stakeholders for each branch – these are people who will decide on granting 
permissions to users of the branch, control and regulate check-ins into that branch, and enforce 
the quality criteria you’ve defined for accepting merges to and from another branch. 
5.
Once #4 is decided, define the permissions for each branch – read, write, branch, label, etc. 
Documents you may be interested
Documents you may be interested