利用.NET Compiler API构建创新应用：开发指南

5星 · 超过95%的资源需积分: 10 63 浏览量更新于2024-07-20 收藏 6.85MB PDF 举报

".NET Development Using the Compiler API" 是一本由 Jason Bock 所著的专著，出版于 2016 年，由 Apress 出版。这本书是首部详细介绍 .NET 编译过程重大变革的书籍，并展示了开发者如何利用新的 Compiler API 来构建出有吸引力的应用程序。随着 .NET Compiler API 转变为开源，它为开发者提供了前所未有的强大工具，让任何人都能访问其源代码。本书的核心内容围绕以下几个方面展开： 1. **平台开放性**：作为开源编译器，.NET Compiler API 提供了丰富的资源，使得开发者能够在分析应用程序、改进代码生成和实现强制执行模式时，利用平台的内部实现来提升开发效率。这在以前的开发环境中是不可得的，或者难度较大。 2. **代码分析与缺陷检测**：作者指导读者学习如何使用 Compiler API 进行高效、无污染的代码分析，以便快速识别和修复潜在问题，这是传统方法无法比拟的创新技术。 3. **自动重构与动态代码生成**：书中通过实例演示如何在解决方案和项目中应用自动重构功能，以及如何根据需要在运行时动态生成代码，从而为应用程序提供更加灵活和定制化的实现方式。 4. **技术发展与道路图**：面对庞大的 API，本书为开发者提供了一个宝贵的指南，帮助他们适应这个全新的开发环境，把握住 .NET Compiler API 带来的各种机遇。 5. **版权与授权**：该书享有版权，所有权利归 Jason Bock 所有，但允许进行必要的学术引用或计算机系统使用，以确保作品的传播和研究价值。《.NET Development Using the Compiler API》是一本为那些寻求理解和利用 .NET 新编译器技术的开发者量身打造的实用指南，它不仅提供了理论知识，还通过实践案例引导读者深入掌握这一革命性的技术。对于希望提升应用程序性能、优化开发流程的.NET开发者来说，这是一本不可或缺的参考资料。

Introduction

Most developers I know typically view coding as a means to an end. That is, they write

the code to satisfy the requirements set forth by the business. The code is interpreted or

compiled, but either way, the final result is machine code that executes and (hopefully)

does the right thing.

However, there’s more to software development than just that. I’m not talking about

process or patterns per se; what I’m getting at is for developers to view their code in

a more analytical way. Throughout my career, I’ve run into numerous cases in which

I would’ve loved to have the ability to analyze my code so I could find errors quickly.

I’ve also wanted to be able to extend and augment languages in certain ways so I didn’t

have to write the same code over and over again. The primary language that I’ve used

throughout my career has been C#, and although C# is a fine language to develop in, it

seemed to lack these dynamic, analytical capabilities.

That’s no longer the case. Microsoft has provided public, open-source components

in its Compiler API that allows developers to create analyzers that will help them detect

problematic issues. This API also empowers developers to build code at runtime to create

amazing, dynamic applications and libraries. Because all of this code is open source, it’s

available to read and contribute to. Enabling .NET developers to shape and mold the

future of the .NET compilation system is a wonderful thing to behold, and it’s exciting to

see the development community embrace this model.

I wrote this book to help you navigate this new open-source API world. In it, I

demonstrate how to use the Compiler API to write custom analyzers and refactorings to

improve your code base. I show you how to use the Scripting API (part of the Compiler

API) to use C# as a scripting language, a feature that was essentially unavailable to C#

developers. I also illustrate how to use the Compiler API in innovative ways that go

beyond these typical scenarios. My hope is that when you’ve finished this book, you’ll

view C# and the ecosystem that supports it in a fundamentally different (and hopefully

positive!) way—as a language that is open in terms of its implementation and its

community involvement.

Who This Book Is For

This book is for architects and developers who have experience with C# and want to dive

deeper into how code is compiled and executed. There’s no expectation that the reader

has any experience with compilers, but I do assume that the reader has foundational

knowledge of C#.

www.it-ebooks.info

■ INTRODUCTION

xvi

Chapter Contents

To give you a feel for the content in the book, here’s a brief synopsis of each chapter.

• Chapter

1 —You’ll get an introduction to the Compiler API and its

constituent parts: syntax trees, semantic models, and formatters.

• Chapter

2 —This chapter covers diagnostics. You’ll learn how to

write analyzers and build code fixes to automate code corrections.

• Chapter

3 —Refactoring code is a primary tenant for developers.

This chapter shows you how to write refactorings to clean up your

code base.

• Chapter

4 —C# is now a scripting language! In this chapter, you’ll

see how the Scripting API works.

• Chapter

5 —You’ll discover how developers are using the

Compiler API to empower their own components and get a

preview of a future C# feature based on the Compiler API that

could fundamentally change how you write code in C#.

Code Samples

Throughout the book I show code snippets to illustrate various aspects of the Compiler

API. You’ll find all of the code at

https://github.com/jasonbock/compilerAPIBook .

The folder structure is set up to map the code content to each chapter of the book.

Errata

The author, the technical reviewers, and many Apress staff have made every effort to find

and eliminate all errors from this book’s text and code. Even so, there are bound to be

one or two glitches left. To keep you informed, there’s an Errata tab on the Apress book

page (

www.apress.com/9781484221105 ). If you find any errors that haven’t already been

reported, such as misspellings or faulty code, please let us know by e-mailing

support@

apress.com

Customer Support

Apress wants to hear what you think—what you liked, what you didn’t like, and what you

think could be done better next time. You can send comments to feedback@apress.com .

Be sure to mention the book title in your message.

Contacting the Author

Feel free to follow me on Twitter at @jasonbock. My web site is http://www.jasonbock.net .

You can also contact me via e-mail at jasonb@magenic.com .

www.it-ebooks.info

CHAPTER 1 ■ AN OVERVIEW OF THE COMPILER API

The compiler will find everything it can about that line of text and break it up into

separate chunks. That includes the period between Console and Out , the tabs before

the Console token, and the semicolon at the end of the line. The compiler also has to be

smart enough to figure out when there are problems and report meaningful errors when

its process is finished without stopping on that one error because there may be more

issues in the code.

But the complexities of tokenizing code don’t stop here. Now the compiler needs

to figure out what those tokens really mean. A tab isn’t important from an execution

standpoint, but it may matter if you’re debugging your code, as the compiler needs to

make sure the debugging information ignores that whitespace correctly when a developer

creates breakpoints in code. A semicolon means that the line of code is complete, so that’s

important to know, although you’re not really doing any execution with that character.

But what does the period mean? It may mean that you’re trying to access a property

on an object, or call a method. Which one is it? And if it’s a method, is it an extension

method? If so, where does that extension method exist? Is there an appropriate using

statement in the file that will help the compiler figure out where that method is? Or is the

developer using a new feature in C#6, like using static , which needs to be accounted

for? The compiler needs to figure out semantics for these tokens based on the rules of the

C# language, and if you’ve ever read the C# specification, you know that this can be an

extremely difficult endeavor.

■ Note You’ll find the C# specification at https://www.microsoft.com/en-us/

download/details.aspx?id=7029

, although at the time of this writing, it was at version 5;

C#6 features are not included.

Finally, the last job of the compiler is to take all the information it’s assembled and

actually generate a .NET assembly . This assembly, in turn, contains what’s known as an

Intermediate Language (IL) that can be interpreted by the Common Language Runtime

(CLR) along with metadata information, such as the names of types and methods.

Transforming tokens into IL is a nontrivial job. If you’ve spent any time working with

members in the System.Reflection.Emit namespace , you know it’s not easy to encode

a method correctly. Forget just one IL instruction and you may end up creating an

assembly that will crash horribly at runtime.

Figure 1-2. B r e a k i n g c o d e i n t o s e p a r a t e t o k e n s

www.it-ebooks.info

剩余174页未读，继续阅读

vanridin

粉丝: 108
资源: 1188

利用.NET Compiler API构建创新应用：开发指南

Tell CMake where to find the compiler by setting either the environment variable "CUDACXX" or the CMake cache entry CMAKE_CUDA_COMPILER to the full path to the compiler, or to the compiler name if it is in the PATH.

OpenModelica Compiler API 的头文件和库文件

Compiler did not create the expected binary

Qt 项目中添加 OpenModelica Compiler API 的头文件和库文件

ASP.NET Web编写java编译器‘

using the gnu compiler collection pdf中文

No CMAKE_CUDA_COMPILER could be found. Tell CMake where to find the compiler by setting either the environment variable "CUDACXX" or the CMake cache entry CMAKE_CUDA_COMPILER to the full path to the compiler, or to the compiler name if it is in the PATH.

*** Target 'Target 1' uses ARM-Compiler 'Default Compiler Version 5' which is not available.

design compiler2016安装包资源

最新资源