rp-app | create react app within php at the back-end - With php | Frontend Framework library

The Visual C++ dlls you need to ship with your CefSharp based project:

If you use CefSharp v63.0.3 or below:

• msvcp120.dll
• msvcr120.dll

If you use CefSharp v65.0.0 or above:

At the end the problem was that visual studio does not create a .exe.config file for the CLR console application project with the binding redirect info. that did have the console application in C#.

So, I created a ConsoleApplication.exe.config as the one that VS creates for the C# console project:

This was an issue with the last app update, it's been resolved with the latest 0.0.49 release now on NuGet which you can update to after NuGet has finished indexing the package:

Look in your bin directory and you should see a file named YourProjectName.exe.config with a type of XML configuration. Whatever is in your app.config is copied here when you compile the project. You can change the values in code as follows:

Finally solved this by adding an inserting extra (and redundant) PowerShell build step:

• Runner Type: PowerShell
• Script: SourceCode
• Working directory:
• Script Source: npm install

and it magically worked.

Now, of course I already was executing npm install from deep down inside my build automation build.ps1.

For some reason, the above works and the buried one doesn't. I can't explain why. Confirmed that the execution folder was correct and also used get-command npm from both contexts and the result was the same for both:

You can use the native library pre-loading feature as described on the System.Data.SQLite website:

If the development and customer machines may have different processor architectures, more than one binary package may be required. For this situation, using the native library pre-loading feature is highly recommended. It is available as of version 1.0.80.0 and enabled by default. In order to take advantage of this feature, the separate managed and interop assemblies must be used with XCOPY deployment (i.e. this feature is not supported by the mixed-mode assembly, nor when the assembly is deployed to the global assembly cache), resulting in an application deployment that looks something like this: 

• \App.exe (optional, managed-only application executable assembly)
• \App.dll (optional, managed-only application library assembly)
• \System.Data.SQLite.dll (required, managed-only core assembly)
• \System.Data.SQLite.Linq.dll (optional, managed-only LINQ assembly)
• \System.Data.SQLite.EF6.dll (optional, managed-only EF6 assembly)
• \x86\SQLite.Interop.dll (required, x86 native interop assembly)
• \x64\SQLite.Interop.dll (required, x64 native interop assembly)

The string "" above represents the directory where the application binaries are to be deployed on the target machine. With the native library pre-loading feature enabled and the application deployment shown above, the System.Data.SQLite managed-only assembly will attempt to automatically detect the processor architecture of the current process and pre-load the appropriate native library.

1. Remove all copies of any System.Data.SQLite.dll you have in your project and make sure there is no System.Data.SQLite.dll registered in the Global Assembly Cache on your system.

2. In Your Project folder, add a subfolder names "x64" and a subfolder named "x86".

3. In order to use this, you must download two ZIP archives from the System.Data.SQLite website.

4. Download the second ZIP file listed under "Precompiled Binaries for 64-bit Windows (.NET Framework 4.5)", the one where it does NOT say "mixed-mode". Currently, this is http://system.data.sqlite.org/downloads/1.0.109.0/sqlite-netFx45-binary-x64-2012-1.0.109.0.zip

Copy the file System.Data.SQLite.dll from this zip to your project folder. Copy the file SQLite.Interop.dll from this zip to the x64 folder below your project folder.

1. Download the second ZIP file listed under "Precompiled Binaries for 32-bit Windows (.NET Framework 4.5)", the one where it does NOT say "mixed-mode". Currently. this is http://system.data.sqlite.org/downloads/1.0.109.0/sqlite-netFx45-binary-Win32-2012-1.0.109.0.zip

Copy the file SQLite.Interop.dll from this zip to the x86 folder below your project folder.

1. In your Visual Studio project, add these three files as links to your project, so that it looks like this:

1. In your Visual Studio project, select these three files and set their property "Copy to Output Directory" to "Copy always".

2. In your Visual Studio project, under references, remove a reference to System.Data.SQLite if there is already one and instead add a reference to the System.Data.SQLite.dll that you copied into your project directory. Set the property "Specific Version" to true.

3. Build the project.

4. You will now see this file structure in your output directory and everything will work as expected independent of whether the application runs in 32bit or 64bit mode.

1. For distributing the application, those three dlls have to be distributed as well keeping the same file structure and not registering the DLLs in the Global Assembly Cache.

Note, that following the above steps you also have to distribute the x86 and x64 versions of the "Visual C++ 2012 Update 4 runtime" by Microsoft on customer pcs. If you don't do that, then download the ZIP files that are marked as "Precompiled Statically-Linked Binaries" instead in steps 4 and 5.

The only difference lies in how the two files named SQLite.Interop.dll are compiled in this variant.

You can download two different variants of the System.Data.SQLite.dll:

mixed-mode

There is the mixed-mode variant. In this variant, this same dll (System.Data.SQLite.dll) contains both the actual unmanaged SQLite source code as well as the managed .net wrapper. Mixed-Mode assemblies (because they contain unmanaged native code) are bound to either a 32bit or 64bit environment during compilation. Therefore, there is a 32bit version of the mixed-mode System.Data.SQLite.dll, and there is a 64bit version of the mixed-mode System.Data.SQLite.dll.

When you reference either of these two mixed-mode assemblies, your application can only run in either 32bit or 64bit mode.

managed-only

Then there is the managed-only variant. In this variant, the System.Data.SQLite.dll contains only the managed wrapper code. In this variant, the assembly is an ANY CPU assembly. It can be used in both 32bit and 64bit processes.

The actual unmanaged SQLite code is then contained in a dll named SQLite.Interop.dll. This is a native (unmanaged, no .net) dll. There is a 32bit version of SQLite.Interop.dll. And there is a 64bit version of SQLite.Interop.dll.

The managed-only variant of System.Data.SQLite.dll determins the processor architecture of the current process when loaded and then tries to load the appropriate SQLite.Interop.dll from a subdirectory with the processor architecture name.

Alternatively, you can get both version (32bit and 64bit) of the mixed-mode variant of System.Data.SQLite.dll and install both of them in the Global Assembly Cache both on your development machine and on customer computers. Your application will then automatically choose the version with the correct processor architecture from the Global Assembly Cache during runtime.

Inside the App.Config you can specify the version of the runtime you can support.

https://docs.microsoft.com/en-us/dotnet/framework/migration-guide/how-to-configure-an-app-to-support-net-framework-4-or-4-5

Figured it out..

To enable .NET to use all NUMA nodes, add the following to your app.config:

You need click on your project in Solution explorer, select Add File option and choose app.config. When you will rebuild solution file will by added configuration file like your_application.exe.config