VisualBasic_NETNotesForProfessionals.pdf

(2259 KB) Pobierz
Visual Basic
.NET
Visual Basic .NET
Notes for Professionals
®
Notes for Professionals
of professional hints and tricks
100+ pages
GoalKicker.com
Free Programming Books
Disclaimer
This is an unocial free book created for educational purposes and is
not aliated with ocial Visual Basic
®
.NET group(s) or company(s).
All trademarks and registered trademarks are
the property of their respective owners
Contents
About
................................................................................................................................................................................... 1
Chapter 1: Getting started with Visual Basic .NET Language
................................................................ 2
Section 1.1: Hello World
................................................................................................................................................. 2
Section 1.2: Hello World on a Textbox upon Clicking of a Button
............................................................................ 2
Section 1.3: Region
......................................................................................................................................................... 3
Section 1.4: Creating a simple Calculator to get familiar with the interface and code
.......................................... 4
Chapter 2: Declaring variables
.............................................................................................................................. 8
Section 2.1: Declaring and assigning a variable using a primitive type
................................................................... 8
Section 2.2: Levels of declaration – Local and Member variables
......................................................................... 10
Section 2.3: Example of Access Modifiers
................................................................................................................. 11
Chapter 3: Introduction to Syntax
..................................................................................................................... 14
Section 3.1: Intellisense Helper
................................................................................................................................... 14
Section 3.2: Declaring a Variable
............................................................................................................................... 14
Section 3.3: Comments
............................................................................................................................................... 15
Section 3.4: Modifiers
.................................................................................................................................................. 15
Section 3.5: Object Initializers
..................................................................................................................................... 16
Section 3.6: Collection Initializer
................................................................................................................................. 17
Section 3.7: Writing a function
................................................................................................................................... 19
Chapter 4: Operators
............................................................................................................................................... 21
Section 4.1: String Concatenation
.............................................................................................................................. 21
Section 4.2: Math
......................................................................................................................................................... 21
Section 4.3: Assignment
.............................................................................................................................................. 22
Section 4.4: Comparison
............................................................................................................................................. 23
Section 4.5: Bitwise
...................................................................................................................................................... 23
Chapter 5: Conditions
............................................................................................................................................... 25
Section 5.1: If operator
................................................................................................................................................ 25
Section 5.2: IF...Then...Else
........................................................................................................................................... 25
Chapter 6: Short-Circuiting Operators (AndAlso - OrElse)
.................................................................... 27
Section 6.1: OrElse Usage
........................................................................................................................................... 27
Section 6.2: AndAlso Usage
........................................................................................................................................ 27
Section 6.3: Avoiding NullReferenceException
......................................................................................................... 27
Chapter 7: Date
........................................................................................................................................................... 30
Section 7.1: Converting (Parsing) a String to a Date
............................................................................................... 30
Section 7.2: Converting a Date To A String
.............................................................................................................. 30
Chapter 8: Array
......................................................................................................................................................... 31
Section 8.1: Array definition
........................................................................................................................................ 31
Section 8.2: Null Array Variables
............................................................................................................................... 31
Section 8.3: Array initialization
................................................................................................................................... 32
Section 8.4: Declare a single-dimension array and set array element values
..................................................... 32
Section 8.5: Jagged Array Initialization
.................................................................................................................... 32
Section 8.6: Non-zero lower bounds
......................................................................................................................... 32
Section 8.7: Referencing Same Array from Two Variables
.................................................................................... 33
Section 8.8: Multidimensional Array initialization
..................................................................................................... 33
Chapter 9: Lists
............................................................................................................................................................ 34
Section 9.1: Add items to a List
................................................................................................................................... 34
Section 9.2: Check if item exists in a List
................................................................................................................... 34
Section 9.3: Loop through items in list
...................................................................................................................... 34
Section 9.4: Create a List
............................................................................................................................................ 35
Section 9.5: Remove items from a List
...................................................................................................................... 36
Section 9.6: Retrieve items from a List
...................................................................................................................... 36
Chapter 10: Enum
........................................................................................................................................................ 38
Section 10.1: GetNames()
............................................................................................................................................ 38
Section 10.2: HasFlag()
............................................................................................................................................... 38
Section 10.3: Enum definition
...................................................................................................................................... 39
Section 10.4: Member initialization
............................................................................................................................. 39
Section 10.5: The Flags attribute
................................................................................................................................ 39
Section 10.6: GetValues()
............................................................................................................................................ 40
Section 10.7: String parsing
........................................................................................................................................ 40
Section 10.8: ToString()
............................................................................................................................................... 41
Section 10.9: Determine whether a Enum has FlagsAttribute specified or not
..................................................... 41
Section 10.10: For-each flag (flag iteration)
.............................................................................................................. 42
Section 10.11: Determine the amount of flags in a flag combination
..................................................................... 42
Section 10.12: Find the nearest value in a Enum
....................................................................................................... 43
Chapter 11: Dictionaries
........................................................................................................................................... 45
Section 11.1: Create a dictionary filled with values
.................................................................................................... 45
Section 11.2: Loop through a dictionary and print all entries
.................................................................................. 45
Section 11.3: Checking for key already in dictionary - data reduction
................................................................... 45
Section 11.4: Getting a dictionary value
..................................................................................................................... 46
Chapter 12: Looping
................................................................................................................................................... 47
Section 12.1: For...Next
.................................................................................................................................................. 47
Section 12.2: For Each...Next loop for looping through collection of items
............................................................ 48
Section 12.3: Short Circuiting
...................................................................................................................................... 48
Section 12.4: While loop to iterate while some condition is true
............................................................................. 50
Section 12.5: Nested Loop
........................................................................................................................................... 50
Section 12.6: Do...Loop
................................................................................................................................................. 51
Chapter 13: File Handling
........................................................................................................................................ 53
Section 13.1: Write Data to a File
................................................................................................................................ 53
Section 13.2: Read All Contents of a File
................................................................................................................... 53
Section 13.3: Write Lines Individually to a Text File using StreamWriter
............................................................... 53
Chapter 14: File/Folder Compression
.............................................................................................................. 54
Section 14.1: Adding File Compression to your project
............................................................................................ 54
Section 14.2: Creating zip archive from directory
.................................................................................................... 54
Section 14.3: Extracting zip archive to directory
....................................................................................................... 54
Section 14.4: Create zip archive dynamicaly
............................................................................................................ 54
Chapter 15: Connection Handling
....................................................................................................................... 55
Section 15.1: Public connection property
................................................................................................................... 55
Chapter 16: Data Access
.......................................................................................................................................... 56
Section 16.1: Read field from Database
..................................................................................................................... 56
Section 16.2: Simple Function to read from Database and return as DataTable
................................................. 57
Chapter 17: Type conversion
................................................................................................................................ 58
Section 17.1: Converting Text of The Textbox to an Integer
.................................................................................... 58
Chapter 18: ByVal and ByRef keywords
......................................................................................................... 59
Section 18.1: ByRef keyword
....................................................................................................................................... 59
Section 18.2: ByVal keyword
...................................................................................................................................... 59
Chapter 19: Console
................................................................................................................................................... 61
Section 19.1: Console.ReadLine()
................................................................................................................................ 61
Section 19.2: Console.Read()
...................................................................................................................................... 61
Section 19.3: Console.ReadKey()
................................................................................................................................ 61
Section 19.4: Prototype of command line prompt
................................................................................................... 61
Section 19.5: Console.WriteLine()
............................................................................................................................... 62
Chapter 20: Functions
.............................................................................................................................................. 63
Section 20.1: Defining a Function
............................................................................................................................... 63
Section 20.2: Defining a Function #2
........................................................................................................................ 63
Chapter 21: Recursion
............................................................................................................................................... 64
Section 21.1: Compute nth Fibonacci number
........................................................................................................... 64
Chapter 22: Random
................................................................................................................................................. 65
Section 22.1: Declaring an instance
........................................................................................................................... 65
Section 22.2: Generate a random number from an instance of Random
............................................................ 65
Chapter 23: Classes
.................................................................................................................................................... 67
Section 23.1: Abstract Classes
.................................................................................................................................... 67
Section 23.2: Creating classes
.................................................................................................................................... 67
Chapter 24: Generics
................................................................................................................................................ 69
Section 24.1: Create a generic class
.......................................................................................................................... 69
Section 24.2: Instance of a Generic Class
................................................................................................................. 69
Section 24.3: Define a 'generic' class
........................................................................................................................ 69
Section 24.4: Use a generic class
.............................................................................................................................. 69
Section 24.5: Limit the possible types given
............................................................................................................. 70
Section 24.6: Create a new instance of the given type
........................................................................................... 70
Chapter 25: Disposable objects
........................................................................................................................... 71
Section 25.1: Basic concept of IDisposable
............................................................................................................... 71
Section 25.2: Declaring more objects in one Using
................................................................................................. 71
Chapter 26: NullReferenceException
................................................................................................................ 73
Section 26.1: Empty Return
......................................................................................................................................... 73
Section 26.2: Uninitialized variable
............................................................................................................................ 73
Chapter 27: Using Statement
............................................................................................................................... 74
Section 27.1: See examples under Disposable objects
............................................................................................ 74
Chapter 28: Option Strict
........................................................................................................................................ 75
Section 28.1: Why Use It?
............................................................................................................................................ 75
Section 28.2: How to Switch It On
.............................................................................................................................. 75
Chapter 29: Option Explicit
..................................................................................................................................... 77
Section 29.1: What is it?
............................................................................................................................................... 77
Section 29.2: How to switch it on?
............................................................................................................................. 77
Chapter 30: Option Infer
......................................................................................................................................... 78
Section 30.1: How to enable/disable it
...................................................................................................................... 78
Section 30.2: What is it?
.............................................................................................................................................. 78
Section 30.3: When to use type inference
................................................................................................................ 79
Chapter 31: Error Handling
..................................................................................................................................... 81
Section 31.1: Try...Catch...Finally Statement
............................................................................................................... 81
Section 31.2: Creating custom exception and throwing
.......................................................................................... 81
Section 31.3: Try Catch in Database Operation
........................................................................................................ 82
Section 31.4: The Un-catchable Exception
................................................................................................................ 82
Section 31.5: Critical Exceptions
................................................................................................................................. 82
Chapter 32: OOP Keywords
................................................................................................................................... 84
Section 32.1: Defining a class
..................................................................................................................................... 84
Section 32.2: Inheritance Modifiers (on classes)
...................................................................................................... 84
Section 32.3: Inheritance Modifiers (on properties and methods)
......................................................................... 85
Section 32.4: MyBase
.................................................................................................................................................. 86
Section 32.5: Me vs MyClass
....................................................................................................................................... 87
Section 32.6: Overloading
........................................................................................................................................... 88
Section 32.7: Shadows
................................................................................................................................................ 88
Section 32.8: Interfaces
............................................................................................................................................... 90
Chapter 33: Extension methods
........................................................................................................................... 91
Section 33.1: Creating an extension method
............................................................................................................. 91
Section 33.2: Making the language more functional with extension methods
..................................................... 91
Section 33.3: Getting Assembly Version From Strong Name
................................................................................. 91
Section 33.4: Padding Numerics
................................................................................................................................ 92
Chapter 34: Reflection
............................................................................................................................................. 94
Section 34.1: Retrieve Properties for an Instance of a Class
................................................................................... 94
Section 34.2: Get a method and invoke it
................................................................................................................. 94
Section 34.3: Create an instance of a generic type
................................................................................................. 94
Section 34.4: Get the members of a type
................................................................................................................. 94
Chapter 35: Visual Basic 14.0 Features
........................................................................................................... 96
Section 35.1: Null conditional operator
...................................................................................................................... 96
Section 35.2: String interpolation
............................................................................................................................... 96
Section 35.3: Read-Only Auto-Properties
................................................................................................................. 97
Section 35.4: NameOf operator
................................................................................................................................. 97
Section 35.5: Multiline string literals
........................................................................................................................... 98
Section 35.6: Partial Modules and Interfaces
........................................................................................................... 98
Section 35.7: Comments after implicit line continuation
......................................................................................... 99
Section 35.8: #Region directive improvements
........................................................................................................ 99
Chapter 36: LINQ
....................................................................................................................................................... 101
Section 36.1: Selecting from array with simple condition
...................................................................................... 101
Section 36.2: Mapping array by Select clause
....................................................................................................... 101
Section 36.3: Ordering output
.................................................................................................................................. 101
Section 36.4: Generating Dictionary From IEnumerable
....................................................................................... 101
Section 36.5: Projection
............................................................................................................................................. 102
Section 36.6: Getting distinct values (using the Distinct method)
........................................................................ 102
Chapter 37: FTP server
.......................................................................................................................................... 103
Section 37.1: Download file from FTP server
.......................................................................................................... 103
Section 37.2: Download file from FTP server when login required
...................................................................... 103
Section 37.3: Upload file to FTP server
................................................................................................................... 103
Section 37.4: Upload file to FTP server when login required
................................................................................ 103
Chapter 38: Working with Windows Forms
................................................................................................. 104
Section 38.1: Using the default Form instance
....................................................................................................... 104
Section 38.2: Passing Data From One Form To Another
...................................................................................... 104
Chapter 39: Google Maps in a Windows Form
........................................................................................... 106
Section 39.1: How to use a Google Map in a Windows Form
................................................................................ 106
Chapter 40: WinForms SpellCheckBox
.......................................................................................................... 115
Section 40.1: ElementHost WPF TextBox
................................................................................................................ 115
Chapter 41: GDI+
....................................................................................................................................................... 119
Section 41.1: Draw Shapes
........................................................................................................................................ 119
Section 41.2: Fill Shapes
............................................................................................................................................ 119

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin