Professional Visual Studio Extensibility.
Title:
Professional Visual Studio Extensibility.
Author:
Nayyeri, Keyvan.
ISBN:
9780470370278
Personal Author:
Edition:
1st ed.
Physical Description:
1 online resource (554 pages)
Contents:
Professional Visual Studio 2008 Extensibility -- About the Author -- About the Technical Editor -- Credits -- Acknowledgments -- Contents -- Introduction -- Wrapping Up -- About Visual Studio Extensibility -- Why Extend Visual Studio? -- Why C#? -- Whom This Book Is For -- Aims of This Book -- What You Need to Use This Book -- What This Book Covers -- How to Use This Book -- Chapter 1: What Is Visual Studio? -- Introduction to Visual Studio -- History -- Extensibility -- Visual Studio SDK -- Installation -- An Overview of the IDE -- Summary -- Chapter 2: The .NET Framework -- What Is Microsoft .NET? -- Common Language Runtime (CLR) -- Architecture of the . NET Framework -- Programming Languages -- Technologies -- The .NET Framework and Visual Studio 2008 -- .NET and COM -- Additional Resources -- Summary -- Chapter 3: Quick Tour -- Different Ways to Extend Visual Studio -- What Is a Macro? -- Sample Macro -- What Is an Add-In? -- Sample Add-In -- Working with Visualizers -- Sample Visualizer -- Using the Help Options -- Summary -- Chapter 4: The Automation Model -- What Is the Automation Model? -- The Architecture -- Main Parts of DTE -- What You Can't Achieve with the DTE -- The Automation Model and Macros IDE -- Summary -- Chapter 5: Add-In Wizard -- Before Building an Add-In -- Add-in Wizard -- What Is Generated for You -- Shared Add-In Wizard -- Summary -- Chapter 6: The Anatomy of an Add-In -- The Structure of an Add-In -- AddIn Interface -- Other Options to Load an Add-in -- .AddIn File -- Shared Add-ins -- Summary -- Chapter 7: Manipulating the Solutions, Projects, and Project Items -- Background -- Solution -- Project -- Project Items -- ActiveSolutionProjects -- Events -- Summary -- Chapter 8: Manipulating Documents -- Background -- Documents -- Document -- TextSelection -- TextPoint -- EditPoint -- VirtualPoint -- TextDocument.
Document Manipulation Samples -- Summary -- Chapter 9: Manipulating Code and the Build Process -- Introduction -- Code Elements Hierarchy -- CodeElement -- CodeNamespace -- CodeClass -- CodeFunction -- Code Manipulation Samples -- Builds -- Summary -- Chapter 10: The User Interface -- Adding User Interface Elements to Add-Ins -- Manipulating User Interface Elements -- Manipulating Visual Studio Windows -- Summary -- Chapter 11: Tools Options Page -- Background -- Implementing the Options Page -- Configuring the Add-In -- Summary -- Chapter 12: Debugging and Testing Add-Ins -- Background -- Debugging -- Exception Handling -- Unit Testing -- Summary -- Chapter 13: Deploying Add-Ins -- An Overview of the Deployment Process -- Windows Installer -- Visual Studio Content Installer -- Add-In Manager -- Summary -- Chapter 14: Localizing Add-Ins -- What Is Localization? -- Embedded Resources -- Using Embedded Resources to Localize Add-Ins -- Further Localization -- Summary -- Chapter 15: Visual Studio Shell -- What Is Visual Studio Shell? -- A Working Example -- Additional Information -- Summary -- Chapter 16: Domain-Specific Language Tools -- Introducing Domain-Specific Languages -- Domain-Specific Languages in Visual Studio -- Creating a Domain-Specific Language Solution -- Basic Concepts -- Anatomy of a Domain-Specific Language Solution -- An Overview of the Domain-Specific Language Tools -- Summary -- Chapter 17: Extending the Debugger -- How to Extend the Debugger -- Type Proxy -- Visualizers -- Summary -- Chapter 18: VSPackages -- What Is a VSPackage? -- The Anatomy of a VSPackage -- Building a VSPackage -- Testing a VSPackage -- Deploying a VSPackage -- Package Load Analyzer -- Summary -- Chapter 19: Code Snippets -- What Is a Code Snippet? -- The Anatomy of a Code Snippet -- How to Build a Code Snippet -- Managing Code Snippets -- Summary.
Chapter 20: Templates -- Project Templates -- Item Template -- The Anatomy of Visual Studio Templates -- Template Manifest -- Creating a Template -- Customizing a Template -- Custom Template Wizards -- Starter Kits -- Summary -- Chapter 21: MSBuild -- What Is MSBuild? -- The Anatomy of MSBuild Files -- MSBuild Structure -- How to Use MSBuild Files -- Sample MSBuild File -- Summary -- Chapter 22: Macros -- Introduction to Macros -- The Anatomy of a Macro -- Macros IDE -- Macro Explorer -- Running and Stopping a Macro -- Building a Macro -- Recording a Macro -- Developing a Macro -- Debugging a Macro -- Deploying a Macro -- Some Points About Macros -- Run Macros Easier -- Sample Macro -- Summary -- Appendix A: Third-Party Add-Ins and Extensions -- Appendix B: Resources -- Communities -- Blogs -- Books -- Index.
Abstract:
Visual Studio is a development IDE created by Microsoft to enable easier development for Microsoft programming languages as well as development technologies. It has been the most popular IDE for working with Microsoft development products for the past 10 years. Extensibility is a key feature of Visual Studio. There have not been many books written on this aspect of Visual Studio. Visual Studio Extensibility (VSX) can be considered a hard topic to learn for many developers in comparison with most .NET related topics. Also, its APIs are very complex and not very well written. Some may refer to these APIs as "dirty" because they do not have good structure, naming convention, or consistency. Visual Studio is now 10 years old. It was created during the COM days for COM programming but later migrated to .NET. However, Visual Studio still relies heavily on COM programming. It was revamped when moving to the .NET platform but still contains its COM nature; this fact is what makes it harder for .NET developers to work with VSX. Because it is an older product built on two technologies, it has produced inconsistency in code. Although there are problems with the current version of VSX, the future looks bright for it. The many different teams working on the software have been moved into one umbrella group known as the Visual Studio Ecosystem team. Throughout the past 10 years Visual Studio has continued to grow and new extensibility features have been added. Learning all of the options with their different purposes and implementations is not easy. Many extensibility features are broad topics such as add-ins, macros, and the new domain-specific language tools in Visual Studio. Learning these topics can be difficult because they are not closely related to general .NET programming topics. This book is for .NET developers who are interested in extending
Visual Studio as their development tool. In order to understand the book you must know the following material well: Object-oriented programming (OOP), the .NET Framework and .NET programming, C# or Visual Basic languages, some familiarity with C++, some familiarity with XML and its related topics, and Visual Studio structure and usage. A familiarity with COM programming and different .NET technologies is helpful. The aims of this book are to: Provide an overview of all aspects of VSX Enable readers to know where/when to use extensibility Familiarize readers with VS Extensibility in detail Show readers the first steps and let them learn through their own experiences Use examples, sample code, and case studies to demonstrate things in such a way that helps readers understand the concepts Avoid bothering readers with long discussions and useless code samples In order to use this book, and get the most out of it, there are some technical requirements. You must have the following two packages installed on your machine to be able to read/understand the chapters and test code samples: Visual Studio 2008 Team System Edition (or other commercial editions) Visual Studio 2008 SDK 1.0 (or its newer versions) You will need to buy Visual Studio 2008 to register for an evaluation version. The Free Express editions of Visual Studio do not support the extensibility options. The Visual Studio SDK is needed in order to read some of the chapters in the book and can be downloaded as a free package. The operating system doesn't matter for the content of the book, but all code was written with Visual Studio 2008 Team System Edition in Windows Vista x86. Chapters 1, 2, and 3 will give you an introduction to the basic concepts you need to understand before you can move on to the rest of the book. Chapter 4 discusses the automation model, which is an important
prerequisite for many.
Local Note:
Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2017. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.
Genre:
Electronic Access:
Click to View