C#入门指南：Visual C# .NET Developer's Handbook

需积分: 10 56 浏览量更新于2024-07-23 收藏 4.71MB PDF 举报

"C# Visual C# .NET Developers Handbook 是一本由John Paul Mueller编写的C#开发书籍，适合初学者入门，书中的内容被认为比国内的一些教程更易理解。" 本书详细介绍了C#编程语言和.NET Framework的基础知识以及高级概念，是针对希望在Windows平台上进行软件开发的程序员的一份全面指南。C#（读作"C sharp"）是一种由Microsoft公司推出的面向对象的编程语言，设计用于构建各种类型的Windows应用程序，包括桌面应用、Web应用和移动应用。在C#的学习中，初学者将接触到的关键知识点包括： 1. **基础语法**：学习C#的基本数据类型（如int、string、bool等）、变量、常量、运算符、流程控制语句（如if、switch、for、while等）以及函数的定义和调用。 2. **类与对象**：理解面向对象编程的基本概念，包括类的定义、对象的创建、封装、继承、多态性以及接口。 3. **异常处理**：了解如何使用try-catch块进行错误处理，以及throw和finally关键字的使用。 4. **数组与集合**：学习不同类型的数组（一维、多维、 Jagged）以及ArrayList和Generic List<T>等集合类的使用。 5. **文件与流操作**：掌握读写文件、处理输入输出流以及序列化和反序列化对象的方法。 6. **面向组件编程**：深入.NET Framework，学习如何使用Assembly、命名空间以及引用外部组件。 7. **Windows Forms**：通过实例介绍如何创建和设计用户界面，包括控件的使用、事件处理和对话框的显示。 8. **图形与GDI+**：了解如何使用GDI+库进行图形绘制、图像处理和打印。 9. **数据库访问**：学习ADO.NET框架，包括Connection、Command、DataAdapter和DataSet等对象，以及如何执行SQL查询和事务处理。 10. **Web服务与.NET Remoting**：探讨如何使用SOAP和XML来创建和消费Web服务，以及.NET Remoting实现跨进程通信。 11. **线程与并发**：理解多线程编程，学习同步、互斥锁、线程池和异步编程模型。 12. **调试与性能优化**：学习使用Visual Studio的调试工具，以及如何分析和优化代码性能。 13. **单元测试**：介绍单元测试的概念和实践，如使用NUnit或Microsoft的Unit Testing框架。 14. **代码管理和版本控制**：理解源代码控制的重要性，如Git或SVN的使用。此外，技术编辑Ross Russell Mullen的专业审校确保了书中内容的准确性，而详细的索引和清晰的示例代码则有助于读者更好地理解和应用这些知识。这本书还附带了一张CD-ROM，可能包含了示例代码、练习和其他补充材料，以便读者亲手实践所学内容。 "C# Visual C# .NET Developers Handbook" 是一本全面覆盖C#编程语言和.NET开发的实用指南，为初学者提供了扎实的理论基础和实践经验，有助于他们在IT行业中开启C#开发的职业生涯。

assemblies are an ordered method of packaging an application or an application unit such as a

component.

Attributes

Attributes are special features that enable you to describe an application that would normally

require code. For example, you can use an attribute to define an event receiver or an event

source. A single word or short set of words serves to augment some code within an

application or a component.

So, why is this feature so important? Imagine writing the components you always have in the

past, but with as little as 25% of the code you use today. Less code means fewer potential

errors and a shorter development time. Programmers from all walks are finding they have a

hard time meeting delivery dates, and are given shorter deadlines and increasing application

complexity. Any technology that promises to reduce development time using a tool that you're

already familiar with is a welcome relief.

We'll use attributes a lot throughout the book. Attributes are such a useful feature that using

them is an essential part of learning C#. Once you learn how to use the built-in attributes,

we'll also discuss creating custom attributes. Using custom attributes can significantly

improve an already great feature. (See the section titled "An Attribute Example" in Chapter 3

for details.)

Other Language Interoperatiblity

All of the .NET languages are designed to work together with relative ease. In fact, you can

use a mixed language environment when scripting. A component you create in C# will work

with Visual Basic because both use the same IL. Mixing and matching languages that rely on

the .NET Framework doesn't require much work. If you want to use a Visual Basic

component in your C# application, simply place the component in the project folder or

Working with non-.NET languages is a little harder, but not impossible. You can use your

managed component in an unmanaged application, or your unmanaged component in a

managed application. Microsoft provides a special namespace:

System.Runtime.InteropServices and some special attributes to make interoperability easier.

We'll discuss this topic further as the book progresses.

Understanding the Benefits of Using C#

In the previous sections of the chapter, you learned what C# is and what it has that you didn't

have before. This is important, but some developers will still say, "So what?" Yes, C# does

solve many problems that developers have with older languages, but experienced developers

already know how to get around those issues and may see C# as yet another language to learn.

The fact is that C# has a lot to offer developers from a personal perspective. I wouldn't say

any of these features are earth shattering, and you've probably heard these promises for other

languages in the past. C# actually delivers on these promises and makes life easier for the

developer. Will C# make you a better programmer? Yes, in some ways. For example, it helps

you catch more errors before they become problems. However, only experience creates great

programmers.

Most developers will find that C# makes them faster and more efficient programmers. You'll

spend less time figuring out how to code something due to an ambiguity in the development

environment. In many cases, you'll also find that you spend less time searching for just the

right API call or switch that isn't documented.

Now that you have some idea of what you have to gain from C#, let's discuss the topic in

detail. The following sections answer the question, "What will C# do for me?" You'll learn

why C# is such an important improvement in the development community.

Developer Productivity Enhancements

There's one overriding reason to use C#-it's the language of choice for many developers who

work extensively with COM or other object-based development technologies. Spending even

a small amount of time on the microsoft.public.dotnet.csharp.general,

microsoft.public.dotnet.vb.general, and microsoft.public.dotnet.vc.general newsgroups shows

widespread developer interest in C# as a language. (You can find all of these newsgroups on

the news://news.microsoft.com server, if you can't find them on your local ISP.) Many

developers on these newsgroups already plan to move to C# because it alleviates so many

application development problems. In addition, Microsoft has submitted C# to the European

standards group, ECMA (http://www.ecma.ch/), which means that the language will benefit

from the efforts of a standards committee. (The http://www2.hursley.ibm.com/tc39/ website

contains a better description of the standards effort.) Finally, more than one company is

interested in C#, which could mean some level of platform independence for the language.

The high interest in this language, coupled with a standards-oriented approach, means that

developers will want to adopt C# relatively quickly.

Now that we've covered the main reason to move to C#, let's talk about all of the reasons to

use it. The following sections will tell you about the benefits of C#, the prototyping and

development speed, and how you can use C# to create better COM+ applications.

Simplicity

C# adds simplicity to the development environment in several ways. We've already talked

about how Microsoft has simplified the data types by consolidating some and adding others.

For example, you no longer need to worry about which char data type to use-there's only one.

Likewise, the new decimal data type will greatly reduce programming complexity.

The use of the .NET Framework will simplify matters as well. The hierarchical structure of

namespaces will make it easier to find methods that you need. In addition, more system

resources are available as methods, rather than API calls. For example, with C# you can now

write event log entries using a simple method call, rather than using the convoluted method

for Visual C++.

One item I haven't mentioned yet is the IDE provided with Visual Studio .NET. Microsoft has

added a variety of automation features to the product. For example, when you type a

statement name, the IDE will automatically add the required braces for you. This feature

won't necessarily save a lot of time, but it should reduce the number of simple coding errors

that programmer will have to find before an application compiles.

Managed environments simplify programming tasks. For example, C# will greatly reduce

memory leaks using garbage collection. Of course, the use of garbage collection will also

reduce debugging time because the programmer will have fewer errors to find. Since memory

leaks are notoriously difficult to find and fix, most developers will find that garbage collection

greatly reduces the amount of debugging time for a given project.

Consistency

There are many new types of consistency within C#. However, three forms deserve special

mention because they have such a great impact on the development environment.

Everything is an object. C# even treats variables as objects. The runtime environment

"boxes" variables into an object when you need to perform a task like data conversion. Once

the data conversion is finished, the variable is unboxed. The point is that you can access

everything in the same way-there aren't any special rules to remember.

The .NET Framework ensures function call consistency. Instead of having to remember a

lot of very odd API calls, you just follow a hierarchy of namespace entries to the method you

need to perform a specific task. Since every call is handled in the same way, the developer

only needs to worry about the task at hand, rather than try to remember the odd exception to

the rule that an API call might require.

Error trapping is easier than ever before. Unlike Visual C++ and Visual Basic where there

are a number of ways to detect errors, C# uses a single standard method. This means that

developers can standardize error-trapping routines and reduce the complexity of finding and

eradicating problems like data entry errors.

Modern Development Options

Visual C++ and other languages were developed at a time when the Desktop was king.

Vendors updated these languages with moderate success for the world of client/server

programming. In the past few years, Internet development has become the area where most

developers spend their time. Updates to these older languages now feel like kludges added to

compensate for a development environment that vendors never designed these languages to

address.

Given the need for distributed applications today, it's time for a new language that's designed

to better meet the needs of modern developers. C# is that language. The use of a modern IDE

and programming techniques will allow developers to gain the level of operating system

access they require. We've talked about all of these features throughout this briefing, so I

won't cover them again here.

Object Orientation

Unlike Visual C++ and Visual Basic, C# provides true object orientation. Everything is an

object. This language does make some concessions for the sake of performance, but even in

these areas, C# provides the means to use objects. For example, C# stores and uses variables

in the same way that Visual C++ and Visual Basic have in the past. The difference is that C#

can box a variable within an object, making it easy to access the variable as an object when

needed. This means that C# provides the same level of object orientation that languages like

Eiffel and Smalltalk do, but without the performance penalties.

C# also embraces the COM+ virtual object system. This means that all objects execute within

a context. You can assign role-based security to objects, which means that you can allow user

interaction based on the role the user has within an organization. In short, you have much

finer control over the component execution environment.

Finally, C# gets rid of the global variables, methods, and constants. Everything appears within

a class. This means there are fewer chances for naming conflicts and the data contained within

variables remains safer. While it will take some developers time to get used to the new

method of handling data, the result is more reliable components and applications.

Compatibility

C# provides an environment that's compatible with everything that has gone before. If you

really want to use the old APIs that you used in C programs long ago, C# provides a means to

access them. Likewise, you have access to standard COM and OLE Automation through the

APIs you've used in the past. C# provides access to all of the required data types through the

COM+ runtime.

Flexibility

You'll find that C# is extremely flexible. It can't quite do everything that Visual C++ can. For

example, if you need a native code output such as a DLL or EXE, then Visual C++ is the only

choice when using Visual Studio .NET. However, in all other ways, C# is more flexible than

anything that has gone before. You obtain all of the best features of Visual Basic and Visual

C++ in one package.

Faster Prototyping and Development

To provide an honest evaluation in this section, you have to separate the benefits of using the

new Visual Studio .NET IDE from the benefits of using C#. For example, everyone has

access to the autocomplete and help features that the Visual Studio .NET IDE provides. While

the new IDE does help you work faster, you'd also receive this benefit when using other

languages.

C# provides its own set of productivity features. The way Microsoft put the language together

means you'll spend less time guessing and more time writing code. You don't have to worry

about pointers any longer. That alone should save both development and debugging time.

You'll also find that the organizational benefits of C# help you prototype and develop

applications faster. The consistent look of every class you create means you spend less time

worrying about structure and more time coding your project. However, as with any other new

product, you'll spend some time overcoming the C# learning curve before you actually see the

benefits of the new way of creating classes.

When C# Isn't the Right Choice

Developers are always looking for the silver bullet-the solution that works every time.

Unfortunately, there aren't any silver bullets in the computer industry. While you can bend a

computer language to your will and force it to perform a task, some tasks naturally work

better with some languages. C# has limitations-some architectural and some as a matter of

convenience. The following sections tell you about the areas where C# isn't necessarily the

best language choice.

Native Executable Development

C# is the language of choice for many types of managed application development, those types

of applications that rely upon the .NET Framework. However, C# can't provide native

executables, those that rely exclusively on the underlying operating system. In fact, the only

way to generate native executables with Visual Studio .NET is by using Visual C++. The lack

of native code development potential means you can't use C# in situations where native

executables are the only answer. The following list provides some ideas on when you should

avoid using C# because of native code development requirements:

• Older versions of Windows

• Drivers and other low-level programming

• Downloadable components

It's especially important to consider your knowledge of the client for application services.

Many existing Windows platforms lack .NET Framework support, which means they can't run

managed applications. Consider the fact that the client would need to download such support

before using your component if you used managed code when a native EXE would work

better.

Older Application Support

Most companies have a wealth of existing code that they can ill afford to move to another

development environment. These older applications might work fine as they are today or

require small tweaks in order to keep pace with current technology. Even if you decide to

build part of the application in a mixed environment (part managed and part unmanaged

code), it's often better to continue using the current language. Continuing with Visual C++ or

Visual Basic makes sense from a developer learning curve and code maintenance perspective

when an application already relies on these products and has nothing to gain from using C#.

However, you should differentiate a local monolithic application from a distributed

application on the Internet. Developing new services for an existing application using C#

could make sense if the service is used for generalized access. For example, a web service that

provides support to a company database for your company and several partners might make a

good candidate for C#.

Older Platform Support

Microsoft has been touting platform independence as the reason to use .NET, yet the .NET

Framework doesn't even run on all Windows platforms yet. As of this writing, there aren't any

plans to port the .NET Framework to older Windows platforms, and the deafening quiet from

剩余480页未读，继续阅读

vector_Raster

粉丝: 0
资源: 2

C#入门指南：Visual C# .NET Developer's Handbook

Visual C# 2010 Step-by-Step: A Comprehensive Guide for .NET Developers

#.NET MAUI: Empowering C# Developers

C# 4.0经典指南：Essential C# for .NET Developers (第3版)

From_Java_To_C_Sharp_-_A_Developers_Guide

Visual+C#+.NET_Developers+HandbooK

c_sharp_dot_net_web_developers_guide.pdf

使用_Eclipse_IDE_for_C_C++_Developers_搭建_C++_开发环境.doc

bandswitch.zip_通讯编程_Visual_C++_

WDK_Build.rar_驱动编程_Visual_C++_

Cryptography for Developers_fordevelopers_cryptography_

最新资源