Scribd
Upload
74 views15 pages

Differences VO XS

The major differences between VO and X# are: 1) X# applications run on the .NET runtime instead of a proprietary runtime, improving stability and performance but losing some VO-specific features. 2) Code is organized into .NET assemblies and namespaces instead of the VO repository. 3) Error handling uses .NET exceptions instead of the global VO ErrorBlock. 4) Access/assign and functions are emulated instead of native language features.

Uploaded by

Jose Cordero
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
74 views15 pages

Differences VO XS

The major differences between VO and X# are: 1) X# applications run on the .NET runtime instead of a proprietary runtime, improving stability and performance but losing some VO-specific features. 2) Code is organized into .NET assemblies and namespaces instead of the VO repository. 3) Error handling uses .NET exceptions instead of the global VO ErrorBlock. 4) Access/assign and functions are emulated instead of native language features.

Uploaded by

Jose Cordero
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

Differences between VO and X#

The major differences between VO and X#

Wolfgang Riedmann
[email protected]

Meeting Italiano 2018 a Bolzano


Runtime
A X# application is executed under the control of the .NET runtime and not anymore
under the control of a proprietary runtime. This changes a few things:
• Stabler runtime, more performant garbage collector
• Available on all .NET platforms: x86, x64, AnyCPU, Linux
• Some features of the VO language are not available anymore. For example:
access/assign cannot have the same name as a method, a class cannot have the same
name as the enclosing binary
• The repository with its incremental compiling does not exists anymore, the code is
located in prg files, but can be organized in folders and subfolders
• The ErrorBlock is not available anymore!!!
• The largest code library is available at no cost: the .NET Framework with thousands of
classes
• Faster codeblocks, but slower in the compilation (for now!)
• Function() does not exists anymore, is emulated by static methods of the class
Functions. You can continue to write and use functions.
• Access/Assign does not exists anymore, is emulated with property. An assign cannot
return any value!
Meeting Italiano 2018 a Bolzano
Runtime? What is it?
As runtime we specify the libraries/DLLs than come with :
• The real runtime: data types, base functions, macrocompiler.
• VO 2.8: VO28RUN.DLL
• Vulcan: VulcanRT.DLL, VulcanRTFuncs.DLL, VulcanMacroCompiler.DLL
• X#: Xsharp.Core.DLL, Xsharp.VO.DLL, Xsharp.MacroCompiler.DLL

• Data access functionality: RDD (Replaceable database drivers):


• VO 2.8: CavoDBF.RDD, DBFCDX.RDD, DBFNTX.RDD, _DBFCDX.RDD
• Vulcan: VulcanDBFCDX.DLL, VulcanDBFFPT.DLL
• X#: currently in development, beta planned for August 2018

• Class Libraries (System, GUI, RDD, SQL, OLE, Windows API, Internet):
• VO 2.8: VO28SYS.DLL, VO28GUI.DLL, VO28RDD.DLL, VO28SQL.DLL, VO28OLE.DLL
• Vulcan: VulcanVOSystemClasses.DLL, VulcanVOGUIClasses.DLL,
VulcanVORDDClasses.DLL, VulcanVOSQLClasses.DLL
• X#: will be created by a tool from your own VO source code. GUI classes based on
WinForms and SQL classes based on ADO.NET arriving too!
Meeting Italiano 2018 a Bolzano
Everything is an object
Every data type is an object, even basic data types like "string", "int", "logic"

This means that even these datatypes can have methods and properties:

MyString:ToUpper()
MyString:Length
nNumber:ToString()

Meeting Italiano 2018 a Bolzano


Unicode !!!
In .NET all strings are Unicode.
• No problems with national character sets anymore
• A character is NOT a byte! A string of 10 characters is 20 bytes long (normally)
• String != array of char != array of byte
• Attention to the conversions!
• You cannot more use easily memo fields for binary content (compressed or crypted
data, etc.). The content would be destroyed by the automatich conversions.

Meeting Italiano 2018 a Bolzano


String, Char, Byte
To read from a file on disk:
File.ReadAllBytes( cFileName ) -> aContent as byte[]
File.ReadAllText( cFileName, Encoding.ASCII ) -> cContent as string

To convert:
System.Text.Encoding.Unicode.GetString( aBytes ) -> aBytes as byte[] -> cString as string
System.Text.Encoding.Unicode:GetBytes( cString ) -> cString as string -> aBytes as byte[]

between string and array of char:


cString := String{ aChars } -> aChars as char[]
aChars := cString:ToCharArray() -> aChars as char[]

Meeting Italiano 2018 a Bolzano


Literals, Suffix, Prefix
A string in X# è is delimited with the double apostrophe: " but in the VO dialect also the
single apostrophe can be used. The parentheses [] cannot be used anymore.

A single character delimited with single apostrophe is not a string, but a char!

Attention to the dialects: Vulcan does not permits the single apostroph as string delimiters

Escaped string: e"Hi guys,\nwelcome to Bolzano, the capital of \"Südtirol\""


Interpolated string i"Hi {cNome}"
Prefix to specify a char in VO dialect: c'A'

Suffixes for numbers:


d – double 10d
s – single 10s
m – decimal 10m
b – binary 10b (=2)

Meeting Italiano 2018 a Bolzano


Namespaces and Assemblies
The namespaces are helping to organize your own classes, and to avoid conflicts.

It is possible to have two different classes with the same name in two different
namespaces.

The „Using“ statement declares the used namespace, but it is optional, then you need
to specify the fully qualified class name.
Separator between class and namespace : the dot "."

System.Collections.Generic.List{}

Attention: Assembly and namespace are two different things!!!! Microsoft gives a bad
example because they mix namespaces and assemblies (more different namespaces in
one assembly, and namespaces sparsed over multiple assemblies)

Meeting Italiano 2018 a Bolzano


Dot or colon?
In VO we use the colon to access the methods and assign/access of classes, and the dot
for the members of structures.
In X# we need delimiters on more occasions:
• Method/Assign/Access/Property: colon
• Static method: dot
• Separatore di namespace: dot
• Structure: dot

Attention: some uses have requested that colon and dot are treated the same, and in
some places this should work! (C# uses only the dot, so the Roslyn compiler make no
distinction)

Meeting Italiano 2018 a Bolzano


Try – catch – end try
Since the application does not run under the VO runtime control anymore, we have to
adjust to the .NET Framework way.
Attention: without error handling the application could terminate without error message or
with a message that gives no meaningful message!

Meeting Italiano 2018 a Bolzano


Global Error Handlers
There is not more the possibility to set a global error handler. Error handling in .NET is local,
no more global like in VO!
But we can (and should) set error handlers for errors occurring in WinForms, WPF, etc.

AppDomain.UnhandledException: handles otherwise not handled errors


Application.ThreadException: handles errors occurring in WinForms
Application.DispatcherUnhandledException: handles errors in WPF code
Please see: https://docs.xsharp.it/doku.php?id=exceptions

Please pay attention to "begin sequence – end sequence" in applications migrated from VO!
Often in these blocks the errors are not handled.

Most important properties of the Exception class:


Exception:Message
Exception:Stacktrace
Exception: InnerException

Meeting Italiano 2018 a Bolzano


Interface
Interface is an entirely new possibility to define the interface of a class.

Every class that implements an interface must have all methods and properties that are
defined in the interface

Variables can be defined "as IName"

In VO for such purposes classes needed to have the same father class, using interfaces the
classes don‘t need to have any relation. Please see the documentation for the interface
IDisposable

Convention: every interface definition name starts with an uppercase i "I"

Meeting Italiano 2018 a Bolzano


Problems with float? Decimal!
Float in Clipper and VO, and therefore also in Vulcan and X# is a „floating point“ data type,
with a floating comma and a exponent.

A number „123456789.1“ internally could be „123456789.0999999999“ .


This can lead to rounding problems since
„123456789.1 == nVariable“ could return false. In fact, with the float datatype a number
with a decimal part cannot represented correctly.

In the .NET Framework there is a datatype „decimal“ with high precision, where these
sort of errors does not occur anymore. Unique problem: it is slower.

Very good notice: in the X# runtime the „decimal“is supported directly (or better: used
internally)!
You can store a decimal in a usual, and it will be a decimal(27).

Meeting Italiano 2018 a Bolzano


Performance
The performance of VO e X# is very difficult to compare.

X# has been developed with performance in mind. But code executed in the .NET runtime
is slower than native code like VO.

Optimizations:
• Interal all arrays are typed
• Macros are slower in compilation, but faster in execution because is effectively
compiled code
• Garbage collector enhanced, stable and fast, in AnyCPU all the memory can be used,
not only 2 GB

Meeting Italiano 2018 a Bolzano


End of session

Thank you for your attention!

https://www.xsharp.info
https://docs.xsharp.it
https://www.xsharp.info/help/index.html

Meeting Italiano 2018 a Bolzano

You might also like