Memmingen 2023 Sessions


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)
- NewtonSoft.Json (Json data handling)
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.