.NET开发利器：利用Compiler API

.NET

Compiler

4星 · 超过85%的资源需积分: 9 194 浏览量更新于2024-07-20 3 收藏 6.69MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"《.NET Development Using the Compiler API》由Jason Bock撰写，是一本详细介绍.NET编译过程重大变革和如何利用新的.NET Compiler API创建强大应用程序的书籍。本书旨在为开发者提供一个简洁、集中的视角，使他们能够利用平台实现的任何部分来分析应用程序、优化代码生成，并在开源软件（OSS）模型下实施可强制执行的模式。书中涵盖了代码缺陷分析、自动化重构、动态代码生成等主题，为.NET开发者提供了新的开发环境的导航指南。" 在.NET平台上，Compiler API的开放源代码使得开发者可以以前所未有的方式快速、清晰地分析代码中的问题。通过这本书，读者将学习如何利用这个API来查找和修复代码缺陷，提升代码质量。作者Jason Bock介绍了一系列解决方案和项目，以展示如何实现自动重构，这是一种提高代码质量和可维护性的强大工具。此外，书中还探讨了如何在运行时动态生成代码，以实现应用程序的动态实现，这在很多场景下具有很高的灵活性和实用性。 .NET Compiler API的引入为.NET开发者打开了许多新的可能性。过去难以实现或者不存在的功能现在变得触手可及。然而，由于API的庞大性，开发者可能会面临理解和应用上的挑战。本书正是为了帮助开发者导航这个全新的开发环境，它提供了一个宝贵的路线图，指导读者如何有效地利用Compiler API来增强他们的应用程序开发能力。这本书是针对那些希望深入了解.NET Compiler API并将其应用于实际项目中的开发者的宝贵资源。无论是在代码分析、代码生成优化还是动态编程方面，开发者都能从中获得深入的理解和实用的技巧，进一步提升他们的.NET开发技能。通过阅读这本书，开发者不仅能够掌握.NET Compiler API的核心概念，还能学习到如何在实践中应用这些概念，从而创建更高效、更灵活的.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#.

■ 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 .               

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

剩余174页未读，继续阅读

DWcsdnNET

粉丝: 415
资源: 651

.NET开发利器：利用Compiler API

wx494社区门诊管理系统小程序-php+vue+uniapp.zip（可运行源码+sql文件+文档）

HTML+CSS+JS+JQ+Bootstrap的家具风格趋势展示响应式网页.7z

高分项目，基于Python+OpenCV的实时疲劳驾驶检测系统，内含源码+演示视频+部署教程

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.

在上述代码中 报错了 You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.

The C compiler ndk/25.2.9519653/toolchains/llvm/prebuilt/windows-x86_64/bin/clang.exe" is not able to compile a simple test program.

vue.runtime.esm.js:619 [Vue warn]: You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.

vue.runtime.esm.js?c320:4605 [Vue warn]: You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.

the compiler compliance specif

java: You aren't using a compiler supported by lombok, so lombok will not work and has been disabled.

最新资源

在上述代码中报错了 You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.