C#数据库编程入门指南

需积分: 9 183 浏览量更新于2024-08-01 收藏 3.9MB PDF 举报

"APress 的《Database Programming with C#》由 Laxxuss 在 2002 年编写，本书旨在向读者介绍如何使用 C# 进行数据库编程。" 在本书中，作者首先对 C# 和数据库编程的基础进行了简要介绍。章节一“ALightning-Quick Introduction to C#”概述了 C# 语言的核心概念和 .NET Framework 的基本组成部分。此部分提到，这本书适合已有一定编程基础，并希望学习如何在 C# 环境下进行数据库编程的读者。书中指出，所有的代码示例都会提供，读者可以自行下载并运行。在技术要求方面，读者需要了解基本的编程概念，并且需要一个支持 C# 开发的环境，如 Visual Studio .NET（VS.NET）。VS.NET 的集成开发环境（IDE）是本书的重点之一，它被描述为所有语言共享的平台，具备多种功能，如两种界面模式、内置 Web 浏览器功能、对象浏览器、调试器、帮助系统、宏、升级的部署工具、文本编辑器以及 IDE 和工具的自定义等。进入数据库编程的主题，第二章“Using Databases”探讨了数据库的基本概念。作者解释了为什么需要使用数据库，区分了关系型数据库和层次型数据库的差异。层次型数据库（如 IBM 的 IMS）和关系型数据库（如 SQL Server、Oracle）在结构和操作上有着显著的不同。对于 C# 编程人员来说，理解这些基本概念是至关重要的，因为这将帮助他们选择合适的数据库系统并有效地进行数据操作。书中后续章节很可能会深入讨论如何在 C# 中创建和管理数据库连接，执行 SQL 查询，处理事务，以及使用 ADO.NET 或 Entity Framework 等库来实现更高级的功能，例如数据绑定和数据访问。还会涉及如何利用 VS.NET 的各种工具（如 Server Explorer、Data Connections、Toolbox 和 Task List）来简化数据库相关的开发工作。《Database Programming with C#》是一本面向有经验的程序员，旨在提升他们在 C# 环境下进行数据库开发能力的实用指南。通过阅读本书，读者将能够掌握如何利用 C# 进行高效、可靠的数据库应用程序开发。

Because I'm using some of the Enterprise functionality of Visual Studio .NET, you'll need either of the two

Enterprise editions to follow all the exercises. However, the Professional edition will do for most of the

example code, and it will certainly do if you just want to see how everything is done while you learn

ADO.NET. This means that the only thing extra you get from the Enterprise editions in terms of database

access is an extra set of database tools to be used from within the IDE.

Example Code

All the example code for this book can be found on the Apress Web site (http://www.apress.com) in the

Downloads section, or on the UserMan Web site (http://www.userman.dk).

Data Source

The data source for the example code in this book is running on SQL Server 2000. However, the example

code also includes how to connect to and manipulate data in MySQL 3.23.45 or later, Oracle 8i or later,

Microsoft Access 2000 or later, and SQL Server.

Feedback

I can be reached at <carstent@dotnetservices.biz> and I'll gladly answer any e−mail concerning this book.

Now, I don't need any unnecessary grief, but I'll try to respond to any queries you might have regarding this

book.

I have set up a Web site for the UserMan example application, where you can post and retrieve ideas on how

to take it further. The Web site address is http://www.userman.dk. Please check it out.

Database Programming with C#

Example Code 5

Chapter 1: A Lightning−Quick Introduction to C#

Overview

The .NET Framework is an environment for building, deploying, and running services and other applications.

This environment is all about code reuse and specialization, multilanguage development, deployment,

administration, and security. The .NET Framework will lead to a new generation of software that melds

computing and communication in a way that allows the developer to create truly distributed applications that

integrate and collaborate with other complementary services. In other words, you now have the opportunity to

create Web services, such as search engines and mortgage calculators, that will help transform the Internet as

we know it today. No longer will it be about individual Web sites or connected devices; it's now a question of

computers and devices, such as handheld computers, wristwatches, and mobile phones, collaborating with

each other and thus creating rich services. As an example, imagine calling a search engine to run a search and

then displaying and manipulating the results of the search in your own application.

There are rumors that the .NET Framework is solely for building Web sites, but this is not true. You can just

as easily create your good old−fashioned Windows applications with the .NET Framework. The .NET

Framework is actually more or less what would have been called COM+ 2.0 if Microsoft had not changed its

naming conventions. Granted, the .NET Framework is now a far cry from COM+, but initially the

development did start from the basis of COM+. I guess not naming it COM+ 2.0 was the right move after all.

This book is based on the assumption that you already know about the .NET Framework. However, this

chapter provides a quick run−through of .NET concepts and terms. Although the terms are not specific to C#,

but rather are relevant to all .NET programming languages, you'll need to know them if you're serious about

using C# for all your enterprise programming.

Reviewing Programming Concepts

The .NET environment introduces some programming concepts that will be new even to those who are

familiar with a previous version of a Windows programming language, such as Visual Basic or Visual C++. In

fact, these concepts will be new to most Windows developers because the .NET programming tools, such as

C#, are geared toward enterprise development in the context of Web−centric applications. This does not mean

the days of Windows platform−only development is gone, but .NET requires you to change the way you think

about Windows programming. The good old Registry is "gone"that is, it's no longer used for registering your

type libraries in the form of ActiveX/COM servers. Components of .NET Framework are self−describing; all

information about referenced components, and so on, are part of the component in the form of metadata.

Visual Studio .NET is based on the Microsoft .NET Framework, which obviously means that the C#

programming language is as well. C# is part of the Visual Studio .NET package and it's just one of the

programming languages that Microsoft ships for the .NET platform.

At first some of these new terms and concepts seem a bit daunting, but they really aren't that difficult. If you

need to refresh your memory regarding .NET programming concepts and the .NET Framework, simply keep

reading, because this chapter is indeed a very quick review of these basics.

Chapter 1: A Lightning−Quick Introduction to C# 6

A Quick Look at Components of the .NET Framework

The .NET Framework adheres to the common type system (CTS) for data exchange and the Common

Language Specification (CLS) for language interoperability. In short, three main parts make up the .NET

Framework:

Active Server Pages.NET (ASP.NET)•

Common language runtime (CLR)•

.NET Framework class library (the base classes)•

The .NET Framework consists of these additional components:

Assemblies•

Namespaces•

Managed components•

Common type system (CTS)•

Microsoft intermediate language (MSIL)•

Just−In−Time (JIT)•

I discuss all of these components in the following sections.

Active Server Pages.NET

Active Server Pages.NET is an evolution of Active Server Pages (ASP) into so−called managed space, or

rather managed code execution (see the sections "Common Language Runtime" and "Managed Data" later in

this chapter). ASP.NET is a framework for building server−based Web applications. ASP.NET pages

generally separate the presentation (HTML) from the logic/code. This means that the HTML is placed in a

text file with an .aspx extension and the code is placed in a text file with a .cs extension (when you implement

your application logic/code in C#, that is).

ASP.NET is largely syntax compatible with ASP, which allows you to port most of your existing ASP code to

the .NET Framework and then upgrade the ASP files one by one. ASP.NET has different programming

models that you can mix in any way. The programming models are as follows:

Web Forms allow you to build Web pages using a forms−based UI. These forms are quite similar to

the forms used in previous versions of Visual Basic. This also means that you have proper event and

exception handling, unlike in ASP, where event and especially exception handling is a difficult task to

manage.

•

XML Web services are a clever way of exposing and accessing functionality on remote servers. XML

Web services are based on the Simple Object Access Protocol (SOAP), which is a firewall−friendly

protocol based on XML. SOAP uses the HTTP protocol to work across the Internet. XML Web

services can also be invoked using the HTTP GET method simply by browsing to the Web service

and the HTTP POST method.

•

Standard HTML allows you to create your pages as standard HTML version 3.2 or 4.0.•

Common Type System

The .NET environment is based on the common type system (CTS), which means that all .NET languages

share the same data types. This truly makes it easy to exchange data between different programming

languages. It doesn't matter if you exchange data directly in your source code (for example, inheriting classes

Database Programming with C#

A Quick Look at Components of the .NET Framework 7

created in a different programming language) or use Web services or COM+ components. CTS is built into

the common language runtime (CLR). Have you ever had a problem exchanging dates with other

applications? If so, I'm sure you know how valuable it is to have the CTS to establish the correct format. You

don't have to worry about the format being, say, DD−MM−YYYY; you simply need to pass a DateTime data

type.

Common Language Specification

The Common Language Specification (CLS) is a set of conventions used for promoting language

interoperability. This means that the various programming languages developed for the .NET platform must

conform to the CLS in order to make sure that objects developed in different programming languages can

actually talk to each other. This includes exposing only those features and data types that are CLS compliant.

Internally, your objects, data types, and features can be different from the ones in the CLS, as long as the

exported methods, procedures, and data types are CLS compliant. So in other words, the CLS is really nothing

more than a standard for language interoperability used in the .NET Framework.

Common Language Runtime

The common language runtime (CLR) is the runtime environment provided by the .NET Framework. The

CLR's job is to manage code execution, hence the term managed code. The compilers for C# and Visual Basic

.NET both produce managed code, whereas the Visual C++ compiler by default produces unmanaged code.

By unmanaged code, I mean code for the Windows platform like that produced by the compilers for the

previous versions of Visual C++. You can, however, use the managed code extensions for Visual C++ for

creating managed code from within Visual C++.

Implications for JScript

Does the appearance of .NET and the CLR mean the end of JScript? Well, not quite. If you are referring to

server−side development in the new compiled JScript language, I guess it's up to the developer. JScript as it is

known today (i.e., client−side code execution) will continue to exist, largely because of its all−browser

adoption. But if the CLR is ported to enough platforms and supported by enough software vendors, it might

well stand a good chance of competing with the Virtual Machine for executing Java applets. Microsoft now

also has a programming language called J#, which comes with upgrade tools for Visual J++ 6.0. You're

reading this book because you like C#, Microsoft's Java−killer, but you might want to also check out J#,

especially if you've crossed over from the Java camp (at least just to make sure you've made the right choice).

VBScript, VBA, and VSA

Okay, what about VBScript and Visual Basic for Applications (VBA)? This is obviously another issue that

relates to the introduction of VB .NET, the other major .NET programming language. A new version of VBA,

Visual Studio for Applications (VSA), is available for customizing and extending the functionality of your

Web−based applications. VSA is built with a language−neutral architecture, but the first version only comes

with support for one programming language, Visual Basic .NET. However, later versions will support other

.NET languages such as C#.

Built−in CLR Tasks

The CLR performs the following built−in tasks:

Managing data•

Performing automatic garbage collection•

Database Programming with C#

A Quick Look at Components of the .NET Framework 8

Sharing a common base for source code•

Compiling code to the Microsoft intermediate language (MSIL)•

I discuss these features in the next few sections.

Managed Data

The .NET Framework compilers mainly produce managed code, which is managed by the CLR. Managed

code means managed data, which in turn means data with lifetimes managed by the CLR. This is also referred

to as garbage collection, which you can read about in the next section. Managed data will definitely help

eliminate memory leaks, but at the same time it also means you have less control over your data, because you

no longer have deterministic finalization, which is arguably one of the strengths of COM(+).

Automatic Garbage Collection

When objects are managed (allocated and released) by the CLR, you don't have full control over them. The

CLR handles the object layout and the references to the objects, disposing of the objects when they're no

longer being used. This process is called automatic garbage collection. This process is very different from the

one for handling objects in previous versions of Visual Basic or Visual C++ known as deterministic

finalization. These programming languages used COM as their component model and, as such, they used the

COM model for referencing and counting objects. As a result, whenever your application instantiated an

object, a counter for this object reference was incremented by one, and when your application destroyed the

object reference or when it went out of scope, the counter was decremented. When the counter hit zero, the

object would be released automatically from memory. This is something you have to be very aware of now,

because you no longer have full control over your object references. If you're aJava programmer, you

probably already know about this.

Source Code Shares Common Base

Because all the CLR−compliant compilers produce managed code, the source code shares the same basethat

is, the type system (CTS) and to some extent the language specification (CLS). This means you can inherit

classes written in a language other than the one you're using, a concept known as cross−language inheritance.

This is a great benefit to larger development teams, where the developers' skill sets are likely rather different.

Another major benefit is when you need to debugyou can now safely debug within the same environment

source code across various programming languages.

Intermediate Language Compilation

When you compile your code, it's compiled to what is called Microsoft intermediate language (MSIL) and

stored in a portable executable (PE) file along with metadata that describes the types (classes, interfaces, and

value types) used in the code. Because the compiled code is in an "intermediate state," the code is platform

independent. This means the MSIL code can be executed on any platform that has the CLR installed. The

metadata that exists in the PE file along with the MSIL enables your code to describe itself, which means

there is no need for type libraries or Interface Definition Language (IDL) files. The CLR locates the metadata

in the PE file and extracts it from there as necessary when the file is executed.

At runtime, the CLR's JIT compilers convert the MSIL code to machine code, which is then executed. This

machine code is obviously appropriate for the platform on which the CLR is installed. The JIT compilers and

the CLR are made by various vendors, and I suppose the most notable one is Microsoft's Windows CLR

(surprise, eh?).

Database Programming with C#

A Quick Look at Components of the .NET Framework 9

剩余519页未读，继续阅读

sojjer

粉丝: 0
资源: 1

C#数据库编程入门指南

Apress - Pro WPF in C# 2008, 2nd Edition (Feb 2008)

Apress - Professional Jms Programming.pdf

Apress - Pro Java Programming, 2nd Edition.pdf

Apress - Beginning XML with DOM and Ajax - From Novice to Professional.pdf

Apress - Personal Finance with Python.2018

Apress.Web.Programming.with.Dart.2014

APress - The Definitive Guide to MySQL, 2nd Ed - 2004 - (By Laxxuss).chm

Apress.Reactive.Programming.with.Angular.and.ngrx

APress,..NET.Game.Programming.with.DirectX.9.0.pdf

Apress.-.Pro.WPF.and.Silverlight.MVVM.2010

最新资源