Used to convert from one type to another, providing custom functionality.
When you use the convert-to form of the operator (the one with a parameter), the compiler needs to create a new object implicitly so that you can copy data into it. When you use a convert-to operator, the compiler needs to create a new instance of the item it located the Operator_Convert method on, and then it calls that method to complete the conversion. When it creates the new instance of the item, it does not call any constructors for it. The Operator_Convert method takes the place of the constructor.
When you use a convert-from operator (the one without a parameter), the compiler doesn't have to do any extra work. Whenever an implicit (or explicit) conversion needs to take place, the compiler looks for the convert-from operator, and if it finds one, it calls it. The function itself already does all of the conversion work.
Constructors aren't called when doing a convert-to operation. That's something to be aware of. If you're doing required work in your constructor, you'll need to perform that work yourself in the conversion. This generally won't need to happen, since most constructors initialize things to sensible values, and conversion operations would do exactly the same thing. But if you are doing some sort of Declare work, it may still be necessary. For instance, let's say that you were doing some sort of COM work on Windows. Your Operator_Convert method had better call CoInitialize just to be on the safe side.
Another issue with convert-to operators is that they won't work for interfaces. There's no way for the compiler to instantiate a new instance of an interface. That means the following code can be quite confusing:
Interface SomeInterface Sub Operator_Convert(rhs As String) End Interface
Class SomeClass Implements SomeInterface Sub Operator_Convert(rhs As String) End Sub End Class
Var c As SomeClass = "12" Var c1 As SomeInterface = "32"
This code may look perfectly sensible, but you will get a compile error at about c1 = "32". The problem is that the compiler cannot create a new instance of SomeInterface, even though it is perfectly legal to do so for SomeClass.
A Person class using Operator Convert:
// Person is a class with a property FullName As Text Var p1 As New Person p1.FullName = "Bob Roberts" // You can define an Operator_Convert method on Person to allow // the name to be assigned directly: Sub Operator_Convert(name As String) Self.FullName = name End Sub
Now you can write code like this, which takes a String value and converts-to to a new instance of Person:
Var p2 As Person p2 = "Bob Roberts" // p2.FullName = "Bob Roberts"
You can also define an Operator_Convert method on Person which converts-from the Person to a String value:
Function Operator_Convert As String Return Self.FullName End Function // This allows you to write code like this, // which converts from a Person to a Text value for use by a Label: Label1.Text = p2
Sub Operator_Convert(rhs As Integer) Self.x = rhs Self.y = rhs End Sub
You use this definition of the Operator_Convert method like this:
Var v As Vector v = 10 // both elements of V get the value 10
Note that the New operator is not needed here. This is because the assignment operator is returning a new instance of Vector. If you were to write v = [New]] Vector, it would create one instance of Vector but that would be overwritten by the assignment statement.
The second type of conversion is a "convert-to" conversion. Use this when you want to convert the class to another type. In the following example, the Vector is converted to a string that represents its square length.
Function Operator_Convert As String Return Str(Self.x ^ 2 + Self.y ^ 2) End Function
After defining both forms of Operator_Convert, you can use them with code like this:
Var v As Vector = 10 MessageBox(v)
Desktop, console, web and iOS project types on all supported operating systems.