Home > Store > Programming > Windows Programming

Developing Applications with Visual Studio.NET

Register your product to gain access to bonus material or receive a coupon.

Developing Applications with Visual Studio.NET

Book

  • This product is temporarily unavailable.
Not for Sale

Description

  • Copyright 2002
  • Dimensions: 7-3/8x9-1/4
  • Pages: 832
  • Edition: 1st
  • Book
  • ISBN-10: 0-201-70852-3
  • ISBN-13: 978-0-201-70852-3

DEVELOPING APPLICATIONS WITH VISUAL STUDIO.NET is an in-depth guide that takes Windows programming to the next level: creating .NET applications that leverage the prior knowledge and experience of C++ Win32 programmers. The .NET Framework supplies programmers with rich standard run-time services, supports the development of Web-based services, and provides both inter-language and inter-machine interoperability. Programmers can now focus on creating more complex, more distributed, and more Web-enabled applications.

This book begins by describing the .NET Framework, introducing the facilities .NET offers and the classes programmers can use. It goes on to describe the tools available in Visual Studio.NET and demonstrates their use. Readers are then ready to develop and debug applications with the help of clearly illustrated examples in C# and Managed C++.

DEVELOPING APPLICATIONS WITH VISUAL STUDIO.NET covers commonly overlooked topics such as error handling, memory management, event logging, localization issues, performance monitoring, ATL Server, and Managed C++. Author Richard Grimes shares his hard-won understanding of Visual Studio.NET, emphasizing the innovations that save you time and trouble and steering you away from those that limit programming power.

Among the topics explored in-depth:

  • The Common Language Runtime (CLR)
  • Core classes in the Framework Class Library
  • Contexts and .NET remoting
  • Interoperation and COM+
  • The Visual Studio.NET environment
  • Creating and building solutions
  • Visual C++.NET
  • Application development
  • Debugging

With this book as your guide, you will learn how to efficiently develop strong, robust code within .NET.



0201708523B01092002

Sample Content

Online Sample Chapter

.NET Application Development

Downloadable Sample Chapter

Click below for Sample Chapter related to this title:
grimesch08.pdf

Table of Contents

(NOTE: Each chapter concludes with a Summary.)

Preface.


Acknowledgments.


1. NET Runtime.

.NET Features.

.NET Languages.

Executing Code.

Interop.

Garbage Collector.

Security.

Types.

Classes.

Managed and Unmanaged C++ Classes.

Value Types.

Boxing.

Managed Arrays.

Member Access.

Common Language Specification.

Other .NET Features.

Interfaces.

Metadata and Attributes.

Exceptions.

Delegates.

Events.

Packaging and Deployment.

Assemblies and Modules.

Versioning before .NET.

Locating and Versioning .NET Assemblies.

Application Domains.

Administering Security.



2. Framework Class Library.

The Win32 API.

Memory Allocation.

Error Handling.

Framework Class Library.

The Core Library.

General-Purpose Classes.

System Classes.

Tracing and Debugging.

Net.

Threading.

Reflection.

GDI+ and Windows.

System.Drawing.

System.Drawing.Drawing2D.

System.Windows.Forms.

Other Framework Class Library Classes.

Event Log.

Performance Counting.

Process Information.

Data.

Message Queuing.



3. Contexts and Remoting.

Contexts.

Context Bound and Context Agile.

Passing Parameters by Reference and by Value.

Marshaling Objects between Contexts.

Context Sink Chains.

Dynamic Properties and Sinks.

Tracking Handler s.

Serialization.

Serializing Objects.

Formatters.

Object Manager.

Custom Serialization.

MSMQ Serialization.

Remoting.

.NET Remoting.

.NET Remote Components.

Marshaling.

Leases and Lifetime.

Message Sinks and Channels.

Channels.

Extending the Remoting Framework.

SOAP.

Security.

Web Services.

Architecture.

Managed Web Services.

SOAP Invocation.

Web Service Clients.

ASP.NET Services334

Web Services and Security.

Asynchronous Programming.

Asynchronous Delegates.

Fire and Forget.

Delegates and Remoting.



4. Interoperation and COM+.

Interoperation.

Interop with Native Code.

Calling DLLs.

Platform Invoke.

String Conversions.

Errors and Exceptions.

Data Flow Direction.

Structures.

Arrays and Buffers.

Marshaling.

Explicit Allocation of Buffers.

Unmanaged Exceptions.

Unsafe Code.

COM Interop.

Interop of COM and Managed Code.

COM Callable Wrapper.

Exporting Type Information.

Registration.

Runtime Callable Wrapper.

COM Automation Types.

COM Interface Types.

COM Events.

COM Aggregation.

COM Interop and the CRT.

Component Services.

Serviced Components.

Assemblies and Applications.

COM+ Context.

Object Pooling.

Transactions.

COM+ Security.

Queued Components.

Loosely Coupled Events.

Catalog Configuration.



5. Visual Studio.NET Environment.

The Visual Studio Environment.

Menus, Commands, and Shortcut Keys.

Docking Windows and Toolbars.

Documents.

Start Page.

Projects and Solutions.

Project Types.

Project Wizard Files.

Project Files.

Solution Configurations.

Project Configurations.

Project Properties.

Configuring Code.

Adding Items to C++ Projects.

Resource View.

Adding Items to C# Projects.

Adding References.

Class View.

Properties.

C# Resources.

Editing Code.

The Text Editor.

HTML Editor.

XML Editor.

Data.

Designers.

Binary Editor.

Searching and Browsing Code.

Find In Files.

Find In Project.

Command Window.

Incremental Searches.

Bookmarks.

Braces.

Object Browser.

Tools.

External Tools.

The Help System.

Toolbox.

Clipboard Ring.

The Macro Explorer and Editor.

Add-In Manager.

The VS.NET Command Line.



6. Creating and Building Solutions.

C++ and C# Project Types.

ATL Projects.

MFC Projects.

Managed C++ Projects.

Other C++ Projects.

C++ Project Options.

C# Project Types.

C++ Classes.

Simple Object.

COM+ Component.

Control.

Performance Monitor.

C# Classes.

Components, Controls, and Forms.

Inherited Forms and Controls.

Data.

Enterprise Template Projects.

Enterprise Solutions.

Enterprise Template Files and Proxy Projects.

Policy File.

Server Explorer.

Data Connections.

Servers Node.

The Build Process.

Source Control.

Customizing Builds.

Building and Task List.

Deploying Solutions.

Deployment Solutions.

Visual Studio Analyzer.



7. Visual C++ .NET.

ATL.

A Few New Keywords.

ATL Attributes.

Interfaces.

ATL Object Map.

ATL Server Project and ATL Server Web Service.

Managed Extensions for C++.

Class Declaration.

Member Access.

Properties and Fields.

Compiling to IL.

.NET Pointers.

Managed C++ and Interfaces.

Multiple Interfaces.

Managed Arrays.

Managed Strings.

Exceptions.

Operators.

Global Methods.

Using Managed Code in Unmanaged Code.

Using Managed Types within Unmanaged Types.

Calling Managed Code.



8. Application Development.

Developing Components.

Developing Controls.

Developing a Sample Control.

Property Editor.

Licensing.

Toolbox Items.

Resources and Internationalization.

Resources and .NET.

Locales, Cultures, and Languages.

Creating Resources.

Managed C++ and Resources.

C# and Resources.

Forms and Localization.

Resource Classes.

Satellite Assemblies.

The Event Log, Again.

Win32 Resources.



9. Debugging.

IDE Tool Windows.

Setting Breakpoints.

Threads and Modules Windows.

Call Stack Window.

Watch Windows.

Memory Windows.

Using the Command Window.

Formatting Values.

Exceptions.

Edit and Continue.

Using the Debugger.

Starting Debugging.

Start-up Options.

Stepping.

Crashes.

Compile-Time Checks.

Compiler Runtime Checks.

Remote Debugging.

Disassembly Window.

Debug Symbols.

Debugging ATL Server Projects.

CRT and ATL Memory Debugging.

ATL Interface Debugging.



Index. 0201708523T01242002

Preface

.NET is a whole new way to program. It has taken me a while to get used to using it, but now I feel that .NET is the future of developing code. The two main features that .NET brings are the runtime and the Framework Class Library. The runtime executes all .NET code and provides a secure environment. The Framework Class Library is available to all .NET code regardless of the language that is used to create that code. The library is a culmination of all the libraries that Win32 developers are accustomed to using, and some APIs are provided through a new paradigm, but others are mere mirrors of the Win32 APIs that they replace. The significant point is that all of the APIs are accessed in the same way, so the application developer no longer has to learn multiple ways to access libraries (DLL exported functions, class libraries, template libraries, COM). The intention is to put more focus on using the APIs than on accessing them.

I have spent a considerable amount of time determining how .NET works and how the various classes in the library are related. On occasion it was a joy to see how .NET had provided a new API that put more power in the hands of the developer, and on a few occasions I was frustrated to see that .NET had provided a solution that reduced the facilities offered to the developer. In this book I want to give you the benefit of my odyssey through .NET. I will enthuse when .NET does it right, and I will tell you straight when .NET does it wrong.

One thing is clear: .NET is here to stay. Expect in the future that Microsoft will put more and more emphasis on .NET. Your future as a developer will be intimately entwined with .NET, and by becoming familiar with .NET now, you'll ensure that you'll be ready for whatever Microsoft decides to release in the future.

Intended Audience

I have deliberately decided to target C++ Win32 developers. This book has no VB.NET code and only the barest minimum of ASP.NET. If you want to develop in VB.NET, or you want to develop Web applications with ASP.NET, there are other excellent books that will suit you better than this one.

I also make no excuses about the fact that this book is packed full of details, and in places it touches on tough concepts. I have worked hard to glean the information that I present in this book. I didn't have access to privileged knowledge. What you see here is the result of writing many hundreds of test applications, of pouring over IL generated with ILDASM, and of single-stepping through code with the .NET debuggers. Where I present code, you can be assured that what you see is code that I have written and tested. When I describe how an API works, you can be assured that I have determined that behavior by actually trying out the code. I have worked hard to write this book, and I expect you to work hard as you read through it. That way you'll have the enlightening learning experience that I had.

What to Expect

My intention when writing this book was to give you a grand tour of developing applications with Visual Studio.NET. As with all grand tours, you have to do a lot of preparation before you can start. For this reason the book is split into three parts: The first four chapters describe the .NET Framework, Chapters 5 through 7 describe the tools in Visual Studio.NET that you can use to develop applications, and Chapters 8 and 9 explain how to develop and debug applications.

The chapters follow a logical progression from a basic description of the .NET Runtime, through a description of the framework and the tools to develop .NET executables and libraries, to developing applications with the Visual Studio. NET design environment. I made a deliberate choice to leave an introduction of Visual Studio.NET until Chapter 5 because much of the development that you can do with .NET can be done with a simple text editor like Notepad (indeed, I urge you to use Notepad as you work through the first few chapters). However, at the point that your project grows larger than a handful of files, at the point that you move away from trivial resources and XML files to use more real-life files, you'll start to realize that you need a more accomplished editor and tools to help you develop your application.

It is at this point that you'll need to use Visual Studio.NET. If you use VS.NET before you've gone through the details of .NET's facilities, you won't appreciate the tools that VS.NET provides. I also want to give you the impression that there is a life beyond wizard-generated code.

The following is a brief description of what to expect in the chapters of this book.

Chapter 1: .NET Runtime

In this chapter I start exactly where I should: right at the beginning with a description of the .NET Runtime. The runtime executes all .NET code, so in this chapter I describe the basic concepts of the runtime and how it locates and runs code. I describe the languages that you can use and various .NET features used to generate events, to provide error information, and to access code outside of the current code module. Then I describe the .NET facilities for adding type information to a code module, and how you can add custom type information. Finally, I explain how code is packaged and the new mechanism for locating and loading that code.

Chapter 2: Framework Class Library

I use this chapter to give an overview of what I consider to be the "core" library. The framework library is available to all .NET languages and can be considered to be a culmination of the various APIs that Win32 developers are accustomed to using. The Framework Class Library contains many classes, and I have chosen to explain just a few. These are the classes that you are most likely to use--the classes without which you are unlikely to be able to do any .NET development.

I explain threading, basic input/output using streams to files and to the console, the debugging classes, and collection classes. Once I have made the foundation with the fundamental classes, I follow up with a description of the user interface classes to allow you to create windows and draw in those windows. Finally, I describe what I call the "other" classes. Strictly speaking, they are not core classes, but they are important for application development, so I give an overview of these classes and how to use them.

Chapter 3: Contexts and Remoting

.NET provides a new level of code isolation: application domains, which I introduced in Chapter 1. In this chapter I explain how code in one application domain can access code in another domain: .NET remoting. .NET defines an idea called context--domain membership is one property of a context--and .NET needs to take special action to allow calls to be made across contexts. I explain how cross-context calls are made and how you can change the way that .NET manages these calls.

This chapter explains in detail how .NET remoting works, the types of objects that can be accessed remotely, how long they live, and the security aspects of accessing those objects. Finally, the chapter has a description of asynchronous programming, including how exceptions and return values are handled when a call is made asynchronously.

Chapter 4: Interoperation and COM+

Interoperation is required to allow your .NET code to access native code. In this chapter I cover all aspects of interoperation from accessing DLLs, through Platform Invoke, to accessing COM and COM+ components. I start by describing how Platform Invoke works and contrast this to how you can access native C++ code from managed C++. I also explain marshaling non-simple types, how exceptions are handled, and "unsafe" code.

In the second half of the chapter I explain how interoperation with COM and COM+ is achieved. .NET provides tools to allow you to use COM objects in .NET code and to use .NET objects in COM code. I show you how to use these tools and describe how COM concepts like events, aggregation, and registration are achieved. The final part of the chapter explains the .NET classes that allow you to write COM+ classes.

Chapter 5: Visual Studio.NET Environment

By this point in the book you should have a good grounding in the facilities that .NET offers and the classes that you can use. In this chapter I introduce you to the facilities in Visual Studio.NET that you can use to develop .NET code. I start with a general description of the user interface: the various windows and toolbars that are provided. I then give a brief description of the code-generating wizards and the UI features of VS.NET that you can use to change the code that is generated.

In the latter half of the chapter I explain how to manage your code and the tools that you can use to search in your code and to get help. Finally, I explain the Toolbox and how to use external tools.

Chapter 6: Creating and Building Solutions

In this chapter I look in detail at how you create and build solutions. A solution is a collection of projects, and a project contains source files that are compiled to create an output. I start this chapter by explaining the various project types that you can add to a solution and the various classes that you can add to those projects. Following the general theme of this book, I explain only C++ and C# classes, but I do include a description of the C++ projects that create native code.

In the second half of the chapter I explain how to build and deploy solutions. I describe how to start a compilation, and how to customize it. I also explain how you can deploy the outputs from a solution and the various project types that are provided to do this.

Chapter 7: Visual C++.NET

C++ is the most flexible of the .NET languages. Visual C++ allows you to develop both native and managed code, as well as a mixture of the two. I start this chapter by describing the new features in ATL, beginning with a description of Visual C++ attributes and an explanation of how these help your development. Then I explain ATL Server, which is used to write ISAPI extensions for Web applications and Web Services.

The rest of the chapter is concerned with managed code, and I explain how managed C++ differs from native C++ in declaring classes and in handling interfaces, arrays, and strings.

Chapter 8: Application Development

This chapter is concerned with two main subjects: developing UI controls and forms, and localizing resources. In the first half of the chapter I explain components and controls and lead you through the process of developing a control that is integrated with the Visual Studio.NET Toolbox and Properties windows. In the second half of this chapter I describe .NET resources and how you can use the Visual Studio.NET tools to create localized resources.

Chapter 9: Debugging

After you have designed, written, and built your application, the next step will be to check that it does what it is designed to do, and to correct code that is in error. That is, you will have to debug your application. Visual Studio.NET allows you to debug both native and managed code, and even to step from the managed to the unmanaged world and vice versa. In this chapter I explain all the facilities that you can use to debug your code: how to set breakpoints, how to use the debugging windows, and how to debug more than one process.



0201708523P01242002

Index

7-bit encoded integers, 152
16-bit integer, converting to string, 142
64-bit integer data type, 410
64-bit number, 365
2013 warning message, 238
+= operator, 78-79AAbort() method, 187, 195
Abs function, 160
Absolute values, 9-10
Absolute zero, 143
Abstract classes, 21, 24, 59-60, 473, 592-593
Abstract methods, 24-25
Accept() method, 180
AcceptSocket() method, 181
AcceptTcpClient() method, 181
Access
    attribute checking, 436-437
    checking, 18
    levels of, 37-38
    members, 37-39
    programmatic checking, 437
    role checking, 436-437
Access property, 474
Access token, 17
Account object, 437
ACL (access control list), 17
ACos function, 159
Activate() method, 431, 433, 434
Activation, 432
Activator class, 163
Activator.GetObject() method, 303
Active Server Page Component wizard, 521
ActiveX components, 552
ActiveX controls, 564
ActiveXMessageFormatter class, 289
Add ATL Support to MFC wizard, 521
Add class, 530
Add Class command, 520
Add Class dialog, 464, 520, 533, 534, 665
Add Class wizard, 465-467, 473, 530, 543
Add Component command, 488
Add Connection Point wizard, 472
Add context command, 530, 552
Add context menu, 463
Add Existing Item command, 664
Add Field wizard, 471
Add handler code, 85
Add Indexer wizard, 471
Add Item dialog, 477
add_ method, 84, 85
Add Method wizard, 470
Add New Item dialog, 664
Add New Item wizard, 465, 467
Add PerfMon Counter Wizard, 527
Add PerfMon Object command, 526
Add Property wizard, 471
Add Reference dialog, 467-468
Add Reference item, 467
Add Resource command, 520
Add Resource dialog, 463, 520
Add Task List Shortcut command, 496
Add Variable wizard, 471
Add Watch command, 692
Add Web Reference item, 467, 587
Add-In Manager, 505-506
Add-ins, 505-506
Add() method, 221, 229, 634
.addon directive, 83
AddRange() function, 221, 229
AddRef() method, 389, 744
Administrative policies, 109
Administrative Tools Start Menu folder, 122-123
Age variable, 27
Aggregation and COM, 423-424
Al.exe assembly builder tool, 113, 115, 673
Alias command, 494
Aliases, 494, 696-698
Allocated memory, 5
AllocateDataSlot() method, 198, 261
AllocateNamedDataSlot() method, 199, 261
AllocCoTaskMem() method, 381
AllocHGlobal() method, 380, 381
Alpha blending, 216
Alpha component, 216
ALT$__m data segment, 575
Analyzer wizard, 558-559
Animation routines, 205
ANSI C++, compiled by managed C++ compiler, 349
ANSI strings, 362, 617
Any constant, 181
Apartments, 407
APIs, xv, 130-133
AppBase folder, 116
App.cs file, 660, 661
AppDomain class, 70, 121, 163
_AppDomain interface, 630
AppDomain.AssemblyLoad events, 202
AppDomain.CreateInstance() method, 122
AppDomain.UnhandledException event, 199
App.exe assembly, 660, 676
Application class, 219
Application domains, 118-119, 263
    assemblies, 99
    lease manager, 310
    security policy, 125
Application Error dialog, 64, 135
Application event log, 235, 238
Application Folder node, 556
Application log, 234, 241
Application object, 130
Application Options page, 516
Application policies, 109
Application.Exit() method, 219
Application.Run() method, 219
Applications
    aborting, 170
    access checks, 435
    application ID, 427
    bugs, 168
    closing, 219
    component services, 427-430
    configuring, 428
    dependencies, 110
    developing, 633
    diagnostic information, 162
    end point, 178
    environment variables, 161
    form-based, 232
    information about, 160-161
    settings, 120
    status code, 162
    stopping without throwing exception, 162
    strong name, 427
    type, 428
    updating, 428
Application-specific private DLLs (Dynamic Link Libraries), 105
App.resources.dll library, 673, 675
Areas, 658
Arithmetic operators and watch windows, 693
Array class, 42, 44, 141
Array::CreateInstance() method, 612, 613
Array::GetUpperBound() method, 614
Array::GetValue() method, 612
ArrayList class, 42, 44, 141, 608
Arrays
    accessing members, 613
    allocating, 616
    complex type, 367
    creation of, 611-612
    __gc types, 616
    how much data to marshal, 368
    indexes, 36
    initializing, 611-612
    Length property, 37
    listing members, 690-691
    managed, 36-37, 409-410, 611-616
    managing, 10
    marshaling, 371
    multidimensional arrays, 611
    number of elements, 36
    primitive type, 367
    reference types, 36
    size of, 368, 370-371
    unmanaged C++, 611, 612-613
    value type, 36
    __value types, 616
    vectors, 611
    watch windows, 690
Array::SetValue() method, 612
As keyword, 44
ASCII
    converting, 149
    strings, 360
ASCIIEncoding class, 149
Asembly.GetManifestResourceNames() method, 666
ASin function, 159
.Asmx files, 329-331
ASP.NET, 323
    accessing Web Service, 330
    architectural overview, 328
    assemblies, 96
    code-behind, 329
    compiled code, 329
    cookies, 334
    managed Web Services, 327-331
    permission set, 124
    script code, 328-329
    Web Application wizard, 521
    Web Service wizard, 521
    Web Services, 325, 329, 331, 334
    XSD schema, 332
Aspnet_isapi.dll file, 328
Assem access level, 37
Assemblies, 88
    adding modules, 93-94
    application domains, 99
    ASP.NET, 96
    attributes, 48, 58, 200-201
    autoregistration feature, 430
    base code identifying location, 394
    build and revision number, 113-114
    compiled resources, 659
    component services, 427-430
    components, 427
    containing current type, 201
    C#, 90, 97
    creation of, 93
    culture, 114
    current, 122
    default, 108-109
    domain-neutral, 120
    dynamic, 99
    dynamically loading, 117-118
    embedding resources, 660
    entry point, 203-204<

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership