Dalam membuat program, optimasi code sangat penting untuk diketahui yang sedikit banyaknya akan mempengaruhi proses kinerja dari program. Saya akan coba share tentang tips dan trik dalam pemrograman visual basic 6, dan semoga dapat berguna.

* Penggunaan Option Explicit

Penggunaan Option Explicit sangat berguna di dalam source code, kenapa? karna dengan option explicit, seluruh variabel dan object yang digunakan di dalam kode program harus di definisikan terlebih dahulu, sehingga kita akan dapat memantau penggunaan tipe dari tiap-tiap variabel tersebut. Akan berbeda apabila kita tidak menggunakan option explicit, kita akan seenaknya meng-assign suatu variabel atau objek tanpa mendeklarasikan terlebih dahulu, karna tidak ada pemaksaan untuk itu, sehingga akan sangat memungkinkan banyaknya penggunaan variabel yang bertipe variant, di mana penggunaan variabel dengan tipe tersebut sangat dianjurkan untuk tidak digunakan. Karena menggunakan alokasi memori yang besar.

Untuk menggunakan Option Explicit, cukup mengetikkan Option Explicit pada awal tiap modul. Atau dengan cara klik menu Tools pada IDE VB6, lalu pilih Options, kemudian klik tab Editor dan beri tanda centang pada pilihan Require Variable Declaration. Hal ini secara otomatis akan menyisipkan pernyataan Option Explicit di modul apapun yang akan Anda buat, tapi tidak di modul yang sudah pernah dibuat; sehingga oleh karena itu, Anda harus secara manual menambahkan pernyataan Option Explicit kepada setiap modul yang terdapat di sebuah project.

* Penggunaan string dengan maximal length

Tipe variabel string merupakan salah satu tipe yang menggunakan alokasi memori yang cukup besar. Kadang-kadang kita mendeklarasikan variabel dengan tipe string tanpa membatasi jumlah karakter maksimalnya, sementara kebutuhan maksimal panjang karakter yang kita gunakan, sudah dapat kita perkirakan. Alangkah lebih baik jika maksimal karakter tersebut kita batasi sesuai kebutuhan. Sebagaimana properti yang dimiliki oleh textbox (properti maxlength), untuk variabel string, maksimal panjang karakternya dapat dibatasi pada saat pendeklarasian variabel tersebut. Adapun sintaksnya :

‘Misal : deklarasi variabel strVariable, dengan maksimal panjang karakter yang dibutuhkan : 10

Dim strVariable as string * 10

* Penggunaan array dinamis

Penggunaan array dinamis dapat mengalokasikan penggunaan memori sesuai kebutuhan, karena setiap saat indeks dari array dapat ditambah atau dikurangi pada saat runtime, sehingga penggunaan array tersebut juga akan efisien.

Untuk membuat array dinamis, dapat dilakukan dengan menggunakan keyword ReDim PreServe, di mana saat dilakukan penambahan atau pengurangan jumlah indeks dari array tersebut, nilainya tidak akan terganggu. Berbeda dengan apabila hanya menggunakan keyword ReDim, nilai dari setiap indeks array akan terhapus.

sintaks :

Dim myArray(3)  ‘Deklarasi awal

ReDim myArray(10)  ‘Mendeklarasikan ulang dengan nilai yang tidak tersimpan

ReDim PreServe myArray(13)  ‘Mendeklarasikan ulang dengan nilai yang tidak terganggu(nilainya tidak terhapus)

I use VBSmart Menu XP (SmartMenuXP.dll and SmartMenuXP.ocx) in Windows 98 and XP for a long time. Now, I switched to Windows Vista Business Edition. It comes the problem, every time I click menu VBSmart Menu XP, the program hangs.

After trying to find many solution, at last, I try to change themes from “Windows Vista” to “Windows Classic”,then VBSmart was no problem anymore.

In fact, this solution is sufficient, but it was jammed, when to use my program, i have to change the theme again.

Then I tried to restore the theme to “Windows Vista”, then I try to change the visual effects settings in

Control Panel \ System and Maintenance \ System

then select “Advanced system settings”
in the frame “Performance” , click the button “Settings”,
then disable the option “Enable desktop composition”.

^_^

This bit of nostalgic humour will be lost on n00b developers, or anyone lucky enough to have missed out on developing in VB6 (or older–I think these features were introduced in VB4 or 5, but can’t recall for sure).

C# has finally decided to embrace optional parameters and named arguments!

That’s right.  It only took 4 versions to catch up to what you were doing well before the .NET days.  Oh well, better late than never!

Of course, you could at least partially work around this in C# 3.0 and older by putting the method implementation in the most verbose signature version of your method and creating any number of overloads needed.

Using the example from the blog posting linked above (please read it before continuing), you’d create:

//main method with all the parameters and full implementation
public void SomeMethod(int a, int b, int c)
{
/* put the actual implementation here */
}

//overload to omit the c parameter and default to 100
public void SomeMethod(int a, int b)
{
SomeMethod(a, b, 100);
}

//overload to omit the b and c parameters and use the defaults 50 and 100, respectively
public void SomeMethod(int a)
{
SomeMethod(a, 50, 100);
}

However, if we then want an overload that omits the b parameter only, we run into trouble.  If we try this:

public void SomeMethod(int a, int c)
{
SomeMethod(a, 50, 100);
}

We would end up with a compile error, since the signature of this overload would be the same as the first overload I declared above, namely:

public void SomeMethod(int, int)

If a, b, and c were of different datatypes, we could declare any combination of parameters, but this example of all int’s does demonstrate the weakness of this approach, and why the new optional parameters and named arguments is so exciting!

Visual Basic 6.0′da kullanabilecek renk kodları üreten küçük bir programcıktır.

İndirme Linki:
İndirmek için Tıklayın…

intipadi.com – berikut adalah source code DLL injection dengan visual basic, silakan gunakan dan aplikasikan sesuai kebutuhan.

Download source via Ziddu di:
http://ziddu.com/download/7039852/source-dll-injection-dotexe-intipadi.txt.html

Private Type MODULEENTRY32
    dwSize As Long
    th32ModuleID As Long
    th32ProcessID As Long
    GlblcntUsage As Long
    ProccntUsage As Long
    modBaseAddr As Long
    modBaseSize As Long
    hModule As Long
    szModule As String * 256
    szExePath As String * 260
End Type
Private Const TH32CS_SNAPMODULE As Long = &H8
Private Const PAGE_READWRITE As Long = &H4
Private Const MEM_RELEASE As Long = &H8000
Private Const MEM_COMMIT As Long = &H1000
Private Const STANDARD_RIGHTS_REQUIRED As Long = &HF0000
Private Const SYNCHRONIZE As Long = &H100000
Private Const PROCESS_ALL_ACCESS As Long = (STANDARD_RIGHTS_REQUIRED Or SYNCHRONIZE Or &HFFF)
Private Const INFINITE As Long = &HFFFFFF

Private Declare Function VirtualAllocEx Lib "kernel32" (ByVal hProcess As Long, ByVal lpAddress As Long, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Private Declare Function VirtualFreeEx Lib "kernel32" (ByVal hProcess As Long, lpAddress As Any, ByVal dwSize As Long, ByVal dwFreeType As Long) As Long
Private Declare Function CreateRemoteThread Lib "kernel32" (ByVal hProcess As Long, lpThreadAttributes As Any, ByVal dwStackSize As Long, lpStartAddress As Long, lpParameter As Any, ByVal dwCreationFlags As Long, lpThreadId As Long) As Long
Private Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long
Private Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Private Declare Function GetModuleHandle Lib "kernel32" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long
Private Declare Function GetProcAddress Lib "kernel32" (ByVal hModule As Long, ByVal lpProcName As String) As Long
Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal hHandle As Long, ByVal dwMilliseconds As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long
Private Declare Function FreeLibrary Lib "kernel32.dll" (ByVal hLibModule As Long) As Long
Private Declare Function CreateToolhelp32Snapshot Lib "kernel32" (ByVal lFlags As Long, ByVal lProcessID As Long) As Long
Private Declare Function Module32First Lib "kernel32" (ByVal hSnapshot As Long, uProcess As MODULEENTRY32) As Long
Private Declare Function Module32Next Lib "kernel32" (ByVal hSnapshot As Long, uProcess As MODULEENTRY32) As Long
Public Function Inject_Dll(Strdll As String, StrProcID As String)
Dim LoadlibAdr As Long, RemThread As Long, LngModule As Long, LngProcess As Long, LngBytes As Long, LngThreadID As Long
On Error GoTo ErrTrap
    LngProcess = OpenProcess(PROCESS_ALL_ACCESS, False, CLng(StrProcID))
    LoadlibAdr = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA")
    LngModule = VirtualAllocEx(LngProcess, 0, Len(Strdll), MEM_COMMIT, PAGE_READWRITE)
    WriteProcessMemory LngProcess, ByVal LngModule, ByVal Strdll, Len(Strdll), LngBytes
    RemThread = CreateRemoteThread(LngProcess, ByVal 0, 0, ByVal LoadlibAdr, ByVal LngModule, 0, LngThreadID)
    WaitForSingleObject RemThread, INFINITE
    CloseHandle LngProcess
    CloseHandle RemThread
    Injection.injector.Enabled = False
    End
    MsgBox "dll Sucussfuly Injection", vbInformation, "Sucsses"
    Exit Function
ErrTrap:
    MsgBox "dll UnInjection Error", vbCritical, "dll UnInjection Error"
End Function

Public Function UnInject_Dll(Strdll As String, StrProcID As String)
Dim MODE32 As MODULEENTRY32, LngBaseAddr As Long, RetVal As Long, LngCT32S As Long, LngProcess As Long, FreelibAdr As Long, RemThread As Long
On Error GoTo ErrTrap
    LngCT32S = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, CLng(StrProcID))
    MODE32.dwSize = Len(MODE32)
    RetVal = Module32First(LngCT32S, MODE32)
    Do While RetVal
        If Strdll = Left(MODE32.szExePath, InStr(MODE32.szExePath, Chr(0)) - 1) Then
            LngBaseAddr = MODE32.modBaseAddr
        End If
        RetVal = Module32Next(LngCT32S, MODE32)
    Loop
    CloseHandle LngCT32S
    LngProcess = OpenProcess(PROCESS_ALL_ACCESS, False, CLng(StrProcID))
    FreelibAdr = GetProcAddress(GetModuleHandle("Kernel32.dll"), "FreeLibrary")
    RemThread = CreateRemoteThread(LngProcess, ByVal 0, 0, ByVal FreelibAdr, ByVal LngBaseAddr, 0, 0)
    CloseHandle LngProcess
    CloseHandle RemThread

    MsgBox "dll Sucussfuly Injection", vbInformation, "Sucsses"
    Exit Function
ErrTrap:
    MsgBox "dll UnInjection Error", vbCritical, "dll UnInjection Error"
End Function

Set conn = New ADODB.Connection
conn.ConnectionString = “Driver={SQL Server};Server=NomeServer;Database=NomeDB;Uid=User;Pwd=pass;”
conn.Open
‘Activo = True

Dim rs As ADODB.Recordset
Dim strQry As String
strQry = “SELECT * FROM NomeTab”

Set rs = New ADODB.Recordset

rs.Open strQry, conn, adOpenStatic, adLockReadOnly, adCmdText

If rs.EOF Then
MsgBox “ciao”
Else
MsgBox rs(“cliente”)

End If

Set conn = New ADODB.Connection
conn.ConnectionString = “Driver={SQL Server};Server=NomeServer;Database=NomeDB;Uid=User;Pwd=pass;”
conn.Open
‘Activo = True

Dim rs As ADODB.Recordset
Dim strQry As String
strQry = “SELECT * FROM NomeTab”

Set rs = New ADODB.Recordset

rs.Open strQry, conn, adOpenStatic, adLockReadOnly, adCmdText

If rs.EOF Then
MsgBox “ciao”
Else
MsgBox rs(“cliente”)

End If

Dim con1 As New ADODB.Connection

Conn.Open “Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\prova\db1.mdb”
Dim rs As New ADODB.Recordset

rs.Open “SELECT * FROM prova1″, con1, 1, 2

Dim conStr As String = “Provider=Microsoft.JET.OLEDB.4.0;data source=c:\prova\prova.mdb”

Dim strSQL As String = “SELECT * FROM Tabella1″

Dim conn As OleDb.OleDbConnection = New OleDb.OleDbConnection(conStr)

Dim objCommand As OleDb.OleDbCommand
objCommand = New OleDb.OleDbCommand(strSQL, conn)

conn.Open()

Dim rdr As OleDb.OleDbDataReader = objCommand.ExecuteReader

tw1.Nodes.Clear()
Do While rdr.Read
Dim nd As New TreeNode
nd.Text = rdr.Item(“aaa”)

nd.Tag = rdr.Item(“bbb”)

tw1.Nodes.Add(nd)
Loop
‘cleanup

rdr.Close()

‘cmd.Dispose()

ខ្ញុំមានតែ Visual Basic 6.0 តើខ្ញុំអាចសរសេរកូដជាមួយនឹងខ្មែរយូនីកូដបានទេ ?

បើខ្ញុំចង់ប្រើ ខ្មែរយូនីកូដ ដើម្បីអោយឈ្មោះជា String សម្រាប់ Label1, Text1,
Command1 ដែលមានដូចជារូបខាងលើនេះ តើខ្ញុំត្រូវធ្វើអ្វីខ្លះ ?

បើបងប្អូនណាដឹង សូមជួយប្រាប់ផង ។

សូមអរគុណ !

មើលទៅដូចជាយ៉ាប់ណាស់ តែខ្ញុំបានរកឃើញ Visual Basic 2008 Express
ដែលអាចយកមកប្រើដោយអត់អស់លុយពី Microsoft ។

ដូច្នេះខ្ញុំត្រូវរៀនប្រើ Visual Basic 2008 Express វិញ ហើយប្រហែល
ជាឈប់ប្រើ Visual Basic 6.0 ហើយតាមមើល ។

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante. Donec eu libero sit amet quam egestas semper. Aenean ultricies mi vitae est. Mauris placerat eleifend leo. Quisque sit amet est et sapien ullamcorper pharetra. Vestibulum erat wisi, condimentum sed, commodo vitae, ornare sit amet, wisi. Aenean fermentum, elit eget tincidunt condimentum, eros ipsum rutrum orci, sagittis tempus lacus enim ac dui. Donec non enim in turpis pulvinar facilisis. Ut felis. Praesent dapibus, neque id cursus faucibus, tortor neque egestas augue, eu vulputate magna eros eu erat. Aliquam erat volutpat. Nam dui mi, tincidunt quis, accumsan porttitor, facilisis luctus, metus.

pada kesempatan ini saya akan bercerita, menuangkan ilmu untuk berbagi dengan teman-teman, yaitu tentang tip & trik php query b.base

Application Configuration

* .NET Configuration System
* Configuration API
* Config Files Security
* Standard Config Sections
* Demo: Application Settings
* Read AppSettings
* View Raw AppSettings XML
* Demo: Connection Strings
* Conn. Strings in web.config
* Read Connection Strings
* Retrieve all Conn. Strings
* Other Standard Sections
* Demo: Impersonate Setting

Manipulate Config Files

* Demo: Write to AppSettings
* Add a Setting
* Remove a Setting
* Standard Config. Settings
* Toggle Debugging in Setting
* Read machine.config
* Read Root web.config
* Read App. web.config
* Config Files in WinForms
* Section Groups / Props.
* Read machineKey section
* Section Collections
* Read from Pages Section
* Enumerating Section Groups

Custom Config Sections

* Create a Custom Section
* Write Section Handlers
* Declarative Section Handler
* Link Class in web.config
* Test Declarative Header
* Programmatic Section Handler
* Property Validators
* Test Programmatic Header
* More Complex Sect. Header
* View Class Code

Custom Config Providers

* View SettingsProvider
* User vs App. Scope
* Use SettingsProvider
* userSettings Section
* SQL Settings Provider
* View AssemblyInfo
* GetPropertyValues Code
* GetValue Code
* SetPropertyValues Code
* Scope Support Functions
* Test the Provider

Installation Components

* Overview
* Pre-Defined Components
* Create a Windows App
* Add an Installer
* View Installer Code
* Add Code to Form
* Create Deployment Project
* Build the App
* Test the App

Custom Install Components

* Overview
* Create Install Comp.
* InstallHappened Event
* Database events Code
* Run Installation Code
* InstallUtil.exe Tool
* AssemblyInstaller Class
* View Installer Code

Configuring Assemblies

* Specify Framework Version
* Specific Assembly Versions
* Concurrent Garbage Coll.
* Register Remote Objects
* .NET Configuration Tool

Event Logs

* Overview: Tools
* WinForms Components
* Use an Event Log
* Security Note About Logs
* EventLog Class
* Create an Event Log
* Setup Form Code
* Create/Delete Logs Code
* Read From an Event Log
* Log Changed Code
* Get Log Entries Code
* Write to an Event Log
* WriteEvent Method

Processes

* Run ProcessManager Demo
* List Running Processes
* List Process”s Modules
* Retrieve Current Process
* Starting a New Process

Application Performance

* Run Perf. Counter App
* Windows Perf. Tool
* Create Perf. Counters
* Using Perf. Counters

Debugging

* Run Debugging Sample
* View Debug Sample Code
* Overview: Stack Trace
* Examine Stack Trace
* Stack Trace Code
* Debugger Attributes
* BrowsableAttribute
* DisplayAttribute
* HiddenAttribute
* StepThroughAttribute
* TypeProxyAttribute
* VisualizerAttribute
* View Text Visualizer
* Impl. Custom Visualizer

Tracing

* Run Tracing Demo
* Trace Sources
* Trace Switches
* Trace Listeners
* Filtering Traces
* Configuring Traces

Instrumenting

* The Debug Class
* Write Debug Information
* Debug Fail
* Assertions
* The Trace Class
* Debug vs Trace
* Trace Switching
* Correlating Traces
* Enable Debugging/Tracing

Management

* WMI Object Browser
* Interesting WMI Classes
* Access Windows Resources
* Enum. Physical Drives
* Enum. Logical Disks
* Enum. Network Adapters
* Enum. System Processes
* Enum. Paused Services

Events

* WMI Query
* Sample App. Code
* Synchronous WMI Events
* Asynchronous WMI Events

Code Access Security

* Overview: CAS
* CAS: Evidence
* CAS: Security Policy
* CAS: Code Groups
* CAS: Permissions
* Sample Runtime Sec. Pol.
* CAS / Windows Security
* Configuring CAS
* Framework Config. Tool
* Default Permission Sets
* Create Permission Set
* Analyze Assemblies
* Reset All Sec. Pols.

Assemblies

* Use CAS in Assemblies
* Testing CAS
* VS Project Sec. Settings
* Set Security on Assemblies
* Add RequestMinimum
* Add RequestOptional
* Add UIPermission
* Edit File/UI Permissions
* Add RequestRefuse

Methods

* Use CAS with Methods
* Method Permission Requests
* Setup Method Example
* Declarative Demand
* Imperative Demand
* Declarative Demand Fail
* Imperative Demand Fail
* Declarative Link Demand
* Declarative Assert
* Imperative Assert
* Declarative Permit Only
* Imperative Permit Only
* Declarative Inheritance
* Analyze Permissions
* Safe Error Handling
* Custom Permission Sets
* Named Permission Sets

Windows Identity

* Authentication
* .NET Role-Based Security
* IIdentity / IPrincipal
* Identities / Principals
* Windows Identity
* Use Windows Identity
* Windows Principal
* Use Windows Principal
* Group Membership
* Use Group Membership
* Impersonation
* Use Impersonation
* Create an IIS Directory

Security Demands

* PrincipalPermission Class
* Declarative Demands
* Imperative Demands
* Generic/Custom Identities
* Generic Identities/Principals
* Use Generic Objects
* Custom Identities/Principals

Windows Security

* DACLs / SACLs
* Effective Permissions
* Explore DACLs / SACLs
* Access Control
* Classes/Enumerations
* Access/Audit Rule Classes

Access Audit Rules

* Run Access Control Demo
* View Access Control Code
* Retrieve Security Info
* Retrieve Access Rules
* Retrieve Audit Rules
* Get Rules for Directories
* Get Rules for Registry
* Change Access Rules
* Allowing Access
* Denying Access
* Removing Access
* Change Audit Rules
* AuditFlags.None value

Low Level Security

* ACL / ACE Classes
* CommonSecurityDescriptor
* PropagationFlags Enums.
* Maintain Security Settings
* Ownership
* Securing New Objects
* Access Object Ownership
* Inheritance/Propagation
* SetAccessRuleProtection

Cryptography

* Cryptography Overview
* Protection Issues
* Algorithms
* Block Padding
* Cryptography in .NET
* Hashing Data
* Hashing Algorithms
* Algorithm Characteristics
* .NET Framework Classes
* Cryptography Demo
* Hashing Code
* Hashing a File
* Message Integrity
* Compare Hash Codes
* CryptoConfig Object
* Key Hashing Algorithm

Encryption

* Symmetric Key Encryption
* Algorithms
* Algorithm Characteristics
* Symmetric in .NET
* Symmetric Key Demo
* Symmetric Key Code
* Encrypt/DeCrypt Data
* Random Number
* Asymmetric Key Encryption
* RSA
* Asymmetric in .NET
* Asymmetric Key Demo
* Asymmetric Key Code

Digital Sigs and DPAPI

* Digital Signature Hierarchy
* Digital Signature Demo
* Digital Signature Code
* DSACryptoServiceProvider
* Data Protection API (DPAPI)
* The DPAPI Process
* Store Options
* ProtectedMemory Class
* ProtectedMemory Demo
* ProtectData Option

Handle Concurrency Errors

* Handle Optimistic Concurrency
* Use Update Criteria
* Demo: Run Scripts from VS
* Update w/Stored Procs
* Check Validations
* Perform the Update
* @@ERROR/@@ROWCOUNT
* Handle Concurrency Errors
* Try/Catch in SQL Server 2K5
* SQL Server 2K5 Scripts
* Data Updates with ADO.NET
* Page_Load/Refresh Data
* Code for Updating Changes
* Code for Cancel Changes
* RowUpdated event
* Code for Concurrency Errors

Asynchronous Processing

* Async Query Execution
* Async Completion Signaling
* Asynchronous Processing
* View Connection String
* View SQL Strings
* SqlCommands/WaitHandles
* Setup Asynchronous Loop
* Setup the Results Textbox

Development Enhancements

* Enumerate SQL Servers
* MARS Scenarios and Caveats
* Mutliple Active Result Sets
* Demo: Max DataTypes
* Retrieve Max DataTypes
* Retrieve Text Values
* Enable Query Notifications
* Rules for Query Notifications
* Code: Query Notifications
* View Global.asax

Advanced.NET Framework 2.0 Using VB 2005

Multithreaded Applications

* Creating Multithreaded Apps
* Thread Class
* Join() Method
* ThreadStart Delegates
* Demo: Creating a Thread
* Demo: Synchronizing Threads
* Demo: Starting a Thread
* ThreadPool Class
* Reverse DNS Lookups
* Demo: ThreadPool Class
* Timer Class
* Demo: Timer Class
* Modifying the UI from a Thread
* Calling the Invoke Method
* Background Worker
* Calling an Async. Method
* Demo: Asynchronous Call
* ThreadState Enumeration
* ThreadPriority Enumeration
* Demo: Thread State
* Demo: Thread Priority

Locking

* Deadlock
* Race Conditions
* Demo: Race Condition
* Demo: Deadlock
* Thread Safe Code and Locking
* Monitor Class
* SyncLock Statement
* Interlocked Class
* ReaderWriterLock Class
* Demo: Non-Thread Safe
* Demo: Monitor Lock
* Demo: SyncLock
* Demo: Interlocked Class
* Demo: ReaderWriterLock 1
* Demo: ReaderWriterLock 2
* WaitHandle Class
* AutoResetEvent Class
* ManualResetEvent Class
* Demo: AutoResetEvent
* Demo: ManualResetEvent

Synchronization

* Mutex Class
* Semaphore Class
* Demo: Local Mutex
* Demo: Global Mutex
* Demo: Semaphore
* RegisterWaitForSingleObject
* Demo: Wait
* ExecutionContext Class
* Demo: ExecutionContext
* Demo: ExecutionContext(Run)

Encoding

* Using Encoding
* ASCII Encoding
* ANSI Code Pages
* Unicode
* UTF-8
* UTF-16
* Other Encoding Schemes
* Demo: Enumerating Encodings
* Demo: Encoding a String
* Demo: File Writing/Reading
* Demo: Fallback
* Demo: Exception Fallback

Using Culture Information

* Types of Cultures
* Invariant Culture
* Neutral Cultures
* Specific Cultures
* CultureInfo Class
* CurrentUI/Current (Culture)
* Getting the List of Cultures
* Demo: Retrieving Cultures
* Culture Names
* Language Code
* Country or Region Code
* Using a CultureInfo Object
* Assigning CultureInfo
* Parsing Dates
* Parsing Numbers
* Demo: Parsing Dates
* Demo: Parsing Numbers

Creating Windows Services

* Overview
* Examples of Win Services
* Creating a Windows Service
* Visual Studio Settings
* Starting a Visual Studio Project
* Naming the Service
* OnStart and OnStop Methods
* Installing the Service
* Service Process Installer
* Service Installer
* Starting the Service
* Stopping the Service
* Windows Event Logs
* Registry Entries
* Creating the Setup Program
* Uninstalling the Service
* Adding Functionality
* Testing the Service

Debugging Windows Services

* Creating a Test Harness
* Running the Test Harness
* Debug the Running Service
* ServiceController Comp.
* Demanding Permissions
* Override Other Service Methods
* Two-way Communication

Application Domains

* Overview
* Creating an App. Domain
* Unloading a Domain
* Configuring a Domain
* Retrieving Setup Information
* Loading Assemblies
* Demo: Student Projects
* Demo: Domain Security
* Demo: Evidence
* Demo: Evidence on Domain

.NET Framework Class Library

* Overview
* System Types
* Value Type / Ref. Types
* Built-in Value Types
* Number Types
* Demo: Numeric Types
* ToString Method
* Demo: Numeric ToString
* Instance vs. Shared
* Nullable Type
* Numeric Shared Methods
* Demo: Nullable Value
* Dates and Times
* Demo: Date/Time Properties
* Demo: Date/Time ToString
* Date/Time Instance Methods
* Date/Time Shared Methods

Reference Types

* Copy a Value Type
* Copy a Reference Type
* Value vs Ref. Types
* Work with Strings
* Overview: Stringbuilder
* String ReferenceTypes
* Demo: String Formatting
* Demo: Concatenate Strings
* Demo: Stringbuilder
* Overview: Arrays
* Array Methods
* Iterating Arrays
* Demo: Work with Arrays
* Handling Exceptions
* Demo: Work w/Exceptions

Custom Types

* Overview: Custom Types
* Value vs Ref. Type
* Constants
* Enumerations
* Demo: Constants
* Demo: Enumerations
* More Complex Enum.
* Structures
* Demo: Simple Structure
* Constructors
* Properties
* Add Methods to Structure
* Property vs Method
* More Complex Structure

Advanced Custom Types

* Using Attributes
* Built-in Attributes
* TypeForwardedToAttribute
* Build Your Own Attributes
* Implement Interfaces
* Use IComparable
* Use IDisposable
* Use IConvertible
* Use ICloneable
* Use IEquatable
* Use IFormattable
* Create Custom Interfaces
* View Custom interface

Delegates and Events

* Overview: Delegates
* Overview: Events
* Custom Event Handler
* Generic Classes
* Create Generic Types
* Consume Generic Type
* Add Constraints
* Demo: Generic Class
* Demo: Constraints

Simple Collections

* System.Collections
* Overview: ArrayList
* Demo: ArrayList
* Common Functionality
* IEnumerable Interface
* IEnumerator Interface
* ICollection Interface
* IList Interface
* CollectionBase Class
* ReadOnlyCollectionBase
* Implement Custom Collection
* Sequential Lists
* Queue Class
* Stack Class
* Demo: Queue
* Demo: Stack

Dictionaries and Sorting

* Dictionary Classes
* Handle Key/Value Pairs
* Hashtable
* GetEnumerator
* Demo: Hashtable
* Demo: DictionaryEntry
* Determine Duplicates
* IEqualityComparer
* Demo: IEqualityComparer
* SortedList
* Demo: SortedList
* Sort Collections
* Comparer Class
* Implement ICompare
* SortedList Collection
* Custom Sort Collection

Generic Collections

* Generic Collections
* Generic List Class
* Use Predicates
* Demo: Array List Issues
* Demo: Generic List
* Demo: Iterate Generic List
* Demo: Find / Predicates

Additional Generic Collections

* Generic Dictionary Class
* Sorted Classes
* Queues and Stacks
* Generic Queue Class
* Generic Stack Class
* Demo: Generic Dictionary
* Demo: Generic SortedList
* Demo: Generic Queue
* Demo: Generic Stack
* Generic LinkedList
* LinkedList Methods
* LinkedListNode Class
* Demo: Generic LinkedList
* Demo: LinkedListNode

Specialized Collections

* Generic Collection Classes
* Generic Collection Enums
* Demo: Gen Collections
* Specialized Collections
* StringCollection
* StringDictionary
* NameValueCollection
* Demo: StringCollection
* Demo: StringDictionary
* Demo: NameValueCollection
* BitArray
* BitVector32
* Demo: BitArray
* Demo: BitVector32

Isolated Storage (IS)

* Overview: IS
* IsolatedStorageFile Class
* Retrieve IS for Machine
* Work with Folders
* Demo: Work with Folders
* Work with Files
* IS File Permission Attrib
* Demo: Work with Files
* Access from Other Apps
* Demo: Create/Store Files
* Demo: Open/Read Files
* Compress Files in IS
* CompressDecompressIS Class
* Demo: Compress File in IS

Debug JavaScript

* Overview: Debug JavaScript
* Demo: Debug Sample
* View Page Source
* Attach to IE Process
* Types of Debuggers
* VS Script Explorer
* Test Breakpoint
* Overview: Visualizers
* Quick Watch Window
* Add a Watch
* ScriptManager ScriptMode
* Examine ScriptResource File
* Debug JavaScript File
* Sys.Stringbuilder
* Debug in Framework

Debug in Internet Explorer

* Overview: Debug in IE
* Demo: Debug in IE
* Nikhil”s Web Dev Helper
* HTTP Logging
* Deserialize to JSON
* Script Console
* Sys.Debug
* Create Debug Scripts
* trace v. traceDump
* Script Class Browser

Retrieve Data

* Overview: ADO.NET
* ADO.NET Classes
* OleDb vs SqlClient
* ADO.NET Architecture
* DataTable Object
* Demo: Fill DataTable
* Connect to Data Source
* Set Up Connections
* Make the Connections
* The using statement
* Exception Handling
* Overview: Commands
* Overview: Command Object
* Overview: Read Data
* Demo: SqlDataReader

.NET Configuration

* Benefits
* Navigate Hierarchy
* machine.config
* Demo: config files
* Root web.config
* Application web.config
* Use location Element
* Config File Elements
* system.web Element
* Demo: web.config
* appSettings Section
* connectionStrings Section
* system.web Section
* ASP.NET Configuration Tools
* Config Security Features
* Web Site Admin Tool
* Demo: Web Site Admin Tool
* Unified Error Handling

Security Trimming

* Demo: Navigation Security
* Authentication/Authorization
* Website Admin Tool
* Configure Authentication
* Enable User Login
* Test the Application
* Set Up Roles
* Override Automatic Trimming

Caching

* Improvements
* Types of Caching in ASP.NET
* Page Output Caching
* Caching Static Pages
* Demo: Caching Example Pgs
* Caching Multiple Pg Versions
* Demo: Multiple Page Versions
* Varying by Form Parameters
* Demo: Form Parameters
* Varying by HTTP Header
* Demo: Vary by HTTP Header
* Varying by Browser
* Demo: Varying by Browser
* Varying by a Custom String
* Demo: Varying by String

Page Fragments

* Demo: Cache Page Fragments
* Using VaryByControl
* Demo: Using VaryByControl
* Multiple Versions of a Control
* Demo: Multiple Ctrl Versions
* Post-Cache Substitution
* Call a Method to Insert HTML
* Demo: WriteSubstitution
* Caching Configuration
* Demo: Caching Configuration

Web Parts

* Web Parts in Action
* Demo: Personalization
* Design and Edit Modes
* Demo: Design and Edit Modes
* Catalog Mode
* Demo: Catalog Mode
* Connect Mode
* Demo: Connect Mode
* Custom Properties and Menus
* Demo: Properties and Menus
* Web Part Server Controls
* WebPartManager
* ProxyWebPartManager
* WebPartZone
* CatalogZone
* EditorZone
* ConnectionsZone

Coding Web Parts

* Page”s Display Mode
* Demo: Control Display Mode
* Demo: Personalization Scope
* Resetting Personalization Data
* Demo: Reset Data
* Coding Connections
* Demo: Web Part Connections
* User Controls as Web Parts
* Demo: User Controls
* Custom Controls as Web Parts
* Demo: Custom Controls

Security Models

* X.509 Certificates
* Client Side
* Server Side
* Policy Assertion
* Client Configuration
* Demo: Create Certificates
* Run Certificate Manager
* X.509 Cert. Settings
* Service Configuration
* Demo: Service Config
* Kerberos
* Kerberos Client Config.
* Demo: Client Config
* Kerberos Service Config.
* Demo: Server Config
* Set up Web Service

Exploring MTOM

* Overview: MTOM
* MTOM Structure
* MTOM uses XOP
* Use / Non-use of MTOM
* Non-use of MTOM
* Use of MTOM
* MTOM and WSE3.0

Ntier Data

* Overview: 2-Tier
* Overview: N-Tier
* Demo: Split DataSet Code
* Create N-Tier App
* Define 2-Tier DataSource
* DataSet Project Property
* Create Multi-Tier Form
* Define N-Tier DataSource
* Test N-Tier App
* LINQ to SQL
* LINQ to SQL Mappings
* DataContext Class
* Entity Classes
* Object Relational Designer
* Demo: LINQ to SQL
* View Designer Class
* Create Front End
* Configure Behavior
* Specify Mappings

Code Access Security

* Overview of Security
* Evidence
* Security Zones
* Security Policy
* Security Policy Levels
* Code Groups
* Permission Sets
* Security Policy Overview
* Demo: Code Access Security
* CLR Grants Permissions
* Configuring Security Policy
* Demo: Granting Permissions

Permissions

* Checking For Permissions
* Code Access Permissions
* Using Declarative Syntax
* Demo: Check Permissions

Role Based Security

* Overview
* Identity
* WindowsIdentity Class
* GenericIdentity Class
* Principal
* WindowsPrincipal Class
* GenericPrincipal Class
* PrincipalPermission
* Demo: Role-based Security

Windows Communication Framework (WCF) services that support Representational State Transfer (REST) and syndication

Intro To WCF

* History
* Service Orientation
* Principles
* What’s Wrong
* WCF to the Rescue
* WCF vs Web Services
* WCF
* Demo: WCF Service

Building Blocks

* WCF Building Blocks
* Service
* Service Contracts
* Data Contracts
* Endpoints
* Bindings
* Provided Bindings
* Demo: WCF Service
* Hosting Service
* Client to Call Service

IIS And Self Hosting

* Hosting a WCF Service
* Hosting Options
* Which Should You Use?
* Demo: Hosting Using IIS
* Self Host WCF Services
* Demo: Self Hosting
* Multiple Endpoints
* Two Services

Sessions

* Sessions
* Bindings and Sessions
* Instancing
* PerCall Instancing
* PerSession Instancing
* Single Instancing
* Demo: TCP Sessions
* Demo: HTTP Sessions
* Demo: Instancing
* Control Sessions
* Demo: Control Sessions
* Sessions and Concurrency
* Single Thread Concurrency
* Reentrant Thread Concurrency
* Multiple Threads Concurrency
* Demo Scenario
* Demo: Concurrency

Transactions

* Transactions
* Enable Transactions in WCF
* Starting a Transaction
* Demo: Configure Transactions
* Transactions and Sessions
* Demo: Transactions-Sessions

Security Basics

* Security Concepts
* WCF Security Mechanisms
* Transport Level Security
* Message Level Security
* Pros and Cons
* Default Security Settings
* Demo: Encrypting Messages

Authentication

* Overview
* Transport Security Credentials
* Message Security Credentials
* Default Security Settings
* Scenario
* Demo: Passing Credentials
* Demo: User Authentication
* Scenario
* Demo: Basic Authentication
* ASP Membership Provider
* Configure Web Site Security
* Configure Binding and Service
* Demo: ASP.NET Membership

Authorization

* Overview
* Role Based Authorization
* Role Based Security
* Identity
* Principal
* WindowsPrincipal Class
* GenericPrincipal Class
* PrincipalPermission
* Demo: Using Identities
* Demo: Generic Indentity
* ASP.Net Role Provider
* Configure Web Site Security
* Configure Binding and Service
* Demo: ASP.NET Role Provider

Windows Workflow Foundation
Workflow Services

* Windows Workflow Foundation
* Sequential Workflow
* State Machine Workflow
* Workflow Services
* ReceiveActivity
* Authoring Styles
* Hosting Workflow Services
* Demo: Workflow Service
* Demo: Hosting Workflow IIS

Stateful Workflow Services

* Overview
* Using the State Activity
* Using the SetState Activity
* Using the EventDriven Activity
* Workflow Persistence
* SQL Persistence Service
* Demo:StateMachine Workflow
* Demo: Setup Persistence

Restful Services

* REST
* REST Principles
* Why use REST vs SOAP?
* REST and WCF
* WebGet Attribute
* WebHttpBinding
* WebServiceHost
* Demo: RESTful Service
* Uploading Data

Syndication

* Overview
* Syndication and WCF
* Syndication Classes
* Demo: Syndication Feed
* Demo: ATOM Feed
* Demo: ATOM and RSS

Workflow Foundation

* Overview: WF
* What App Types Benefit
* What is Needed for WF
* Verify Pieces are Installed
* Two Types of Workflows
* Base Classes
* Workflow Activities
* Create First Workflow
* Workflow Activities
* Add Code Activities
* Test the Workflow
* Debug Your Workflow
* Workflow Architecture
* Types of Host Apps
* Workflow Startup Code
* Two Ways to Create Workflows
* Create Workflow w/XOML

Windows Form Host

* Hosting Workflow
* Pass Parameters
* Demo: Create Host App
* Demo: Create Workflow
* Add Amount/ItemName
* Set Delay Activity Behavior
* Add IfElse Activity Condition
* Add Code Activities
* Create the Form
* WorkFlowCompleted
* Create Parameters Coll.
* Test the Workflow

CAG / Replicator

* Overview: CAG
* Demo: CAG Activity
* Replicator Activity
* Demo: Replicator Activity
* Using a Custom Activity
* Demo: Custom Activity

Chaining

* Forward Chaining
* Demo: Forward Chaining
* Attribute Chaining
* Explicit Chaining
* Demo: Attribute Chaining
* Demo: Explicit Chaining
* Control Chaining
* Demo: Halt Chaining

Call Host Methods

* Overview: Host Methods
* Cross-Threading Issues
* Important Specifics
* Create a Console Host
* Create Shared Interface
* Create the Workflow
* Interface Implementation
* ExternalDataExchangeService
* Add Windows App Host
* Review: Host Methods

<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
Public Class Exception _
    Implements ISerializable, _Exception

A catch block handles an exception of type T if the type filter of the catch block specifies T or any type that T derives from. The system stops searching after it finds the first catch block that handles the exception. For this reason, in application code, a catch block that handles a type must be specified before a catch block that handles its base types, as demonstrated in the example that follows this section. A catch block that handles System.Exception is specified last.

If none of the catch blocks associated with the current try block handle the exception, and the current try block is nested within other try blocks in the current call, the catch blocks associated with the next enclosing try block are searched. If no catch block for the exception is found, the system searches previous nesting levels in the current call. If no catch block for the exception is found in the current call, the exception is passed up the call stack, and the previous stack frame is searched for a catch block that handles the exception. The search of the call stack continues until the exception is handled or until no more frames exist on the call stack

Exception Type Categories

Handling and Throwing Exceptions.

Allows exceptions to be thrown across process and even machine boundaries.

Exceptions offer several advantages over other methods of error notification, such as return codes. Failures do not go unnoticed. Invalid values do not continue to propagate through the system. You do not have to check return codes. Exception-handling code can be easily added to increase program reliability. Finally, the runtime’s exception handling is faster than Windows-based C++ error handling.

Because execution threads routinely traverse managed and unmanaged blocks of code, the runtime can throw or catch exceptions in either managed or unmanaged code. Unmanaged code can include both C++-style SEH Exceptions and COM-based HRESULTS.

ApplicationException Class (System)

If you are designing an application that needs to create its own exceptions, you are advised to derive custom exceptions from the Exception class. It was originally thought that custom exceptions should derive from the ApplicationException class; however in practice this has not been found to add significant value.

SystemException Class (System)

SystemException does not provide information as to the cause of the Exception. In most scenarios, instances of this class should not be thrown. In cases where this class is instantiated, a human-readable message describing the error should be passed to the constructor.

SystemException is thrown by the common language runtime when errors occur that are nonfatal and recoverable by user programs. These errors result from failed runtime check (such as an array out-of-bound error), and can occur during the execution of any method. SystemException adds no new functionality to Exception.

Exceptions Overview.

The runtime uses an exception handling model based on exception objects and protected blocks of code. An Exception object is created to represent an exception when it occurs.

The runtime creates an exception information table for each executable. Each method of the executable has an associated array of exception handling information (which can be empty) in the exception information table. Each entry in the array describes a protected block of code, any exception filters associated with that code, and any exception handlers (catch statements). This exception table is extremely efficient and there is no performance penalty in processor time or in memory use when an exception does not occur. You use resources only when an exception occurs.

The exception information table represents four types of exception handlers for protected blocks:

• A finally handler that executes whenever the block exits, whether that occurs by normal control flow or by an unhandled exception.
• A fault handler that must execute if an exception occurs, but does not execute on completion of normal control flow.
• A type-filtered handler that handles any exception of a specified class or any of its derived classes.
• A user-filtered handler that runs user-specified code to determine whether the exception should be handled by the associated handler or should be passed to the next protected block.

Each language implements these exception handlers according to its specifications. For example, Visual Basic 2005 provides access to the user-filtered handler through a variable comparison (using the When keyword) in the catch statement; C# does not implement the user-filtered handler.

Note that the order of exception handlers is important: the innermost exception handler is evaluated first. Also note that exception handlers can access the local variables and local memory of the routine that catches the exception, but any intermediate values at the time the exception is thrown are lost.

If no match occurs in the current method, the runtime searches each caller of the current method, and it continues this path all the way up the stack. If no caller has a match, the runtime allows the debugger to access the exception. If the debugger does not attach to the exception, the runtime raises the UnhandledException event. If there are no listeners for the UnhandledException event, the runtime dumps a stack trace and ends the program.

Exception Class and Properties.

The Exception class is the base class from which exceptions inherit. Most exception objects are instances of some derived class of Exception, but you can throw any object that derives from the Object class as an exception.

Note that not all languages support throwing and catching objects that do not derive from Exception. In almost all cases, it is recommended to throw and catch only Exception objects.

The InnerException property.

This property can be used to create and preserve a series of exceptions during exception handling. You can use this property to create a new exception that contains previously caught exceptions. The original exception can be captured by the second exception in the InnerException property, allowing code that handles the second exception to examine the additional information.

• For example, suppose you have a method that reads a file and formats the data. The code tries to read from the file, but a FileException is thrown. The method catches the FileException and throws a BadFormatException. In this case, the FileException can be saved in the InnerException property of the BadFormatException.

To improve the caller’s ability to determine the reason an exception is thrown, it is sometimes desirable for a method to catch an exception thrown by a helper routine and then throw an exception more indicative of the error that has occurred. A new and more meaningful exception can be created, where the inner exception reference can be set to the original exception. This more meaningful exception can then be thrown to the caller. Note that with this functionality, you can create a series of linked exceptions that ends with the exception that was thrown first.

It is not recommended that you catch a SystemException, nor is it good programming practice to throw a SystemException in your application.

The most severe exceptions — those thrown by the runtime or in nonrecoverable conditions — include

• ExecutionEngineException,
• StackOverflowException,
• OutOfMemoryException.

Interoperation exceptions derive from SystemException and are further extended by ExternalException.

• COMException is the exception thrown during COM interop operations and derives from ExternalException.
• Win32Exception
• SEHException

Best Practices for Handling Exceptions.

1. Know when to set up a try/catch block. For example, you can programmatically check for a condition that is likely to occur without using exception handling. In other situations, using exception handling to catch an error condition is appropriate.

The method you choose depends on how often you expect the event to occur. If the event is truly exceptional and is an error (such as an unexpected end-of-file), using exception handling is better because less code is executed in the normal case. If the event happens routinely, using the programmatic method to check for errors is better. In this case, if an exception occurs, the exception will take longer to handle.

• When creating user-defined exceptions, you must ensure that the metadata for the exceptions is available to code executing remotely, including when exceptions occur across application domains. For example, suppose Application Domain A creates Application Domain B, which executes code that throws an exception. For Application Domain A to properly catch and handle the exception, it must be able to find the assembly containing the exception thrown by Application Domain B. If Application Domain B throws an exception that is contained in an assembly under its application base, but not under Application Domain A’s application base, Application Domain A will not be able to find the exception and the common language runtime will throw a FileNotFoundException. To avoid this situation, you can deploy the assembly containing the exception information in two ways:
  • Put the assembly into a common application base shared by both application domains

    - or -

  • If the domains do not share a common application base, sign the assembly containing the exception information with a strong name and deploy the assembly into the global assembly cache.

• In C# and C++, use at least the three common constructors when creating your own exception classes. For an example, see How to: Create User-Defined Exceptions.

Imports System
Public Class EmployeeListNotFoundException
   Inherits Exception

   Public Sub New()
   End Sub 'New

   Public Sub New(message As String)
      MyBase.New(message)
   End Sub 'New

   Public Sub New(message As String, inner As Exception)
      MyBase.New(message, inner)
   End Sub 'New
End Class 'EmployeeListNotFoundException

• Return null for extremely common error cases. For example, Open returns null if the file is not found, but throws an exception if the file is locked.
• Design classes so that an exception is never thrown in normal use. For example, a FileStream class exposes another way of determining whether the end of the file has been reached. This avoids the exception that is thrown if you read past the end of the file.
• Use exception builder methods. It is common for a class to throw the same exception from different places in its implementation. To avoid excessive code, use helper methods that create the exception and return it. For example:
  Visual Basic

  Class File
     Private fileName As String
  
     Public Function Read(bytes As Integer) As Byte()
        If Not ReadFile(handle, bytes) Then
           Throw NewFileIOException()
        End If
     End Function 'Read
  
     Function NewFileIOException() As FileException
        Dim description As String = __unknown ' Build localized string, including fileName.
        Return New FileException(description) '
     End Function 'NewFileIOException
  End Class 'File

Handling COM Interop Exceptions.

Choosing When to Use Structured and Unstructured Exception Handling.

you might use unstructured exception handling under these circumstances:

• You are upgrading an application written in an earlier version of Visual Basic.
• You are developing a preliminary or draft version of an application and you don’t mind if the program fails to shut down gracefully.
• You know in advance exactly what will cause the exception.
• A deadline is pressing, you need to take shortcuts, and are willing to sacrifice flexibility for speed.
• Code is trivial or so short that you only need to test the branch of code generating the exception.
• You need to use the Resume Next statement, which is not supported in structured exception handling.

The common language runtime catches exceptions that are not caught by a catch block. Depending on how the runtime is configured, either a debug dialog box appears, or the program stops executing and a dialog box with exception information appears. For information about debugging, see Debugging and Profiling Applications.

After a VBScript was implemented into a file move task that my team’s application depends upon, a limitation of the FileSystemObject caused data to be lost.  This brought about the realization that care must be taken when using the FSO (FileSystemObject) to perform tasks on fixed-width flat-file data files.  In this case, the ReadLine method was being used to read in each line in such a file and getting the length of the string using the LEN() function. The problem here is that the ReadLine method reads the entire line up to but not including the newline character.  This causes a significant problem when this length value is used to feed a line of data to a mainframe program which is expecting the count to include the newline character.  This was previously not a problem because the FSO was not previously used to manage information about record lengths in the file.  However, one this change was introduced, this limitation became an issue in our environment.

There are so many related topics that are potential candidates for future posts, such as using VBScript in environments where byte counting is required, or using it to customize enterprise-class COTS applications through a scripting interface, to how such a seemingly minimal change can impact a production environment, etc…but at the end of the day, as the development landscape and paradigms change, implementing old technology should be done so with care.  Technologies and platforms such as the .NET Framework offer more powerful and robust capabilities which overall far outweigh the simplicity and familiar comfort that the VB6/COM world has given us for years. 

//T

I just love Open Source software. I have a number of Visual Basic 6 projects that I use quite often for work and school. I move them to different computers.

I usually use the VB6 Package and Deployment Wizard to build an install package for these. However, at least three of these VB6 packages have cratered while trying to get them to install on the target system. One time, the target system was a computer on the E-4B, and I was trying to help a guy get it to install, with little luck. The errors being reported were (1) random and not consistent, and (2) cryptic, to say the least.

I can hand-install most any Windoze program with a little patience, but in that case I was 1400 miles away, and it needed to be installed that day!

I searched around on the web and found NSIS. Just a bit more searching and I found a companion to NSIS that acted as a VB6-NSIS Converter. The way it works, you run the VB6 Package and Deployment Wizard. If the installer fails, then run the VB6-NSIS converter, point it at the VB6 “SETUP.LST”, and it creates a script for NSIS. Then run NSIS, point it at the converted script, and it builds a nice setup.exe file. Burn it to CD or email it to it’s destination, or copy it to a flash drive, and you are on your way.

In every case where the built-in VB6 tool at trouble, NSIS/VB6 converter got the job done. Great stuff.

Almost forgot:

http://nsis.sourceforge.net/Main_Page

http://nsis.sourceforge.net/VB_Converter

<img src=gambar/vb-penjualan.jpg>

Terdiri dari contoh-contoh aplikasi untuk Penjualan / POS baik grosir, toko retail,butik, dan bisnis lainnya. Anda akan diberikan bagaimana mekanisme kerja dari sistem penjualan dari yang sederhana sampai tingkat lanjut baik manual maupun dengan sistem barcode.

download disini