|
This
book is split into three parts: The
first four chapters describe the .NET Framework, Chapter 5 through 7 describe
the tools in Visual Studio.NET that you can use to develop applications in
Visual Studio .NET and Chapters 8 and 9 explain how to develop and debug
applications.
Part I:
Provides a nice, easy to understand,
overview of the .NET Framework, which includes the .NET features like the
.NET Languages, Execution Engine with Schematics, Interop with COM or COM+ ,
a very detailed Garbage Collector
section, Security, Types, Managed and Unmanaged C++ Classes, Value
Types, Reference Types, Interfaces, Metadata and Attributes. You will find a big section on Attributes
in Chapter 1. The Attribute section
consists of writing attributes, Reading Attributes and Attribute Scenarios.
Exceptions were covered in
details and then you will find a good section on Delegates and Events. Next come Packaging and Deployment that
includes good explanation of Assemblies, Modules, Assembly Types and Names.
A well done section was on
Versioning before .NET,
Application-Specific Private DLLs, Windows File Protection and
Side-by-Side Components. After
solving the DLL hell the author goes on to explain on how to locate and
version .NET Assemblies.
Configuration Files was
discussed, .NET Versioning and Satellite Assemblies.
Binding and Probing,
Application Domains and Administering Security finished Chapter one.
Chapter 2 handles the Framework
Class Library (FCL). The Core Library
includes the General-Purpose Classes, Collections, Type manipulation, Type
conversion, IO Streams, Console IO and Mathematical Functions.
Also in this chapter the author
had a nice section on Context. I
liked the Schematic to help me understand the text. More on Context in chapter 3 with Remoting.
Next in this chapter the author
talks about Tracing and Debugging
Next the author talks about the
System.Net class, long section (relatively speaking) on Threading then
Reflection which is very interesting to me.
GDI+ and Windows was next about
30 pages worth.
Other Framework Classes for
Event Logging, Performance Counting,
Process Information, Data ( DataSet, DataReader, in here the author intentionally did not
cover ASP.NET and ADO.NET in full because that is best left for other books
to cover), and finally the chapter ends with a small section on Message Queuing.
Chapter 3 covers Context and
Remoting.
You will find very nice
schematics on pages 268, 269 and beyond that can help anyone and everyone
understand Context and Remoting. Context Bound, Context Agile, parameter
passing, Object Marshaling between contexts, Context Sink Chains, Dynamic
Properties and Sinks and Tracking Handlers.
Serialization is next then
Formatters, Custom Serialization, and MSMQ Serialization etc.
Remoting section talked about
.NET remote Components.
Client-Activated Objects, Server-Activated Objects (Singleton and
Single Call), Remote CallBacks, Remote Objects and Exceptions, Hosting Remote
Objects in IIS, Proxies, Marshaling, Leases and Lifetimes, Message Sinks and
Channels (see figure 3.8 on page 314).
Channels, Extending the Remoting
Framework, SOAP (SHAMPOO? ISNEXT:NEVER), Security and all about Web Services,
SOAP invocation etc….
Asynchronous Programming (Fire
and Forget) ended chapter 3.
Again I found chapter 3 very
easy to read
Chapter 4 is about
Interoperation and COM +
Interop with native code and
how it works with Win32 APIs. (Calling DLLs and Platform Invoke) You will
also see a talk about the following
related issues like String Conversions, Errors and Exceptions, Data Flow Direction,
Structures, Arrays and Buffers.
Marshaling included sections on
Custom Marshaling, String Marshaling and Explicit Allocation of Buffers. The chapter goes on to talk about
Unmanaged Exceptions, Unsafe Code to complete section 3. The next section talks about COM Interop
(CCW and RCW) this is very nicely done.
More details about COM
Automation Types, COM Interface Types, COM Events and COM Aggregation.
Chapter 4 ends with a
discussion on Component Services which includes Assemblies and Applications,
Object Pooling, COM+ Context, Transactions, COM+ Security, Queued Components,
Loosely Coupled Events and finally Catalog Configuration.
The First Part of this book
consisted of 4 chapters of 440 Pages which is over half of the book. Part Two of this book consists of 3
chapters.
Part II (120 pages chap 5, 6
and 7)
Chapter 5 talks about Visual
Studio.NET Environment
You need to open Visual
Studio.NET to follow this chapter and it is not like Part I of this
book. I think this chapter is very
important to any developer to understand the tool you are using. I liked the Keyboard shortcuts, Class View
Icons, Properties window icons, The XML comment tags, Outlining Code Regions,
Find in all files, Incremental Searches, Bookmarks and so on…
The tools/External Tools are
very important to know about.
Chapter 6 talks about Creating
and Building solutions.
Concentration was on ATL, ATL Server Project, ATL Server Web
Service Wizard, C++ and C# projects.
C++ and C# Classes, COM+ Components, Perf Mon.., Enterprise Template
Projects and Server Explorer. The
Build Process was discussed. Source
Control, Customizing Builds, Building and Task List. Deploying Solutions, CAB Project, Windows
Installer Projects, Registry, File types on Target Machine, Custom Actions,
User Interface, Launch Conditions and finally Visual Studio Analyzer.
This is a must read chapter.
Chapter7: Visual C++.NET
ATL, New Key Words, ATL
Attributes, Interfaces, ATL Object Map, ATL Server Project and ATL Server Web
Service. Managed Extensions for C++ ,
Member Access, Properties and Fields, Compiling to IL, .NET Pointers. Managed C++ and Interfaces, Multiple
Interfaces, Managed Arrays, Managed Strings, Exceptions, Operators and Global
Methods. Chapter 7 ends with Using Managed Code in Unmanaged Code.
Part III: (Last part of this book consists of two
chapters 8 and 9)
Chapter 8: Application Development
A user application consists of
forms that have components and controls.
This chapter talks about
Developing Components and Developing Controls.
How to add controls to the
Toolbox window.
Property Editor discussed in
details, Licensing and Toolbox Items.
Resources and
Internationalization, Resources and .NET, Locales, Cultures, and
Languages. Managed C++ Resources, C#
and Resources, Forms and Localization, Resource Classes, Satellite
Assemblies, the Event Log, Win32 Resources,
Chapter 9: Debugging
The following details were
covered in this chapter.
IDE Tool Windows, Setting
Breakpoints, Data, Condition, Hit Count, Unset Breakpoints, Threads and
Modules Windows, Call Stack Window, Watch Windows, Format modifiers for
variables in the watch windows, Using the command Windows, Formatting Values,
Exceptions, Edit and Continue.
Using the Debugger, Attach to
process, Startup options, Stepping, Crashes, Compile-Time Checks, Remote
Debugging, Disassembly Window, and Debug Symbols.
Debugging ATL Server Projects,
CRT and ATL Memory Debugging and Finally ATL Interface Debugging. I learned a lot from this chapter.
This book is for anyone
developing in .NET. This book did not
discuss ASP.NET, ADO.NET, in any
details by design and left for other books to cover. Again, I strongly recommend this book.
Enjoy reading it.
|