Accelerated C# 2010 pdf
About This Book
I assume that you already have a working knowledge of some object-oriented programming language, such as C++, Java, or Visual Basic .NET. Since C# derives its syntax from both C++ and Java, I don’t spend
much time covering C# syntax, except where it differs starkly from C++ or Java. If you already know some
C#, you may find yourself skimming or even skipping Chapters 1 through 3.
Chapter 1, “C# Preview,” gives a quick glimpse of what a simple C# application looks like, and it
describes some basic differences between the C# programming environment and the native C++
environment.
Chapter 2, “C# and the CLR,” expands on Chapter 1 and quickly explores the managed environment
within which C# applications run. I introduce you to assemblies, the basic building blocks of
applications, into which C# code files are compiled. Additionally, you’ll see how metadata makes
assemblies self-describing.
Chapter 3, “C# Syntax Overview,” surveys the C# language syntax. I introduce you to the two
fundamental kinds of types within the CLR: value types and reference types. I also describe namespaces
and how you can use them to logically partition types and functionality within your applications.
Chapters 4 through 13 provide in-depth descriptions on how to employ useful idioms, design
patterns, and best practices in your C# programs and designs. I’ve tried hard to put these chapters in
logical order, but occasionally one chapter may reference a technique or topic covered in a later chapter.
It is nearly impossible to avoid this situation, but I tried to minimize it as much as possible.
Chapter 4, “Classes, Structs, and Objects,” provides details about defining types in C#. You’ll learn
more about value types and reference types in the CLR. I also touch upon the native support for
interfaces within the CLR and C#. You’ll see how type inheritance works in C#, as well as how every
object derives from the System.Object type. This chapter also contains a wealth of information regarding
the managed environment and what you must know in order to define types that are useful in it. I
introduce many of these topics in this chapter and discuss them in much more detail in later chapters.
Chapter 5, “Interfaces and Contracts,” details interfaces and the role they play in the C# language.
Interfaces provide a functionality contract that types may choose to implement. You’ll learn the various
ways that a type may implement an interface, as well as how the runtime chooses which methods to call
when an interface method is called.
Chapter 6, “Overloading Operators,” details how you may provide custom functionality for the
built-in operators of the C# language when applied to your own defined types. You’ll see how to
overload operators responsibly, because not all managed languages that compile code for the CLR are
able to use overloaded operators.
Chapter 7, “Exception Handling and Exception Safety,” shows you the exception-handling
capabilities of the C# language and the CLR. Although the syntax is similar to that of C++, creating
exception-safe and exception-neutral code is tricky—even more tricky than creating exception-safe code
in native C++. You’ll see that creating fault-tolerant, exception-safe code doesn’t require the use of try,
catch, or finally constructs at all. I also describe some of the new capabilities added with the .NET 2.0
runtime that allow you to create more fault-tolerant code.
Chapter 8, “Working with Strings,” describes how strings are a first-class type in the CLR and how to
use them effectively in C#. A large portion of the chapter covers the string-formatting capabilities of
various types in the .NET Framework and how to make your defined types behave similarly by
implementing IFormattable. Additionally, I introduce you to the globalization capabilities of the
framework and how to create custom CultureInfo for cultures and regions that the .NET Framework
doesn’t already know about.
Chapter 9, “Arrays, Collection Types, and Iterators,” covers the various array and collection types
available in C#. You can create two types of multidimensional arrays, as well as your own collection
types while utilizing collection-utility classes. You’ll see how to define forward, reverse, and bidirectional
iterators using the new iterator syntax introduced in C# 2.0, so that your collection types will work well
with foreach statements.
Chapter 10, “Delegates, Anonymous Functions, and Events,” shows you the mechanisms used
within C# to provide callbacks. Historically, all viable frameworks have always provided a mechanism to
implement callbacks. C# goes one step further and encapsulates callbacks into callable objects called
delegates. Additionally, C# 2.0 allows you to create delegates with an abbreviated syntax called
anonymous functions. Anonymous functions are similar to lambda functions in functional
programming. Also, you’ll see how the framework builds upon delegates to provide a publish/subscribe
event notification mechanism, allowing your design to decouple the source of the event from the
consumer of the event.
Chapter 11, “Generics,” introduces you to probably the most exciting feature added to C# 2.0 and
the CLR. Those familiar with C++ templates will find generics somewhat familiar, though many
fundamental differences exist. Using generics, you can provide a shell of functionality within which to
define more specific types at run time. Generics are most useful with collection types and provide great
efficiency compared to the collections of previous .NET versions. Starting with C# 4.0, generic type usage
became even more intuitive with the support of co- and contravariance. Assigning from one generic type
to another when it makes intuitive type-sense is now possible, thus reducing the clutter of conversion
methods needed prior to that.
Chapter 12, “Threading in C#,” covers the tasks required in creating multithreaded applications in
the C# managed virtual execution environment. If you’re familiar with threading in the native Win32
environment, you’ll notice the significant differences. Moreover, the managed environment provides
much more infrastructure for making the job easier. You’ll see how delegates, through use of the I Owe
You (IOU) pattern, provide an excellent gateway into the process thread pool. Arguably, synchronization
is the most important concept when getting multiple threads to run concurrently. This chapter covers
the various synchronization facilities available to your applications. In today’s world, concurrency is at
the forefront because, rather than spending exorbitant amount of time and money to create faster
processors, the industry has gravitated to creating processors with multiple cores. Therefore, I introduce
the new Parallel Extensions and the Task Parallel Library (TPL) added to .NET 4.0.
Chapter 13, “In Search of C# Canonical Forms,” is a dissertation on the best design practices for
defining new types and how to make them so you can use them naturally and so consumers won’t abuse
them inadvertently. I touch upon some of these topics in other chapters, but I discuss them in detail in
this chapter. This chapter concludes with a checklist of items to consider when defining new types using
C#.
Chapter 14, “Extension Methods,” are new since C# 3.0. Because you can invoke them like instance
methods on a type they extend, they can appear to augment the contract of types. But they are much
more than that. In this chapter, I show you how extension methods can begin to open up the world of
functional programming in C#.
Chapter 15, “Lambda Expressions,” are another feature added to C# 3.0. You can declare and
instantiate delegates using lambda expressions using a syntax that is brief and visually descriptive.
Although anonymous functions can serve the same purpose just mentioned, they are much more
verbose and less syntactically elegant. However, in C# 3.0 and beyond, you can convert lambda
expressions into expression trees. That is, the language has a built-in capability to convert code into data structures. By itself, this capability is useful, but not nearly as useful as when coupled with Language Integrated Query (LINQ). Lambda expressions, coupled with extension methods, really bring functional programming full circle in C#.
Chapter 16, “LINQ: Language Integrated Query,” is the culmination of all of the new features added to C# 3.0. Using LINQ expressions via the LINQ-oriented keywords, you can seamlessly integrate data queries into your code. LINQ forms a bridge between the typically imperative programming world of C# programming and the functional programming world of data query. LINQ expressions can be used to manipulate normal objects as well as data originating from SQL databases, Datasets, and XML just to name a few.
Chapter 17, “Dynamic Types,” covers the new dynamic type added in C# 4.0. Along with the
dynamic type comes easier integration with dynamic .NET languages, including COM Automation objects. Gone are the days of coding unnatural-looking and hard-to-read code purely in efforts to integrate with these components because the dynamic type implementation handles all of that rote work for you. The implementation of the dynamic type utilizes the Dynamic Language Runtime (DLR)
which is the same foundation for dynamic languages such as IronRuby and IronPython, among others.
And while using the dynamic type in conjunction with DLR types such as ExpandoObject, you can create
and implement truly dynamic types in C#.
Hiç yorum yok:
Yorum Gönder