Tuesday, February 17, 2009

Applied Microsoft NET Framework Programming or Network Security Foundations

Applied Microsoft .NET Framework Programming

Author: Jeffrey Richter

The Microsoft® .NET Framework allows developers to quickly build robust, secure ASP.NET Web Forms and XML Web service applications, Windows® Forms applications, tools, and types. Find out all about its common language runtime and learn how to leverage its power to build, package, and deploy any kind of application or component. APPLIED MICROSOFT .NET FRAMEWORK PROGRAMMING is ideal for anyone who understands object-oriented programming concepts such as data abstraction, inheritance, and polymorphism. The book carefully explains the extensible type system of the .NET Framework, examines how the runtime manages the behavior of types, and explores how an application manipulates types. While focusing on C#, it presents concepts applicable to all programming languages that target the .NET Framework. Topics covered include:

. The .NET Framework architecture

. Building, packaging, deploying, and administering applications and their types

. Building and deploying shared assemblies

. Type fundamentals

. Primitive, reference, and value types

. Operations common to all objects

. Type members and accessibility

. Constants, fields, methods, properties, and events

. Working with text

. Enumerated types and bit flags

. Array types

. Interfaces

. Custom attributes

. Delegates

. Error handling with exceptions

. Automatic memory management

. AppDomains and reflectionIncludes coverage of C#

Table of Contents:

1. The Architecture of the .NET Framework Development Platform
Compiling Source Code into Managed Modules
Combining Managed Modules into Assemblies
Loading the Common Language Runtime
Executing Your Assembly's Code
   IL and Verification
The .NET Framework Class Library
The Common Type System
The Common Language Specification
Interoperability with Unmanaged Code
2. Building, Packaging, Deploying, and Administering Applications and Types
.NET Framework Deployment Goals
Building Types into a Module
Combining Modules to Form an Assembly
   Adding Assemblies to a Project Using the Visual Studio .NET IDE
   Using the Assembly Linker
   Including Resource Files in the Assembly
Assembly Version Resource Information
   Version Numbers
Simple Application Deployment (Privately Deployed Assemblies)
Simple Administrative Control (Configuration)
3. Shared Assemblies
Two Kinds of Assemblies, Two Kinds of Deployment
Giving an Assembly a Strong Name
The Global Assembly Cache
   The Internal Structure of the GAC
Building an Assembly That References a Strongly Named Assembly
Strongly Named Assemblies Are Tamper-Resistant
Delayed Signing
Privately Deploying Strongly Named Assemblies
Side-by-Side Execution
How the Runtime Resolves Type References
Advanced Administrative Control (Configuration)
   Publisher Policy Control
Repairing a Faulty Application

4. Type Fundamentals
All Types Are Derived from System.Object
Casting Between Types
   Casting with the C# is and as Operators
Namespaces and Assemblies
5. Primitive, Reference, and Value Types
Programming Language Primitive Types
   Checked and Unchecked Primitive Type Operations
Reference Types and Values Types
Boxing and Unboxing Value Types
6. Common Object Operations
Object Equality and Identity
   Implementing Equals for a Reference Type Whose Base Classes Don't Override Object's Equals
   Implementing Equals for a Reference Type When One or More of Its Base Classes Overrides Object's Equals
   Implementing Equals for a Value Type
   Summary of Implementing Equals and the ==/!= Operators
Object Hash Codes
Object Cloning

7. Type Members and Their Accessibility
Type Members
Accessibility Modifiers and Predefined Attributes
   Type Predefined Attributes
   Field Predefined Attributes
   Method Predefined Attributes
8. Constants and Fields
9. Methods
Instance Constructors
Type Constructors
Operator Overload Methods
   Operators and Programming Language Interoperability
Conversion Operator Methods
Passing Parameters by Reference to a Method
Passing a Variable Number of Parameters to a Method
How Virtual Methods Are Called
Virtual Method Versioning
10. Properties
Parameterless Properties
Parameterful Properties
11. Events
Designing a Type That Exposes an Event
Designing a Type That Listens for an Event
Explicitly Controlling Event Registration
Designing a Type That Defines Lots of Events
Designing the EventHandlerSet Type
12. Working with Text
The System.String Type
   Constructing Strings
   Strings Are Immutable
   Comparing Strings
   String Interning
   String Pooling
   Examining a String's Characters
   Other String Operations
Dynamically Constructing a String Efficiently
   Constructing a StringBuilder Object
   StringBuilder's Members
Obtaining a String Representation for an Object
   Specific Formats and Cultures
   Formatting Multiple Objects into a Single String
   Providing Your Own Custom Formatter
Parsing a String to Obtain an Object
Encodings: Converting Between Characters and Bytes
    Encoding/Decoding Streams of Characters and Bytes
   Base-64 String Encoding and Decoding
13. Enumerated Types and Bit Flags
Enumerated Types
Bit Flags
14. Arrays
All Arrays Are Implicitly Derived from System.Array
Casting Arrays
Passing and Returning Arrays
Creating Arrays That Have a Nonzero Lower Bound
Fast Array Access
Redimensioning an Array
15. Interfaces
Interfaces and Inheritance
Designing an Application That Supports Plug-In Components
Changing Fields in a Boxed Value Type Using Interfaces
Implementing Multiple Interfaces That Have the Same Method
Explicit Interface Member Implementations
16. Custom Attributes
Using Custom Attributes
Defining Your Own Attribute
Attribute Constructor and Field/Property Data Types
Detecting the Use of a Custom Attribute
Matching Two Attribute Instances Against Each Other
Pseudo-Custom Attributes
17. Delegates
A First Look at Delegates
Using Delegates to Call Back Static Methods
Using Delegates to Call Back Instance Methods
Demystifying Delegates
Some Delegate History: System.Delegate and System.MulticastDelegate
Comparing Delegates for Equality
Delegate Chains
C#'s Support for Delegate Chains
Having More Control over Invoking a Delegate Chain
Delegates and Reflection

18. Exceptions
The Evolution of Exception Handling
The Mechanics of Exception Handling
   The try Block
   The catch Block
   The finally Block
What Exactly Is an Exception?
The System.Exception Class
FCL-Defined Exception Classes
Defining Your Own Exception Class
How to Use Exceptions Properly
   You Can't Have Too Many finally Blocks
   Don't Catch Everything
   Gracefully Recovering from an Exception
   Backing Out of a Partially Completed Operation When an Unrecoverable Exception Occurs
   Hiding an Implementation Detail
What's Wrong with the FCL
Performance Considerations
Catch Filters
Unhandled Exceptions
   Controlling What the CLR Does When an Unhandled Exception Occurs
   Unhandled Exceptions and Windows Forms
   Unhandled Exceptions and ASP.NET Web Forms
   Unhandled Exceptions and ASP.NET XML Web Services
Exception Stack Traces
   Remoting Stack Traces
Debugging Exceptions
   Telling Visual Studio What Kind of Code to Debug
19. Automatic Memory Management (Garbage Collection)
Understanding the Basics of Working in a Garbage-Collected Platform
The Garbage Collection Algorithm
   What Causes Finalize Methods to Get Called
   Finalization Internals
The Dispose Pattern: Forcing an Object to Clean Up
   Using a Type That Implements the Dispose Pattern
   C#'s using Statement
   An Interesting Dependency Issue
Weak References
   Weak Reference Internals
   Designing an Object Pool Using Resurrection
Programmatic Control of the Garbage Collector
Other Garbage Collector Performance Issues
   Synchronization-Free Allocations
   Scalable Parallel Collections
   Concurrent Collections
   Large Objects
Monitoring Garbage Collections
20. CLR Hosting, AppDomains, and Reflection
Metadata: The Cornerstone of the .NET Framework
CLR Hosting
   Accessing Objects Across AppDomain Boundaries
   AppDomain Events
   Applications and How They Host the CLR and Manage AppDomains
The Gist of Reflection
Reflecting Over an Assembly's Types
Reflecting Over an AppDomain's Assemblies
Reflecting Over a Type's Members: Binding
Explicitly Loading Assemblies
   Loading Assemblies as "Data Files"
   Building a Hierarchy of Exception-Derived Types
Explicitly Unloading Assemblies: Unloading an AppDomain
Obtaining a Reference to a System.Type Object
Reflecting Over a Type's Members
   Creating an Instance of a Type
   Calling a Type's Method
   Bind Once, Invoke Multiple Times
Reflecting Over a Type's Interfaces
Reflection Performance


Books about: Human Services in Contemporary America or Nationalism Reader

Network Security Foundations

Author: Matthew Streb

The world of IT is always evolving, but in every area there are stable, core concepts that anyone just setting out needed to know last year, needs to know this year, and will still need to know next year. The purpose of the Foundations series is to identify these concepts and present them in a way that gives you the strongest possible starting point, no matter what your endeavor.

Network Security Foundations provides essential knowledge about the principles and techniques used to protect computers and networks from hackers, viruses, and other threats. What you learn here will benefit you in the short term, as you acquire and practice your skills, and in the long term, as you use them. Topics covered include:

• Why and how hackers do what they do

• How encryption and authentication work

• How firewalls work

• Understanding Virtual Private Networks (VPNs)

• Risks posed by remote access

• Setting up protection against viruses, worms, and spyware

• Securing Windows computers

• Securing UNIX and Linux computers

• Securing Web and email servers

• Detecting attempts by hackers

No comments:

Post a Comment