docs.xsharp.it

ads_linux

Anonymous (anonymous@undisclosed.example.com) — 2022-01-26T19:50:41+00:00

The Advantage Database Server on Linux Unfortunately the ADS software was not written originally for Linux, and therefore there are several important differences to ADS for Windows (I have never used ADS for Novell Netware, and I have my doubts there will be any new installations).

advantage_database_server_notes

Anonymous (anonymous@undisclosed.example.com) — 2022-01-26T19:00:03+00:00

Advantage Database Server notes These notes are referring to the ADS installation and maintenance, and not limited to X# itself. * Advantage Database Server on Linux * Differences between the DBFCDX RDD and the AXDBFCDX RDD

advantage_database_server

Anonymous (anonymous@undisclosed.example.com) — 2018-06-09T09:31:20+00:00

Advantage Database Server If you are using the Advantage Database Server with the Vulcan RDD, please follow the instructions how to use the ADS Vulcan RDD. For the ADSSQLServer class and some ADS functions please not port them over from VO, but use the prg files that are supplied with the Vulcan RDD. There are some differences that will give you runtime errors if you are using the ported VO version. This is particularly important for the DBFAXS library - there are some very important changes b…

application_samples

Anonymous (anonymous@undisclosed.example.com) — 2019-10-14T18:58:25+00:00

Application samples * Windows Service sample * Basic WPF application in pure code * Enhanced WPF application in pure code using inherited control classes * Basic WPF/MVVM application in pure code * Enhanced WPF/MVVM application in pure code using inherited control classes * WinForms databinding * Create a COM module in X# for a VO application using XIDE * Create a COM module in X# for a VO application using Visual Studio * A VO GUI application with a Windows Forms window

application_structure

Anonymous (anonymous@undisclosed.example.com) — 2018-06-04T05:40:11+00:00

How to structure an application In VO, there are applications, and every application consists of one or more modules, and every module has from zero to X entities. X#, since it uses the C# base does not have a repository, but is based on source code files. It is a good rule to keep a class per source code file and name the file like the class. To structure your application, you can uses directories, so your application looks like a tree. Smaller source code files give you more oversight over y…

assemblies

Anonymous (anonymous@undisclosed.example.com) — 2018-01-23T19:59:14+00:00

Assemblies In VO we have applications, libraries and DLLs. In .NET we don't have any libraries, only assemblies. These assemblies can be executable files (.exe) or DLLs. In VO, we have an incremental linker, and starting an even big application from the IDE is fast, because there are the .dbg and .vom files that contain executable code, and that are not completely rewritten on every application start.

assign_no_returnvalue

Anonymous (anonymous@undisclosed.example.com) — 2018-06-09T10:48:22+00:00

Assign cannot have a return value VO unfortunately permits to return a value from an assign. Since this is not permitted in .NET, the X# compiler will return an error of Warning XS9032 This entity type cannot return a value. Return value ignored.

attached_methods

Anonymous (anonymous@undisclosed.example.com) — 2018-01-28T17:41:02+00:00

Extension methods In Visual Objects, you could define methods to classes where you had no sources and that are defined in other libraries. In the .NET Framework this is not possible, but since this is a very powerful language feature, you can use the

begin_end_sequence

Anonymous (anonymous@undisclosed.example.com) — 2019-08-29T17:57:45+00:00

begin sequence - end sequence The begin sequence - recover - end sequence statements are widely used in VO applications, and the X# compiler translates it mainly in the try - catch and end try statements. So, if you are transporting VO code, you can keep these statements safely, but for new code please use the .NET equivalents

casting_astype

Anonymous (anonymous@undisclosed.example.com) — 2018-04-22T09:45:24+00:00

.NET and X# permit an enhanced casting of variables. Using the casting the compiler can will check the properties and methods of the object. local oObject as object local oDateTime as object oObject := DateTime.Now oObject:AddYears( 1 ) // compiler error here ( ( DateTime ) oObject ):AddYears( 1 ) // works oDateTime := oObject // compiler error here oDateTime := ( DateTime ) oObject //works

casting

Anonymous (anonymous@undisclosed.example.com) — 2018-09-07T04:04:26+00:00

Casting Casting is a very dangerous technique, specially when it comes to the 64 bit mode. There are functions that return an int value, but this value in reality is a pointer that points to a structure or an object or some other memory construct. This perfectly legal (but also dangerous) in a 32 bit world, but wrong in a 64 bit world where pointers are not more occupying 32 bit, but 64 bit.

collections

Anonymous (anonymous@undisclosed.example.com) — 2018-02-05T05:20:31+00:00

Collections The collections in many aspects are similar to the VO arrays, but they differ from them as you need to specify the type of the elements (of course, you can type the elements as object leaving this completely open. The collections are available in the namespaces

com_module_sample_vs

Anonymous (anonymous@undisclosed.example.com) — 2018-06-08T05:40:39+00:00

Creating a COM module in X# for a Visual Objects application using Visual Studio (Side-by-Side / DLL registration with manifest) It is not too difficult to create a X# DLL and use it from VO; you can even enter other languages like C# in the same DLL and call C# methods from X# (or v.v.).

com_module_sample

Anonymous (anonymous@undisclosed.example.com) — 2022-10-11T12:02:14+00:00

Create a COM module for a VO application using XIDE * Create a prg file for the interface begin namespace COMTest using System.Runtime.InteropServices [ComVisible(true)]; [Guid("750E557E-9DA6-4508-A36E-C4141D27B5D4")]; [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]; interface ICOMTester [DispId(1)]; method Output() as string end interface end namespace

compare_symbols_numeric

Anonymous (anonymous@undisclosed.example.com) — 2018-03-21T16:02:06+00:00

Compare symbols to numerics Since in VO symbols really are a numeric value, some statements work: local aField as array local nSearch as usual local nPos as dword aField := { #Chris, #Robert, #Fabrice, #Nikos } nSearch := 5 nPos := AScan( aField, nSearch )

compiler_option_ins

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T06:36:42+00:00

/ins Compiler option In VO all classes were without namespaces. In .Net that is not very common. For example: we have placed the VO SDK classes in the namespace VO. So Control is actually VO.Control. We did that because other libraries may also have a Control class (Windows.Forms, WPF etc.)

compiler_options

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T06:38:25+00:00

Some compiler options explained /ins Compiler option

conditional_access

Anonymous (anonymous@undisclosed.example.com) — 2018-03-28T11:08:50+00:00

Conditional access In X# you can use a conditional access to an object. Instead of writing if oObject != null oObject:ExecuteMethod() endif you can write oObject?:ExecuteMethod() This means that there will be no exception in the case oObject is null. Of course this works not only with methods, but also with properties (and access/assigns):

createinstance_libraries

Anonymous (anonymous@undisclosed.example.com) — 2018-02-19T04:59:32+00:00

CreateInstance() and Libraries If you are using CreateInstance() to dynamically create objects, you need to make sure the runtime knows the class that you are using to create your object. And you can create only objects that are contained in libraries compiled in the Vulcan or VO dialect - classes created in the Core dialect cannot be used.

default

Anonymous (anonymous@undisclosed.example.com) — 2018-05-09T11:28:55+00:00

Default VO has a Default statement. This is not typed and checks only if the passed value has a value of NIL. The Default statement in X# is strongly typed. This means that the compiler checks if the assigned value is of the correct type for the variable. There is another difference: since the .NET Framework does not knows about the Xbase datatype

define

Anonymous (anonymous@undisclosed.example.com) — 2019-08-21T06:02:12+00:00

Defines In VO, a define is a global constant value. That means that a define in in included library is available in all dependent applications (if the define has not the static modifier). define MyDefine := 123 In Vulcan.NET, defines are like in other languages, simple replaced by the compiler or preprocessor, and they are written in a different manner:

delegates

Anonymous (anonymous@undisclosed.example.com) — 2018-07-11T09:36:08+00:00

Delegates Why Delegates Delegates are a new concept in the X# language - in VO they don't exist. In every language there is sometimes the need to pass code as parameter to a function. VO has codeblocks, therefore normally you don't need function pointers, but pass codeblocks instead.

dll_function_changes

Anonymous (anonymous@undisclosed.example.com) — 2018-09-03T18:48:44+00:00

_dll function changes In VO, the following _dll declaration is correct: _DLL function zLibCompress( ptrDest as ptr, nBytesOut ref long, ptrSource as ptr, nBytesIn as long ) as int:zlib.compress This function has the C calling convention (comes from the Linux/Unix world), and therefore the

dll_function

Anonymous (anonymous@undisclosed.example.com) — 2018-09-03T18:51:40+00:00

_DLL Function In VO functions from DLLs can be used with the _dll function statement. This works als in X#, but the ptr datatype is not available in the Core dialect, you need something else, often the intptr datatype, but this depends on the function declaration.

docase

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:06:27+00:00

do case ... endcase The do case statement is exactly as it was in the Clipper, the VO and the Vulcan.NET language: do case case cExpr == "abc" DoSomething() case cExpr >= "d" .and. cExpr < "f" DoSomethingOther() case Upper( cExpr ) == "z" DoAnotherThing() otherwise DoWhatEverYouLike() endcase

doswitch

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:06:16+00:00

do switch The do switch statement is new in the X# language (but it was present also in the Vulcan.NET language). It is more similar to the switch statement that C has. Please look at this sample code: method( cLanguage as string ) as string local cResult as string do switch cLanguage case "german" cResult := "Deutsch" case "italian" cResult := "Italiano" case "english" cResult := "English" otherwise cResult := "unspported language" end switch

encodings

Anonymous (anonymous@undisclosed.example.com) — 2018-01-27T20:12:18+00:00

Encodings Since all strings in .NET are Unicode strings (see String, Char and Byte, you need to use the right encoding when reading and writing (disk, network, database). For the Encodings please see the classes that inherit from the System.Text.Encoding class: * System.Text.ASCIIEncoding: 7 bit

everything_object

Anonymous (anonymous@undisclosed.example.com) — 2020-06-14T22:55:52+00:00

Everything is an object In .NET even basic datatypes like string or int are an object. This means that even these datatypes can (an have) own methods. One method common to every object is AsString() . This method sometimes returns useful data: local nInt as int local oDate as DateTime local lLogic as logic nInt := 1234 oDate := DateTime.Now lLogic := true System.Console.WriteLine( nInt:ToString() ) System.Console.WriteLine( oDate:ToString() ) System.Console.WriteLine( lLogic:ToString() )

exception_handler_vogui

Anonymous (anonymous@undisclosed.example.com) — 2018-03-25T17:57:29+00:00

Exception handler for a VO GUI application The following code shows the exception message in a VO GUI messagebox. You should combine every exception handler with a logging functionality - a messagebox is gone too easily. static class ExceptionHandler static method ProcessException( oException as Exception ) as void local cMessage as string local oParent as object local oBox as TextBox cMessage := oException:Message // log to disk here do while oException:InnerException != NULL_OBJECT // lo…

exception_handler_winforms

Anonymous (anonymous@undisclosed.example.com) — 2018-03-25T18:07:06+00:00

Exception handler for a WinForms application The following code can be used to display an exception in a Windows Forms application. Please don't forget to log the exception also somewhere. class wfExceptionEventHandler constructor( oSender as object, oArgs as ThreadExceptionEventArgs ) local oException as Exception local nResult as DialogResult local cMessage as string oException := oArgs:Exception cMessage := "An error has been occurred:" + e"\n\n" + oException:Message + e"\n\n" + ; …

exception_handler_wpf

Anonymous (anonymous@undisclosed.example.com) — 2018-03-25T18:02:38+00:00

Exception handler for a WPF application The following piece of code can be used to display an exception text in a WPF GUI application. Please don't forget to log the exception also to a logfile. You can take this code also as sample how to build a WPF window from pure code.

exceptions

Anonymous (anonymous@undisclosed.example.com) — 2018-03-25T17:47:09+00:00

Exceptions As already described in the topic Try - Catch the .NET Framework uses exceptions to notify about an error condition. Take as sample the String:SubString() method: local cString as string local cResult as string cString := "Hello world" cResult := cString:Substring( 5, 30 )

extended_syntax

Anonymous (anonymous@undisclosed.example.com) — 2018-09-06T19:24:49+00:00

Extended Syntax Samples * The StringBuilder * Read a file * Read a file using a stream * String.Format * Extension Methods * Async and Await * Collections - typed arrays * Tuples * Delegates * Yield * The Preprocessor * Commands, Actions, Delegates * Interfaces * Dynamic loading libraries * _dll function * Casting * GCHandle: cast an object to a number * Indexers and indexed properties

extension_methods

Anonymous (anonymous@undisclosed.example.com) — 2018-01-28T17:39:48+00:00

float_real8_decimal

Anonymous (anonymous@undisclosed.example.com) — 2018-07-02T18:59:18+00:00

Float, Real8 and Decimal Please see this very interesting thread in the X# Forum: Float, Real8 or Decimal

gchandle

Anonymous (anonymous@undisclosed.example.com) — 2018-09-07T04:23:52+00:00

GCHandle: cast an object to a number When working with callback functions and the Windows API, sometimes it is important to map an object to a numeric variable. In VO, often the object was casted to an int variable. This was possible since in VO and Win32 a pointer has the same width as an int, but it could lead to problems if the object was moved by the garbage collector. Therefore this is dangerous and could lead to problems if not used correctly. In X#, this is not more possible, as a pointe…

generics

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:06:56+00:00

Generics Generics are a new feature in the .NET framework, and they permit to specify also the type of a parameter for a function. Whenever you see a parameter, it is a generic definition (but it could be any letter). Use of generics As sample how to use generics look at the

indexers_indexed_property

Anonymous (anonymous@undisclosed.example.com) — 2018-09-11T08:37:47+00:00

Indexers and indexed properties Indexers are a new concept for xBase developers. They permit to access the properties of an object like an array. Please see this sample class: class IndexerTest protect oValues as List constructor() oValues := List{} return property self[ nIndex as int ] as string get if oValues:Count >= nIndex return oValues[nIndex-1] else return "" endif end get set while oValues:Count < nIndex oValues:Add( "" ) …

is_type

Anonymous (anonymous@undisclosed.example.com) — 2018-04-02T18:16:45+00:00

Variable is type In VO, it was not so immediate to check the type of a variable. For objects, you need to use IsInstance(), there are functions like ValType() and UsualType other than specialized functions like IsString(). In .NET, things are much easier, fortunately.

lambda_codeblock_anonymous

Anonymous (anonymous@undisclosed.example.com) — 2018-01-30T05:10:55+00:00

Lambda expressions, Codeblocks, Anonymous methods Codeblocks are a datatype in Clipper and Visual Objects (and Vulcan.NET). In .NET there are Lambda expressions for the same purpose. X# permits also the codeblock syntax for lambda expressions and is smart enough to create the correct code.

language_syntax

Anonymous (anonymous@undisclosed.example.com) — 2020-08-28T03:54:31+00:00

Language Syntax Basics * Everything is an object * Strings and prefixes * String, Char and Byte * Literals, suffixes and prefixes * Try - catch * do switch * do case * property * Generics * Namespaces * Assemblies * Encodings * Exceptions and Exception Handlers * Method overloading * Lambda expressions, Codeblocks, Anonymous expression * .NET Arrays * Collections * Conditional access * Casting and astype * Variable is type * yield * using ... end usin…

literals

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:05:00+00:00

Literals, prefixes and suffixes String literals A string literal is delimited with the double quotation mark “. "This is a string" Please note that in the VO dialect a string can also be delimited with the quotation mark ' . 'This is a string' // valid only in the VO dialect, not in Core or Vulcan

method_overloading

Anonymous (anonymous@undisclosed.example.com) — 2018-01-24T12:56:39+00:00

Method Overloading Method Overloading is a concept that is not known in VO, but is implemented in the .NET runtime. It means that you can define multiple methods with the same name in a class. The only difference is that the signature (the parameter list) is different. This is true also for constructors - you can define more than one constructor in a class.

migrate_vo_vulcan_rt

Anonymous (anonymous@undisclosed.example.com) — 2019-03-08T18:08:29+00:00

Migrate from VO using XIDE and the Vulcan runtime * Export your VO application to an AEF file (if your application is using libraries you need to migrate them first * Launch XIDE, and select (or create) a project where your application should reside

namespace_assembly_reference

Anonymous (anonymous@undisclosed.example.com) — 2020-02-12T05:15:09+00:00

Namespaces, Assemblies, References These three concepts are new for anyone that comes from VO. An application can use code that is located in the application itself, or it can use code from other assemblies. An assembly is simply a DLL (the concept of an entirely linked library as in VO does not exists anymore). Such an assembly can be:

namespaces_migrated_applications

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T06:35:02+00:00

Namespaces in migrated VO applications Migrated applications does not have indicated any namespace, therefore some special rules apply. Normally, such applications use the compiler option /ins (use implicit namespace), so the compiler searches the referenced libraries and adds namespaces with special attribute. You can see that if you open the compiled exe with a tool like ILSpy. For more informations please look at

namespaces

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:07:29+00:00

Namespaces Namespaces are a possibility (that you should use, but not overuse!) to structure your classes. A sample of working code: Customer.Item.prg begin namespace Customer class Item # Class code end class end namespace Supplier.Item.prg

naming_conflicts

Anonymous (anonymous@undisclosed.example.com) — 2018-02-18T05:53:33+00:00

Naming conflicts Unfortunately, the .NET runtime is very sensitive to any naming conflicts, and X# is more accurate than Vulcan.NET. So these rules apply: * No class in your application can have the same name as your application itself. So if your application (exe or dll) is has a name of MyClass, you cannot have a class MyClass in your application. If you cannot change the name of your class, change the name of your application to app.MyClass or something similar

net_array

Anonymous (anonymous@undisclosed.example.com) — 2018-09-09T04:20:02+00:00

.NET Arrays Compared with the VO and Vulcan.NET dynamic arrays, the .NET arrays are very limited. They cannot grow, cannot shrink and cannot be sorted, and they can contain only elements of one datatype (or class). Of course, the could contain data of type

net_introduction

Anonymous (anonymous@undisclosed.example.com) — 2018-02-11T14:56:37+00:00

From VO to .Net The information included here is designed to give those coming from VO a broad overview of this new technology through the environment of Visual Studio. Visual Studio Dot Net

null_string

Anonymous (anonymous@undisclosed.example.com) — 2019-08-19T08:32:02+00:00

null_string The behavior of a string variable with a null_string value is defined by the /vo2 compiler option: With /vo2+ NULL_STRING is translated to String.Empty Without /vo2 NULL_STRING is translated to NULL Calling the :ToString() method on a variable that has a null_string value throws an exception if the code is compiled without the /vo2 option.

nullable

Anonymous (anonymous@undisclosed.example.com) — 2018-07-02T03:54:59+00:00

Nullable Datatypes Contrary to VO, many datatypes in the .NET Framework don't allow null values. One of the most important ones is the DataTime class, that cannot have a null value, contrarily to VO, where a date variable can contain null_date. In the .NET Framework there is the

other_vo_compatibility

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T04:46:50+00:00

VO compatibility issues * Naming conflicts * Createinstance and Libraries * Begin - End Sequence * VO ErrorBlock * Assign cannot have a return value in .NET * VO methods are virtual * Binary content in DBF files * Other issues * VO functions translated to .NET * Compare symbols to numerics * .NET Structure and VOStruct * Advantage Database Server * Disabled warnings by Xporter/VO * _dll function changes * RT_MANIFEST constant * Start() function needs the [STAThre…

other_vo_to_x_issues

Anonymous (anonymous@undisclosed.example.com) — 2018-03-20T07:37:03+00:00

Other compatibility issues There are a lot of small issues. Some of them should be listed here: * You are using a method Open() in any of your VO windows classes? This will not compile anymore because the Window class has a variable oPen that conflicts with this method name

preprocessor

Anonymous (anonymous@undisclosed.example.com) — 2018-02-14T04:52:50+00:00

The Preprocessor The preprocessor is an unique feature of the X# compiler. In the Clipper times, the preprocessor was used to implement the commands (they were mapped to function calls), and in the VO times the preprocessor was present, but very few people used it.

property

Anonymous (anonymous@undisclosed.example.com) — 2020-08-28T04:04:41+00:00

Property The property statement can have different forms in X# (it is the .NET equivalent for access/assign in VO). The “full” version (read and write): property MyProp as string get return _cMyProp end get set _cMyProp := value end set end property

quickstart_xsharp_vo

Anonymous (anonymous@undisclosed.example.com) — 2019-03-08T16:48:12+00:00

How to start with X# if you are a VO programmer If you are a VO programmer, these tips can be helpful to you. * X# comes with an (optional) IDE that is similar to the Visual Objects IDE. So if you are not familiar with Microsoft Visual Studio, starting with XIDE may make learning easier.

read_file_stream

Anonymous (anonymous@undisclosed.example.com) — 2018-01-27T20:44:20+00:00

Read a file using a stream If you need to read a larger file and process it during the read, you should use a stream for it. This is largely used when reading or writing in the network using internet protocols. This is a sample how to read a file using a stream:

read_file

Anonymous (anonymous@undisclosed.example.com) — 2018-01-27T20:35:48+00:00

Read a file If you need to read or write to files and wish to keep the entire file in memory, you can use the static methods of the System.IO.File class: (the following static methods are only a small fraction of the functionality this class offers - please read the full documentation of this class!)

rt_manifest_constant

Anonymous (anonymous@undisclosed.example.com) — 2018-09-04T03:49:30+00:00

RT_MANIFEST constant In VO (and Vulcan.NET) the RT_MANIFEST constant is defined as follows: DEFINE RT_MANIFEST := PTR (_CAST,24) In VO, this may work (but there are cases where it seems to not work correctly, i.e. the builtin manifest is not correctly recognized correctly when it comes to load COM modules in SideBySide operations), but the X# compiler will return an error:

scope

Anonymous (anonymous@undisclosed.example.com) — 2018-05-09T11:33:44+00:00

begin scope .... end scope The begin scope .... end scope statement let you restrict the variable visibility to a defined part of your program. begin scope local cVar as string cVar := "Hello X#" System.Console.WriteLine( cVar ) end scope System.Console.WriteLine( cVar ) // compile error here

start_function

Anonymous (anonymous@undisclosed.example.com) — 2018-10-29T10:07:13+00:00

Start() function needs the [STAThread] attribute The Start() function in migrated VO applications needs to have the [STAThread] attribute: [STAThread]; function Start() as void If this attribute is not set, you may experience strange crashes. As sample: when opening a printer selection dialog in an application without this attribute the application crashed. After adding the attribute, the printer selection dialog showed up correctly and the application does not crashed anymore.

start

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T06:37:36+00:00

Welcome to the X# Documentation Project! Here we are collecting samples and documentation about the X# Language. If you don't know what X# is, please see www.xsharp.info * X# Online Documentation * Where to find Help * Language syntax basics * Extended syntax samples * The dialects * GUI choices: VO GUI, WinForms, WPF * Application type samples * How to start with X# for VO programmers * Status of VO Addons for X# * Migration from VO (Visual Objects) to X# * Migration fr…

string_char_byte

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:04:18+00:00

String, Char and Byte In .NET every string is Unicode. That means that a string of 10 characters has not more 10 bytes like in VO, but normally has 20 (2 byte per character). And the second, not less important issue: when converting between binary data and strings you need to care about

stringbuilder

Anonymous (anonymous@undisclosed.example.com) — 2018-01-27T20:57:26+00:00

The StringBuilder If you are processing strings, of course you can concatenate them using the + operator: cString := "Hello" + " " + "from" + " " + "my" + " " + "X#" + " " + "program" But if you are building longer strings, composed by many substrings, you should use the

stringformat

Anonymous (anonymous@undisclosed.example.com) — 2019-07-30T10:02:11+00:00

String.Format This static method of the System.String class is very, very useful. It permits you to insert values into a string, like in this sample: cString := String.Format( "Today is {0}", DateTime.Now:ToShortDateString() ) . You can also control the formatting:

strings_codepages

Anonymous (anonymous@undisclosed.example.com) — 2018-11-09T07:53:18+00:00

Strings and codepages or "The Unicode Advantage" This article is a copy of the article on the X# website, written by Robert v.d.Hulst. Introduction We have been quite busy creating the X# runtime. And when we did that we stumbled on the problem of bytes, characters, codepages, Ansi and Unicode. X# has to deal with all of that and that can become quite complicated. That is why we decided to write a blob post about this. In this post we look back to explain the problems from the past and how th…

strings

Anonymous (anonymous@undisclosed.example.com) — 2018-10-06T05:09:43+00:00

Strings and their prefixes A string in X# is delimited by the double quotation mark: cString := "this is a string" This is valid for the VO, Vulcan and Code dialects. In the VO dialect a string can also be delimited by the single quotation mark: cString := 'this is a string'

trycatch

Anonymous (anonymous@undisclosed.example.com) — 2018-08-20T04:05:35+00:00

Try - Catch The Try - Catch block is very important, and should be used where an error can occur, for example if a file that needs to be read does not exist, you are specifying an invalid path, the current user has not the rights to read and so forth - please read the documentation about

tuples

Anonymous (anonymous@undisclosed.example.com) — 2018-02-10T08:28:24+00:00

System.Tuple The System.Tuple class can be used to hold different objects, it is like a list with predefined data. A tuple is very useful when you need fixed groups of data and don't like to define a own class for it. To define and to create a tuple you need generics.

using

Anonymous (anonymous@undisclosed.example.com) — 2018-04-22T11:10:57+00:00

The using statement is very useful if you are working with objects that need to be disposed by the garbage collector at a defined point. using System.IO using System.Text function Start( ) as void local cFileName as string local aBytes as byte[] cFileName := "c:\temp\Using.txt" System.Console.WriteLine("start working with" + cFileName ) begin using var oFile := FileStream{ cFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite } // as FileStream …

virtual_methods

Anonymous (anonymous@undisclosed.example.com) — 2018-06-07T07:25:37+00:00

All VO methods are virtual If you receive the warning Warning XS0108 'MySon.MyMethod()' hides inherited member 'MyFather.MyMethod()'. Use the new keyword if hiding was intended. please check the compiler option /VO3 Virtual Instance Methods or add the keyword

vo_addons_status

Anonymous (anonymous@undisclosed.example.com) — 2021-03-30T05:22:05+00:00

Status of VO Addons for X# * ReportPro: The maintenance for ReportPro was taken over by the X# development team. You have to be a member of the FoX program and send a documentation of your ReportPro purchase to the development team and you will have access to the current X# version for ReportPro 2/3 (and the enhanced VO version too)

vo_errorblock

Anonymous (anonymous@undisclosed.example.com) — 2019-08-31T14:46:50+00:00

The VO ErrorBlock The VO ErrorBlock() function gives the possibility to set a global error handler. Unfortunately, in .NET this is not more possible as the CLR (the Common Language Runtime) does not supports such a feature. In a .NET application you need to make extensive use of

vo_to_xsharp

Anonymous (anonymous@undisclosed.example.com) — 2021-03-30T05:24:24+00:00

Migration from VO (Visual Objects) to X# * Hints for a successful migration * Compile errors in the migration process * Hints for a better use of VO Xporter

vogui_with_winform

Anonymous (anonymous@undisclosed.example.com) — 2019-10-14T19:11:03+00:00

A VO GUI application with a Windows Forms window Thanks to the work of Paul Piko there is the possibility to add a WinForms to a VO GUI application. These are the steps: * Instead of using the “normal” App class from the VO GUI classes use the VOWinFormApp class (contained in the X# VO

vulcan_compatibility

Anonymous (anonymous@undisclosed.example.com) — 2018-05-29T06:16:49+00:00

Vulcan.NET compatibility issues Some things are different in X# than in Vulcan.NET. * String delimiters * Defines

vulcan_to_xsharp

Anonymous (anonymous@undisclosed.example.com) — 2018-02-01T23:39:21+00:00

Migrate an existing Vulcan.NET application to X# This chapter contains the steps you must take to have an existing Vulcan run in X# with the least amount of work. You may not need to do all steps, and the few errors I got and solved you may not see at all, while some others errors may occur in your project. But in general, if you are aware of what is described below, the Vulcan to X# conversion can be done very quickly.

where_to_find_help

Anonymous (anonymous@undisclosed.example.com) — 2018-04-15T14:30:05+00:00

Where to find help Unfortunately it is not easy to find the right source for help and documentation. This is caused mainly by the fact that X# is very open and can use functionalities from different worlds. * The X# language itself: in the X# language documentation, and because it is not yet complete, sometimes also in the Vulcan.NET help file

winforms_databinding_sample

Anonymous (anonymous@undisclosed.example.com) — 2018-07-29T05:28:51+00:00

WinForms Databinding The databinding in WinForms is not so advanced like the databinding in WPF, but it is possible. The data object on which the controls content can be bound (usually called ViewModel in MVVM terms) needs to implement the INotifyPropertyChanged

write_exception_log

Anonymous (anonymous@undisclosed.example.com) — 2018-03-25T17:52:28+00:00

Write an exception to a log file The following code writes the passed exception to a file named XSharpError.log in the application directory. If this file exists, the error is appended, otherwise the file is created first. static class ErrorHandling static method WriteErrorLog( oException as Exception ) as void local cFileName as string local oSB as StringBuilder cFileName := Path.Combine( AppDomain.CurrentDomain:BaseDirectory, "XSharpError.log" ) oSB := StringBuilder{ String.Format( "Error o…

xbase_dialects

Anonymous (anonymous@undisclosed.example.com) — 2020-02-03T07:02:33+00:00

xBase Dialects The xBase family of languages comes from Ashton Tate's DBase product. There were several descendants, and only some of them have retained importance. DBase was a database environment. Code was not compiled, but present with sources, and to execute DBase programs, a license of the product was needed.

xide_editor_filetypes

Anonymous (anonymous@undisclosed.example.com) — 2018-01-25T12:20:10+00:00

Specify an editor for some filetypes If you don't like to use XIDE's internal editor for some filetypes, you can attribute an external editor. Simply edit the XIDE.cfg file in your main XIDE folder, and add entries in the [FileTools] section. If this section does not exist, add it.

xide_extend_toolsmenu

Anonymous (anonymous@undisclosed.example.com) — 2018-01-25T12:17:06+00:00

Extend the Tools menu in XIDE To add own utilities on the XIDE Tools menu, you need to edit the Config\Toys.cfg file in your XIDE folder. This a sample of such a configuration: MENUENTRY=Windows API help file EXECUTE=C:\cavo28\Help\win32sdk.chm SEPARATOR MENUENTRY=Vulcan At Warp Speed EXECUTE=C:\Program Files (x86)\Vulcan.NET 4.0\Doc\Vulcan.NETAtWarpSpeed.pdf MENUENTRY=ADS Help EXECUTE=C:\CAVOTOOL\advantage.chm MENUENTRY=VO-xPorter EXECUTE=C:\XSharp\Compiler\VOXPorter\VOXporter.exe

xide_navigate

Anonymous (anonymous@undisclosed.example.com) — 2018-03-07T04:53:23+00:00

How to navigate in XIDE * Alt+C opens the classes navigation combobox, there you can quickly select the desired class * Alt+G opens the entities navigation combobox, to quickly navigate to entity in the class * Alt+Up goes to the previous entity

xide_placeholders_prebuild

Anonymous (anonymous@undisclosed.example.com) — 2018-01-26T15:06:19+00:00

Placeholders and Prebuild/Postbuild events For Prebuild and Postbuild events in XDIE the following placeholders are available: * %NETSDKPATH% * %OUTPUTFILE% * %OUTPUTPDB% * %OUTPUTPATH% * %ProjectOutputPath% * %AppPath% * %ProjectPath%

xide_plugin_sample

Anonymous (anonymous@undisclosed.example.com) — 2018-01-26T05:17:04+00:00

A sample XIDE plugin Here you can find a complete sample for an XIDE plugin with some useful functions. For a short description how a plugin works please see here: The XIDE plugin system. This plugin has the following functions: * Insert a textblock at cursor position (textblocks can be defined as prg files)

xide_plugin_system

Anonymous (anonymous@undisclosed.example.com) — 2018-01-26T05:05:58+00:00

The XIDE plugin system XIDE comes with a possibility to easily enhance it. Here you can find a complete sample (binaries and source) to use and maybe to enhance. The core of a plugin is to define a class that inherits from Xide.PluginSystem.Plugin and implements the

xide_reference_templates

Anonymous (anonymous@undisclosed.example.com) — 2018-01-25T12:05:59+00:00

Reference Templates To simplify the addition of references to a project, you can add your own references groups to XIDE. Simply edit the file Config\References.cfg in your XIDE folder and add what you like. This is a sample for WPF applications: NAME = CLR4 WPF FF = CLR4,PresentationCore FF = CLR4,PresentationFramework FF = CLR4,System FF = CLR4,System.Core FF = CLR4,System.Data FF = CLR4,System.Windows FF = CLR4,System.XAML FF = CLR4,System.XML FF = CLR4,WindowsBase

xide_select_framework_version

Anonymous (anonymous@undisclosed.example.com) — 2018-01-26T15:32:15+00:00

Select a specific .NET Framework version for an XIDE project Unfortunately, XIDE hides the .NET Framework selection from the user and uses the newest one available on the developers machine, but fortunately it is possible to change - maybe to build an executable that runs on Windows XP where only .NET 4.0 is available.

xide_viaef_file

Anonymous (anonymous@undisclosed.example.com) — 2018-03-13T04:34:10+00:00

What to do with a .viaef file XIDE is organized in projects like VO. But the “Empty project” that XIDE shows at the first start can be used only for standalone prg files, but not for applications. As said, XIDE has projects, and every project can contain from zero to many applications. Contrarily to VO, projects can contain not only applications, but also application groups to better organize the applications in the project. XIDE knows two different export files:

xide

Anonymous (anonymous@undisclosed.example.com) — 2018-03-13T04:26:45+00:00

XIDE Use Cases The articles in this section show how to accomplish some things in XIDE. Most of them are not documented elsewere, but were explained by the author in private mails. * What to do with a .viaef file * Reference Templates * The Plugin System * A sample for a XIDE plugin, complete with sources * Placeholders and Prebuild/Postbuild Events * Extend the Tools menu with own utilities * Configure an external editor for file types * How to select a specific .NET Framework…

xporter_disabled_warnings

Anonymous (anonymous@undisclosed.example.com) — 2018-08-27T05:35:20+00:00

Disabled warnings by Xporter/VO When moving a VO application over to X#, the Xporter/VO disables some warnings. These are: * 9032 This entity type cannot return a value. Return value ignored. * 9043 Function or type '{0}' is ambiguous. Could be '{1}' or '{2}'. Using the first one.

xporter_hints

Anonymous (anonymous@undisclosed.example.com) — 2021-03-30T05:42:13+00:00

Hints for use of the VO XPorter The VO XPorter does a very good job migrating your VO code to X#, but of course it cannot fix all your code in the porting process. There are some constructs that are not compatible between X# and VO. If you need a continuos migration process where the VO version of your software continues to evolve, then you should make all your changes on the VO side, and there are some possibilities to keep code different between VO and X#.

xsharp_dialects

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T07:22:03+00:00

The dialects X# has introduced a new term in the world of .NET programming: the dialect. Why this? The Xbase language that was started with DBase in the MS-DOS days has several descendants, evolved each on its own, and with different syntax. Since X# was started with the intention to give a future to all or several of them, a sort of a switch is needed to differentiate them from each other.

xsharp_service_sample

Anonymous (anonymous@undisclosed.example.com) — 2018-07-29T06:14:39+00:00

Windows Service Sample X# is very well suited for Windows Services. A Windows Service is a GUI less application that runs in the background of any Windows machine, and even without any logged in user. Therefore services are well suited for background tasks.

xsharp_sites

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T07:26:24+00:00

Sites around X# * www.xsharp.info - The X# Project homepage * docs.xsharp.it - The X# Documentation Project * www.fabtoys.net - Fabrice Foray's tools, also for X# * enotes.xsharp.it - Phil Hepburns eNotes collection * www.xsharp.it - X# Italian site * www.riedmann.it - Samples and documents for X# and Vulcan.NET If you know other sites that should be added to this page, please let us know.

xsharp_story

Anonymous (anonymous@undisclosed.example.com) — 2024-09-11T07:16:30+00:00

The Story of X# The origin of the X# Project has to start many years ago in the MS-DOS area with DBase III (Wikipedia). DBase III was a database with a integrated language and it was very easy to write applications with it. But it had a few drawbacks: it was slow because interpreted and every user needed a licence of the product. Therefore a few software houses created compilers of this language to make the programs faster an run standalone. One of this new products was FoxPro (

yield

Anonymous (anonymous@undisclosed.example.com) — 2018-04-22T10:20:10+00:00

yield permits to return a part of a result in a executing loop. Please look at the following code that does not uses yield: foreach cFile as string in GetFiles( "c:\" ) WriteLine( cFile ) next return function GetFiles( cFolder as string ) as List local aFiles as string[] local oFiles as List WriteLine( "start creating list" ) oFiles := List{} aFiles := Directory.GetFiles( cFolder ) foreach cFile as string in aFiles oFiles:Add( cFile ) next WriteLine( "end creatin…