Item Details

Print View

Presenting C #

Christoph Wille
Format
Book
Published
Indianapolis, Ind. : Sams, c2000.
Language
English
ISBN
0672320371
Contents
  • Why Another Programming Language? 6
  • Simple 7
  • Modern 8
  • Object-Oriented 9
  • Type-Safe 10
  • Versionable 11
  • Compatible 11
  • Flexible 12
  • 2 Underpinnings--The NGWS Runtime 15
  • NGWS Runtime 16
  • Intermediate Language and Metadata 17
  • JITters 18
  • Virtual Object System 21
  • VOS Type System 22
  • Metadata 23
  • Common Language Specification 24
  • Virtual Execution System 28
  • 3 Your First C# Application 31
  • Choosing an Editor 32
  • Hello World Code 33
  • Compiling the Application 35
  • Input and Output 36
  • Adding Comments 38
  • 4 C# Types 41
  • Value Types 42
  • Simple Types 42
  • Struct Types 46
  • Enumeration Types 47
  • Reference Types 48
  • Object Type 48
  • Class Type 48
  • Interfaces 49
  • Delegates 50
  • String Type 50
  • Arrays 51
  • Boxing and Unboxing 52
  • Boxing Conversions 53
  • Unboxing Conversions 53
  • 5 Classes 55
  • Constructors and Destructors 56
  • Methods 58
  • Method Parameters 58
  • Overriding Methods 61
  • Method Hiding 64
  • Class Properties 66
  • Indexers 68
  • Events 71
  • Applying Modifiers 73
  • Class Modifiers 73
  • Member Modifiers 74
  • Access Modifiers 75
  • 6 Control Statements 79
  • Selection Statements 80
  • If Statement 80
  • Switch Statement 83
  • Iteration Statements 87
  • For Statement 87
  • Foreach Statement 89
  • While Statement 91
  • Do Statement 92
  • 7 Exception Handling 95
  • Checked and Unchecked Statements 96
  • Compiler Settings for Overflow Checking 97
  • Programmatic Overflow Checking 97
  • Exception-Handling Statements 98
  • Catching with try and catch 99
  • Cleaning Up with try and finally 101
  • Handling All with try-catch-finally 103
  • Throwing Exceptions 105
  • Re-Throwing Exceptions 107
  • Creating Your Own Exception Class 107
  • Do's and Donts of Exception Handling 109
  • 8 Writing Components in C# 111
  • Your First Component 112
  • Building the Component 112
  • Compiling the Component 115
  • Creating a Simple Client Application 115
  • Working with Namespaces 117
  • Wrapping a Class in a Namespace 118
  • Using Namespaces in Your Client Application 120
  • Adding Multiple Classes to a Namespace 123
  • 9 Configuration and Deployment 125
  • Conditional Compilation 126
  • Preprocessor Usage 126
  • Conditional Attribute 130
  • Documentation Comments in XML 133
  • Describing an Element 134
  • Adding Remarks and Lists 136
  • Providing Examples 139
  • Describing Parameters 142
  • Describing Properties 144
  • Compiling the Documentation 145
  • Versioning Your Code 147
  • NGWS Components 148
  • 10 Interoperating with Unmanaged Code 151
  • COM Interoperability 152
  • Exposing NGWS Runtime Objects to COM 152
  • Exposing COM Objects to the NGWS Runtime 160
  • Platform Invocation Services 164
  • Unsafe Code 166
  • 11 Debugging C# Code 169
  • Debugging Tasks 170
  • Creating a Debug Version of Your Application 171
  • Selecting the Executable 171
  • Setting Breakpoints 173
  • Stepping Through Your Program 175
  • Attaching to a Process 176
  • Inspecting and Modifying Variables 178
  • Managing Exception Handling 179
  • JIT Debugging 180
  • Debugging Components 181
  • Intermediate Language Disassembler 182
  • 12 Security 185
  • Code-Access Security 186
  • Verification of Type Safety 187
  • Permissions 187
  • Role-Based Security 190.
Description
vii, 204 p. : ill. ; 23 cm.
Notes
Includes index.
Technical Details
  • Access in Virgo Classic
  • Staff View

    LEADER 04389nam a22003374a 4500
    001 u3701649
    003 SIRSI
    005 20010511075506.0
    008 000602s2000 inua 001 0 eng
    010
      
      
    a| 00105188
    015
      
      
    a| GBA0-V9840
    020
      
      
    a| 0672320371
    035
      
      
    a| (Sirsi) i0672320371
    035
      
      
    a| (OCoLC)44918501
    040
      
      
    a| DLC c| DLC d| ORX d| UKM d| MvI
    042
      
      
    a| pcc
    050
    0
    0
    a| QA76.73.C154 b| W55 2000
    082
    0
    0
    a| 005.13/3 2| 21
    100
    1
      
    a| Wille, Christoph.
    245
    1
    0
    a| Presenting C # / c| Christoph Wille.
    260
      
      
    a| Indianapolis, Ind. : b| Sams, c| c2000.
    300
      
      
    a| vii, 204 p. : b| ill. ; c| 23 cm.
    500
      
      
    a| Includes index.
    505
    0
    0
    t| Why Another Programming Language? g| 6 -- t| Simple g| 7 -- t| Modern g| 8 -- t| Object-Oriented g| 9 -- t| Type-Safe g| 10 -- t| Versionable g| 11 -- t| Compatible g| 11 -- t| Flexible g| 12 -- g| 2 t| Underpinnings--The NGWS Runtime g| 15 -- t| NGWS Runtime g| 16 -- t| Intermediate Language and Metadata g| 17 -- t| JITters g| 18 -- t| Virtual Object System g| 21 -- t| VOS Type System g| 22 -- t| Metadata g| 23 -- t| Common Language Specification g| 24 -- t| Virtual Execution System g| 28 -- g| 3 t| Your First C# Application g| 31 -- t| Choosing an Editor g| 32 -- t| Hello World Code g| 33 -- t| Compiling the Application g| 35 -- t| Input and Output g| 36 -- t| Adding Comments g| 38 -- g| 4 t| C# Types g| 41 -- t| Value Types g| 42 -- t| Simple Types g| 42 -- t| Struct Types g| 46 -- t| Enumeration Types g| 47 -- t| Reference Types g| 48 -- t| Object Type g| 48 -- t| Class Type g| 48 -- t| Interfaces g| 49 -- t| Delegates g| 50 -- t| String Type g| 50 -- t| Arrays g| 51 -- t| Boxing and Unboxing g| 52 -- t| Boxing Conversions g| 53 -- t| Unboxing Conversions g| 53 -- g| 5 t| Classes g| 55 -- t| Constructors and Destructors g| 56 -- t| Methods g| 58 -- t| Method Parameters g| 58 -- t| Overriding Methods g| 61 -- t| Method Hiding g| 64 -- t| Class Properties g| 66 -- t| Indexers g| 68 -- t| Events g| 71 -- t| Applying Modifiers g| 73 -- t| Class Modifiers g| 73 -- t| Member Modifiers g| 74 -- t| Access Modifiers g| 75 -- g| 6 t| Control Statements g| 79 -- t| Selection Statements g| 80 -- t| If Statement g| 80 -- t| Switch Statement g| 83 -- t| Iteration Statements g| 87 -- t| For Statement g| 87 -- t| Foreach Statement g| 89 -- t| While Statement g| 91 -- t| Do Statement g| 92 -- g| 7 t| Exception Handling g| 95 -- t| Checked and Unchecked Statements g| 96 -- t| Compiler Settings for Overflow Checking g| 97 -- t| Programmatic Overflow Checking g| 97 -- t| Exception-Handling Statements g| 98 -- t| Catching with try and catch g| 99 -- t| Cleaning Up with try and finally g| 101 -- t| Handling All with try-catch-finally g| 103 -- t| Throwing Exceptions g| 105 -- t| Re-Throwing Exceptions g| 107 -- t| Creating Your Own Exception Class g| 107 -- t| Do's and Donts of Exception Handling g| 109 -- g| 8 t| Writing Components in C# g| 111 -- t| Your First Component g| 112 -- t| Building the Component g| 112 -- t| Compiling the Component g| 115 -- t| Creating a Simple Client Application g| 115 -- t| Working with Namespaces g| 117 -- t| Wrapping a Class in a Namespace g| 118 -- t| Using Namespaces in Your Client Application g| 120 -- t| Adding Multiple Classes to a Namespace g| 123 -- g| 9 t| Configuration and Deployment g| 125 -- t| Conditional Compilation g| 126 -- t| Preprocessor Usage g| 126 -- t| Conditional Attribute g| 130 -- t| Documentation Comments in XML g| 133 -- t| Describing an Element g| 134 -- t| Adding Remarks and Lists g| 136 -- t| Providing Examples g| 139 -- t| Describing Parameters g| 142 -- t| Describing Properties g| 144 -- t| Compiling the Documentation g| 145 -- t| Versioning Your Code g| 147 -- t| NGWS Components g| 148 -- g| 10 t| Interoperating with Unmanaged Code g| 151 -- t| COM Interoperability g| 152 -- t| Exposing NGWS Runtime Objects to COM g| 152 -- t| Exposing COM Objects to the NGWS Runtime g| 160 -- t| Platform Invocation Services g| 164 -- t| Unsafe Code g| 166 -- g| 11 t| Debugging C# Code g| 169 -- t| Debugging Tasks g| 170 -- t| Creating a Debug Version of Your Application g| 171 -- t| Selecting the Executable g| 171 -- t| Setting Breakpoints g| 173 -- t| Stepping Through Your Program g| 175 -- t| Attaching to a Process g| 176 -- t| Inspecting and Modifying Variables g| 178 -- t| Managing Exception Handling g| 179 -- t| JIT Debugging g| 180 -- t| Debugging Components g| 181 -- t| Intermediate Language Disassembler g| 182 -- g| 12 t| Security g| 185 -- t| Code-Access Security g| 186 -- t| Verification of Type Safety g| 187 -- t| Permissions g| 187 -- t| Role-Based Security g| 190.
    596
      
      
    a| 5
    650
      
    0
    a| C # (Computer program language)
    019
      
      
    a| 45315019
    994
      
      
    a| Z0 b| VA@
    999
      
      
    a| QA76.73 .C154 W55 2000 w| LC i| X004474763 l| STACKS m| SCI-ENG t| BOOK
▾See more
▴See less

Availability

Google Preview

Google Books Preview
Library Location Map Availability Call Number
Brown Science and Engineering Stacks N/A Available