`CallByName` Function

Executes a method, sets or returns a property, or sets or returns a field of an object.

Syntax

CallByName(object, procname, calltype, [args()])

Parameters

object - Required. Object expression on which the function will be executed.
procname - Required. String expression containing the name of the property, method, or field member of the object.
calltype - Required. Member of the VbCallType enumeration representing the type of procedure being called.
args() - Optional. Variant array containing the arguments to be passed to the property, method, or field being called.

`VbCallType` Constants

Constant	Value	Description
`VbMethod`	1	A method is being called
`VbGet`	2	A property value is being retrieved
`VbLet`	4	A property value is being set
`VbSet`	8	A reference to an object is being set

Return Value

Returns a Variant containing the result of the called property or method. For VbLet and VbSet, the return value is not meaningful.

Remarks

The CallByName function allows you to execute object members by name at run time, providing a form of late binding. This is particularly useful for:

Creating generic routines that work with multiple object types
Implementing dynamic property access based on user input
Building reflection-like functionality in VB6
Simplifying repetitive property access code

Important Notes

Late Binding: CallByName always uses late binding, even if the object variable is early bound
Performance: Slower than direct method/property calls due to name lookup overhead
Case Insensitive: The procname parameter is case-insensitive
Error Handling: Raises run-time error if the member doesn't exist
Type Safety: No compile-time checking of member existence or argument types

Call Type Details

VbMethod (1): - Calls a Sub or Function - Returns the function's return value (or Empty for Subs) - Passes arguments in the args array

VbGet (2): - Retrieves a property value or field value - Can be used with property procedures (Property Get) or public fields - For parameterized properties, pass indices in args array

VbLet (4): - Sets a property value or field value - For simple data types (numbers, strings, etc.) - The new value must be the last element in the args array - For parameterized properties, indices come before the value

VbSet (8): - Sets an object reference property - Similar to VbLet but for object references - Used when you would normally use the Set keyword

Examples

Basic Method Call

Dim obj As Object
Set obj = CreateObject("Scripting.FileSystemObject")

' Call the GetFolder method
Dim folder As Variant
folder = CallByName(obj, "GetFolder", VbMethod, "C:\Temp")

Property Get

Dim fs As Object
Set fs = CreateObject("Scripting.FileSystemObject")

' Get the Drives property
Dim drives As Variant
drives = CallByName(fs, "Drives", VbGet)

Property Let

Dim txt As Object
Set txt = CreateObject("Scripting.TextStream")

' Set a property value
CallByName txt, "Line", VbLet, 10

Property Set (Object Reference)

Dim form As Form
Set form = New Form1

Dim btn As CommandButton
Set btn = New CommandButton

' Set an object property
CallByName form, "ActiveControl", VbSet, btn

Dynamic Property Access

Function GetPropertyValue(obj As Object, propName As String) As Variant
GetPropertyValue = CallByName(obj, propName, VbGet)
End Function

Function SetPropertyValue(obj As Object, propName As String, value As Variant)
CallByName obj, propName, VbLet, value
End Function

Common Patterns

1. Generic Property Copier

Sub CopyProperties(source As Object, dest As Object, propNames() As String)
Dim i As Integer
Dim value As Variant

For i = LBound(propNames) To UBound(propNames)
value = CallByName(source, propNames(i), VbGet)
CallByName dest, propNames(i), VbLet, value
Next i
End Sub

2. Form Field Population

Sub PopulateFormFromRecordset(frm As Form, rs As Recordset)
Dim fld As Field
Dim ctl As Control

For Each fld In rs.Fields
On Error Resume Next
Set ctl = frm.Controls(fld.Name)
If Not ctl Is Nothing Then
CallByName ctl, "Text", VbLet, fld.Value & ""
End If
On Error GoTo 0
Next fld
End Sub

3. Dynamic Method Invocation

Function InvokeMethod(obj As Object, methodName As String, _
ParamArray args() As Variant) As Variant
Dim argArray() As Variant
Dim i As Integer

If UBound(args) >= 0 Then
ReDim argArray(LBound(args) To UBound(args))
For i = LBound(args) To UBound(args)
argArray(i) = args(i)
Next i
InvokeMethod = CallByName(obj, methodName, VbMethod, argArray)
Else
InvokeMethod = CallByName(obj, methodName, VbMethod)
End If
End Function

4. Property Name Validation

Function HasProperty(obj As Object, propName As String) As Boolean
On Error Resume Next
Dim temp As Variant
temp = CallByName(obj, propName, VbGet)
HasProperty = (Err.Number = 0)
On Error GoTo 0
End Function

5. Bulk Property Setting

Sub SetMultipleProperties(obj As Object, propNames As Variant, _
propValues As Variant)
Dim i As Integer

For i = LBound(propNames) To UBound(propNames)
CallByName obj, propNames(i), VbLet, propValues(i)
Next i
End Sub

' Usage:
SetMultipleProperties myControl, _
Array("Left", "Top", "Width", "Height"), _
Array(100, 100, 200, 50)

6. Parameterized Property Access

' Access a property with parameters (like an indexed property)
Sub SetIndexedProperty(obj As Object, propName As String, _
index As Integer, value As Variant)
CallByName obj, propName, VbLet, index, value
End Sub

Function GetIndexedProperty(obj As Object, propName As String, _
index As Integer) As Variant
GetIndexedProperty = CallByName(obj, propName, VbGet, index)
End Function

7. Configuration-Driven Object Initialization

Sub InitializeFromConfig(obj As Object, configFile As String)
Dim fs As Object
Dim ts As Object
Dim line As String
Dim parts() As String

Set fs = CreateObject("Scripting.FileSystemObject")
Set ts = fs.OpenTextFile(configFile)

Do While Not ts.AtEndOfStream
line = ts.ReadLine
If InStr(line, "=") > 0 Then
parts = Split(line, "=")
CallByName obj, Trim(parts(0)), VbLet, Trim(parts(1))
End If
Loop

ts.Close
End Sub

8. Error-Safe Property Access

Function SafeGetProperty(obj As Object, propName As String, _
Optional defaultValue As Variant) As Variant
On Error Resume Next
SafeGetProperty = CallByName(obj, propName, VbGet)
If Err.Number <> 0 Then
If Not IsMissing(defaultValue) Then
SafeGetProperty = defaultValue
Else
SafeGetProperty = Empty
End If
End If
On Error GoTo 0
End Function

Advanced Usage

Calling Methods with Multiple Arguments

Dim obj As Object
Set obj = CreateObject("SomeLibrary.SomeClass")

' Call a method with multiple arguments
Dim result As Variant
result = CallByName(obj, "Calculate", VbMethod, 10, 20, "sum")

Working with Collections

Sub EnumerateCollection(coll As Collection, methodName As String)
Dim item As Variant
For Each item In coll
CallByName item, methodName, VbMethod
Next item
End Sub

Building a Simple ORM

Sub SaveObjectToDatabase(obj As Object, tableName As String, _
propNames() As String)
Dim sql As String
Dim values As String
Dim i As Integer
Dim value As Variant

sql = "INSERT INTO " & tableName & " ("
values = " VALUES ("

For i = LBound(propNames) To UBound(propNames)
If i > LBound(propNames) Then
sql = sql & ", "
values = values & ", "
End If

sql = sql & propNames(i)
value = CallByName(obj, propNames(i), VbGet)
values = values & "'" & value & "'"
Next i

sql = sql & ")" & values & ")"
' Execute SQL...
End Sub

Error Handling

Common errors when using CallByName:

Error 438: Object doesn't support this property or method
The specified member doesn't exist
Check spelling and case (though CallByName is case-insensitive)
Error 450: Wrong number of arguments or invalid property assignment
Incorrect number of arguments in the args array
Using VbLet for an object (should use VbSet)
Using VbSet for a value type (should use VbLet)
Error 13: Type mismatch
Argument types don't match what the member expects

On Error Resume Next
result = CallByName(obj, "PropertyName", VbGet)
If Err.Number <> 0 Then
MsgBox "Error accessing property: " & Err.Description
End If
On Error GoTo 0

Performance Considerations

CallByName is significantly slower than direct member access
Name resolution happens at runtime, not compile time
Consider caching frequently accessed members
Use early binding and direct calls in performance-critical code
CallByName is best for scenarios where dynamic access is necessary

Limitations

Cannot call private members
Cannot call Friend members from outside the project
No IntelliSense support for the member being called
No compile-time type checking
Cannot call default members by passing empty string
More difficult to debug than direct calls

Eval: Evaluates an expression (only in VBA, not VB6)
Execute: Executes a statement (only in VBA, not VB6)
GetObject: Returns a reference to an object
CreateObject: Creates an instance of an object
TypeName: Returns the type name of a variable
VarType: Returns the variant subtype of a variable

Parsing Notes

The CallByName function is not a reserved keyword in VB6. It is parsed as a regular function call (CallExpression). This module exists primarily for documentation purposes and to provide a comprehensive test suite that validates the parser correctly handles CallByName function calls in various contexts.

CallByName Function