Effective C# (第三版)：编程指导原则

需积分: 29 139 浏览量更新于2024-07-18 收藏 17.01MB PDF 举报

"Effective C#（第三版）是关于C#编程语言深度实践的书籍，重点关注在.NET框架下优化C#代码的策略。本书旨在帮助开发者掌握C#的最佳实践，提升编程效率和代码质量。尽管书中的设计ations可能涉及商标，但已尽可能尊重并正确处理这些标识。作者和出版商对书中可能存在的错误或遗漏不承担任何明示或暗示的担保责任，也不对由此产生的间接或后果性损害负责。" 在Effective C#（第三版）中，读者可以期待学习到一系列关键知识点： 1. **C#语言特性**：书中深入探讨了C#的高级特性，如LINQ、匿名方法、委托、属性、接口、泛型、异步编程等，并提供如何最佳利用这些特性的建议。 2. **.NET框架集成**：讲解了如何有效地与.NET框架集成，包括垃圾回收、类型转换、异常处理、集合类的使用等，帮助开发者写出更高效、更稳定的应用程序。 3. **面向对象编程**：书中可能涵盖面向对象设计原则，如单一职责原则、开闭原则、里氏替换原则等，以及如何在C#中实现这些原则。 4. **代码可读性和可维护性**：强调编写清晰、简洁的代码的重要性，讨论注释、命名约定、代码组织和重构等最佳实践。 5. **性能优化**：分析C#代码的性能瓶颈，提供关于内存管理、算法优化、并发编程等方面的指导，帮助开发者编写出运行更快的程序。 6. **错误处理和调试**：介绍有效的错误处理策略，包括异常的适当使用，以及如何设置和使用日志，以便于调试和问题排查。 7. **多平台支持**：随着.NET Core的出现，C#已经成为跨平台开发的重要工具，书里可能会涵盖如何利用C#进行跨平台开发的知识。 8. **新版本特性**：第三版可能包含C#最新版本的新特性，如C# 7及更高版本引入的模式匹配、本地函数、async streams等。 9. **代码示例和最佳实践**：书中会通过丰富的代码示例来说明理论知识，提供可以直接应用到实际项目中的最佳实践。 10. **阅读设备适应性**：由于是电子书格式，作者还关注了不同阅读设备和应用程序对内容显示的影响，提醒读者调整设置以获得最佳阅读体验。为了充分利用这本书，读者应该熟悉他们的阅读设备或应用的设置，尤其是对于包含编程代码的部分，可能需要调整至单列、横屏模式，并适当调整字体大小以优化代码的可读性。遇到代码展示可能受影响的地方，还可以点击链接查看保真度更高的代码图像。

Who Should Read This Book?

Effective C# was written for professional developers who use C# as part of

their daily toolset. It assumes you are familiar with the C# syntax and the

language’s features. This book does not include tutorial instruction on language

features. Instead, it discusses how you can integrate all the features of the current

version of the C# language into your everyday development.

In addition to language features, I assume you have some knowledge of the

Common Language Runtime (CLR) and Just-In-Time (JIT) compiler.

About The Content

There are language constructs you’ll use every day in almost every C# program

you write. Chapter 1, “C# Language Idioms,” covers those language idioms you’ll

use so often they should feel like well-worn tools in your hands. These are the

building blocks of every type you create and every algorithm you implement.

Working in a managed environment doesn’t mean the environment absolves you

of all your responsibilities. You still must work with the environment to create

correct programs that satisfy the stated performance requirements. It’s not just

about performance testing and performance tuning. Chapter 2, “.NET Resource

Management,” teaches you the design idioms that enable you to work with the

environment to achieve those goals before detailed optimization begins.

Generics are the enabling technology for everything else added to the C#

language since C# 2.0. Chapter 3, “Working with Generics,” covers generics as a

replacement for System.Object and casts and then moves on to discuss advanced

techniques such as constraints, generic specialization, method constraints, and

backward compatibility. You’ll learn several techniques in which generics will

make it easier to express your design intent.

Chapter 4, “Working with LINQ,” explains LINQ, query syntax, and related

features. You’ll see when to use extension methods to separate contracts from

implementation, how to use C# closures effectively, and how to program with

anonymous types. You’ll learn how the compiler maps query keywords to method

calls, how to distinguish between delegates and expression trees (and convert

between them when needed), and how to escape queries when you’re looking for

scalar results.

Chapter 5, “Exception Practices,” provides guidance on managing exceptions

and errors in modern C# programs. You’ll learn how to ensure that errors are

reported properly and how to leave program state consistent and ideally

unchanged when errors occur. You’ll learn how to provide a better debugging

Download from finelybook www.finelybook.com

experience for developers who use your code.

Code Conventions

Showing code in a book still requires making some compromises for space and

clarity. I’ve tried to distill the samples down to illustrate the particular point of the

sample. Often that means eliding other portions of a class or a method. Sometimes

that will include eliding error recovery code for space. Public methods should

validate their parameters and other inputs, but that code is usually elided for

space. Similar space considerations remove validation of method calls and

try/finally clauses that would often be included in complicated algorithms.

I also usually assume most developers can find the appropriate namespace when

samples use one of the common ones. You can safely assume that every sample

implicitly includes the following using statements:

Click here to view code image

using System;

using static System.Console;

using System.Collections.Generic;

using System.Linq;

using System.Text;

Providing Feedback

Despite my best efforts, and the efforts of the people who have reviewed the

text, errors may have crept into the text or samples. If you believe you have found

an error, please contact me at bill@thebillwagner.com, or on Twitter @billwagner.

Errata will be posted at http://thebillwagner.com/Resources/EffectiveCS. Many of

the items in this book are the result of email and Twitter conversations with other

C# developers. If you have questions or comments about the recommendations,

please contact me. Discussions of general interest will be covered on my blog at

http://thebillwagner.com/blog.

convenient access to downloads, updates, and corrections as they

become available. To start the registration process, go to

informit.com/register and log in or create an account. Enter the product

ISBN (9780672337871) and click Submit. Once the process is

complete, you will find any available bonus content under “Registered

Products.”

Download from finelybook www.finelybook.com

Acknowledgments

There are many people to whom I owe thanks for their contributions to this

book. I’ve been privileged to be part of an amazing C# community over the years.

Everyone on the C# Insiders mailing list (whether inside or outside Microsoft) has

contributed ideas and conversations that made this a better book.

I must single out a few members of the C# community who directly helped me

with ideas, and with turning ideas into concrete recommendations. Conversations

with Jon Skeet, Dustin Campbell, Kevin Pilch-Bisson, Jared Parsons, Scott Allen,

and, most importantly, Mads Torgersen are the basis for many new ideas in this

edition.

I had a wonderful team of technical reviewers for this edition. Jason Bock,

Mark Michaelis, and Eric Lippert pored over the text and the samples to ensure the

quality of the book you now hold. Their reviews were thorough and complete,

which is the best anyone can hope for. Beyond that, they added recommendations

that helped me explain many of the topics better.

The team at Addison-Wesley is a dream to work with. Trina Macdonald is a

fantastic editor, taskmaster, and the driving force behind anything that gets done.

She leans on Mark Renfro and Olivia Basegio heavily, and so do I. Their

contributions created the quality of the finished manuscript from the front cover to

the back, and everything in between. Curt Johnson continues to do an incredible

job marketing technical content. No matter what format of this book you chose,

Curt has had something to do with its existence.

It’s an honor, once again, to be part of Scott Meyers’s series. He goes over

every manuscript and offers suggestions and comments for improvement. He is

incredibly thorough, and his experience in software, although not in C#, means he

finds any areas where I haven’t explained an item clearly or fully justified a

recommendation. His feedback, as always, is invaluable.

My family gave up time with me so that I could finish this manuscript. My wife,

Marlene, gave up countless hours while I went off to write or create samples.

Without her support, I never would have finished this or any other book. Nor

would it be as satisfying to finish.

About the Author

Bill Wagner is one of the world’s foremost C# developers and a member of the

ECMA C# Standards Committee. He is president of the Humanitarian Toolbox, has

been awarded Microsoft Regional Director and .NET MVP for 11 years, and was

recently appointed to the .NET Foundation Advisory Council. Wagner has worked

Download from finelybook www.finelybook.com

1. C # Language Idioms

Why should you change what you are doing today if it works? The answer is that

you can be better. You change tools or languages because you can be more

productive. You don’t realize the expected gains if you don’t change your habits.

This is harder when the new language, C#, has so much in common with a familiar

language, such as C++ or Java. C# is another curly-braced language, making it

easy to fall into the same idioms you used in other languages in the same family.

That will prevent you from getting the most out of C#. The C# language has

evolved since its first commercial release in 2001. It’s now much farther removed

from C++ or Java than it was in its original release. If you are approaching C#

from another language, you need to learn the C# idioms so that the language works

with you, rather than against you. This chapter discusses the habits that you should

change—and what you should do instead.

Item 1: Prefer Implicitly Typed Local Variables

Implicitly typed local variables were added to the C# language to support

anonymous types. A second reason for using implicitly typed locals is that some

queries create results that are an IQueryable<T>, whereas others return

IEnumerable<T>. If you coerce an IQueryable<T> collection into an

IEnumerable<T> collection, you miss out on any enhancements provided by the

IQueryProvider (see Item 42). Using var also improves a developer’s

comprehension of the code. Dictionary<int, Queue<string>> doesn’t add

much comprehension, but the variable name jobsQueuedByRegion does.

I prefer var and use it to declare many local variables because I find that it

focuses the developer’s attention on the important part (the semantic meaning) and

not on the particulars of a variable’s type. The compiler still warns me if I have

created any construct that doesn’t type-check. Variable type safety is not the same

as developers writing full type names. In many cases, the differences between

IQueryable and IEnumerable do not add any information to you as a developer.

However, if you try to tell the compiler which type it is, you’ll find that you can

change the behavior by getting it wrong (see Item 42). There are times when it’s

better to use implicitly typed variables, because the compiler will pick a better

type than you will. At other times, however, overusing var only decreases the

readability of your code. Even worse, using implicitly typed variables can lead to

subtle conversion bugs.

Local type inference doesn’t have any real effect on the static typing used in C#.

Download from finelybook www.finelybook.com

剩余758页未读，继续阅读

瘦马不瘦

粉丝: 0
资源: 26

Effective C# (第三版)：编程指导原则

Effective C# 中文版改善C#程序的50种方法

[Effective.C.中文版].(Scott.Meyers).(中文版&第3版).pdf

Effective C# 中文版

Effective C# 第三版：Java编程基础与表单验证

Effective C# 中文版改善C#程序 E书

effective c++第三版PDF

Effective C#.pdf

More Effective C#中文版 改善C#程序的50个具体办法

Effective C# (Covers C# 6.0)

Effective C# 2nd Edition.pdf

最新资源

More Effective C#中文版改善C#程序的50个具体办法