| 000 | 00760camuu22002414a 4500 | |
| 001 | 000000800036 | |
| 005 | 20021227102634 | |
| 008 | 010917s2002 waua 001 0 eng | |
| 010 | ▼a 01051181 | |
| 020 | ▼a 0735612544 | |
| 040 | ▼a DLC ▼c DLC ▼d 211009 | |
| 042 | ▼a pcc | |
| 049 | 1 | ▼l 121068101 ▼f 과학 |
| 050 | 0 0 | ▼a QA76.73.B3 ▼b C659 2002 |
| 082 | 0 0 | ▼a 005.2/768 ▼2 21 |
| 090 | ▼a 005.2768 ▼b C752c | |
| 100 | 1 | ▼a Connell, John. |
| 245 | 1 0 | ▼a Coding techniques for Microsoft Visual Basic.NET / ▼c John Connell. |
| 260 | ▼a Redmond, Wash. : ▼b Microsoft Press, ▼c c2002. | |
| 300 | ▼a xxv, 633 p. : ▼b ill. ; ▼c 23 cm. + ▼e 1 CD-ROM (4 3/4 in.). | |
| 630 | 0 0 | ▼a Microsoft Visual BASIC. |
| 650 | 0 | ▼a BASIC (Computer program language) |
소장정보
| No. | 소장처 | 청구기호 | 등록번호 | 도서상태 | 반납예정일 | 예약 | 서비스 |
|---|---|---|---|---|---|---|---|
| No. 1 | 소장처 과학도서관/Sci-Info(2층서고)/ | 청구기호 005.2768 C752c | 등록번호 121068101 (1회 대출) | 도서상태 대출가능 | 반납예정일 | 예약 | 서비스 |
컨텐츠정보
책소개
이 책은 초급 Visual Basic 프로그래머를 위한 서적으로 전문적인 어플리케이션 디자인과 코딩 테크닉을 사용하여 실제 어플리케이션을 처음부터 끝까지 구축하는 방법을 설명한다. Visual Basic 구문과 구조를 설명하는 초급용 도서와 코딩 테크닉에 능숙한 고급 사용자를 위한 도서간의 공백을 메운다.
전문적인 어플리케이션 디자인과 코딩 테크닉을 사용하면서, 프로그램 작성의 시작과 끝을 설명하기 위하여 코드의 단편만을 보여주는 것 이상을 담고 있다. 초급자를 위한 셀프 스터디용으로 제작되었지만 다른 언어에서 Microsoft Visual Basic (VB)으로 이동하고자 하는 경력 프로그래머에게도 적당하다.
이 책은 혁신적인 Visual Basic .NET, 통합된 개발 환경(IDE), XML을 위한 증가된 지원 및 Active Server Pages+ (ASP+)로 웹 개발 기능의 세부사항을 제공한다.
This unique title goes beyond simply using academic snippets of code to demonstrate a point or language construct to teach Visual Basic.Net. Designed for the beginning, self-taught, or even experienced programmers who are switching to Microsoft Visual Basic.Net from other languages, this book provides insights.
정보제공 :
저자소개
John Connell(지은이)
<Beginning Visual Basic 6 Database Programming>
목차
CONTENTS Acknowledgments = xv Introduction = xvii 1 Visual Basic .NET from the Ground Up = 1 What a Long, Strange Trip It's Been = 2 From COM to .NET = 4 The .NET World = 6 Why You Need to Learn Visual Basic .NET = 8 What Are the Pieces and How Do They Fit Together? A .NET Framework Overview = 9 Web Services = 11 User Interface = 11 Data and XML = 12 Base Class Library = 12 Common Language Runtime = 13 Where Do We Start to Access Functionality from Visual Basic .NET Source Code? = 15 Visual Basic .NET Is Object Oriented = 16 A Brief Look at How the Visual Basic .NET Language Works = 18 How Is a Visual Basic .NET Program Put Together? = 20 Metadata - Data About Data = 20 The Just-In-Time Compiler = 21 Execution of Visual Basic .NET Code = 22 Assemble the Troops = 23 Configuring the Interactive Development Environment = 23 A First Look at the Visual Basic .NET IDE = 25 Some Visual Basic .NET Code = 27 Files Created by the IDE for Our First .NET Program = 33 Another Word on Assemblies = 38 A Closer Look at the Code = 41 You Mean I Get an Inheritance? = 41 Starting Up Our Form1 Class = 42 Warning! Don't Fiddle with the Designer's Code = 46 The Big Event = 47 Nothing but .NET = 48 2 Object-Oriented Programming in Visual Basic .NET = 49 An Object Lesson = 49 Starting Out with Objects = 50 A Class Is Really Only a Blueprint = 50 Let's Talk Objects = 51 Our Form as an Object = 52 Reading, Writing, Invoking = 54 Inheritance = 56 Understanding Namespaces = 58 Inheriting from System. Windows. Forms. Form : Forms and Controls = 62 A Word About Visual Basic .NET Controls = 63 Check Out the Code = 65 The Code Added for the Button = 67 Enough Talk : Press F5 and Run Your Program = 69 The Doppelganger Program : Creating Clones of the Form1 Class = 70 Important Object Concepts from the Doppelganger Program = 71 Using the Class View to Spy on Structure and Access Modifiers = 76 More About Access Types = 78 Overloading Methods = 79 Some of the Overloaded Show Methods = 81 Polymorphism = 83 What's Controlling Our Form When We Run It? = 84 Try This Out = 84 Your First Real Visual Basic .NET Program = 86 Telling the Application Object Which Form to Run = 88 Let's Add Some Controls = 90 Examining the Handiwork of the IDE-Generated Code = 94 How Do We Hardwire the Controls? = 98 Can You Name That Namespace? = 98 Date and Time Arithmetic = 99 Formatting the Date and Time = 101 Let's Run This Baby! = 103 Conclusion = 105 3 Writing Your First Class = 109 Creating the Employee Class = 110 Examining the Class Code = 113 Our Class's Namespace = 118 Declaring Our Class = 118 Using Shared Variables = 120 Class Constructors = 120 Overloading Constructors = 121 MyBase.New = 122 Assigning Values to Our Private Data Fields = 123 Overriding = 124 #Region = 126 The Employee Class Properties = 127 More About Inheritance = 130 Virtual Methods = 134 Synchronizing the Class View = 134 Creating Instances of the Employee Class = 136 Conclusion = 140 4 Visual Basic .NET Data Types and Features = 143 Getting to Know Data Types = 143 Visual Basic .NET Data Types = 144 Value Types = 145 Reference Types = 147 Data Type Features = 148 The System.Object Class = 149 Strong Typing = 152 Type Safety = 152 Data Widening = 157 Garbage Collection : Getting Rid of Our Objects = 160 The Stack and the Managed Heap = 160 Conclusion = 161 5 Examining the .NET Class Framework Using Files and Strings = 163 What Exactly Is the .NET Framework? = 164 Tapping into the .NET Framework = 165 It All Starts with the System Namespace = 165 Learning to Find and Use What You Need = 169 Searching in Windows Class Viewer = 170 Using the Namespaces = 171 Examining the File Class = 171 Streams = 173 What's the Difference Between a File and a Stream? = 174 Reading and Writing Binary, Numeric, or Text Data = 174 Using the File and StreamWriter Classes in the .NET Framework = 175 Reading Our File = 176 The Filelnfo Class = 177 Creating a New File = 179 Enumerating Directory Entries Using the Framework = 180 Let's Talk Strings = 183 What's New in Strings? = 184 Uninitialized Strings = 184 Working with Strings = 185 Copying and Cloning a String = 187 Conclusion = 190 6 Arrays and Collections in Visual Basic .NET = 191 Building Your First Visual Basic .NET Array = 192 Array Boundaries = 194 Why Arrays Are Based on the System.Array Class = 198 What If I Don't Know How Many Elements I Need Ahead of Time? = 202 Arrays Start at Zero in Visual Basic .NET = 204 Initializing the Array During Declaration = 204 Arrays Are Reference Types = 205 Arrays in Action : A Roman Numeral Calculator = 207 Writing the Code = 208 Examining the Code = 209 Caching Our Variables = 210 Visual Basic .NET Collections = 212 The ArrayList Collection = 213 Queues = 216 Stacks = 218 Eliza and the Beginning of Artificial Intelligence = 219 Eliza in Action = 220 Coding Eliza = 222 Topology of Our Dialog.vb Code Module = 224 Writing the Dialog.vb Code Module = 226 Examining Our Code = 234 Arrays vs. Collections = 235 The Entry Point for Eliza = 236 Is the Patient Discussing the Good Doctor? = 240 Can Eliza Return a Quick Response? = 241 Can Eliza Translate the Patient's Response to Make It a Question? = 243 Return a Previous Patient Phrase = 247 When All Else Fails = 250 Calling the Module from the Form = 251 Conclusion = 253 7 Handling Errors and Debugging Programs = 255 What Can Possibly Go Wrong? = 255 Types of Visual Basic .NET Errors = 258 The Classic Visual Basic Err Object Is Gone in Visual Basic .NET = 259 Try, Catch, and Finally = 259 Adding Structured Error Handling = 261 The Try...Catch Block = 262 Making Our Simple Program Even More Bullet Proof = 264 The Finally Block = 266 Setting a Breakpoint in Your Code = 267 Running the Program Using the Debugger = 268 Stepping Through Our Code = 270 Helpful Debugging Windows = 271 The Call Stack = 276 The Debug and Trace Classes = 278 Debug.WriteLine = 278 Debug.Assert = 279 Tracing = 281 Adding a Tracing Class to Our Code = 282 Examining the ErrorTrace.vb Code = 284 Setting the Trace Level = 288 Adding the Errors.vb Class to a Program = 289 Adding Event Logging to Your Programs = 293 The Philosophy of Logging Events to the Event Viewer = 295 Adding Event Logging to the ErrorTrace.vb Class = 296 Using Our New Event Logging Capability = 300 Conclusion = 301 8 Assemblies in Detail = 303 The Right to Assemble = 303 Private Assemblies = 304 Shared Assemblies = 305 The Other Parts of an Assembly = 308 Reflection : How to Go About Examining Assemblies = 309 The Assembly Spy Program = 310 Building the Assembly Spy Program = 313 Let's Write Some Code = 315 Examining the Code = 320 Self-Examination : Contemplating Our Own Assembly = 329 Code Signing = 330 Creating a Strongly Named Assembly = 330 The Global Assembly Cache Revisited = 333 Assembly Versioning = 335 New Variable Scoping in Visual Basic .NET = 338 Namespace Scope = 340 Determining the Scope of a Variable = 340 Conclusion = 341 9 File System Monitoring = 343 The File Sentinel Program = 344 How the File Sentinel Program Works = 345 Starting to Write the File Sentinel Program = 346 Adding the Sentinel Class to Our Program = 349 Delegates = 356 Handling the Changed, Created, and Deleted Events = 358 Handling the Renamed and Error Events = 360 Writing to Our Log File = 361 Wiring Up the User Interface = 362 Possible Enhancements to the File Sentinel = 370 Introduction to Windows Services = 372 The Life and Death of a Service = 372 Building Our File Sentinel into a Windows Service = 373 Adding Our Sentinel Class to Our Service = 374 Updating the Service1.vb File = 375 How Our Service Works = 377 Looking at vbMonitorService in the Services Window = 387 Debugging a Windows Service = 389 Conclusion = 392 10 Data Access with ADO.NET = 393 From ADO to ADO.NET = 393 ADO.NET from 50,000 Feet = 394 Individual Tables, Not the Join, Are in a DataSet = 395 Comparing Classic ADO and ADO.NET = 397 A Closer Look at the Foundation of ADO.NET : The DataSet Object = 399 The DataTable Object = 400 The DataSet Object and XML = 401 DataView Objects = 402 Managed Providers in ADO.NET = 402 A Common Provider Model = 404 Enough Talk, Let's Look at Some Code = 405 Connecting to Our Data Source = 406 Commands to Manipulate Data from the Data Source = 406 Creating the DataReader Object = 407 Putting the Pieces of Our DataReader Together = 408 Writing a Simple SQLClient Class DataSet Program = 410 Getting Started = 410 Adding a DataAdapter Object to Our Program = 414 Finishing the User Interface = 418 A Sneak Preview of Our Data from the DataAdapter = 419 XML Schema for the Customers Table = 421 Just Add Code = 422 Running Our Program = 423 Editing Our Data = 424 How the Code Works = 424 Updating the Data Source = 426 Conclusion = 429 11 Data Sets in Detail = 431 Looking Again at the ADO.NET Object Model = 431 Data Sets and XML = 434 Building the Data Set and XML Viewer Project = 436 Adding the Connection, Data Adapter, and DataSet Objects = 438 Adding Code to Our Program = 439 How It Works = 440 Generating XML from Our Data Set = 441 Updating the Data Source = 441 ADO.NET and XML = 443 Examining Our Program's XML Output = 443 The XML Schema Output = 444 Persisting Our XML Information = 446 Testing Our Persistence Code = 447 Examining the DiffGram = 449 Leveraging Our XML File for New Classes = 452 The Xsd.exe Program = 452 Adding a Relationship to Our Program = 455 The Data Sets and XML Program = 456 Creating the Parent／Child Relationship = 457 Adding a Relationship to Our Tables = 458 Examining DataSet Properties = 461 Populating a Data Grid from a Persisted XML File = 462 Run the Program = 463 How the Program Works = 464 Hand Coding a Simple Program = 465 Data Binding = 467 Creating the Program = 467 Adding the Code That Wires the Controls to the Data Set = 469 Run the Program = 470 How It Works = 471 Updating Our Data Grid = 476 Conclusion = 476 12 ADO.NET Data Binding = 477 The BindingContext Object = 477 The CurrencyManager Object = 479 Record Navigation = 479 A Simple Example = 479 Add the Code = 481 How the Code Works = 484 The DataTable, DataRow, and DataColumn Objects = 488 Examining the DataTable Schema = 488 Building a Table Programmatically = 490 How the Code Works = 491 Finding Specific Records = 493 Conclusion = 495 13 ASP.NET and Web Services = 497 A Look Back at ASP = 497 Why ASP.NET? = 498 Our First Web Form = 500 New Server Controls = 503 The HTML Presentation Template = 505 Viewing the Code-Behind File = 508 Setting the Properties on Our Web Page = 509 Adding the Calendar Control Code = 510 Running the Web Form = 511 Examining the HTML Sent to the Browser = 512 Building a Loan Payment Calculator = 514 Building Our Loan Application Project = 517 Adding Code to the Code-Behind Form = 519 The Life of a Web Form = 520 How Our Program Works = 521 Taking a Closer Look at Our Drop-Down List = 523 Adding the Payment Schedule Page = 524 Adding Our Class Code = 526 How the Calculator Works = 529 Tracing Our Program = 532 Web Services : The New Marketplace = 533 What Are Web Services? = 533 OK, Now How Do We Communicate? = 534 Finding Out Who Is Offering What in the Global Marketplace = 535 Where Are Web Services Going? = 537 Building a Web Service = 538 Run the Program = 540 Consuming the MagicEightBall Web Service = 543 Building Our Web Services Client Program = 545 Adding a Proxy Class to Our Program = 546 Adding Code to get Our Magic Eight Ball Answers = 547 Conclusion = 548 14 Visual Inheritance and Custom Controls = 549 Visual Inheritance = 549 Building a Base Form = 550 Adding the Inherited Form = 552 Creating a Custom Control = 555 Changing the Background Color of a Text Box = 555 Building Our Control = 556 Adding Code to Our Control = 556 Adding Our Custom Control to the Host Form = 558 How it Works = 559 Putting it Together : What We've Learned So Far = 561 How Do We Save the Notes? XML, Of Course = 562 Building the Sticky Notes Program = 564 Constructing a Sticky Note = 570 Adding Code to the Sticky Note = 571 How Does it Work? = 574 Adding Even Handler Delegates = 575 The serialize Class in More Detail = 577 When the User Quits the Sticky Notes Program = 582 How the BaseNote Sticky Yellow Form Works = 585 Deploying Our Sticky Notes Program = 588 Installing Our Program on a Client Machine = 592 Install the Sticky Notes Program = 593 Conclusion = 594 Appendix : Some Helpful ADO.NET Wizards = 595 Using the Data Form Wizard = 595 Run the Program = 600 Under the Hood = 601 Generating a Crystal Report from a Data Source = 603 Building a Crystal Report = 603 Getting Ready to View Our Report = 609 Index = 613