C#_程序设计与WEB开发_计算机类_最新资料_得益网

More Effective C#: 50 Specific Ways to Improve Your C#

2008-10-27 16:04:44

Effective C#的第二版，2008年10月出版，强烈推荐所有.NET开发人员阅读

Introduction
Chapter 1. Working with Generics
Item 1. Use Generic Replacements of 1.x Framework API Classes
Item 2. Define Constraints That Are Minimal and Sufficient
Item 3. Specialize Generic Algorithms Using Runtime Type Checking
Item 4. Use Generics to Force Compile-Time Type Inference
Item 5. Ensure That Your Generic Classes Support Disposable Type Parameters
Item 6. Use Delegates to Define Method Constraints on Type Parameters
Item 7. Do Not Create Generic Specialization on Base Classes or Interfaces
Item 8. Prefer Generic Methods Unless Type Parameters Are Instance Fields
Item 9. Prefer Generic Tuples to Output and Ref Parameters
Item 10. Implement Classic Interfaces in Addition to Generic Interfaces
Chapter 2. Multithreading in C#
Item 11. Use the Thread Pool Instead of Creating Threads
Item 12. Use BackgroundWorker for Cross-Thread Communication
Item 13. Use lock() as Your First Choice for Synchronization
Item 14. Use the Smallest Possible Scope for Lock Handles
Item 15. Avoid Calling Unknown Code in Locked Sections
Item 16. Understand Cross-Thread Calls in Windows Forms and WPF
Chapter 3. C# Design Practices
Item 17. Create Composable APIs for Sequences
Item 18. Decouple Iterations from Actions, Predicates, and Functions
Item 19. Generate Sequence Items as Requested
Item 20. Loosen Coupling by Using Function Parameters
Item 21. Create Method Groups That Are Clear, Minimal, and Complete
Item 22. Prefer Defining Methods to Overloading Operators
Item 23. Understand How Events Increase Runtime Coupling Among Objects
Item 24. Declare Only Nonvirtual Events
Item 25. Use Exceptions to Report Method Contract Failures
Item 26. Ensure That Properties Behave Like Data
Item 27. Distinguish Between Inheritance and Composition
Chapter 4. C# 3.0 Language Enhancements
Item 28. Augment Minimal Interface Contracts with Extension Methods
Item 29. Enhance Constructed Types with Extension Methods
Item 30. Prefer Implicitly Typed Local Variables
Item 31. Limit Type Scope by Using Anonymous Types
Item 32. Create Composable APIs for External Components
Item 33. Avoid Modifying Bound Variables
Item 34. Define Local Functions on Anonymous Types
Item 35. Never Overload Extension Methods
Chapter 5. Working with LINQ
Item 36. Understand How Query Expressions Map to Method Calls
Item 37. Prefer Lazy Evaluation Queries
Item 38. Prefer Lambda Expressions to Methods
Item 39. Avoid Throwing Exceptions in Functions and Actions
Item 40. Distinguish Early from Deferred Execution
Item 41. Avoid Capturing Expensive Resources
Item 42. Distinguish Between IEnumerable and IQueryable Data Sources
Item 43. Use Single() and First() to Enforce Semantic Expectations on Queries
Item 44. Prefer Storing Expression<> to Func<>
Chapter 6. Miscellaneous
Item 45. Minimize the Visibility of Nullable Values
Item 46. Give Partial Classes Partial Methods for Constructors, Mutators, and Event Handlers
Item 47. Limit Array Parameters to Params Arrays
Item 48. Avoid Calling Virtual Functions in Constructors
Item 49. Consider Weak References for Large Objects
Item 50. Prefer Implicit Properties for Mutable, Nonserializable Data

Introduction
When Anders Hejlsberg first showed Language-Integrated Query (LINQ) to the world at the 2005 Professional Developers Conference (PDC), the C# programming world changed. LINQ justified several new features in the C# language: extension methods, local variable type inference, lambda expressions, anonymous types, object initializers, and collection initializers. C# 2.0 set the stage for LINQ by adding generics, iterators, static classes, nullable types, property accessor accessibility, and anonymous delegates. But all these features are useful outside LINQ: They are handy for many programming tasks that have nothing to do with querying data sources.

This book provides practical advice about the features added to the C# programming language in the 2.0 and 3.0 releases, along with advanced features that were not covered in my earlier Effective C#: 50 Specific Ways to Improve Your C# (Addison-Wesley, 2004). The items in More Effective C# reflect the advice I give developers who are adopting C# 3.0 in their professional work. There's a heavy emphasis on generics, an enabling technology for everything in C# 2.0 and 3.0. I discuss the new features in C# 3.0; rather than organize the topics by language feature, I present these tips from the perspective of recommendations about the programming problems that developers can best solve by using these new features.

Consistent with the other books in the Effective Software Development Series, this book contains self-contained items detailing specific advice about how to use C#. The items are organized to guide you from using C# 1.x to using C# 3.0 in the best way.

Generics are an enabling technology for all new idioms that are part of C# 3.0. Although only the first chapter specifically addresses generics, you'll find that they are an integral part of almost every item. After reading this book, you'll be much more comfortable with generics and metaprogramming.

Of course, much of the book discusses how to use C# 3.0 and the LINQ query syntax in your code. The features added in C# 3.0 are very useful in their own right, whether or not you are querying data sources. These changes in the language are so extensive, and LINQ is such a large part of the justification for those changes, that each warrants its own chapter. LINQ and C# 3.0 will have a profound impact on how you write code in C#. This book will make that transition easier.

Who Should Read This Book?
This book was written for professional software developers who use C#. It assumes that you have some familiarity with C# 2.0 and C# 3.0. Scott Meyers counseled me that an Effective book should be a developer's second book on a subject. This book does not include tutorial information on the new language features added as the language has evolved. Instead, I explain how you can integrate these features into your ongoing development activities. You'll learn when to leverage the new language features in your development activities, and when to avoid certain practices that will lead to brittle code.

In addition to some familiarity with the newer features of the C# language, you should have an understanding of the major components that make up the .NET Framework: the .NET CLR (Common Language Runtime), the .NET BCL (Base Class Library), and the JIT (Just In Time) compiler. This book doesn't cover .NET 3.0 components, such as WCF (Windows Communication Foundation), WPF (Windows Presentation Foundation), and WF (Windows Workflow Foundation). However, all the idioms presented apply to those components as well as any other .NET Framework components you happen to prefer.

About the Content
Generics are the enabling technology for everything else added to the C# language since C# 1.1. Chapter 1 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.

Multicore processors are already ubiquitous, with more cores being added seemingly every day. This means that every C# developer needs to have a solid understanding of the support provided by the C# language for multithreaded programming. Although one chapter can't cover everything you need to be an expert, Chapter 2 discusses the techniques you'll need every day when you write multithreaded applications.

Chapter 3 explains how to express modern design idioms in C#. You'll learn the best way to express your intent using the rich palette of C# language features. You'll see how to leverage lazy evaluation, create composable interfaces, and avoid confusion among the various language elements in your public interfaces.

Chapter 4 discusses how to use the enhancements in C# 3.0 to solve the programming challenges you face every day. 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.

Chapter 5 explains LINQ and query syntax. 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 6 covers those items that defy classification. You'll learn how to define partial classes, work with nullable types, and avoid covariance and contravariance problems with array parameters.

Regarding the Sample Code
The samples in this book are not complete programs. They are the smallest snippets of code possible that illustrate the point. In several samples the method names substitute for a concept, such as AllocateExpensiveResource(). Rather than read pages of code, you can grasp the concept and quickly apply it to your professional development. Where methods are elided, the name implies what's important about the missing method.

In all cases, you can assume that the following namespaces are specified:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

Where types are used from other namespaces, I've explicitly included the namespace in the type.

In the first three chapters, I often show C# 2.0 and C# 3.0 syntax where newer syntax is preferred but not required. In Chapters 4 and 5 I assume that you would use the 3.0 syntax.

Making Suggestions and Providing Feedback
I've made every effort to remove all errors from this book, but if you believe you have found an error, please contact me at bill.wagner@srtsolutions.com. Errata will be posted to http://srtsolutions.com/blogs/MoreEffectiveCSharp.

Acknowledgments
A colleague recently asked me to describe what it feels like to finish a book. I replied that it gives you that same feeling of satisfaction and relief that shipping a software product gives you. It's very satisfying, and yet it's an incredible amount of work. Like shipping a software product, completing a book requires collaboration among many people, and all those people deserve thanks.

I was honored to be part of the Effective Software Development Series when I wrote Effective C# in 2004. To follow that up with More Effective C# and cover the numerous and far-reaching changes in the language since then is an even greater honor. The genesis of this book was a dinner I shared with Curt Johnson and Joan Murray at PDC 2005, when I expressed my excitement about the direction Hejlsberg and the rest of the C# team were presenting there. I was already taking notes about the changes and learning how they would affect the daily lives of C# developers.

Of course, it was some time before I felt comfortable in offering advice on all these new features. I needed to spend time using them and discussing different idioms with coworkers, customers, and other developers in the community. Once I felt comfortable with the new features, I began working on the new manuscript.

I was lucky enough to have an excellent team of technical reviewers. These people suggested new topics, modified the recommendations, and found scores of technical errors in earlier drafts. Bill Craun, Wes Dyer, Nick Paldino, Tomas Restrepo, and Peter Ritchie provided detailed technical feedback that made this book as useful as it is now. Pavin Podila reviewed those areas that mention WPF to ensure correctness.

Throughout the writing process, I discussed many ideas with members of the community and the C# team. The regulars at the Ann Arbor .NET Developers Group, the Great Lakes Area .NET User Group, the Greater Lansing User Group, the West Michigan .NET User Group, and the Toledo .NET User Group acted as prototype audiences for much of the advice presented here. In addition, CodeMash attendees helped me decide what to leave in and what to leave out. In particular, I want to single out Dustin Campbell, Jay Wren, and Mike Woelmer for letting me discuss ideas with them. In addition, Mads Torgersen, Charlie Calvert, and Eric Lippert joined me in several conversations that helped clarify the advice detailed here. In particular, Charlie Calvert has the great skill of mixing an engineer's understanding with a writer's gift of clarity. Without all those discussions, this manuscript would be far less clear, and it would be missing a number of key concepts.

Having been through Scott Meyers's thorough review process twice now, I'd recommend any book in his series sight unseen. Although he's not a C# expert, he's highly gifted and clearly cares about the books in his series. Responding to his comments takes quite a bit of time, but it results in a much better book.

Throughout the whole process, Joan Murray has been an incredible asset. As editor, she's always on top of everything. She prodded me when I needed prodding, she provided a great team of reviewers, and she helped shepherd the book from inception through outlines, manuscript drafts, and finally into the version you hold now. Along with Curt Johnson, she makes working with Addison-Wesley a joy.

The last step is working with a copy editor. Betsy Hardinger was somehow able to translate an engineer's jargon into English without sacrificing technical correctness. The book you're holding is much easier to read after her edits.

Of course, writing a book takes a large investment of time. During that time, Dianne Marsh, the other owner of SRT Solutions, kept the company moving forward. The greatest sacrifice was from my family, who saw much less of me than they'd like while I was writing this book. The biggest thanks go to Marlene, Lara, Sarah, and Scott, who put up with me as I did this again.

ArcObjects GIS应用开发——基于C#.NET

2008-10-09 00:39:42

资料简介
ArcObjects GIS应用开发—基于C#.NET，本书详细讨论ArcObjects开发中的基本概念、方法以及实现用例，很不错的ArcGIS Engine资料，详细目录如下：

1. 开发基础
1.1 ArcObjects基础
1.2 组件对象模型
1.3 .NET平台概述
1.4 .NET组件与COM组件的互操作
1.5 ArcGIS开发资源
1.6 ArcGIS的二次开发方式

2. ArcMap用户界面定制
2.1 Application对象
2.2 Document对象
2.3 定制ArcMap的界面
2.4 UIControl的使用
2.5 使用Extention扩展ArcGIS

3. 使用ArcObjects控件编程
3.1 MapControl控件
3.2 PagelayeroutControl控件
3.3 TOCControl控件
3.4 ToolbarControl及相关对象
3.5 ControlCommands
3.6 应用开发实例

4. 几何形体对象——Geometry
4.1 Geometry模型
4.2 Point和MultiPoint对象
4.3 包络线Envelope
4.4 曲线（curve）
4.5 Geometry集合接口
4.6 动态跟踪
4.7 空间参考

5. 地图的组成
5.1 Map对象
5.2 图层对象
5.3 ScreenDisplay对象
5.4 地图排版
5.5 Element对象
5.6 MapGird对象模型
5.7 MapSurround对象
5.8 使用Style对象
5.9 IdentifyDialog对象

6. 空间数据的符号华
6.1 颜色对象
6.2 Symbol对象
6.3 制作专题图
6.4 地图的标志
6.5 如何与地图进行互动

7. 地图的输出
7.1 地图的打印输出
7.2 地图的转换输出

8. 空间数据管理
8.1 Geodatabase的基础知识
8.2 Worksapce及相关对象
8.3 Dataset对象
8.4 表、对象类和要素类
8.5 Row、Object和Feature对象
8.6 关系与关系类
8.7 数据转换与装载

9. 空间分析
9.1 空间查询
9.2 空间拓扑运算
9.3 空间关系运算
9.4 IproximityOperator接口
9.5 叠加分析

10. 空间数据编辑——MapEditing实例剖析
10.1 IworkspaceEdit接口
10.2 MapEditing功能剖析

11. Arccatalog对象
11.1 GxObject对象
11.2 GxDialog对象

12. Raster数据简介
12.1 RasterWorkspace对象
12.2 栅格数据集
12.3 栅格图层对象

Production Debugging for .NET Framework Applications(.NET软件产品调试)

2008-09-28 02:49:10

关于.NET程序调试的专著。是丰富.NET编程和调试经验的很好的参考书。
特别适合于希望曾进涉及进程间通讯等功能的大型项目的朋友。

Contents
Chapter 1
Introduction to Production Debugging
for .NET Framework Applications 1
Production Debugging vs. Development Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Debugging Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Discovery Phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Debugging Phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
ASP.NET Process Model and Health Monitoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
What Is the ASP.NET Process Model? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
IIS 5.x Process Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Health Monitoring in IIS 5.x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
IIS 6.0 Process Model in Windows .NET Server Release Candidate 1 . . . . . . . . . . . . 9
IIS 6.0 Application Pools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Orphaning Failed ASP.NET Worker Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
System Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Additional Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Documentation Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Chapter 2
Debugging Memory Problems 17
.NET Memory Management and Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Generations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Roots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Large Object Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Scenario: Memory Consumption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Breaking Down the Thought Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Memory Consumption Walkthrough . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Debugging User-Mode Dump Files with WinDbg . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Analyzing the Dump: Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Diagnosing Memory Leaks with the Allocation Profiler . . . . . . . . . . . . . . . . . . . . . . . 51
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
iv Contents
Chapter 3
Debugging Contention Problems 57
ASP.NET Thread Pools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Managed Threads and AppDomains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
The .NET ThreadPool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
ASP.NET Thread Pool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Scenario: Contention or Deadlock Symptoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Breaking Down the Thought Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Contention Walkthrough . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Debugging a Dump File with WinDbg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Debugging with Visual Studio .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Chapter 4
Debugging Unexpected Process Termination 103
Handling COM Threading in ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
ASP.NET and COM Interop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
COM Components and ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Scenario: Unexpected Process Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Breaking Down the Thought Processes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Unexpected Process Termination Walkthrough . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Debugging a Dump File with WinDbg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Examining the Dump File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Appendix
Thread State Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Application Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Contention.aspx.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Memory.aspx.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Unexpected.aspx.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Pmhealth.cs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Debugging with CorDbg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Using CorDbg to Display Call Stack Information . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Using a Script File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
The managed_threads.cmd Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Exploring Further . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

C Sharp Primer - A Practical Approach

2008-09-20 17:22:55

The book is organized into eight relatively long chapters. The first four chapters focus on
the C# language, looking at the built-in language features, the class mechanism, class
inheritance, and interface inheritance. The second four chapters explore the various library
domains supported within the .NET class framework.
Chapter 1 covers the basic language, as well as some of the fundamental classes provided
within the class framework. The discussion is driven by the design of a small program.
Concepts such as namespaces, exception handling, and the unified type system are
introduced.
Chapter 2 covers the fundamentals of building classes. We look at access permission,
distinguish between const and readonly members, and cover specialized methods such
as indexers and properties. We walk through the different strategies of member
initialization, as well as the rules for operator overloading and conversion operators. We
look at the delegate type, which serves as a kind of universal pointer to a function.
Chapters 3 and 4 cover, in turn, class and interface inheritance. Class inheritance allows us to
define a family of specialized types that override a generic interface, such as an abstract
WebRequest base class and a protocol-specific HttpWebRequest subtype. Interface
inheritance, on the other hand, allows us to provide a common service or shared attribute
for otherwise unrelated types. For example, the IDisposable interface frees resources.
Classes holding database connections or window handles are both likely to implement
IDisposable, although they are otherwise unrelated.
Chapter 5 provides a wide-ranging tour of the .NET class library. We look at input and output,
including file and directory manipulation, regular expressions, sockets and thread
programming, the WebRequest and WebResponse class hierarchies, a brief introduction
to ADO.NET and establishing database connections, and the use of XML.
Chapters 6 and 7 cover, in turn, drag-and-drop Windows Forms and Web Forms development.
Chapter 7 focuses on ASP.NET, and the Web page life cycle. Both chapters provide lots of
examples of using the prebuilt controls and attaching event handlers for user interaction.
The final chapter provides a programmer's introduction to the .NET Common Language
Runtime. It focuses on assemblies, type reflection, and attributes, and concludes with a
brief look at the underlying intermediate language that is the compilation target of all .NET
languages.

Essential C# 3.0: For .NET Framework 3.5 (2nd Edition)

2008-09-20 14:33:30

C# 3.0 的好书.

“If you want to be a C# developer, or if you want to enhance your C# programming skills, there is no more useful tool than a well-crafted book on the subject. You are holding such a book in your hands.”

–From the Foreword by Charlie Calvert, Community Program Manager, Visual C#, Microsoft

“In a time when you can search online for any reference material, Essential C# 3.0 is the one book I still bother to carry in my bag. Any developer can hit F1 for help with the language syntax; this book, however, arms me with the knowledge to make better design and coding decisions (and the confidence to say so). You know when a book has more than twenty pages of index that it’s got depth covered, and although Essential C# 3.0 has introductory chapters, it progresses effortlessly into the lesser known corners of the language, which makes this book indispensible to any level of C# developer.”

–Troy Magennis, C# MVP and creator of HookedOnLINQ.com

“If you are new to C#, as I was, Mark’s book is an excellent way to start. His approach takes you step by step through the structure and syntax of the language, making it easy to understand how things work. I found the code samples extremely helpful and supportive of the concepts being discussed.”

–Robert Stokesbary, senior consultant, Option Explicit

“This book expands on the concepts introduced in Essential C# 2.0 to include C# 3.0 enhancements. One great aspect of this book is that it not only covers the new 3.0 enhancements in great detail, but it also shows where it makes sense to utilize these new features over the existing 2.0 features. While I have been programming C# for many years, I find myself referring to this book often and always seem to find something new buried in the pages. This is a must-read for both the C# newbie as well as the C# seasoned veteran.”

–Michael Stokesbary, senior software engineer, Itron Inc.

目录

1 Introducing C# 1
2 Data Types 31
3 Operators and Control Flow 83
4 Methods and Parameters 147
5 Classes 195
6 Inheritance 261
7 Interfaces 295
8 Value Types 321
9 Well-Formed Types 347
10 Exception Handling 389
11 Generics 405
12 Delegates and Lambda Expressions 445
x Contents at a Glance
13 Events 479
14 Collection Interfaces with Standard Query Operators 507
15 Query Expressions 555
16 Building Custom Collections 577
17 Reflection and Attributes 617
18 Multithreading 657
19 Multithreading Patterns 699
20 Platform Interoperability and Unsafe Code 723
21 The Common Language Infrastructure 749
A Downloading and Installing the C# Compiler and the
CLI Platform 771
B Full Source Code Listings 775
C C# 3.0 Topics 801
Index 807

Professional C# 2008

2008-09-19 17:30:47

Wrox 的2008年C# 新书.

Updated for .NET 3.5 and Visual Studio? 2008, this book is the ultimate guide to C# 2008 and its environment. Beginning with a look into the architecture and methodology of .NET, the team of superlative authors explains why the C# language cannot be viewed in isolation, but rather, must be considered in parallel with the .NET Framework. After gaining an understanding of the foundation of C#, you'll then go on to examine the fundamentals of C# programming with each successive chapter.

New examples provide helpful explanations on how to use C# to solve various tasks. Plus, completely new chapters on LINQ, SQL, ADO.NET entities, Windows Communication Foundation, Windows Workflow Foundation, Windows Presentation Foundation, arrays, system transactions, tracing, and event logging all deliver essential information to help you gain a clear and thorough understanding of all that C# 2008 has to offer.

What you will learn from this book

How to write Windows? applications and Windows? services

Ways to use ASP.NET 3.5 to write web pages

Techniques for manipulating XML using C#

How to use ADO.NET to access databases

Ways to generate graphics using C# 2008

Numerous C# add-ins

How to use LINQ to easily work with your SQL Server databases and XML

目录

Acknowledgments .............................................................................................................. xiii
Introduction .......................................................................................................................xlvii
Part I: The C# Language
Chapter 1: .NET Architecture ..................................................................................................3
Chapter 2: C# Basics ...........................................................................................................25
Chapter 3: Objects and Types ...............................................................................................75
Chapter 4: Inheritance ........................................................................................................101
Chapter 5: Arrays ...............................................................................................................121
Chapter 6: Operators and Casts ..........................................................................................141
Chapter 7: Delegates and Events ........................................................................................177
Chapter 8: Strings and Regular Expressions ........................................................................203
Chapter 9: Generics ...........................................................................................................223
Chapter 10: Collections ......................................................................................................247
Chapter 11: Language Integrated Query ..............................................................................297
Chapter 12: Memory Management and Pointers ..................................................................329
Chapter 13: Reflection .......................................................................................................357
Chapter 14: Errors and Exceptions ......................................................................................377
Part II: Visual Studio
Chapter 15: Visual Studio 2008 ..........................................................................................401
Chapter 16: Deployment .....................................................................................................443
Part III: Base Class Libraries
Chapter 17: Assemblies ......................................................................................................469
Chapter 18: Tracing and Events ..........................................................................................509
Chapter 19: Threading and Synchronization .........................................................................533
Chapter 20: Security ..........................................................................................................583
Chapter 21: Localization .....................................................................................................639
Chapter 22: Transactions ...................................................................................................679
Chapter 23: Windows Services ...........................................................................................715
Chapter 24: Interoperability ................................................................................................749
Part IV: Data
Chapter 25: Manipulating Files and the Registry .................................................................791
Chapter 26: Data Access ....................................................................................................845
Chapter 27: LINQ to SQL .....................................................................................................895
Chapter 28: Manipulating XML............................................................................................921
Chapter 29: LINQ to XML ....................................................................................................967
Chapter 30:.NET Programming with SQLServer ....................................................................985
Part V: Presentation
Chapter 31: Windows Forms .............................................................................................1017
Chapter 32: Data Binding .................................................................................................1061
Chapter 33: Graphics with GDI+ ........................................................................................1093
Chapter 34: Windows Presentation Foundation ..................................................................1149
Chapter 35: Advanced WPF ..............................................................................................1199
Chapter 36: Add-Ins .........................................................................................................1251
Chapter 37: ASP.NET Pages ..............................................................................................1273
Chapter 38: ASP.NET Development ...................................................................................1311
Chapter 39: ASP.NET AJAX ...............................................................................................1355
Chapter 40: Visual Studio Tools for Office .........................................................................1385
Part VI: Communication
Chapter 41: Accessing the Internet ..................................................................................1423
Chapter 42: Windows Communication Foundation .............................................................1455
Chapter 43: Windows Workflow Foundation .......................................................................1487
Chapter 44: Enterprise Services ........................................................................................1527
Chapter 45: Message Queuing ..........................................................................................1555
Chapter 46: Directory Services .........................................................................................1587
Chapter 47: Peer-to-Peer Networking ................................................................................1625
Chapter 48: Syndication ...................................................................................................1643
Part VII: Appendices
Appendix A: ADO.NET Entity Framework ............................................................................1655
Appendix B: C#, Visual Basic, and C++/CLI ......................................................................1681
Appendix C: Windows Vista and Windows Server 2008

插图详解C# 2008

2008-09-18 16:19:47

1、C#和.NET FRAMEWORK 关系；
2、C#程序概述；
3、类型、存储和变量；
4、C#类基础；
5、c#方法；
6、其他类；
7、类和继承；
8、输出和操作；
9、声明类；
10、命名空间和集合；
11、例外；
12、结构；
13、举例；
14、数组；
15、赋值；
16、事件；
17、接口；
18、转化；
19、属性；
20、……

C#大学教程

2008-09-09 20:22:00

目录
第1章 .NET的C#简介

1.1 简介
1.2 Internet和WWW的历史
1.3 W3C
1.4 可扩展标记语言
1.5 软件发展的斗争趋势：对象技术
1.6 微软.NET简介
1.7 C#
1.8 .NET框架和通用语言运行时
1.9 本书一览
1.10 小结
1.11 Internet和万维网资源

第2章 Visual Studio .NET IDE简介

2.1 简介
2.2 Visual Studio .NET集成开发环境概览
2.3 菜单条和工具条
2.4 Visual Studio .NET窗口
2.5 使用帮助
2.6 简单的程序：显示文本和图像
2.7 小结

第3章 C#编程简介

3.1 简介
3.2 简单的程序：打印一行文本
3.3 另一个简单的程序：添加整数
3.4 内存概念
3.5 算术运算
3.6 做出判断：判等和关系运算符
3.7 小结

第4章控制结构（一）

4.1 简介
4.2 算法
4.3 伪代码
4.4 控制结构
4.5 if选择结构
4.6 if/else选择结构
4.7 While重复结构
4.8 设计算法：实例研究1（计算器控制的重复）
4.9 使用自顶向下、逐步完善的方法设计算法：实例研究2（哨兵控制的重复）
4.10 使用自顶向下、逐步完善的方法设计算法：实例研究3（嵌套控制结构）
4.11 同步值运算符
4.12 自增和自减运算符
4.13 Windows应用编程简介
4.14 小结

第5章控制结构（二）

5.1 简介
5.2 计数器控制重复的要点
5.3 for重复结构
5.4 使用for结构的例子
5.5 switch多选择结构
5.6 do/while重复结构
5.7 语句break和continue
5.8 逻辑和条件运算符
5.9 结构化编程小结
5.10 小结

第6章方法

6.1 简介
6.2 C#中的方法
6.3 Math类方法
6.4 方法
6.5 方法定义
6.6 变元提升
6.7 C#名字空间
6.8 值类型和引用类型
6.9 传递变元：值传递和引用传递
6.10 随机数生成器
6.11 案例：机会游戏
6.12 变量的持续时间
6.13 作用域规则
6.14 递归
6.15 使用递归的例子：Fibonacci数列
6.16 递归与迭代
6.17 方法重载
6.18 小结

第7章数组

7.1 简介
7.2 数组
7.3 声明和分配数组
7.4 使用数组的示例
7.5 将数组传递给方法
7.6 按值和按引用传递数组
7.7 数组排序
7.8 数组查找：线性查找和折半查找
7.9 多下标数组
7.10 foreach循环结构
7.11 小结

第8章基于对象的编程

8.1 简介
8.2 用类实现Time抽象数据类型
8.3 类的范围
8.4 控制对成员的访问
8.5 初始化类对象：构造函数
8.6 使用重载构造函数
8.7 属性
8.8 复合：将对象引用当做其他类的实例变量
8.9 使用this引用
8.10 垃圾收集
8.11 static类成员
8.12 const和readonly成员
8.13 索引器
8.14 数据抽象和信息隐藏
8.15 软件重用性
8.16 名字空间和组件
8.17 Class View和Object Browser
8.18 小结

第9章面向对象编辑：继承

9.1 简介
9.2 基类和派生类
9.3 protected和internal成员
9.4 基类和派生类的关系
9.5 实例研究：三级继承
9.6 派生类的构造函数和析构函数
9.7 使用继承的软件工程
9.8 小结

第10章异常处理

10.1 简介
10.2 异常处理概述
10.3 例子：除数为0异常
10.4 .NET异常的层次
10.5 finally块
10.6 异常的属性
10.7 程序员定义的异常类
10.8 用运算符checked和unchecked处理溢出
10.9 小结

第11章图形用户界面概念

11.1 简介
11.2 Windows窗体
11.3 事件处理模型
11.4 控件属性和布局
11.5 标签、文本框和按钮
11.6 组合框和面板
11.7 复选框和单选按钮
11.8 图片框
11.9 鼠标事件处理
11.10 键盘事件处理
11.11 可视化继承
11.12 小结

第12章多线程

12.1 简介
12.2 线程状态：线程生命周期
12.3 线程优先级和线程调度
12.4 小结

第13章字符串和字符

13.1 简介
13.2 字符和字符串基础知识
13.3 字符串构造函数
13.4 字符索引器、属性Length和方法CopyTo
13.5 字符串比较
13.6 字符串的方法GetHashCode
13.7 在字符串中定位字符和子串
13.8 从字符串中提取子串
13.9 连接字符串
13.10 各种字符串方法
13.11 类StringBuilder
13.12 StrigBuilder的索引器、属性Length和Capacity以及方法EnsureCapacity
13.13 StrigBuilder的方法Append和AppendFormat
13.14 StrigBuilder的Insert、方法Remove和Replace
13.15 方法Char
13.16 洗牌和发牌模拟程序
13.17 小结

第14章图形

14.1 简介
14.2 图形环境和图形对象
14.3 颜色控件
14.4 字体控件
14.5 画线、画矩形和画椭圆
14.6 装载、显示和放缩图像
14.7 小结

第15章文件和流

15.1 简介
15.2 数据层次
15.3 文件和流
15.4 创建顺序访问文件
15.5 从顺序访问的文件中读取数据
15.6 小结

第16章数据库、SQL和ADO.NET

16.1 简介
16.2 关系数据库模型
16.3 关系数据库概述：Books数据库
16.4 结构化查询语言
16.5 ADO.NET对象模型
16.6 使用ADO.NET编程：从数据库中提取信息
16.7 小结

第17章 ASP.NET、Web表单和Web控件

17.1 简介
17.2 简单的HTTP事务
17.3 体系结构
17.4 创建和运行一个简单的Web表单实例
17.5 小结
17.6 Internet和万维网资源

第18章可扩展标记语言

18.1 简介
18.2 XML文档
18.3 XML名字空间
18.4 文档对象模型
18.5 小结
18.6 Internet和万维网资源

第19章 ASP.NET和Web服务

19.1 简介
19.2 Web服务
19.3 简单对象访问协议和Web服务
19.4 发布和消费Web服务
19.5 小结

第20章联网：基于流的套接字

20.1 简介
20.2 建立一个简单的服务器（使用流套接字）
20.3 建立一个简单的客户端（使用流套接字）
20.4 流套接字连接的客户/服务器交互
20.5 小结

第21章 FCL集合类

21.1 简介
21.2 集合类
21.3 小结

第22章可访问性

22.1 简介
22.2 规则和资源
22.3 Web可访问性动议
22.4 为图像提供可选择性
22.5 通过集中结构最大化可读性
22.6 Visual Studio .NET的可访问性
22.7 C#的可访问性
22.8 XHTML表格的可访问性
22.9 XHTML框架的可访问性
22.10 XML的可访问???
22.11 在VoiceXML中使用声音合成和识别
22.12 CallXML
22.13 JAWS for Windows
22.14 其他可访问性工具
22.15 微软Windows 2000 的可访问性
22.16 小结
22.17 Internet和万维网资源

第23章移动Internet工具包

23.1 简介
23.2 移动Internet工具包客户端设备
23.3 移动Internet工具包和移动Web表单
23.4 小结
23.5 Internet和万维网资源

附录A 运算符优先级表
附录B 记数系统
附录C Visual Studio .NET调试器
附录D ASCII码字符集
附录E 半于Unicode标准
附录F HTML 4简介
附录G HTML 4介绍
附录H HTML特殊字符
附录I HTML颜色
附录J Visual Studio .NET下的水晶报表

C#编程语言详解

2008-09-02 21:44:49

【本书评语】
“本系列丛书对于使用.NET Framework和Web服务的开发者来说是一套优秀的教材。它涵盖了掌握各种开发语言所需的所有基本知识。这套丛书中的著述对于希望编写严谨受控代码的开发者来说非常有价值。”
——John Montgomery,Microsoft公司Developer Platform and Evangelism部门主管

“这套丛书是由Microsoft .NET Framework及其编程语言的专家编著的。其作者由业界最优秀的作家以及Microsoft的软件设计师和开发者组成。”
——Don Box,Microsoft公司软件设计师

【内容简介】
C#是一门简单、现代、优雅、面向对象、类型安全、平台独立的组件编程语言，是.NET的关键性语言，也是整个.NET平台的基础，它使程序员能快速地为新一代Microsoft.Net平台开发出应用程序。全书以通俗易懂的语言，精辟丰富的实例，从对C#的简介开始，全面讲解了C#编程语言规范以及各个层面的特性，内容包括C#的词法结构、类型、变量、表达式、类、结构、不安全代码、泛型，等等。
本书内容翔实，实用性强，适合作为高等院校学生学习编程语言的教材，也是希望深入探索C#编程知识的广大程序开发人员绝佳的技术参考书。

【转CSDN读书频道黄鸣对本书的评论】
……也几乎成孤本绝版了。你可以不知道此书，但是你不应该不知道作者Anders Hejlsberg，C#之父，Delphi之父。这本书是当年最早讲C#2.0的书也只有Anders Hejlsberg在那个年代先为大家传道泛型。书中前面讲了1.1的语法后面是2.0的泛型，迭代器，匿名方法。没有设计高级知识。大师就是大师，这本书讲知识点讲滴水不漏，讲的最深，书中文字很枯燥，不知道是不是作者就这么写的。

Programming ASP.NET 中文版(第3版)附源码

2008-08-26 20:07:21

经典中的经典，全球经典，五年三版，权威著作，这本书是最最基础的ASP.NET入门书，讲的非常全涵盖所有基本面，每一个控件都细细说明，非常易懂，不过本书讲的难免有点杂，初学者看了难免云里雾里所以要下一本书提纲挈领，此书非看不可。

本书主要介绍.NET平台和ASP.NET；HTML编程基础；比较ASP和ASP.NET；ASP.NET中的事件；比较HTML控件和ASP控件；基本的ASP控件API；代码隐藏窗体；使用Visual Studio .NET集成开发环境；跟踪，调试和错误处理；ASP.NET中的验证控件；数据绑定技术基础；列表控件和DataGrid控件；ADO.NET指南；调用存储过程；更新数据库记录；Repeater和DataList控件；自定义ASP.NET控件；Web服务概观；创建和消费一个用于证券报价机的Web服务示例；解释ASP.NET缓存技术；ASP.NET中用于验证、授权和模拟的安全选项；ASP.NET中的配置和部署选项；一个数据库设计快速指南的附录。\r\n 本书对于ASP.NET 2.0技术和Visual Studio 2005进行了全面讲解，出色地囊括了读者在实际编程中会用到的ASP.NET的重要特性，十分适合初中级读者。

C# 3.0 Unleashed: With the .NET Framework 3.5,Second Edition

2008-08-18 20:42:56

C# 3.0的好书,涵盖了.NET FRAMEWORK 3.5,刚出版的.

目录
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Part 1 Learning C# Basics
1 Introducing the .NET Platform. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Getting Started with C# and Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3 Writing C# Expressions and Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4 Understanding Reference Types and Value Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5 Manipulating Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6 Arrays and Enums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
7 Debugging Applications with Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Part 2 Object-Oriented Programming with C#
8 Designing Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
9 Designing Object-Oriented Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
10 Coding Methods and Custom Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
11 Error and Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
12 Event-Based Programming with Delegates and Events. . . . . . . . . . . . . . . . . . . . . . . . . 249
13 Naming and Organizing Types with Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
14 Implementing Abstract Classes and Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Part 3 Applying Advanced C# Language Features
15 Managing Object Lifetime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
16 Declaring Attributes and Examining Code with Reflection. . . . . . . . . . . . . . . . . . . 339
17 Parameterizing Type with Generics and Writing Iterators . . . . . . . . . . . . . . . . . . . . 365
18 Using Lambda Expressions and Expression Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Part 4 Learning LINQ and .NET Data Access
19 Accessing Data with LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
20 Managing Data with ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
21 Manipulating XML Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
22 Creating Data Abstractions with the ADO.NET Entity Framework . . . . . . . . . 475
23 Working with Data in the Cloud with ADO.NET Data Services . . . . . . . . . . . . . 491
Part 5 Building Desktop User Interfaces
24 Taking Console Applications to the Limit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
25 Writing Windows Forms Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
26 Creating Windows Presentation Foundation (WPF) Applications . . . . . . . . . . 547
Part 6 Designing Web User Interfaces
27 Building Web Applications with ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
28 Adding Interactivity to Your Web Apps with ASP.NET AJAX. . . . . . . . . . . . . . . . . 619
29 Crafting Rich Web Applications with Silverlight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
Part 7 Communicating with .NET Technologies
30 Using .NET Network Communications Technologies . . . . . . . . . . . . . . . . . . . . . . . . . . 661
31 Building Windows Service Applications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
32 Remoting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695
33 Writing Traditional ASMX Web Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
34 Creating Web and Services with WCF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725
Part 8 Examining .NET Application Architecture and Design
35 Using the Visual Studio 2008 Class Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
36 Sampling Design Patterns in C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755
37 Building N-Tier/Layer Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779
38 Automating Logic with Windows Workflow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797
Part 9 Surveying More of the .NET Framework Class Library
39 Managing Processes and Threads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817
40 Localizing and Globalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831
41 Performing Interop (P/Invoke and COM) and Writing Unsafe Code . . . . . . 853
42 Instrumenting Applications with System.Diagnostics Types . . . . . . . . . . . . . . . . . 879
Part 10 Deploying Code
43 Assemblies and Versioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921
44 Securing Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933
45 Creating Visual Studio 2008 Setup Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 947
46 Deploying Desktop Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
47 Publishing Web Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 961
Part 11 Appendixes
A Compiling Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 969
B Getting Help with the .NET Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977

C#三层结构程序设计

2008-08-06 02:37:44

三层结构程序设计 UI introduction DAL BLL Summary
有5个视频教程,每个有20多分钟,讲师很好 ,附源代码. 用7Z压缩,请用WINRAR3.7以上版本

C#软件项目开发全程剖析——全面透视SharpDevelop软件的开发内幕

2008-07-31 19:56:15

SharpDevelop是一个功能完备的免费IDE。本书全面介绍了SharpDevelop开发人员如何利用C#从头到尾实现SharpDevelop的各种界面和功能，从而展示了一个大型C#软件项目的开发过程以及在这个开发过程中所涉及到的具体编程技术、决策思想、问题和解决方案等内容。
本书非常适合那些有一定编程经验并想全面掌握软件项目开发过程以及相关技术的中高级C#开发人员。也可以作为各高等院校和软件学院在软件开发项目方面的参考书目。
第1章功能简介

1.1 ShapDevelop的设计理念
1.2 SharpDevelop软件要求
1.3 ShapDevelop的面板和视图
1.4 ShapDevelop的局限性
1.5 定制ShafpDevelop
1.5.l 国际化支持
1.5.2 定义外观
1.6 定制编码
1.6.1 使用模板
1.6.2 语法醒目显示
1.6.3 代码自动完成和方法识别
1.6.4 书签
1.6.5 查找和替换功能
1.6.6 编译代码
1.7 管理项目
1.7.1 项目组和项目
1.7.2 项目导航
1.8 创建 Windows Forms
1.8.1 向 Windows Forms添加控件
1.8.2 控件的属性和格式
1.9 小结

第2章体系结构设计

2.1 体系结构设计决策史
2.1.1 开及早期.
2.1.2 用SharpDevelop进行SharpDevelop开发
2.1.3 更正错误的设计决策
2.2 设计决策
2.3 最佳惯例
2.3.1 设计模式
2.3.2 编码样式指导原则
2.3.3 故障跟踪和测试
2.3.4 屡次重构
2.4 小结

第3章实现核心功能

3.1 Addln树
3.1.l使用Addln树的优点
3.1.2 Addln树的上层结构
3.1.3 插件定义
3.1.4 从树节点到运行对象
3.1.5 创建密码子
3.1.6 条件二
3.2 插件管理
3.3 ShamDevelop的属性管理
3.3.1 IXm汇nvertable接口的开发理念
3.3.2 Propertes接口简介
3.3.3 默认实现方式
3.3.4 属性的作用
3.3.5 属性的持久性
3.4小结

第4章用插件创建应用程序

4.1 使用密码子
4.1 1ICmmand接口
4.1.2 激活菜单
4.1.3 密码子简介
4.2 通过条件接合插件
4.2.l 条件结构
4.2.2 定义条件
4.2.3 可用条件简介
4. 3 小结

第5章通过工作区服务提供功能

5.1 实现考虑事项
5.1.1 对服务的要求
5.l.2 ServiceManager类
5.1.3 定义服务
5.2 服务中的通用服务
5.2.1 文件实用程序服务
5.2.2 属性服务
5.2.3 资源服务
5.2.4 字符串分析器服务
5.2.5 环境服务
5.2.6 类例览器图标服务
5.2.7 文件服务
5.2.8 项目服务
5.2.9 分析器服务
5.2.10 其他服务
5.3 小结

第6章用户界面

6.1 显示管理工具
6.1.1 工作台窗口
6.1.2 视图
6.1.3 面板
6.1.4 视图和面板的应用——一个集成的HTML帮助查看器
6.1.5 布局管理器
6.2 当前和未来的实现方式
6.3 小结

第7章国际化

7.1 在SharpDevelop中处理国际化
7.1.1 童绘事件
7.1.2 资源历问
7.2 管理转换
7.2.l 转换Web应用程序
7.2.2 编译为资源文件
7.3 小结

第8章文档管理

8.1 文本表示
8.1.l 基本顺序数据结构
8.1.2 间隙缓冲区方法
8.1.3未来的数据表示结构——接合表
8.2 行的表示
8.3 插入符和选择管理
8.4 文本模型
8.5 内容组合
8.6 小结

第9章语法醒目显示

9.1语法醒目显示定义·
9.1.1 增强XML使用的便捷性
9.1.2 实现语法醒目显示
9.2 小结

第10章查找和替换

10.1 查找策略
10.2 深入分析查找和替换
10.2.1 基本的查找和替换实现
10.2.2 使用算法
10.2.3 通配符查找策略
10.3 小结

第11章编写编辑器控件

11.1 编辑器简介
11.2 TCXtAfC＆控件
11.2.1 理论
11.2.2 开始构建编辑器控件
11.2.3 事件处理
11.2.4 更新
11.3 TextAreaPainter
11.4 鼠标管理
11.5 折叠
11.6 SharpPad
11.7 小结

第12章编写分析器

12.1分析器需求
12.2分析器和语言原理
12.3 SharpDevelop分析器
12.3.l 设计决策
12.3.2 实现
12.4 小结

第13章代码自动宪成以及方法识别

13.l 分解内容
13.2 代码自动完成
13.3 方法识别
13.4 小结

第14章利用类搜索和程序集搜索导航代码

14.1 类搜索
14.2 程序集搜索
14.2.1 使用程序集搜索划览引用
14.2.2 编写程序集搜索
14.3 小结

第15章设计器基础结构

15.1 窗体设计器概述
15.1.1 实现考虑
15.1.2 设计概述
15.2 .NET组件模型
15.2 服务接口
15.2.2 .NET设计器
15.2.3 根设计器
15.3 设计器主机实现
15.3.1 设计器主机服务
15.3.2 设计面板
15.4 小结

第16章实现 Windows Forms设计器

16.1 设计器服务
16.1.1 具箱服务
16.1.2 菜单命令服务
16.1.3 选取服务
16.1.4 其他重要服务
16.2小结

第17章代码生成

17.1 永久保存组件
17.1.1 XML窗体永久格式
17.1.2 生成 XML
17.1.3 加载 XML
17.1.4 设计器串行化服务
17.2 生成C＃/VB.NET代码
17.3 回递
17.4 小结

ASP.NET AJAX程序设计：第2卷

2008-07-25 20:56:36

【内容简介】
本书系统介绍ASP.NET Ajax程序设计知识，共3卷。本卷从最易于理解和使用的那部分入手，介绍ASP.NET AJAX框架中能够与传统ASP.NET无缝对接的服务器端部分，包括服务器端ASP.NET AJAX Extensions与ASP.NET AJAX Control Toolkit。这部分内容不需要读者有任何的客户端开发知识，只要在Visual Stuio中轻松拖放即可实现强大的客户端Ajax功能，例如局部页面更新、异步回送、拖放、动画等，非常适合为现有的ASP.NET 2.0应用程序添加少量的Ajax特性，或是基于ASP.NET 2.0的一些简单Ajax功能的实现。
本卷适合对ASP.NET AJAX有兴趣，并希望对其有更进一步了解的Web开发人员阅读。

【作者简介】
陈黎夫（Dflying Chen）微软公司Atlas创始团队——Windows Live Hotmail的软件开发工程师，曾使用Atlas参与开发下一代Email系统Windows Live Mail以及Windows Live Calendar等产品，擅长Web相关技术，有着近8年的Web开发经验。作为Atlas在中国的传道者之一，他在个人博客（http://dflying.cnblogs.com/）中写过大量的Atlas技术文章，并引起了广泛反响。

Teach Yourself Visual C# 2008 in 24 Hours: Complete Starter Kit (24小时自学VC#2008 2008最新版)

2008-06-20 09:25:39

Sams Teach Yourself Visual C#? 2008 in 24 Hours

In just 24 sessions of one hour or less, you will be up and running with
Visual C# 2008. Using a straightforward, step-by-step approach, each
lesson builds upon the previous one, allowing you to learn the
essentials of Visual C# from the ground up.

By the Way notes present interesting pieces of information.

Did You Know? tips offer advice or teach an easier way to do something.

Watch Out! cautions advise you about potential problems and help you
steer clear of disaster.

Learn how to...
- Use the powerful design environment of Visual Studio 2008
- Design a feature-rich interface using components such as tree views
and tabs
- Create robust applications using modern error handling
- Draw fast graphics using GDI+
- Build a database application using ADO.NET
- Distribute a Visual C# 2008 application

James Foxall is vice president of Tigerpaw Software, Inc.
(www.tigerpawsoftware.com), a Bellevue, Nebraska, Microsoft Certified
Partner specializing in commercial database applications. He manages the
development, support, training, and education of Tigerpaw CRM+, an
award-winning application that automates contact management, marketing,
service and repair, proposal generation, inventory control, and
purchasing. Tigerpaw has more than 20,000 licensed users in 27
countries. Foxall’s experience in creating certified Office-compatible
software has made him an authority on application interface and behavior
standards. In addition to being a well-known author, James is an
international speaker on Microsoft technologies, has taught at the
college level, and contributes to several journals.

Introduction................................................................................ 1
Part I: The Visual C# 2008 Environment
HOUR 1 Jumping In with Both Feet: A Visual C# 2008 Programming Tour ........ 7
2 Navigating Visual C# 2008 ......................................................... 31
3 Understanding Objects and Collections ......................................... 59
4 Understanding Events ................................................................ 81
Part II: Building a User Interface
HOUR 5 Building Forms—The Basics ....................................................... 101
6 Building Forms—Advanced Techniques ....................................... 123
7 Working with Traditional Controls ............................................. 151
8 Using Advanced Controls .......................................................... 177
9 Adding Menus and Toolbars to Forms ......................................... 197
Part III: Making Things Happen: Programming
HOUR 10 Creating and Calling Methods ................................................... 221
11 Using Constants, Data Types, Variables, and Arrays ...................... 241
12 Performing Arithmetic, String Manipulation, and Date/Time
Adjustments ........................................................................... 267
13 Making Decisions in Visual C# Code ........................................... 285
14 Looping for Efficiency ............................................................... 297
15 Debugging Your Code ............................................................... 309
16 Designing Objects Using Classes ................................................. 333
17 Interacting with Users ............................................................... 351
18 Working with Graphics.............................................................. 371
Part IV: Working with Data
HOUR 19 Performing File Operations ........................................................ 395
20 Working with Text Files and the Registry ...................................... 413
21 Working with a Database ......................................................... 437
22 Controlling Other Applications Using Automation ........................ 453
Part V: Developing Solutions and Beyond
HOUR 23 Deploying Applications ............................................................ 469
24 The 10,000-Foot View................................................................ 479
Index ..................................................................................... 487

LINQ for Visual C Sharp 2008 (Visual C# 2008 LINQ编程 2008最新版)

2008-06-20 09:14:55

Every C# programmer needs to learn about LINQ (Language杔Integrated
Query), Microsoft抯 breakthrough technology for simplifying and unifying
data access from any data source. With LINQ you can write more elegant
and flexible code not just to access databases and files but to
manipulate data structures and XML. This book is a short yet
comprehensive guide to the major features of LINQ and the significant
enhancements introduced with .NET 3.5. There is no better source for
getting a head杝tart on the future of these technologies than this book.
- A clear and comprehensive yet concise introduction to using LINQ in
C#
- Covers LINQ to Objects, LINQ to SQL, LINQ to DataSet, and LINQ to
XML
- Rich in working examples of LINQ in action

Co

Chapter 1: LINQ to Objects .........................................................2
Introduction.............................................................................................2
A Simple C# 3.0 LINQ to Objects Program...........................................2
Extension Methods..................................................................................4
Lambda Expressions ...............................................................................6
Expression Trees .....................................................................................7
Object Initialization Expressions ...........................................................8
Anonymous Types ...................................................................................9
Implicitly Typed Local Variables..........................................................10
Query Evaluation Time.........................................................................11
Standard Query Operators....................................................................15
Restriction Operator .................................................................................... 22
Projection Operators.................................................................................... 25
Join Operators.............................................................................................. 29
Grouping Operator ...................................................................................... 33
Ordering Operators...................................................................................... 38
Aggregate Operators.................................................................................... 43
Partitioning Operators ................................................................................. 51
Concatenation Operator............................................................................... 54
Element Operators....................................................................................... 55
Generation Operators .................................................................................. 61
Quantifier Operators.................................................................................... 63
Equality Operator ........................................................................................ 65
Set Operators ............................................................................................... 66
Conversion Operators.................................................................................. 69
Summary................................................................................................75
Chapter 2: LINQ to ADO.NET.....................................................76
Introduction...........................................................................................76
Database Interaction.............................................................................77
Mapping a Class to a Database Table ......................................................... 77
Mapping Fields and Properties to Table Columns ...................................... 78
Creating a Data Context .............................................................................. 83
Querying a Database with LINQ to SQL.................................................... 85
Adding, Modifying, and Deleting Rows ..................................................... 89
DataContext: Advanced Features ........................................................92
Defining Relationships Between Entities.................................................... 92
Using Two Related Entity Classes ............................................................ 101
Other LINQ to SQL Features.............................................................105
SQLMetal .................................................................................................. 105
The INotifyPropertyChanging Interface ................................................... 108
Optimistic Concurrency and Database Transactions ................................ 110
Stored Procedures...................................................................................... 116
User-Defined Functions ............................................................................ 123
Database Creation...................................................................................... 125
LINQ to SQL in Visual Studio 2008 ..................................................127
A Linq to SQL File Designer Example..................................................... 127
Debugging LINQ Applications ................................................................. 138
LINQ to DataSet..................................................................................145
Summary..............................................................................................149
Chapter 3: LINQ to XML .......................................................... 150
Introduction.........................................................................................150
Querying XML ....................................................................................150
Searching for Attribute Values.................................................................. 154
The Descendants and Ancestors Methods................................................. 155
Querying XML for Content Type ............................................................. 156
Querying an XML Document That Uses Schemas ................................... 157
The ElementsBeforeSelf and ElementsAfterSelf Methods....................... 160
Miscellaneous Functionalities ................................................................... 161
Creating and Modifying XML Documents ........................................165
Creating an XML Document from Scratch............................................... 165
Loading and Saving XML......................................................................... 171
Modifying XML........................................................................................ 173
LINQ to XML and LINQ to SQL ............................................................. 180
Summary..............................................................................................184
Related Titles ......................................................................... 185
Copyright ............................................................................... 186
What Is LINQ?....................................................................................192
Why LINQ? .........................................................................................192
What You Need to Use LINQ .............................................................195
Resources.............................................................................................195
What’s Next? .......................................................................................196

BeginningMicrosoftVisualCSharp2008

2008-06-20 06:58:40

C# is a relatively new language that was unveiled to the world when Microsoft announced the first
version of its .NET Framework in July 2000. Since then its popularity has rocketed, and it has arguably
become the language of choice for both Windows and Web developers who use the .NET Framework.
Part of the appeal of C# comes from its clear syntax, which derives from C/C++ but simplifies some
things that have previously discouraged some programmers. Despite this simplification, C# has retained
the power of C++, and there is now no reason not to move into C#. The language is not difficult, making
it a great one to learn elementary programming techniques with. This ease of learning, combined with
the capabilities of the .NET Framework, make C# an excellent way to start your programming career.
The latest release of C#, C# 3.0, which is included with version 3.5 of the .NET Framework, builds on the
existing successes and adds even more attractive features. Some of these, again, have their roots in C++ —
at least superficially — but some are entirely new. The latest releases of Visual Studio and the Express line
of development tools also bring many tweaks and improvements to make your life easier and
dramatically increase your productivity.
This book is intended to teach you about all aspects of C# programming, from the language itself,
through Windows and Web programming, to making use of data sources, and finally to some
advanced techniques such as graphics programming. You ’ ll also learn about the capabilities of Visual C#
Express 2008, Visual Web Developer Express 2008, and Visual Studio 2008, and all the ways that these
products can aid your application development. The book is written in a friendly, mentor - style fashion,
with each chapter building on previous ones, and every effort is made to ease you into advanced
techniques painlessly. At no point do technical terms appear from nowhere to discourage you from
continuing; every concept is introduced and discussed as required. Technical jargon is kept to a
minimum, but where it is necessary, it too is properly defined and laid out in context.
The authors of this book are all experts in their fields, and are enthusiastic in their passion for both the
C# language and the .NET Framework. Nowhere will you find a group of people better qualified to take
you under their collective wing and nurture your understanding of C# from first principles to advanced
techniques. Along with the fundamental knowledge it provides, this book is packed full of helpful hints,
tips, exercises, and full - fledged example code (available for download at p2p.wrox.com ) that you will
find yourself using time and again as your career progresses.
We pass this knowledge on without begrudging it, and hope that you will be able to use it to become the
best programmer you can be. Good luck, and all the best!

Beginning Microsoft Visual C# 2008

2008-06-20 03:28:52

2008年5月出版

Part I: The C# Language
Chapter 1: Introducing C# ....................................................... 3
Chapter 2: Writing a C# Program ................................................ 13
Chapter 3: Variables and Expressions ........................................... 31
Chapter 4: Flow Control ........................................................ 59
Chapter 5: More About Variables ................................................ 93
Chapter 6: Functions .......................................................... 125
Chapter 7: Debugging and Error Handling ....................................... 155
Chapter 8: Introduction to Object-Oriented Programming......................... 185
Chapter 9: Defining Classes ................................................... 209
Chapter 10: Defining Class Members ............................................ 241
Chapter 11: Collections, Comparisons, and Conversions ......................... 277
Chapter 12: Generics .......................................................... 331
Chapter 13: Additional OOP Techniques.......................................... 371
Chapter 14: C# 3.0 Language Enhancements ...................................... 399
Part II: Windows Programming
Chapter 15: Basic Windows Programming ......................................... 433
Chapter 16: Advanced Windows Forms Features ................................... 493
Chapter 17: Using Common Dialogs .............................................. 537
Chapter 18: Deploying Windows Applications .................................... 583
Part III: Web Programming
Chapter 19: Basic Web Programming ............................................. 627
Chapter 20: Advanced Web Programming .......................................... 671
Chapter 21: Web Services ...................................................... 709
Chapter 22: Ajax Programming .................................................. 739
Chapter 23: Deploying Web Applications ........................................ 759
Part IV: Data Access
Chapter 24: File System Data .................................................. 777
Chapter 25: XML ............................................................... 819
Chapter 26: Introduction to LINQ .............................................. 849
Chapter 27: LINQ to SQL ....................................................... 895
Chapter 28: ADO.NET and LINQ over DataSet ..................................... 933
Chapter 29: LINQ to XML ....................................................... 993
Part V: Additional Techniques
Chapter 30: Attributes ....................................................... 1019
Chapter 31: XML Documentation ................................................ 1049
Chapter 32: Networking ....................................................... 1075
Chapter 33: Introduction to GDI+ ............................................. 1107
Chapter 34: Windows Presentation Foundation .................................. 1143
Chapter 35: Windows Communication Foundation ................................. 1215
Chapter 36: Windows Workflow Foundation ...................................... 1247
Index ........................................................................ 1279

Microsoft Visual C# 2008 Step by Step

2008-06-03 10:55:04

本书是针对Microsoft Visual C# 2008最新特性而设计的入门指导手册。Visual C#是Microsoft Visual Studio 2008套件中的一个重要组成部分，是一种现代化的编程语言，设计来解决商务应用中的现实问题。无论您是一名初出茅庐的编程员还是经验丰富但初次接触Visual C#，您都可以在这本书里学到Visual Studio 2008的基础特性以及简单易行地理解如何使用Visual C#。您可以遵循自己的节奏，逐步而又实践地训练，学会使用Windows应用程序，并且结合您所有的知识来构建您的第一个Visual C#基础应用程序。在每一个章节中，您都可一“边学边做”，书中提供的实例会告诉您怎样、何时以及为何要使用Visual C#这一高效的程序开发环境。

C#宝典

2008-05-23 17:24:26

作者:佛格森译者:王勇

基本信息·出版社：电子工业出版社
·页码：584 页码
·出版日：2002年
·ISBN：7505380877
·条码：9787505380875
·版次：2002-11-01
·装帧：平装
·开本：16开 16开

--------------------------------------------------------------------------------
内容简介
　　C#是微软在Visual Studio.NET产品中提供的一种全新编程语言,也是一个重要的开发工具.利用C#作为实现语言可以开发下一代桌面及具有Internet功能的应用程序. 全书共分5个部分并包括1个附录,向读者展示了使用这种崭新的语言进行编程的各个方面.包括C#语言的基础知识,利用C#进行面向对象的编程,C#的高级语言功能,使用C#开发.NET解决方案以及C#与.NET框架的相关内容.附录中概括介绍了XML的入门知识. 本书内容全面,语言简炼,实例丰富,适合于初学者,也能够满足各种程序的程序员和正在进行.NET应用程序开发的读者的需求.

--------------------------------------------------------------------------------
编辑推荐
　　C#是微软在Visual Studio.NET产品中提供的一种全新编程语言,也是一个重要的开发工具.利用C#作为实现语言可以开发下一代桌面及具有Internet功能的应用程序. 全书共分5个部分并包括1个附录,向读者展示了使用这种崭新的语言进行编程的各个方面.包括C#语言的基础知识,利用C#进行面向对象的编程,C#的高级语言功能,使用C#开发.NET解决方案以及C#与.NET框架的相关内容.附录中概括介绍了XML的入门知识. 本书内容全面,语言简炼,实例丰富,适合于初学者,也能够满足各种程序的程序员和正在进行.NET应用程序开发的读者的需求.

--------------------------------------------------------------------------------
目录
前言
第1部分 C#语言基础知识
第1章 C#概述
第2章编写第一个C#程序
第3章变量的使用
第4章表达式
第5章控制代码的流程
第6章方法
第7章使用结构组合数据
第2部分利用C#进行面向对象的编程
第8章编写面向对象的代码
第9章 C#类
第10章重载运算符
第11章类继承
第3部分高级C#
第12章名字空间
第13章接口
第14章枚举
第15章事件和委托
第16章异常处理
第17章属性
第18章类的版本升级
第19章不安全代码
第20章高级C#构造
第4部分使用C#制定.NET解决方案
第21章创建WindowsForms应用程序
第22章使用WebForm创建Web应用程序
第23章使用ADO.NET进行数据库编程
第24章使用文件和Windows注册表
第25章访问数据流
第26章使用GDI+绘图
第27章创建Web服务
...
第5部分 C#与.NET框架
附录A XML基础知识

C Sharp in Depth

2008-04-29 11:28:48

contents

PART 1 PREPARING FOR THE JOURNEY
1 The changing face of C# development
2 Core foundations: building on C#

PART 2 C# 2: SOLVING THE ISSUES OF C#
3 Parameterized typing with generics
4 Saying nothing with nullable types
5 Fast-tracked delegates
6 Implementing iterators the easy way
7 Concluding C# 2: the final features

PART 3 C# 3—REVOLUTIONIZING HOW WE CODE
8 Cutting fluff with a smart compiler
9 Lambda expressions and expression trees
10 Extension methods
11 Query expressions and LINQ to Objects
12 LINQ beyond collections
13 Elegant code in the new era

appendix LINQ standard query operators
index

Apress.Pro.WPF.in.C.Sharp.2008.2nd.Edition.Feb.2008

2008-04-28 23:39:12

About the Author
About the Technical Reviewer
Acknowledgments
Introduction
-CHAPTER 1 Introducing WPF
-CHAPTER 2 XAML
-CHAPTER 3 The Application
-CHAPTER 4 Layout
-CHAPTER 5 Content
-CHAPTER 6 Dependency Properties and Routed Events
-CHAPTER 7 Classic Controls
-CHAPTER 8 Windows
-CHAPTER 9 Pages and Navigation
-CHAPTER 10 Commands
-CHAPTER 11 Resources
-CHAPTER 12 Styles
-CHAPTER 13 Shapes, Transforms, and Brushes
-CHAPTER 14 Geometries, Drawings, and Visuals
-CHAPTER 15 Control Templates
-CHAPTER 16 Data Binding
-CHAPTER 17 Data Templates, Data Views, and Data Providers
-CHAPTER 18 Lists, Trees, Toolbars, and Menus
-CHAPTER 19 Documents
-CHAPTER 20 Printing
-CHAPTER 21 Animation
-CHAPTER 22 Sound and Video
-CHAPTER 23 3-D Drawing
-CHAPTER 24 Custom Elements
-CHAPTER 25 Interacting with Windows Forms
-CHAPTER 26 Multithreading and Add-Ins
-CHAPTER 27 ClickOnce Deployment
-INDEX

Network Programming in .NET With C# and Visual Basic .NET

2008-04-27 04:15:58

Preface xv
Who should read this book? xv
What hardware and software do you need? xvi
How this book is organized xvi
Part I: Basic network applications xvi
Part II: Network application design xvi
Part III: Specialized networking topics xvii
Conventions used in this book xvii
Further information xviii
Acknowledgments xix
1 Understanding the Internet and Network Programming 1
1.1 Introduction 1
1.2 Why network programming in .NET? 2
1.3 What can a network program do? 2
1.4 IP addresses 3
1.5 The network stack 6
1.6 Ports 7
1.7 Internet standards 7
1.8 What is .NET? 9
1.9 Getting started 11
1.10 Using Visual Studio .NET 12
1.11 Using the .NET SDK 16
1.11.1 Compiling with Visual Basic.NET 19
1.11.2 Compiling with C# 20
1.11.3 Testing the application 20
1.12 Conclusion 20
2 I/O in the .NET Framework 21
2.1 Introduction 21
2.2 Streams 21
2.2.1 Streams for files 22
2.2.2 Encoding data 28
2.2.3 Binary and text streams 29
2.2.4 Serialization 33
2.2.5 Writing a database to a stream 44
2.3 Conclusion 54
3 Working with Sockets 55
3.1 Introduction 55
3.2 What is a socket? 55
3.3 Creating a simple “hello world” application 56
3.3.1 Writing a simple UDP client 57
3.3.2 Writing a simple UDP server 58
3.4 Using TCP/IP to transfer files 62
3.4.1 Writing a simple TCP/IP client 62
3.4.2 Writing a simple TCP/IP server 65
3.5 Debugging network code 73
3.6 Socket-level networking in .NET 75
3.7 Conclusion 86
4 HTTP: Communicating with Web Servers 87
4.1 Introduction 87
4.1.1 Data mining 88
4.2 HTTP 88
4.2.1 The HTTP request 88
4.2.2 The HTTP response 91
4.2.3 MIME types 93
4.2.4 System.Web 93
4.2.5 Posting data 97
4.2.6 A note on cookies 104
4.2.7 A WYSIWYG editor 105
4.3 Web servers 113
4.3.1 Implementing a Web server 114
4.4 System.Net.HttpWebListener 124
4.5 Mobile Web browsers 128
4.5.1 Mobile Web SDK 130
4.6 Conclusion 130\
5 SMTP and POP3: Communicating with email Servers 131
5.1 Introduction 131
5.2 Sending an email 131
5.3 SMTP 132
5.3.1 Implementing SMTP 133
5.4 Post office protocol 3 140
5.4.1 Implementing POP3 141
5.5 System.Web.Mail 148
5.5.1 Attachments 151
5.5.2 Images 153
5.6 Mail application programming interface 153
5.6.1 Accessing the address book 156
5.6.2 IMAP 158
5.6.3 Network news transfer protocol 159
5.7 Conclusion 161
6 FTP: Communicating with File Servers 163
6.1 Background 163
6.2 Microsoft file sharing 163
6.3 Netware file sharing 164
6.4 An overview of FTP 165
6.4.1 How FTP uses ports 167
6.4.2 The FTP handshake 168
6.4.3 Navigating folders 170
6.4.4 FTP command reference 171
6.4.5 Implementing FTP 172
6.4.6 Implementing FTP with the Internet Transfer Control 174
6.4.7 A more substantial implementation of FTP 178
6.4.8 FTP support in .NET 2.0 193
6.5 Conclusion 194
7 Securing a Network: Firewalls, Proxy Servers,
and Routers 195
7.1 Introduction 195
7.1.1 Building a network from scratch 195
7.2 Building an enterprise network 199
7.2.1 Routers 199
7.2.2 Firewalls 200
7.3 Tunneling out of an enterprise network 203
7.4 Avoiding the networking pitfalls 205
7.4.1 Firewall tunneling 206
7.5 Conclusion 207
8 Protecting Data: Encryption 209
8.1 Introduction 209
8.2 Cryptanalysis 209
8.3 Terminology 212
8.4 Asymmetric encryption 212
8.5 Using RSA as asymmetric encryption 213
8.6 Symmetric encryption 218
8.6.1 Using 3DES as symmetric encryption 218
8.7 Piracy protection 224
8.8 Conclusion 225
9 Controlling User Access: Authentication
and Authorization 227
9.1 Introduction 227
9.2 Authentication techniques 227
9.2.1 IIS authentication 228
9.3 Microsoft .NET Passport authentication 230
9.4 Hashing information 232
9.4.1 Hashing algorithms 234
9.4.2 Using SHA 234
9.5 SSL 236
9.6 Certificates 236
9.7 Server certificates 238
9.8 Client certificates 239
9.8.1 Microsoft Certificate Services 240
9.8.2 Reading certificates 241
9.9 Permissions in .NET 244
9.10 Financial network security 246
9.10.1 X.25 247
9.10.2 ISO 8730 247
9.10.3 SWIFT 248
9.10.4 Corporate transactions 248
9.11 Conclusion 249
10 Programming for Scalability 251
10.1 Introduction 251
10.2 Case study: The Google search engine 251
10.3 Replication and redundancy 253
10.4 Scalable network applications 254
10.5 Future proofing 255
10.6 Thread pooling 256
10.6.1 Implementing a thread pool 258
10.7 Avoiding deadlocks 261
10.8 Load balancing 262
10.9 Conclusion 272
11 Optimizing Bandwidth Utilization 275
11.1 Introduction 275
11.2 Tricks and tips to increase performance 275
11.2.1 Caching 276
11.2.2 Keep-alive connections 277
11.2.3 Progressive downloads 278
11.2.4 Tweaking settings 278
11.3 Multicast UDP 282
11.3.1 Multicast basics 282
11.3.2 Multicast routing 283
11.3.3 Implementing multicast 284
11.4 Data compression 289
11.5 Lossless compression 290
11.5.1 Implementing ZIP compression 291
11.6 Lossy compression 296
11.6.1 Audio compression 296
11.6.2 Image compression 298
11.6.3 Video compression 302
11.7 Conclusion 303
12 Ping, DNS, and WHOIS: Monitoring your Network 305
12.1 Introduction 305
12.2 DNS 305
12.2.1 Implementing DNS MX 306
12.3 Ping 314
12.4 WHOIS 321
12.4.1 Telnet 326
12.5 Other members of the TCP/IP suite 327
12.5.1 ARP 327
12.5.2 RIP 327
12.5.3 OSPF 328
12.5.4 BGP/EGP 328
12.5.5 SNMP 328
12.5.6 PPP 328
12.6 WMI 329
12.6.1 Reading WMI data 330
12.6.2 Leveraging WMI 333
12.7 Conclusion 336
13 Analyzing Network Packets 337
13.1 Introduction 337
13.2 IP-level network tapping 339
13.2.1 Interpreting raw network data 344
13.2.2 IP packets in detail 346
13.2.3 ICMP packets in detail 348
13.2.4 TCP/IP packets in detail 349
13.2.5 UDP packets in detail 351
13.2.6 DNS packets in detail 352
13.3 Layer 2 network tapping 354
13.3.1 Using rvPacket and WinPCap 354
13.3.2 Using PacketX and WinPCap 360
13.4 Physical network tapping 366
13.5 Conclusion 376
14 Adding Digital Telephony 379
14.1 Introduction 379
14.2 Basic telephony 380
14.3 Listening for incoming phone calls 382
14.4 DTMF tones 399
14.5 Audio playback 401
14.5.1 Audio playback over TAPI 413
14.6 Conclusion 417
15 Message Queues 419
15.1 Introduction 419
15.2 MSMQ 420
15.3 Implementing a message queue 420
15.3.1 Queuing complex objects 427
15.3.2 Transactions 435
15.3.3 Acknowledgments 437
15.4 Timeouts 439
15.5 Journal 441
15.6 Queued Components 443
15.7 Security 447
15.8 Scalability 449
15.9 Performance issues 451
15.10 Conclusion 452
16 IPv6: Programming for the Next-generation Internet 453
16.1 Introduction 453
16.2 What is IPv6? 453
16.3 The history of IPv6 454
16.4 So what changes? 455
16.5 IPv6 naming conventions 456
16.6 Installing IPv6 457
16.6.1 Auto configuration 457
16.7 Using IPv6 utilities 458
16.7.1 IPv6 458
16.7.2 NETSH 459
16.7.3 Ping6 459
16.7.4 Tracert6 460
16.7.5 IPSec6 461
16.7.6 Windows 2000 specific 463
16.8 IPv6 routing 464
16.8.1 Route determination process 465
16.8.2 Administering the IPv6 routing table 466
16.8.3 IPv6 routing advertisements 468
16.9 IPv6 coexistence 469
16.9.1 The 6to4 protocol 469
16.9.2 The ISATAP protocol 471
16.9.3 The 6over4 protocol 473
16.10 IPv6 in .NET 473
16.11 Conclusion 479
17 Web Services and Remoting 481
17.1 Introduction 481
17.2 Creating a Web service 481
17.2.1 Deploying a Web service 485
17.3 Using a Web service 486
17.4 Asynchronous calls to Web services 489
17.4.1 Wait handles 490
17.4.2 Callbacks 491
17.5 Interoperability 493
17.6 Performance 494
17.7 Security 495
17.8 Web services enhancements 497
17.8.1 Web service extensions: Attachments 498
17.8.2 Web service extensions: Routing 500
17.8.3 A word on Project Hailstorm (MyServices) 500
17.9 .NET remoting 500
17.9.1 How remoting works 501
17.9.2 Implementing remoting 502
17.9.3 Asynchronous use of remote objects 506
17.9.4 Deployment of a remoting service 508
17.9.5 Configuration 509
17.9.6 Hosting remote objects within IIS 510
17.9.7 Hosting remote objects within a Windows service 511
17.9.8 Distributed garbage collection 515
17.10 Conclusion 518
Index 519

Model-Based Software Testing and Analysis with C#

2008-04-26 21:02:56

Preface xi
Acknowledgments xv
I Overview
1 Describe, Analyze, Test 3
1.1 Model programs 4
1.2 Model-based analysis 5
1.3 Model-based testing 7
1.4 Model programs in the software process 8
1.5 Syllabus 11
2 WhyWe Need Model-Based Testing 13
2.1 Client and server 13
2.2 Protocol 14
2.3 Sockets 15
2.4 Libraries 15
2.5 Applications 20
2.6 Unit testing 23
vi Contents
2.7 Some simple scenarios 25
2.8 A more complex scenario 27
2.9 Failures in the field 28
2.10 Failures explained 29
2.11 Lessons learned 29
2.12 Model-based testing reveals the defect 30
2.13 Exercises 31
3 WhyWe Need Model-Based Analysis 32
3.1 Reactive system 32
3.2 Implementation 34
3.3 Unit testing 41
3.4 Failures in simulation 44
3.5 Design defects 46
3.6 Reviews and inspections, static analysis 47
3.7 Model-based analysis reveals the design errors 47
3.8 Exercises 52
4 Further Reading 53
II Systems with Finite Models
5 Model Programs 57
5.1 States, actions, and behavior 57
5.2 Case study: user interface 59
5.3 Preliminary analysis 61
5.4 Coding the model program 64
Contents vii
5.5 Simulation 70
5.6 Case study: client/server 72
5.7 Case study: reactive program 82
5.8 Other languages and tools 92
5.9 Exercises 93
6 Exploring and Analyzing Finite Model
Programs 94
6.1 Finite state machines 94
6.2 Exploration 99
6.3 Analysis 106
6.4 Exercise 114
7 Structuring Model Programs with Features and
Composition 115
7.1 Scenario control 115
7.2 Features 117
7.3 Composition 121
7.4 Choosing among options for scenario control 129
7.5 Composition for analysis 131
7.6 Exercises 136
8 Testing Closed Systems 137
8.1 Offline test generation 137
8.2 Traces and terms 139
8.3 Test harness 142
8.4 Test execution 146
viii Contents
8.5 Limitations of offline testing 147
8.6 Exercises 148
9 Further Reading 150
III Systems with Complex State
10 Modeling Systems with Structured State 155
10.1 “Infinite” model programs 155
10.2 Types for model programs 157
10.3 Compound values 157
10.4 Case study: revision control system 169
10.5 Exercises 181
11 Analyzing Systems with Complex State 183
11.1 Explorable model programs 183
11.2 Pruning techniques 186
11.3 Sampling 190
11.4 Exercises 190
12 Testing Systems with Complex State 191
12.1 On-the-fly testing 192
12.2 Implementation, model and stepper 194
12.3 Strategies 199
12.4 Coverage-directed strategies 203
12.5 Advanced on-the-fly settings 210
12.6 Exercises 218
13 Further Reading 219
Contents ix
IV Advanced Topics
14 Compositional Modeling 223
14.1 Modeling protocol features 223
14.2 Motivating example: a client/server protocol 224
14.3 Properties of model program composition 241
14.4 Modeling techniques using composition and
features 245
14.5 Exercises 246
15 Modeling Objects 247
15.1 Instance variables as field maps 247
15.2 Creating instances 249
15.3 Object IDs and composition 253
15.4 Harnessing considerations for objects 254
15.5 Abstract values and isomorphic states 256
15.6 Exercises 257
16 Reactive Systems 259
16.1 Observable actions 259
16.2 Nondeterminism 261
16.3 Asynchronous stepping 264
16.4 Partial explorability 265
16.5 Adaptive on-the-fly testing 268
16.6 Partially ordered runs 272
16.7 Exercises 274
17 Further Reading 275
x Contents
V Appendices
A Modeling Library Reference 281
A.1 Attributes 282
A.2 Data types 292
A.3 Action terms 306
B Command Reference 308
B.1 Model program viewer, mpv 308
B.2 Offline test generator, otg 311
B.3 Conformance tester, ct 312
C Glossar y 315
Bibliography 333
Index 341

DATA STRUCTURES AND ALGORITHMS USING C#

2008-04-26 11:11:20

Preface page vii
Chapter 1
An Introduction to Collections, Generics, and the
Timing Class 1
Chapter 2
Arrays and ArrayLists 26
Chapter 3
Basic Sorting Algorithms 42
Chapter 4
Basic Searching Algorithms 55
Chapter 5
Stacks and Queues 68
Chapter 6
The BitArray Class 94
Chapter 7
Strings, the String Class, and the StringBuilder Class 119
Chapter 8
Pattern Matching and Text Processing 147
v
vi CONTENTS
Chapter 9
Building Dictionaries: The DictionaryBase Class and the
SortedList Class 165
Chapter 10
Hashing and the Hashtable Class 176
Chapter 11
Linked Lists 194
Chapter 12
Binary Trees and Binary Search Trees 218
Chapter 13
Sets 237
Chapter 14
Advanced Sorting Algorithms 249
Chapter 15
Advanced Data Structures and Algorithms for Searching 263
Chapter 16
Graphs and Graph Algorithms 283
Chapter 17
Advanced Algorithms 314
References 339
Index 341

C# in Depth: What you need to master C# 2 and 3(深入C# 涵盖C#2.0和C#3.0)

2008-04-17 18:05:28

C# in Depth is a completely new book designed to propel existing C#
developers to a higher level of programming skill. One simple principle
drives this book: explore a few things deeply rather than offer a
shallow view of the whole C# landscape. If you often find yourself
wanting just a little more at the end of a typical chapter, this is the
book for you. Expert author Jon Skeet dives into the C# language,
plumbing new C# 2 and 3 features and probing the core C# language
concepts that drive them. This unique book puts the new features into
context of how C# has evolved without a lengthy rehearsal of the full C#
language. C# in Depth briefly examines the history of C# and the .NET
framework and reviews a few often-misunderstood C# 1 concepts that are
very important as the foundation for fully exploiting C# 2 and 3.
Because the book addresses C# 1 with a light touch, existing C#
developers don't need to pick through the book in order to find new
material to enhance their skills. This book focuses on the C# 2 and 3
versions of the language, but clearly explains where features are
supported by changes in the runtime (CLR) or use new framework classes.
Each feature gets a thorough explanation, along with a look on how you'd
use it in real life applications. C# in Depth is both a vehicle for
learning C# 2 and 3 and a reference work. Although the coverage is
in-depth, the text is always accessible: You'll explore pitfalls that
can trip you up, but you'll skip over gnarly details best left to the
language specification. The overall effect is that readers become not
just proficient in C# 2 and 3, but comfortable that they truly
understand the language.

C Sharp 2008 and the dot NET 3.5 Platform(Fourth Edition)

2008-04-13 18:31:43

Pro C# 2008 and the .NET 3.5 Platform, Fourth Edition is logically divided into eight distinct parts,
each of which contains a number of related chapters. If you have read the earlier editions of this
text, you will quickly notice a number of changes. For example, several topics (such as core C# constructs,
object-oriented programming, and platform-independent .NET development) have been
expanded into several dedicated chapters. Furthermore, this edition of the text contains numerous
new chapters to account for .NET 3.0–3.5 programming features (LINQ, WCF, WPF, WF, etc.). Here is
a part-by-part and chapter-by-chapter breakdown of the text.

Part 1: Introducing C# and the .NET Platform

The purpose of Part 1 is to acclimate you to the nature of the .NET platform and various development
tools (many of which are open source) used during the construction of .NET applications.
Along the way, you will also check out some basic details of the C# programming language and the
.NET type system.

Chapter 1: The Philosophy of .NET
Chapter 2: Building C# Applications

Part 2: Core C# Programming Constructs
The topics presented in this part of the book are quite important, as they will be used regardless of
which type of .NET software you intend to develop (web applications, desktop GUI applications,
code libraries, Windows services, etc.). Here, you will come to understand the core constructs of the
C# language, including the details of object-oriented programming (OOP). As well, this part will
examine how to process runtime exceptions and dive into the details of .NET’s garbage collection
services.

Chapter 3: Core C# Programming Constructs, Part I
Chapter 4: Core C# Programming Constructs, Part II
Chapter 5: Defining Encapsulated Class Types
Chapter 6: Understanding Inheritance and Polymorphism
Chapter 7: Understanding Structured Exception Handling
Chapter 8: Understanding Object Lifetime

Part 3: Advanced C# Programming Constructs
This section of the book will deepen your understanding of the C# language, by examining a number
of more advanced (but very important) concepts. Here, you will complete your examination of
the .NET type system by examining interfaces and delegates. As well, you will learn about the role of
generics and the numerous new language features of C# 2008, and take an initial look at Language
Integrated Query (LINQ).

Chapter 9:Working with Interfaces
Chapter 10: Collections and Generics
Chapter 11: Delegates, Events, and Lambdas
Chapter 12: Indexers, Operators, and Pointers
Chapter 13: C# 2008 Language Features
Chapter 14: An Introduction to LINQ

Part 4: Programming with .NET Assemblies
Part 4 dives into the details of the .NET assembly format. Not only will you learn how to deploy and
configure .NET code libraries, but you will also come to understand the internal composition of a
.NET binary image. This part also explains the role of .NET attributes and the construction of multithreaded
applications. Later chapters examine some fairly advanced topics such as object context,
CIL code, and dynamic assemblies.

Chapter 15: Introducing .NET Assemblies
Chapter 16: Type Reflection, Late Binding, and Attribute-Based Programming
Chapter 17: Processes, AppDomains, and Object Contexts
Chapter 18: Building Multithreaded Applications
Chapter 19: Understanding CIL and the Role of Dynamic Assemblies

Part 5: Introducing the .NET Base Class Libraries
By this point in the text, you have a solid handle on the C# language and the details of the .NET
assembly format. Part 5 leverages your newfound knowledge by exploring a number of commonly
used services found within the base class libraries, including file I/O and database access using
ADO.NET. This part also covers the construction of distributed applications using Windows Communication
Foundation (WCF) and workflow-enabled applications that make use of the Windows
Workflow Foundation (WF) API.

Chapter 20: File I/O and Isolated Storage
Chapter 21: Introducing Object Serialization
Chapter 22: ADO.NET Part I: The Connected Layer
Chapter 23: ADO.NET Part II: The Disconnected Layer
Chapter 24: Programming with the LINQ APIs
Chapter 25: Introducing Windows Communication Foundation
Chapter 26: Introducing Windows Workflow Foundation

Part 6: Desktop User Interfaces
It is a common misconception for newcomers to the .NET platform to assume this framework is
only concerned with the construction of web-based user interfaces (which I suspect is due to the
term “.NET,” as this tends to conjure up the notion of the “Internet” and therefore “web programs”).
While it is true that .NET provides outstanding support for the construction of web applications,
this part of the book focuses on traditional desktop user interfaces using two GUI frameworks,
Windows Forms and Windows Presentation Foundation (WPF).

Chapter 27: Programming with Windows Forms
Chapter 28: Introducing Windows Presentation Foundation and XAML
Chapter 29: Programming with WPF Controls
Chapter 30: WPF 2D Graphical Rendering, Resources, and Themes

Part 7: Building Web Applications with ASP.NET
Part 7 is devoted to the examination of constructing web applications using the ASP.NET programming
API. As you will see, ASP.NET was intentionally designed to model the creation of desktop user
interfaces by layering on top of standard HTTP request/response an event-driven, object-oriented
framework.

Chapter 31: Building ASP.NET Web Pages
Chapter 32: ASP.NET Web Controls, Themes, and Master Pages
Chapter 33: ASP.NET State Management Techniques

Part 8: Appendixes
This final part of this book examines two important topics, which quite frankly did not seem to fit
naturally within the bulk of the text, and have therefore been “appendix-ized.” Here you will complete
your examination of C# and the .NET platform by learning how to integrate legacy code into
your .NET applications as well as how to take .NET development beyond the Windows family of
operating systems.

Appendix A: COM and .NET Interoperability
Appendix B: Platform-Independent .NET Development with Mono