Fabrice Foray Track Summary
Introduction to Visual Studio General - First use from the VO Repo-based perspective
- Editor, Settings, jump to code and more (XMLDoc, Hints, Parameters, ...)
- References and NuGet
- Using Git as Version control
- Extensions add
Migrating Visual FoxPro apps to .Net with X# VFP - Compare VFP and X#, from a VO-based developer point-of-view ;)
- First use of the VFP Xporter : How it works, Settings, What you can expect
- Common troubles, Third parties
- Make your way in your new code
Stefan Hirsch    
Web Applications with X# Backend and VueJS Frontend General First I will show our complete product with its current development state.
Then we will look into the backend part and go through the whole workflow. Starting with configuring
the server, loading plugins, loading scripts, adding routes, starting the server. After the server startup
we look into the request handling that can be done in a plugin or by an X# script. Here we will have a
look into scripting, how we merge scripts, call them with parameters and get return values. After that
we will build a little demo project that can host a web site and can handle some GETs and POSTs for data
fetching and data putting.
In the second part we will focus on the frontend part. We will have a look into the structure of our vue
application, with all the components, store, helper functions, how we handle plugins and the build
process. Then we will start building a demo project from scratch using VisualStudioCode. Vuejs and
vuetify will be used as our frameworks. We will build a simple frontend with some data fetching and
data putting.

- Grapevine (REST-server engine) https://github.com/scottoffen/grapevine-legacy
- NewtonSoft.Json (Json data handling) https://github.com/JamesNK/Newtonsoft.Json.git
Compiler: X#

Nikos Kokkalis    
The evolution of X# core General A lot of effort is devoted to the various dialects, but I think it's nice to have a session about X# core. Maybe talk about integrating new C# features, or come up with something new. And perhaps showcase some work-in-progress?
Fun things to do (with dotNET) on a rainy day General This will be about some advanced topics. May include some things on multithreading, async, performance optimizations, but will also talk about things internal to dotNET and the CLR.
Peter Monadjemi    
Asynchronous programming with X# General "The world is asynchronous"
In this presentation, Peter will show examples for using the keywords async and await and the underlying task class with Winforms applications. Both keywords are probably still new for the majority of the X# developers. He will also point out a few of the base library classes with asynchronous methods based on tasks.
Using asynchronous technique leads to user interfaces that are more responsive, don't freeze that often, and to applications with a better overall performance.
Although for WinForms application there are simpler alternatives like the BackgroundWorker class, when it comes to mobile applications using async and await becomes obligatory (maybe I can present an C# or X# example that uses .Net 8 and MAUI).
Chris Pyrgas    
Migrating Visual Objects Apps to .Net with X#, Part 1 & Part 2 (with Robert) VO This session will show how to migrate Visual Objects applications to .Net with X#. It will cover:
- The VOXporter and the options available for migrating your apps
- Using the converted application in XIDE  (Chris)
- Using the converted application in Visual Studio (Robert)
- Common problems found when converting applications from VO

Please note that the contents of this session is VERY flexible. When there are only "experienced" X# attendees, we can change this session into a tips and tricks session targeted at VO developers.
Wolfgang Riedmann    
Gui Choices for VO Programmers VO You have VO applications, maybe some of them ported to X# and would like to build new applications in X# and you don’t know what type of GUI to use?

This session cannot give an answer, but can give you some oversights over the choices you have and gives you a sample application for every type shown.

Starting from a simple VO application based on DBF tables you will see possibile developments from a simple migration to a WPF application.

Andrej Terkaj    
Building MAUI applications with Blazor and X# in the backend. General Andrej will show the way to use X# in apps that will look much fresher to the younger generations than the established windows forms GUI.  We will step into .NET 7 with X# Core dialect. We will also get an insight into modern environments where different programming languages can be mixed (X#, C#, CSS, HTML and JavaScript).

Furthermore, we'll learn what's behind the word MAUI and whether we can use X# to build apps for Android, iOS, Windows and Mac Catalyst operating systems.  We will build a simple application that will be installed on a smartphone and that will allow to edit data from a MySQL database on a remote server. We will also learn how to create web services and how to do CRUD operations on data so retrieved.

Robert van der Hulst    
Introduction to the X# SQL RDD General There were many requests from the VO community to add an RDD to X# that you can use to access data from SQL database. This RDD, so is the idea, could be used to replace ADS (Advantage Database Server), since SAP is no longer actively supporting this product.
In this session Robert will show the upcoming SQL RDD for X#. This RDD will allow you to:

- Select data in "Query Mode" with a select statement

   DbServer{"Select * from Customers"}
   USE "Select * from Customers"

- Select data in "Table Mode"

   USE Customers

In Query mode, the RDD will fetch all the data from the server into a read only local cursor. You can use normal Xbase filtering on that result set and also create local indexes.

In Table mode, the RDD will build select statements to fetch the data from the database. By default, it will not fetch all rows (you do not want to fetch a million rows from a server) but will limit the # of returned rows. Through a callback mechanism, you can control the behavior of the RDD.

The RDD is not written for a specific SQL backend. Syntax differences between various backends are handled with a special layer, where for example the syntax is defined to limit the # of rows (SELECT TOP for SQL Server, LIMIT for MySql, using ROWNUM in Oracle etc.)

In this session, Robert will demonstrate the new RDD and will show and discuss the design.

Creating apps for the Web and Mobile using Blazor and FoxPro VFP In 2022, Microsoft introduced a new style of developing applications for the Web, as well as for mobile devices, using a product called Blazor. Blazor apps can run on any web browser using a technology called WebAssembly, server-side in ASP.NET Core, or in native client apps. Blazor front ends are usually coded with a mixture of Razor and C#. However, Blazor apps can also call code developed in other .NET languages, such as FoxPro code, compiled for .NET with X#.

There is A LOT of learning material about Blazor on the web already. This session will present an overview and will explain the differences between server side apps (running in ASP.NET Core) and Blazor WebAssembly apps.

We will also show how you can run FoxPro code in an XSharp layer behind the Blazor apps to use existing business logic for new applications. This code will be running from a web server. This means that some things are allowed, but other things not. We will look at some issues you can expect.

We will also look forward to a new version of Blazor that has been announced (Blazor United). This new version can be seen as a mix between Blazor Server and Blazor Client, where some components are running on the server, but other components are running on the client.

You will learn:

  • What Blazor is
  • The difference between Blazor Server and Blazor Web Assembly
  • How to call FoxPro code from a Blazor application
  • What can you do in the code behind the Blazor app and what you can't
  • What is coming with respect to Blazor in the not-too-far future

Opening Session & Closing Session


Various customers


Application Show

General During this session, various customers will demonstrate the programs that they created with X# and explain some of the decisions that they have made during the migration process.

X# Summit Memmingen 2020


In October 2022 we are organizing our first European conference in years. We first tried to do this in 2020, but due to the international Covid crisis that event had to be cancelled.

Since we are a small open source project and we have limited financial resources, we have chosen to organize this as a relatively low budget event. We have also chosen a location in the south of  Germany, so developers from Switzerland, Austria and North Italy are also able to come with a reasonable travel time.

The main audience for this event is XSharp developers with  VO/Vulcan background. However we will also spend ample time on the other dialects.

We will present the current state of the X# development and show how to migrate your apps to XSharp. We will also discuss the internals of X# and how you can extend X#. Finally we will discuss our future plans, such as our support for next versions of .Net and will show some of the work in progress

With the help of our local partner Karl Faller we have selected a venue for the event.

This summit is structured to encourage open and facilitated face-to-face discussion and idea sharing amongst all attendees. Refreshments will be provided all day with scheduled lunch and snack breaks.


The event will take place at the following hotel:

   Hotel Weisses Ross       Hotel Weisses Ross
Kalchstr. 16
87700 Memmingen



Speaker Bio

Wolfgang Riedman

Wolfgang Riedmann is the founder of the small software house Riedmann GmbH in Meran, South Tyrol , Italy, specialized in individual software development.

After working in Cobol on a mainframe, he started to work in Clipper, and then in VO starting with the long awaited prerelease. When X# was presented, he put in production the first small applications written in this language, and today more than the half of ist work time is done in X# using XIDE.

Wolfgang wrote also some articles in the Software Development Techniques journal, and spoke also on some VO and X# conferences.

Living in Italy, but with German mother language, he also has connection in both the German and the Italian X# and VO community.

Meinhard Schnoor

Meinhard is working as a self employed IT consultant. He has studied computer sciences and has over 40 years of experience in the area of software development. Starting his programming career with Pascal, Assembler and Cobol, he adopted the xBase languages beginning with Ashton Tate's DBase environment and moved early to the Clipper compiler in summer 87.
In these years he began to become an expert in Clipper 5.x and then CA's Visual Objects Environment and it's successors. Nowadays he's mainly working with Microsoft's .Net universe, Visual Studio and #X as well as C#.

Andrej Terkaj

Andrej Terkaj, Bachelor of Mechanical Engineering , born and living in Slovenia..

I started my professional career in 1980 as a software project manager in Iskra Delta, the largest Slovenian computer company to date.

In 1987 I founded private company Task Ltd, where I was not only the owner, but mainly a software developer.

After more than 30 active years in the development of software for the logistics and maintenance sector (Computer Maintenance Management System Radix ) I closed Task Ltd. in 2018 as my retirement was approaching.

I am a long-time VO developer, since the very beginning of Visual Objects, and before that I used other programming languages: Nantucket Clipper, Ashton Tate dBase, Borland Turbo Pascal and Fortran.

Within the Visual Objects programming language I also used bBrowser and VO2Ado to be able to successfully manage data for different relational databases, most of them MS SQL Server

I've taken programming as part of my life, so now I'm even more immersed in modern programming tools.

Fabrice Foray

After a first encounter with personal computing and a Tandy TRS-80 in the early 80's, it was the use of Clipper 86 that led me to xBase languages. I have been teaching computer science in France for more than 30 years, especially with C++, Java and C# languages, and at the same time I continued the xBase adventure with CA-Visual Objects, Vulcan.Net and finally XSharp!

Nikos Kokkalis

Nikos Kokkalis studied Computer Engineering at the Democritus University of Thrace, and there also earned his doctorate. He has worked as an independent software developer since 1996 for Anadelta Software and Intracom Telecom. Since 2016 he is an employee of Intracom Telecom. During 2011 - 2015 he was a member of the GrafX development team. Since Sept. 2015 he has been a member of the XSharp development team.


Robert van der Hulst

Robert van der Hulst (The Netherlands) has been part of the IT industry since the 80's. He started developing applications in DOS with dBase, Clipper and FoxBase, C and Assembler. Later he developed applications for Windows and .Net with C/C++, Visual Objects, Vulcan.Net, Visual FoxPro, and C#.

Robert has created several 3rd party components for Visual Objects and Vulcan developers and has been part of the Visual Objects and Vulcan.Net development team, and worked there on the compiler, IDE, runtime and RDD systems.

In 2015, Robert founded the XSharp (X#) Project , together with Fabrice Foray (France), Nikos Kokkalis (Greece) and Chris Pyrgas (Greece). They were all colleagues from the former Vulcan.Net development team who decided there was a need for an open source implementation of XBase for .Net.




Wolfgang Riedmann
SQL Data Access in .Net

Often programmers think that SQL is SQL and that there are no big differences. Unfortunately this is not correct, and since I have programming experience with several big SQL database engines, I will first present an quick overview of some of the most used products and their strengths and licenses (open source and commercial).

Then I will show some differences than affect the programming with these and that need to be respected when working with them.

As last part, I will show an approach how to build libraries with a simple common interface that is able to mask some of the differences between the different engines.

Of course, the sources of these libraries will be shown and will be available for download after the conference.

Andrej Terkaj

I am very happy with the opportunities I have to acquire the latest knowledge in software development. I have finally found the environment I have been looking for more than 10 years, so that I could at least partially use my "old Visual Objects" - tested code and move it to a web applications.

The main purpose of my talk will be to introduce you to the possibilities of web development with the X# programming language. Yes it is written correctly. X# in a web environment. It might be better to write X# and Blazor together. The Blazor environment is the one that will show us that this is also possible. There is nothing written in the literature or in the media about this. Personally, I came up with the idea of trying X# in the Blazor environment, because Blazor is based on C# and C# is based on the .NET (code name Roslyn) compiler platform. And Roslyn is a set of open source compilers and APIs not only for C# but also for X#.

I'll show a concrete example that will demonstrate a simple working application using X# Core dialect and migrate it to the Azure Service Cloud. We will show how different programming languages (from X#, C#, HTML, CSS, javascript) can interact with each other and how a small application is visible on different operating systems and devices (including Android and iOS). In this example, we will perform simple CRUD operations using different methods of accessing the SQLite database. Last but not least, we will finally demonstrate the correctness of our choice of Blazor framework in the latest MAUI environment.

My last goal for this talk is to say: it's never too late to learn new technologies. My topic will offer you the possibility or the way to use X# in apps that will look much fresher to the younger generations than the established windows forms GUI.

Now you have the chance to put on your the .Net Core big boots and try to jump as many high steps as possible.

Meinhard Schnoor
How to use X# in VO using COM Servers as SxS Components
Meinhard demonstrates how to develop COM components in X# and how to use them in Visual Objects. The main focus will be on the development of the components and best practices according to Microsoft. The second part of the session will concentrate on how to make the written components usable in VO by applying the Microsoft's side by side technology, so it will not be necessary to install these components. Instead he will demonstrate the use of manifests so these components can be xcopy deployed with you VO application.
How you should do logging and error handling in X# (.NET)
When moving your development from Visual Objects to the .Net world, you open the door to a complete new cosmos. Looking into the projects of a lot of my customers, I often see that the concept of logging is not present or at least neglected. Meinhard will show how to introduce this in your own programs, by using available packages from the .Net universe. The second part will address exception handling. Lots of X# programmers still use the mechanisms delivered by Visual Objects (Begin Sequence Recover) and ignore the new technology completely. Meinhard will show why this is not a good idea and demonstrate how to achieve this by adopting the new language constructs in X#. By applying widely accepted best practices you will learn how to enhance you error handling to the next level.
Fabrice Foray
Migrating Visual Foxpro Projects to X#

Showing VFPXPorter application; How it can move Forms & Projects of a VFP Application to XSharp, WinForms and Visual Studio projects. What changes it implies, some common troubles we may have and how to solve them.

Nikos Kokkalis
Runtime code sorcery with X#

Working with scripts in X#: taking advantage of the compiler and macro compiler.
How to script and why. Interacting with scripts. Exposing APIs and security concerns.
Analyzing code and finding problems. Code generation.
All these and more in a session about programmatically working with source code.

Robert van der Hulst
.Net Next

So far the most of us have created applications for the .Net Framework.
Parallel to the .Net Framework there are several other versions of .Net, for example .Net Standard, .Net Core, .Net 5, .Net 6 and .Net 7. There were also .Net versions for other platforms, such as Mono and Xamarin.

This session tries to put these various implementations of .Net in perspective and will show you how you can use X# for these various targets.
We will also look at the X# build system and how you can create applications for these different target platforms.

X# Runtime Advanced Tips and Tricks
During this session Robert will demonstrate some of the "new" and not very well known features that were added to the X# Runtime. Some examples are:
- Workarea Events
- Event handlers that repond to changes in settings inside the Runtime State
- Subclassing X# RDDs
- How does the X# Runtime handle multi threading. What about open workareas? What about the runtime state?
- and more
X# Development Team

Opening Session & Closing Session


Various customers

Application Show

During this session various customers will demonstrate the programs that they created with X# and explain some of the decisions that they have made during the migration process.

Session Schedule

Here is the (preliminary) session schedule for our summit in Memmingen, 2 weeks from now.

From  Until Topic Speaker
09:00 09:15 Welcome and opening X# Devteam
09:15 10:30 SQL Data Access in .Net Wolfgang
10:30 10:45 Break  
10:45 12:00 How to use X# COM Servers as SxS Components Meinhard
12:00 13:00 Lunch  
13:00 14:15 X# Runtime Advanced Tips and Tricks Robert
14:15 14:30 Break  
14:30 15:45 Runtime code sorcery with X# Nikos
15:45 16:00 Break  
16:00 17:15 Application Show Various attendees
17:15 18:30 Break + City Tour  
18:30 20:00 Dinner  
20:00 23:00 Evening program  
From  Until Topic  
09:00 10:15 Converting FoxPro code to .Net Fabrice
10:15 10:30 Break  
10:30 11:45 How you should do logging and error handling in X# (.NET) Meinhard
11:45 12:00 Break  
12:00 13:15 Using X# in web applications - Blazor & X# Andrej
13:15 14:15 Lunch  
14:15 15:30 .Net Next Robert
15:30 15:45 Break  
15:45 16:45 Closing session X# Devteam


To register for this event, please send an email to .

We have the following registration fee for the event:

Description FOX
- Early bird (book before September 2022) 350* 400*
- Normal price (starts September1, 2022) 450* 500*
  • This includes the refreshments, lunch and dinner on the 6th and refreshments and lunch on the 7th.
  • We expect people to arrive on Wednesday October 5.
  • We have negotiated a special discounted hotel room price of EUR 90 per person per night including breakfast for a Single room. Double rooms are available at EUR 137 per night including breakfast. Local taxes may apply. You can book directly with the hotel https://www.hotelweissesross.de/. and tell them that you are part of the X# Summit group.
  • Room are available from Wednesday 5th until Saturday 8th.
  • For those attendees that are staying until Saturday 8th, we plan to go out and have dinner together on Friday 7th in a restaurant in Memmingen.
  • Please note that all prices are excluding 21% VAT for EU residents. If you register as a Company and let us know your VAT number then we will not have to charge the VAT.


Today we have released an installer for our FOX subscribers only for XSharp Cahors 2.13 which contains some fixes for problems reported with X# 2.12, and some new features.

The what's new document describing all the changes can be found here:

{rsfiles path="fox/Compiler/XSharpSetupFox2.13.0.7.zip"}

A public release is planned for next week.

We had promised a X# 2.13 release "end of July"
We were about to release this build to our beta testers, but we found some last minute issues, mostly in the VS integration.

Since some of our team members are going for a short, well deserved, holiday, we will delay this build for a couple of weeks.
If you are "deperately" waiting for some of the new features, please contact us.
We can still give you the current installer, but there are a few "known issues" that some people may see as "show stoppers".

We think it is time for a progress update and a preview of what you can expect the rest of this year from us.

When What
End of July 2022 A new build X# 2.13 for our FOX subscribers.
This build will have some changes to the compiler, mostly in the area of the handling of DEFINES and numeric conversions and the /vo4 and /vo11 compiler options.
No real new features are planned for the compiler.
The runtime contains some fixes for FoxPro code and contains some small enhancements.
The VS Integration contains improvements in the formatting and intellisense, Windows Forms editor
End September 2022 We plan to release a new build (most likely called X# 3.0) that is compatible with .Net 5 and beyond.
This requires changes to the build system and VS integration and some changes to the compiler.
We will also additional compile the X# runtime for .Net 5 and beyond.
This build will also no longer be "binary compatible" with X# 2, so new versions of 3rd party components will be needed.
Of course we will still support .Net Framework 4.x
We also plan to release the first version of the VFP Xporter  that takes a VFP project file and converts that to a .Net solution.
October 2022 We hope to meet many of you during our X# summit in Memmingen.
And you can still register for this event.
We will also present a session on Virtual FoxFest about converting FoxPro apps to .Net.
December 2022 We plan to release the final version of the AnyCpu/Unicode VO Compatible GUI Classes and the AnyCpu/Unicode VO Compatible SQL Classes.
A first beta version of the X# SQL RDD is also planned for this month
These runtime components will be for FOX subscribers only.

Today we have released a public installer for XSharp Cahors 2.12.

The what's new document describing all the changes can be found here:

The public installer can be downloaded here.

{rsfiles path="installers/XSharpSetupPublic2.12.2.0.zip"}

We have also updated the installer for the FOX version of 2.12.

{rsfiles path="fox/Compiler/XSharpSetupFox2.12.2.1.zip"}

We have made the following changes in this installer (these changes are also included in the public version)

  • Restored support for VS 2022, versions 17.0 and 17.1
  • Fixed an issue in the VS integration that would cause problems with TFS
  • The runtime help for functions and methods with CLIPPER calling convention (such as the Str() function) has been updated.

If you have downloaded before and you do not use VS 2022 version 17.0 or 17.1 and you do not use TFS then you do not need to download this update, unless you want to get the updated help file.

Today we have released an installer for our FOX subscribers only for XSharp Cahors 2.12 which contains some fixes for problems reported with X# 2.11, and some new features.

The what's new document describing all the changes can be found here:

{rsfiles path="fox/Compiler/XSharpSetupFox2.12.2.1.zip"}

A public release is planned for next week.


You have not heard from us in a while, but that does not mean that we have been idle.
We are finalizing the 2.12 build of X# at this moment that comes with several changes that people have asked for:


  • TEXT .. ENDTEXT support in all dialects. We have change how this command is implemented to make it as flexible as possible. The TEXT .. ENDTEXT is a UDC that is translated to a #text .. #endtext preprocessor directive. You will have the ability to change how this command works.
  • We have added a new compiler option (/vo17) to make the BEGIN SEQUENCE commands more compatible with Visual Objects. Commands with a RECOVER USING statement were "swallowing" exceptions in the past. With this option the exceptions will be sent to a special function (FUNCTION _SequenceError(e AS Exception) AS USUAL)) that you can override in your code. The default implementation of this function calls the runtime error handler.
    And when there is NO RECOVER USING then the compiler will generate one and will call a runtime function that you can also override (FUNCTION _SequenceRecover(uBreakValue AS USUAL) AS VOID).) Of course "real" exceptions will also call the _SequenceError that was mentioned above.
  • We fixed several issues in the compiler


  • We fixed several issues in the runtime

Visual Studio integration

  • Many issues were fixed in the editor.
  • We have added a new options page (Tools/Options/Text Editor/X#) where you can control which suggestions the editor will suggest in "general" code completion list. Code completion after a colon or dot will show namespaces, types, members etc. And codecompltion after AS or IS will show types and namespaces. But for example code completion after the := operator may show locals, fields & properties of the current class, Globals, Functions etc. You can control where the editor looks for these entries.
  • You can now control the indenting settings from the .editorconfig file.

The new version will be tested by a small group of beta testers this week. We plan to release it to the rest of the subscribers next week, and a new public version will most likely be released a week after that.