Hello Michaylov.
Let me try to give you a few answers, otherwise Wolfgang all has to do it
Visual Objects could be called the Windows version of Clipper. Originally you could even run your Clipper programs in it unmodified, although it didn't look as a Windows program at all. You needed to learn object oriented programming and you could use the built in Windows options, like windows and it's controls, menu's, printer drivers and much more. But the syntax of the Clipper commands and functions remained more or less the same.
When .Net became "the future", Grafx sofwware, the product owner of VO at that time, started to develop a .Net version of VO, allowing direct use of everything available in .Net. A clever program, called the Vulcan Transporter, created Vulcan programs from VO programs. Like in VO using Clipper code, you were still using VO forms and menu's but this is less different than the .Net flavours Winforms and WPF. Furthermore, these could be mixed. And the language could still look very much the same, too.
Despite its huge merits to the continuity of the VO language, Grafx failed in the end to deliver as promised. Paid describers, promised multiple new versions, got these less and less. Robert v.d. Hulst, one of the external subcontractors for Vulcan, eventually tried to take over Vulcan and when the product owner did not react with a reasonable offer, he decided to create X#. The other team members quickly joined him and Grafx finally went out of business.
It started by using the Vulcan DLL's, for those who owned it but nowadays you can use X# without Vulcan, the Core version. Part of X# is still the DBF system and of course all the DBF manipulating commands, and there's also an X# native DLL which directly connects to ADS. And there's a much more elaborate converter, here called th XPorter or VOPorter, which can convert VO and Vulcan code. Besides the Clipper/VO/Vulcan users, (Microsoft) Fox users also have a migration path, after all FoxPro was just another XBase language using DBF databases.
X# is built around the Rosalyn compiler, which means that many of the high end .Net functions like those present in C#, can be used about the same in X#. So your project can contain code which still looks not too different from Clipper and at the same time code which more looks like a modern C# program. And you can mix any language by using Visual Studio and creating a project for each language in 1 solution. So you basically have a front end language and a database handling language in one. You might want to skip DBF completely and use SQL, PostgreSQL is recommended and a few regular contributors here like Johan Nel have a lot of knowledge being shared here.
Here's a 32 page paper with much more detail, also the history:
https://saltydogllc.com/wp-content/uplo ... -Sharp.pdf
.Net Core is indeed your choice if you do not have VO or Vulcan.
If you choose WPF you may want to use Visual Studio (free for smaller companies in the Community version) as there's no WPF editor in Xide (written by XSharp Development Team member Chris Pyrgas) . You will see that you can design there a window in WPF by dragging controls, like buttons etc to a screen, but in the background XAML code describing the screen is used. It is very powerful and flexible (you can create elaborate animated windows with most code in XAML instead of X# or C# code) but often more difficult to handle than Winforms or VO compatible forms). If you are fine with writing your screens and menus etc in XAML without having a design screen, XIDE will do and is more friendly than Visual Studio. Personally I use VS but I dislike it as I consider it far less usable than VO. Others completely disagree with me for incomprehensible reasons
Note that the latest programming techniques look very different than you are used to from Clipper but not all are necessarily better. For example:
In Clipper, you describe in a program where in the text based screens your screen content had to appear, and improvised some menu, usually by entering a number of choice to continue with the next screen.
In VO, you would drag controls on a screen and the actual size of the window could move or resize the content, for exampling enlarging a box while keeping other controls the same size. If the user presses a button, or some Windows event is called (like a timer, or when the user leaves a field), a method programmed behind that Pushbutton or for such an event, is executed.
In .Net, you might want to separate your program logic from the window design. MVVM is such a design pattern, where you assign values to properties which will "find their way" to those parts of the window designed to collect changes in these properties "themselves". Drawback is that it's more code to write and less insight in what is actually happening but you might want to consider using that. I would certainly not begin with it however (and personally I use it only in some specific situation). Look for posts of Nick Friend who is an absolute expert in applying MVVM "by the book".
I would start with choosing XIDE or VS and just create some windows and try to program some actual functionality. Also read Getting Started on
https://www.xsharp.eu/help/introduction.html . There are some nice free conferences on the YouTube Channel X# Academy which you can watch. See
https://www.xsharp.eu/itm-downloads?fol ... sentations. You can find examples on
https://www.xsharp.eu/examples.
Indeed you can use X# for free. The development is financed by users who pay a yearly for Fox (Friends of X#). I've personally experienced more than once that e..g. Chris has checked a mailed solution with an issue I had worked on for hours where he could find the cause in a much more acceptable time. Sometimes it was an X# issue, followed by a workaround and, later, a fix in the new version, but not always. Fox is much more than this and if you are really working in X# I'd say you should consider joining.
Lots of visitors here like to help so this is a much more concerned user group than of most of other languages.
I hope I have given some replies. Please keep asking!
Dick