Tài liệu Visual C# .NET Programming pptx

LINK DOWNLOAD MIỄN PHÍ TÀI LIỆU "Tài liệu Visual C# .NET Programming pptx": http://123doc.vn/document/1035380-tai-lieu-visual-c-net-programming-pptx.htm

Part 1: Prelude-Service with a Smile
In classical music, the prelude introduces the work. Often composed in a free-flowing style, it
sets the mood and mode for the rest of the work and is designed to pique the interest of the
audience. It can contain references to ideas that are delivered later-foreshadowings, a taste
of things to come. The themes in the prelude are not whole ideas but snippets, motifs-just
enough to whet the appetite and make the listener want more. These motifs are pre-echoes-
not déjà vu, which are vague memories of things already seen, but rather premonitions of
things to come. If you listen to the composition more than once, then in the prelude you
should be able to begin to hear the pattern of the entire piece.
At the same time that a prelude introduces the larger work; it is an organic unit in and of
itself, with a beginning, middle, and end. This cohesive mini-composition exists within the
larger whole and has its own sense of narrative conflict and resolution, point and
counterpoint, all reconciling in a conclusion that serves as an introduction.
Our prelude introduces the theme of the web service. Web services have been hailed by some
as revolutionary: a brand new kind of unit of executable code, fit for the distributed
environments of the Internet age.
A web service is not an end in and of itself. To actually do anything as a part of a program, it
must be used-or, put another way, 'consumed.'
It is also the case that this book is not 'about' web services; it is about programming in the C#
language and the .NET Framework.
Our prelude explores creating a web service, in Chapter 1, 'Creating a Web Service,' and
coding ASP.NET web applications to consume the web service, in Chapter 2, 'Consuming the
Service on the Web,' as a dramatic way to jump into the topics that will form the pattern of the
composition that is this book. Keep your eyes and ears open for premonitions that reveal this
book's real themes: the best way to write C# code for clarity, and patterns and practice of
communication between objects.
Part II: Allemande-Striding Forward
The allemande is a movement of great substance that directly follows the prelude of a musical
suite and picks up where the prelude leaves off. It is stately in manner and can be highly
stylized. The allemande carries forward the mood prefigured in the prelude and introduces
gravity into the suite; but the prelude's free style gives way to the processional-like regularity
of the allemande.
The sentiments casually introduced in the prelude have become a stepping dance with reality-
and the allemande keeps it all moving. The meter is steady and so is the progress.
The allemande is striding forward without hesitation into the future, and the future is now.
Early allemandes come in three sections, or strains, that are related but not the same. The
second strain contrasts with the first strain. They resolve in the third and final section
, which
paves the way for the next movement in the composition.
You can't have an application without a user interface. Chapter 3, 'Windows Uses Web
Services, Too!,' is an introduction to programming the Windows user interface-while carrying
on the web services motif explicitly introduced in the first part of the book. The allemande
also keeps one of the underlying themes of this book moving, with an explanation of the
asynchronous communication design pattern.
Chapter 4, 'Building a Better Windows Interface,' is about the hard-core plumbing of a
Windows interface. Services have been left behind. This is the territory of displaying lists of
items, menus, common dialogs, and such. This strain of the allemande may be concerned with
conventional Windows development, and it may be a little dissonant, but it has a sense of
humor. For example, you'll start this chapter by making round buttons dance.
The allemande is complete with Chapter 5, 'Reflecting on Classes.' We've taken strides
forward and are now past Windows, in the realm of objects and classes. This chapter fits C#
code in with the .NET Framework. Once again, it's about communication. Classes are not
islands, and they must be instantiated to be used. It is a time for reflection, for understanding
of ourselves and our environment, and also to soar the peaks of what is possible-knowing that
soon we must return to the humble arenas of language and syntax that make it all possible.
Part III: Courante-The Dance of the Language
The courante is a dance movement of vigor and complexity. It is rhythmically interesting and
exciting, but capable of hard work. A courante combines playfulness and movement with
heart, soul, and substance.
Courantes were used for dancing in court and in theater, and later as stylized movements
in instrumental music. The form combines rhythmic and metrical fluidity with a complicated
texture.
This part, the courante, is in many ways the heart and soul of this book.
We start with Chapter 6
, 'Zen and Now: The C# Language.' What could be more important
than a good understanding and grasp of syntax of the beautiful C# language?
Moving on, Chapter 7
, 'Arrays, Indexers, and Collections,' shows you how to work with
groups of objects-and make them dance.
Chapter 8, 'The Life of the Object in C#,' is all about classes and object-oriented
programming. Since all programming in C# is class-based and object-oriented-the only
question is whether the programming is good object-oriented code or bad object-oriented
code-the material in that chapter is important. I think the running example in Chapter 8 is
quite a bit of fun. This program is a simulation based on the ideas of Pulitzer Prize-winning
author Jared Diamond. As you'll see, the program allows users to track the rise (and fall) of
tribes and civilizations.
Strings are everything, and everything is string. If you know how to manipulate strings, you
know lots of things-and you'll find out how in Chapter 9
, 'Everything Is String Manipulation.'
Our courante has proceeded from language and syntax, and onward through arrays,
collections, objects, and classes. Coming back to the beginning, it has explained the
sophisticated manipulation of language elements. This is a complex dance, a spiral within a
spiral. As the courante winds down, we're ready to move onward-by looking outwards instead
of inwards.
Part IV: Gigue-Leaping to Success
The gigue-which became a popular Baroque movement-probably originated in Great Britain
as the 'jig' or 'jigg' (although note that the Old French verb giguer means 'to leap' or 'to
gambol'). Whatever the derivation of the word, it's clear that in Elizabethan times a jig was a
dance-notably performed by Scottish lairds-that involved a great deal of jumping (or, as one
contemporary put it, the dance is 'full of leapings').
In the context of our gigue, this remains true: the movement is full of leapings. It is happy,
exuberant, full of life, and extroverted.
It's time to turn the knowledge we've learned in the early movements outwards-and use the
gigue to interact with the world.
Chapter 10, 'Working with Streams and Files,' shows you how to work with files-and,
generally, how to serialize objects.
Chapter 11, 'Messaging,' explains how to program messaging applications. Using message
queues, as you'll see in Chapter 11, it's possible to build families of applications that divide
workloads and start and stop each other.
Chapter 12, 'Working with XML and ADO.NET,' covers interacting with XML and databases.
Chapter 13, 'Web Services as Architecture,' wraps it all up. Coming back to the beginning-
after all, Chapter 1 started with a web service-we can use the sophisticated tools and
techniques that we've learned in order to build web services that are truly exciting! The
chapter concludes with an example showing how to use the TerraServer web service and
display aerial photos or topographic maps of almost anywhere in the U.S. at a variety of
magnifications.
And, finally, the gigue is up! Now programming in C# is up to you…
How to Download the Code
Most of the code samples in this book are not very long, since they emphasize the principles
of how to do something rather than full implementation details or production software. I
encourage you to follow the examples in this book by re-creating the objects in the projects
and by using your keyboard to enter the source code. You will learn the most by doing this!
Alternatively, you can download projects containing the source code used in this book. (One
reason to do so is for comparison if the code you entered manually doesn't work.) Sybex has
published all the code used in this book on their website at www.sybex.com. Search for this
book (using the title, the author, or the ISBN number 4046), and click the Downloads button.
Once you have accepted the license agreement, you'll be able to download any of the code
listed in this book, organized in zipped projects by chapter.
How to Contact the Author
I've made every effort to make this book as useful and accurate as possible. Please let me
know what you think; I would love to hear from you. I have set up a special e-mail address for
this book: csharp@bearhome.com. I would greatly appreciate any suggestions or information
about problems that you have with the text.
Part I: Prelude: Service with a Smile
Chapter List:
Chapter 1: Creating a Web Service
Chapter 2:
Consuming the Service on the Web
Chapter 1: Creating a Web Service
Overview
• Understanding web services
• Creating a web service using Notepad
• Creating an ASP.NET web service using Visual Studio
• Adding a class module
• XML documentation tags
I believe that the best way to learn something is to plunge in. Of course, that leaves the
question of where it's best to plunge. This book is, of course, about a programming language-
C#-and a programming environment-Visual Studio .NET. It would be natural-and typical-to
start with one or the other. Another conventional possibility would be to start by creating a
Windows application.
But let's not be conventional! C# is a brand new language, and web services are a genuinely
new programming concept. New languages and revolutionary programming architectures
don't come along very often. Why not plunge in in a way that keeps things interesting and isn't
the 'same old, same old'? This chapter will show you how to create a very simple ASP.NET
web service by hand using Notepad (it will be automatically compiled when the service is
opened the first time). You'll also learn how to build somewhat more complex ASP.NET web
services using Visual Studio. Along the way you'll learn (of course) about web services-and
also C# language concepts, and how to work with the Visual Studio environment.
When all is said and done, this is a book about programming in C#, and web services are only
one of the exciting things you can create using C#. In this chapter, I'll use web services as a
launch pad for helping you to understand class-based programming in C#-a truism, since all
C# programming is working with classes. Before we get there, you do need to understand a
bit about web services.
Understanding Web Services
A web service is a mechanism for making components available across the Internet using
open standards, including HTTP (Hypertext Transfer Protocol) and XML (Extensible Markup
Language). The idea is to create 'black box' components that can communicate with each
other, regardless of the operating system or programming language. A little more precisely, a
web service is a component, or module, of executable code with a special interface that makes
its methods available for use (also called 'consumption') by other programs using an HTTP-
based request. This request is made using HTTP GET or using HTTP POST and Simple
Object Access Protocol (SOAP). (You are probably familiar with GETs and POSTs from
working with HTML web forms; SOAP is discussed further in this section.)
Component-Based Distributed Architectures
Web services are by no means the only architectural technology used for component-based
distributed computing; for example, you are probably somewhat familiar with Common
Object Request Broker Architecture (CORBA) and Distributed Component Object Model
(DCOM).
Table 1.1 compares some of the characteristics of CORBA, DCOM, and web services. The
protocols listed under the Web Service column are described throughout the subsequent
sections of this chapter.
Table 1.1: CORBA, DCOM, and Web Services Compared
Characteristic CORBA DCOM Web Service
Mechanism for remote
procedure call (RPC)
Internet Inter-ORB
Protocol (IIOP)
Distributed Computing
Environment Remote
Procedure Call (DCE-
RPC)
HTTP
Encoding Common Data Repre-
sentation (CDR)
Network Data Representa-
tion (NDR)
XML and
SOAP
Interface description Interface Definition
Language (IDL)
IDL WSDL
Discovery Naming service and
trading service
System Registry UDDI
repositories
Works through firewall? No No Yes
Complexity of
protocols?
High High Low
Cross-platform? Somewhat No Yes
As you can see from Table 1.1, web services have some significant advantages over CORBA
and DCOM: web services are less complex, can get through firewalls, and are accessible from
any client platform. Note that this, of course, does not mean that web services are always a
good replacement for CORBA and DCOM-these other protocols have their place in
homogenous systems behind a firewall in which the platform is the same and the servers are
directly connected, and where performance is an important concern.
Ways to Create Web Services
Essentially, a web service is implemented as a SOAP XML document. There are many ways
to create this document. For example, IBM provides a Web Services Toolkit, as does the
Apache project. You can also hand-format the SOAP XML. Even within the Microsoft
universe, there are several different ways of implementing SOAP-based XML web services.
These include
• Microsoft's SOAP Toolkit, which lets you expose COM components as web services
(and does not require the .NET Framework for deployment). To download the SOAP
Toolkit, go to http://msdn.microsoft.com and search for SOAP Toolkit.
• Office XP Web Services Toolkit.
• An ATL Server implementation written in C++. ATL Server is part of Visual Studio
.NET but does not require the .NET Framework for deployment.
• .NET Remoting, which lets classes inherited from a base class named
MarshalByRefObject be exposed as web services using SOAP.
• ASP.NET.
You probably will not be surprised to learn that ASP.NET-using either Visual Basic or C#
('see sharp')-is the easiest way on this list to create web services. As I'll show you shortly, you
can write an ASP.NET web service by hand in a text editor such as Notepad and let ASP.NET
compile and deploy it for you, or you can take advantage of Visual Studio .NET's rich
integrated development environment.

N
ote In this book, I'll use the term 'web service' to mean an ASP.NET web service rather than
any of the other kinds of web services described above.
Simple Object Access Protocol (SOAP)
The SOAP specification can be found at www.w3.org/TR/SOAP/. According to the
specification abstract,
SOAP is a lightweight protocol for exchange of information in a decentralized, distributed
environment. It is an XML based protocol that consists of three parts: an envelope that
defines a framework for describing what is in a message and how to process it, a set of
encoding rules for expressing instances of application-defined datatypes, and a convention
for representing remote procedure calls and responses.
It's worth noting that:
• While SOAP can be used as a remote procedure invocation mechanism, it can also be
used to exchange XML documents.
• SOAP uses XML namespaces.
• The SOAP envelope mentioned in the specification contains the actual message in the
body of the envelope. It also contains SOAP headers, which can be used
programmatically (see Chapter 13, 'Web Services as Architecture,' for an example).
• When you want to invoke a method remotely, you're sending a SOAP request and
getting a SOAP response.
Web Services Description Language (WSDL)
Web Services Description Language (WSDL) describes the methods supported by a web
service, the parameters the methods take, and what the web service returns. You can find
the specification, sponsored by a cross-industry group that includes IBM and Microsoft,
at www.w3.org/TR/wsdl.
A WSDL document is an XML schema that provides the required information about a web
service-methods, data types, and response-so that a proxy can be created (you'll see how to
create and use a proxy in Chapter 2, 'Consuming the Service on the Web').
Generally, creators of ASP.NET web services do not have to worry themselves about WSDL;
a WSDL document is automatically generated at runtime on the fly by the ASP.NET runtime
using a process called reflection. (Reflection is a mechanism that allows metadata about a
program to be examined at runtime.)
Universal Description, Discovery, and Integration (UDDI)
How do you find a web service that you might want to consume? Conversely, how do you
publish a web service so that others can find it?
One answer is word of mouth. I might tell you about a web service, or you might tell me.
Similarly, it's no problem for us to find the web services that we'll create in the remainder of
this chapter. When we want to consume them, we'll know what we named them, and what
URL to use.
Universal Description, Discovery, and Integration (UDDI) is a more general, cross-industry
effort at creating a repository for publishing and finding web services. The UDDI project
(www.uddi.org) consists of a registry and a set of APIs for accessing the registry. IBM and
Microsoft maintain cross-synchronized UDDI registries that can be browsed. The Microsoft
registry can also be accessed from the Visual Studio Start page, as explained in Chapter 2.
In addition to UDDI, there are websites that provide directories of web services you can
consume. You'll find more information about this in the 'UDDI' section of Chapter 2
.
One If by Hand
You have enough background about web services to get started with creating one. We'll start
with a text editor and the simple 'Hello, Web Service!' program shown in Listing 1.1 and in
Notepad in Figure 1.1.
Listing 1.1: 'Hello, Web Service!'

<%@ WebService Language="C#" class="Helloweb" %>

using System.Web.Services;

[WebService (Namespace="http://sybex.com/webservices")]
public class Helloweb {
[WebMethod]
public string HelloWebService() {
return "Hello, Web Service!";
}
}



Figure 1.1: A web service can be created using Notepad.
Let's have a look at this web service line by line. The directive at the top of the code
<%@ WebService Language="C#" class="Helloweb" %>
tells the compiler that this is a web service written in C# and implemented in the Helloweb
class. The next line,
using System.Web.Services;
allows the program to use the types in the System.Web.Services namespace. (For more on the
.NET Framework and namespaces, see Chapter 5, "Reflecting on Classes".)
Tip The Visual Basic equivalent to using in C# is import.
The next line of code adds an optional attribute to the class that implements the service:
[WebService (Namespace="http://sybex.com/webservices")]
The WebService attribute allows you to set the default namespace for the web service. If you
don't set this, ASP.NET will default the namespace to the URI http://tempuri.org and will
display a message when you open the web service test page suggesting that you rename the
default namespace.

URIs and URLs
You should know that the default namespace is a URI (Uniform Resource Identifier) rather
than a URL (Uniform Resource Locator). There's no expectation that a user can click the URI
and gain access to a resource (as opposed to a URL, which does work this way), but it should
a unique string and-if it's a domain-be under your control. In other words, a URI is for
identification, not navigation (although if the URI is a URL, it can also be navigated to).


Next comes the Helloweb class declaration. Everything within the curly braces will be part of
the class:
public class Helloweb {

}
The [WebMethod] directive says that the method coming next is exposed as a web service.
The C# method declaration names the method and says that its return is a string (once again,
everything within the curly braces is part of the method):
public string HelloWebService() {

}
The string literal following the return keyword is, of course, the value returned by the method.
Here's the complete Helloweb class:
public class Helloweb {
[WebMethod]
public string HelloWebService() {
return "Hello, Web Service!";
}
}

The Battle of the Curly Braces
As you probably know, although C# is case sensitive, it is not white-space sensitive, meaning
you can lay your programming statements out any way you'd like, even across multiple lines.
A statement of code is ended when you reach the delimiter, a semicolon (;), no matter how
many physical lines it takes. Similarly, curly braces ({}) are used to mark the beginning and
end of constructs such as namespaces, classes, and methods.
Since you are allowed to position these curly braces any way you'd like, you should aim to do
so for readability. Which brings us to one of the greatest controversies of modern life: do you
place the opening brace on the same line as the declaration, like so:
public class Class1 {
// blah blah
}
or do you position it below the initial character of the declaration, like this:
public class Class1
{
// blah blah
}
Continued on next page
The two are syntactically equivalent, and you'll find both styles in the code examples in this
book. My personal preference is to do it the first way, as I think it helps to make really clear
what is inside the constructbut Visual Studio, and .NET auto-generated code, position the
opening brace on a new line.


Deploying the Web Service
Deploying the web service is a simple matter of making sure that the file it is in has an
extension of .asmx-the file extension for ASP.NET web services-and opening it in Internet
Information Services (IIS). ASP.NET will automatically take care of compiling it.

N
ote As you may know, you can also use the C# command-line compiler to compile C#
p
rograms created in a text editor. The C# compiler, csc.exe, which ships as part of the
.NET Framework, can be found in a folder beneath
\Windows\Microsoft.NET\Framework. C# command-line compiler options can be foun
d

by searching Visual Studio .NET's online help for C# Compiler Options.
With our sample text editor web service in a file named helloc.asmx, the next step is to use
the IIS administrative tools to create a virtual directory that points to it.
It's pretty standard-but not required-to put ASP.NET (and ASP.NET web service) application
files in directories below \Inetpub\wwwroot. In this example, I'll put helloc.asmx in
C:\Inetput\wwwroot\SybexC1.
The next step is to configure IIS to provide a virtual directory to point to this location. To do
this, open the IIS administrative application (which is shown in Figure 1.2) by using the Start
menu to select Control Panel → Administrative Tools → Internet Information Services. Click
to expand the local computer and Web Sites icons, shown in the left pane of Figure 1.2, and
select Default Web Site.

Figure 1.2: The IIS administrative application is used to configure your local instance of IIS.

N
ote Internet Information Services is called 'Internet Services Manager' in Windows 2000.
Choose Action → New → Virtual Directory, and the Virtual Directory Creation Wizard will
open. You must designate the virtual directory with an alias (Figure 1.3)-for example,
SybexC1. The alias is used as part of the URL to access the web application-for example,
http://localhost/SybexC1/helloc.asmx.