Creating wrapper functions for pre-existing stored procedures is surprisingly difficult in .NET. Stored procedures have certain calling conventions that aren’t generally used in the .NET Framework. These include:
- Pass by Reference Parameters
- Output Parameters
- Optional Parameters with default values
- All parameters are nullable
Until recently, full mappings were not possible. C# doesn’t currently support optional parameters, making placeholders for missing parameters necessary. VB could handle optional parameters, but not if those parameters were also nullable. For example, you cannot write:
Function FindCustomer(Optional ByVal firstName As String = Nothing, _
Optional ByVal lastName As String = Nothing, _
Optional ByVal zipCode As Integer? = Nothing) As DataTable
This becomes a real concern when call search-style stored procedures that then to have numerous optional parameters. With C# 4 and VB 10, the last of these holes have been addressed. C# now supports optional values and both languages can use optional types in conjunction with nullable structures.
|
Feature |
C# |
Mapping |
VB |
Mapping |
F# |
Mapping |
|
Pass by Reference |
1 |
ref type [param] |
7 |
ByRef [param] As [type] |
4 |
[param] : [type] byref |
|
Output |
1 |
out type [param] |
7 |
ByRef [param] As [type] |
4 |
[param] : [type] byref |
|
Optional Strings |
4 |
string param = [default] |
7 |
Optional [param] As String = [default] |
N/A 4 |
Normal functions do not support optional parameters. Method functions use: ?[param] : [type] |
|
Optional (other) |
4 |
[type] param = [default] |
7 |
Optional param As [type] = [default] |
||
|
Nullable Strings |
1 |
string param |
7 |
param as String |
4 |
[param] : string [param] : string option |
|
Nullable (other) |
2 |
[type]? param |
8 |
param As Nullable(of [type]) |
4 |
[param] : Nullable<[type]> [param] : [type] option |
|
9 |
param as [type]? |
|||||
|
Optional Nullable (other) |
4 |
[type]? param = [default] |
10 |
Optional param As [type]? = [default] |
4 |
?[param] : Nullable<[type]> ?[param] : [type] option |
It should be noted that while F# does support returning multiple values, the support is very limited. There is no way to update more than one arbitrary mutable value without using the byref syntax.