Visual Studio 2010 Best Practices
Peter Ritchie
Language: English
Pages: 280
ISBN: 1849687161
Format: PDF / Kindle (mobi) / ePub
Learn and implement recommended practices for the complete software development life cycle with Visual Studio 2010
* This book and e-book detail a large breadth of recommended practices in Visual Studio
* Consolidated reference of varied practices including background and detailed implementations, great for inexperienced and experience developers alike.
* A guidelines-based set of practices for all aspects of software development from architecture to specific technologies to deployment.
In Detail
When you are developing on the Microsoft platform, Visual Studio 2010 offers you a range of powerful tools and makes the whole process easier and faster. After learning it, if you are think that you can sit back and relax, you cannot be further away from truth. To beat the crowd, you need to be better than others, learn tips and tricks that other don't know yet. This book is a compilation of the best practices of programming with Visual Studio.
Visual Studio 2010 best practices will take you through the practices that you need to master programming with .NET Framework. The book goes on to detail several practices involving many aspects of software development with Visual Studio. These practices include debugging and exception handling and design. It details building and maintaining a recommended practices library and the criteria by which to document recommended practices.
The book begins with practices on source code control (SCC). It includes different types of SCC and discusses how to choose them based on different scenarios. Advanced syntax in C# is then covered with practices covering generics, iterator methods, lambdas, and closures.
The next set of practices focus on deployment as well as creating MSI deployments with Windows Installer XML (WiX)—including Windows applications and services. The book then takes you through practices for developing with WCF and Web Service.
The software development lifecycle is completed with practices on testing like project structure, naming, and the different types of automated tests. Topics like test coverage, continuous testing and deployment, and mocking are included. Although this book uses Visual Studio as example, you can use these practices with any IDE.
What you will learn from this book
* Learning source code control
* Practices for advanced C# syntax
* Asynchronous programming in C#
* Learn tips for architecting decoupled systems
* Practices for designing multi-threaded and parallel systems
* Practices for designing distributed systems
* Learn better ways of developing web services with WCF
* Learn faster ways to design automated tests
* Tips and tricks to test complex systems
* Understanding proven ways of deploying software systems in Windows
Approach
It will be a step-by-step tutorial that will discuss best practices. The book is structured in such a way that it can be read both from start to end or can dipped into.
Who this book is written for
.Net developers using Visual Studio for programming will find this book useful. If you are developing your application with C#, you will find better ways to do things with Visual Studio.
You should know basics of development with .Net Framework and need working knowledge on VIsual Studio
Excel Programming with VBA Starter
Android Apps for Absolute Beginners (2nd Edition)
Building Hypermedia APIs with HTML5 and Node
Lucene in Action: Covers Apache Lucene 3.0 (2nd Edition)
Oxford Handbook of Developmental Behavioral Neuroscience (Oxford Library of Neuroscience)
helps when building within Visual Studio. It's more common to have lib and src at the same level, especially when the build occurs outside of Visual Studio. Context: When taking dependencies on third-party libraries or frameworks. Practice: Keep dependencies within the source code directory of the project. Generally, you also have other files you may want to keep in SCC that aren't really source code but do change over time and would be aided by tracking revisions and history. It's common to have
arguments for or against separate test projects that are especially persuasive for every situation. For a "production" project (as opposed to "enterprise"), you can't redistribute a third-party testing framework. The easiest way to ensure this doesn't happen is to have a separate test project. Context: Software under development is being delivered outside the organization. Practice: Have separate test projects so that they do not need to be deployed into environments they are not needed. Test
digress. If you are interested in more of the details, I'd recommend Jon Skeet's C# In Depth, where he details use of the static initialization feature of C# to implement singletons and avoid the need for double-check locking altogether. Benefits of using practices There is no point to using practices if they don't add any value. It's important to understand at least some of the benefits that can be obtained from using practices. Let's have a look at some of the common practices. [ 10 ]
we can remove those lines and we end up with a macro similar to the following: Sub TemporaryMacro() DTE.Find.FindWhat = "$" DTE.Find.Target = vsFindTarget.vsFindTargetCurrentDocument DTE.Find.MatchCase = False DTE.Find.MatchWholeWord = False DTE.Find.Backwards = False DTE.Find.MatchInHiddenText = False DTE.Find.PatternSyntax = _ vsFindPatternSyntax.vsFindPatternSyntaxRegExpr DTE.Find.Action = vsFindAction.vsFindActionFind If (DTE.Find.Execute() = _ vsFindResult.vsFindResultNotFound) Then ThrowNew
(ASM). The model is clearly agile-slanted, but many of the factors apply to any team. These factors are discussed next. Geographic distribution This involves the distribution of the team. Is the team co-located or are they distributed over some geographic location? This distribution could be as small as cubes separated by other teams, team members separated by floors, team members in different buildings, cities, or countries and time zones. A practice that assumes the context is a co-located