Initially I created an application that I completely rewrite in a second version. It is a complete different Visual studio solution.
Now I would like that its Setup installer uninstall the previous version but because it was not created using the same solution, the automatic uninstallation of previous version does not work.
Is there any way to force the installer to uninstall certain application based on product name or product code?
I found a WMIC command that works when run from command line
wmic product where name="XXXX" call uninstall /nointeractive
So I created a VBS script which execute a bat file containing the WMIC code and I added it to the Setup project
dim shell
set shell=createobject("wscript.shell")
shell.run "uninstallAll.bat",0,true
set shell=nothing
but when I run the result MSI, it fires an error 1001, meaning that a service already exists. , in other words the uninstallation didn't work.
The old program is still present and they create a service with the same name. :/
any suggestion?
There are 2 options:
You can increase the version of MSI project so it will treat as upgrade and it will not throw any error while installing.
another way out is the write some in the installer project as follows:
protected override void OnBeforeInstall(IDictionary savedState)
{
//Write uninstall powershell script
//installutil /u <yourproject>.exe
using (PowerShell PowerShellInstance = PowerShell.Create())
{
PowerShellInstance.AddScript("");
PowerShellInstance.AddParameter("");
}
PowerShellInstance.Invoke();
}
Note: This InstallUtil is available with the .NET Framework, and its path is %WINDIR%\Microsoft.NET\Framework[64]\<framework_version>.
For example, for the 32-bit version of the .NET Framework 4 or 4.5.*, if your Windows installation directory is C:\Windows, the path is C:\Windows\Microsoft.NET\Framework\v4.0.30319\InstallUtil.exe.
For the 64-bit version of the .NET Framework 4 or 4.5.*, the default path is C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe
I decided to go for the option of introducing c# code in the project installer. Firstly I added the reference for System.Management.Automation via nuget
https://www.nuget.org/packages/System.Management.Automation
After this, I just created a string variable containing the PS code I need to uninstall several programs with a similar name.
string unInstallKiosk = #"$app = get-WMIObject win32_Product -Filter ""name like 'KIOSK'""
foreach ($program in $app){
$app2 = Get-WmiObject -Class Win32_Product | Where -Object { $_.IdentifyingNumber -match ""$($program.identifyingNumber)""
}
$app2.Uninstall()}";
and passed this variable to the method PowerShellInstance.AddScript()
PowerShellInstance.AddScript(unInstallKiosk);
The installation ends but the uninstallation simply dont happens.
anyone has an idea how to solve this?
I have a Asp.Net MVC Core website that's using public static async Task Main(). For that to work I've set the language version to C# 7.2 (in the properties -> build -> advanced dialog, double checked in the csproj) for both Debug and Release build configurations.
App builds and starts fine in both Debug and Release mode.
Now, I'm trying to publish it to an Azure Website directly from Visual Studio 2017 15.5.2 (with WebDeploy) and I get this:
Program.cs(17,29): Error CS8107: Feature 'async main' is not available
in C# 7.0. Please use language version 7.1 or greater. CSC(0,0): Error
CS5001: Program does not contain a static 'Main' method suitable for
an entry point
In the output window I see it's running C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\MSBuild\15.0\Bin\Roslyn\csc.exe with some flags, probably one of them is wrong?
Anyone know if this is a known issue or I'm doing something wrong?
This appears to be a bug in Visual Studio.
Adding this line to main property group in the .csproj file resolved the issue for me:
<LangVersion>latest</LangVersion>
The issue was also reported here in the ASP.NET Home repository.
Not an answer, per se, but for what it's worth async Main is just syntactic sugar. Behind the scenes Roslyn just adds the standard void Main wrapper construction:
static void Main(object[] args)
{
MainAsync(args).GetAwaiter().GetResult();
}
static async Task MainAsync(object[] args)
{
// your code
}
It's probably not worth your time trying to get the server on the same page C# version-wise, just to save literally three lines of code.
I implemented a .NET application where the user browses for solution files. The user can choose to open these solution files in Visual Studio.
The problem is that the solutions need to be opened in Visual Studio 2008. Not in Visual Studio 2010 or above. This is necessary to keep the solution files in their original state.
All this should happen in C#. Bellow is the code but it opens the sln files with the default Visual Studio of the user.
if (file.EndsWith(".sln") && File.Exists(file))
System.Diagnostics.Process.Start(file);
Well, you are just launching a new process indicating file to the file and letting Windows to handle everything for you. Windows know that .SLN files should be opened with default associated program and that's it.
To change this behavior you have to programmatically analize the version of your SLN file, and based on SLN version open concrete version of VisualStudio passing as parameter the SLN file.
So you would need to emulate from your C# code something like:
C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE>devenv.exe "C:\PATH\SOLUTION.sln"
It could look somehow like this:
private static void Main(string[] args)
{
var slnPath = #"C:\PATH\SOLUTION.sln";
var slnVersion = GetVersion(slnPath);
switch (slnVersion)
{
case ...:
break;
case 14:
var startInfo = new ProcessStartInfo();
startInfo.FileName = #"C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe";
startInfo.Arguments = slnPath;
Process.Start(startInfo);
break;
}
}
I figured out that it isn't necessary to detect the original version, in which the solutions were made. All solutions are created in Visual Studio 2008 by default.
Find the solution in the code bellow:
Add the reference EnvDTE.dll and using EnvDTE; in your code
public static void OpenSlnFile(string file)
{
System.Type type = Type.GetTypeFromProgID("VisualStudio.DTE.9.0");
EnvDTE.DTE dte = (EnvDTE.DTE)System.Activator.CreateInstance(type);
dte.MainWindow.Visible = true;
dte.Solution.Open(file);
}
Which program launched on clent depend on the registry key HKEY_CLASSES_ROOT\VisualStudio.Launcher.sln (referenced by HKEY_CLASSES_ROOT.sln)
When you open the file, it runs "c:\Program Files (x86)\Common Files\Microsoft Shared\MSEnv\VSLauncher.exe" "%1", which reads the version from the .sln file and open the correct version.
About .sln file structure you can read at https://msdn.microsoft.com/en-us/library/bb165951.aspx
I print output on the console in WPF and ASP.NET-MVC applications by:
System.Diagnostics.Debug.WriteLine("text");
how to programatically clear the output window?
// Import EnvDTE and EnvDTE80 into your project
using EnvDTE;
using EnvDTE80;
protected void ClearOutput()
{
DTE2 ide = (DTE2)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.12.0");
ide.ToolWindows.OutputWindow.OutputWindowPanes.Item("Debug").Clear();
System.Runtime.InteropServices.Marshal.ReleaseComObject(ide);
}
This is what I use in VS2013, Win10, x64:
private static void ClearVS2013DebugWindow()
{
// add reference to "C:\Program Files (x86)\Common Files\microsoft shared\MSEnv\PublicAssemblies\envdte.dll"
EnvDTE.DTE ide = (EnvDTE.DTE)System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.12.0");
if (ide != null)
{
ide.ExecuteCommand("Edit.ClearOutputWindow", "");
System.Runtime.InteropServices.Marshal.ReleaseComObject(ide);
}
}
Credit to the answers above.
Within the underlying APIs, the debug output is a forward only stream - you shouldn't assume that it is only viewable within Visual Studio. Debug output can only be written by an application, and if you need more detailed control, it should be shown within the User Interface of your application (whether that is a console window, which can be cleared; or a WinForms application, or WPF, etc.)
How do you compile and execute a .cs file from a command-prompt window?
CSC.exe is the CSharp compiler included in the .NET Framework and can be used to compile from the command prompt. The output can be an executable ".exe", if you use "/target:exe", or a DLL; If you use /target:library, CSC.exe is found in the .NET Framework directory,
e.g. for .NET 3.5, c:\windows\Microsoft.NET\Framework\v3.5\.
To run, first, open a command prompt, click "Start", then type cmd.exe.
You may then have to cd into the directory that holds your source files.
Run the C# compiler like this:
c:\windows\Microsoft.NET\Framework\v3.5\bin\csc.exe
/t:exe /out:MyApplication.exe MyApplication.cs ...
(all on one line)
If you have more than one source module to be compiled, you can put it on that same command line. If you have other assemblies to reference, use /r:AssemblyName.dll .
Ensure you have a static Main() method defined in one of your classes, to act as the "entry point".
To run the resulting EXE, type MyApplication, followed by <ENTER> using the command prompt.
This article on MSDN goes into more detail on the options for the command-line compiler. You can embed resources, set icons, sign assemblies - everything you could do within Visual Studio.
If you have Visual Studio installed, in the "Start menu"; under Visual Studio Tools, you can open a "Visual Studio command prompt", that will set up all required environment and path variables for command line compilation.
While it's very handy to know of this, you should combine it with knowledge of some sort of build tool such as NAnt, MSBuild, FinalBuilder etc. These tools provide a complete build environment, not just the basic compiler.
On a Mac
On a Mac, syntax is similar, only C sharp Compiler is just named csc:
$ csc /target:exe /out:MyApplication.exe MyApplication.cs ...
Then to run it :
$ mono MyApplication.exe
Another way to compile C# programs (without using Visual Studio or without having it installed)
is to create a user variable in environment variables, namely "PATH".
Copy the following path in this variable:
"C:\Windows\Microsoft.NET\Framework\v4.0.30319"
or depending upon which .NET your PC have.
So you don't have to mention the whole path every time you compile a code.
Simply use
"C:\Users\UserName\Desktop>csc [options] filename.cs"
or wherever the path of your code is.
Now you are good to go.
You can compile a C# program :
c: > csc Hello.cs
You can run the program
c: > Hello
For the latest version, first open a Powershell window, go to any folder (e.g. c:\projects\) and run the following
# Get nuget.exe command line
wget https://dist.nuget.org/win-x86-commandline/latest/nuget.exe -OutFile nuget.exe
# Download the C# Roslyn compiler (just a few megs, no need to 'install')
.\nuget.exe install Microsoft.Net.Compilers
# Compiler, meet code
.\Microsoft.Net.Compilers.1.3.2\tools\csc.exe .\HelloWorld.cs
# Run it
.\HelloWorld.exe
An example HelloWorld.cs
using System;
public class HelloWorld {
public static void Main()
{
Console.WriteLine("Hello world!");
}
}
You can also try the new C# interpreter ;)
.\Microsoft.Net.Compilers.1.3.2\tools\csi.exe
> Console.WriteLine("Hello world!");
Hello world!
While it is definitely a good thing knowing how to build at the command line, for most work it might be easier to use an IDE. The C# express edition is free and very good for the money ;-p
Alternatively, things like snippy can be used to run fragments of C# code.
Finally - note that the command line is implementation specific; for MS, it is csc; for mono, it is gmcs and friends.... Likewise, to execute: it is just "exename" for the MS version, but typically "mono exename" for mono.
Finally, many projects are build with build script tools; MSBuild, NAnt, etc.
Here is how to install MSBuild with standalone C# 7.0 compiler which is no longer bundled in the latest .Net Framework 4.7:
Is it possible to install a C# compiler without Visual Studio?
Then just run
"C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\MSBuild\15.0\Bin\Roslyn\csc.exe" MyApplication.cs
to compile single source file to executable.
Also note that .Net Core doesn't support compiling single source file without preconfigured project.
Add to path
C:\Windows\Microsoft.NET\Framework\v3.5
To Compile:
csc file.cs
To Execute:
file
PowerShell can execute C# code out of the box.
One liner to compile & execute a file:
(Add-Type -Path "Program.cs" -PassThru)::Main() #'Main' is the entry point
Supposed you have a .cs file like this:
using System;
public class Program
{
public static void Main()
{
Console.WriteLine("Hello from C#");
}
}
You can build your class files within the VS Command prompt (so that all required environment variables are loaded), not the default Windows command window.
To know more about command line building with csc.exe (the compiler), see this article.
In Windows systems, use the command csc <filname>.cs in the command prompt while the current directory is in Microsoft Visual Studio<Year><Version>
There are two ways:
Using the command prompt:
Start --> Command Prompt
Change the directory to Visual Studio folder, using the command: cd C:\Program Files (x86)\Microsoft Visual Studio\2017\ <Version>
Use the command: csc /.cs
Using Developer Command Prompt :
Start --> Developer Command Prompt for VS 2017
(Here the directory is already set to Visual Studio folder)
Use the command: csc /.cs
Once you write the c# code and save it. You can use the command prompt to execute it just like the other code.
In command prompt you enter the directory your file is in and type
To Compile:
mcs yourfilename.cs
To Execute:
mono yourfilename.exe
if you want your .exe file to be different with a different name, type
To Compile:
mcs yourfilename.cs -out:anyname.exe
To Execute:
mono anyname.exe
This should help!
If you have installed Visual Studio then you have Developer Command Prompt for VS. You can easily build your program using csc command and run your application with the name of the application inside the developer command prompt.
You can open Developer command prompt as given below.
Start => Developer Command Prompt for VS
Hope this helps!
I found a simple way to do this if you have the correct system and environmental variables set up and your path is properly configured.
you just need to run in the directory of the project
dotnet new console --> this will generate the required files such as the .csproj. it will also generate a Program.cs file which it automatically uses as the entry point, if you have other files with your static Main method you can remove this file and it should find the Main entry point automatically.
then all you need to do to run is
dotnet run and it should compile and run automatically
this was how i managed to get my projects working in vs code using gitbash as my terminal. Also I have VS 2019 installed, i used the .net 5.0 framework from this as my system variables. This was the simplest solution i found for basic console programs. It also allows you to add custom imports in your .csproj file
C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\MSBuild\15.0\Bin\Roslyn
this is where you can find the c# compiler that supports c#7 otherwise it will use the .net 4 compilers which supports only c# 5
# File : csharp.ps1
# Purpose : Powershell Script to compile a csharp console application from powershell prompt
try {
# CSharp Compiler
#$csc = "C:\Windows\Microsoft.NET\Framework\v3.5\bin\csc.exe"
$csc = "C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe"
# NOTE: if this path doesn't work search Framework folder for csc.exe
$ErrorActionPreference = 'Stop'
if ($args.Count -eq 0) {
write-host "`nUSAGE: csharp.ps1 (console_application.cs)"
exit 1
}
$file = $args[0];
if (-not(test-path $file)) {
throw "file doesn't exist: $file"
}
$cmd = "$csc /nologo /t:exe /out:${file}.exe $file"
write-host -ForegroundColor Green "`nx: $cmd"
invoke-expression $cmd
}
catch {
write-host -ForegroundColor Red "`nEXCEPTION: $_"
}
finally {
write-host ""
}
// File: helloworld.cs
using System;
namespace MyProgram
{
class Program
{
public static void Main(string[] args)
{
Console.Write("Hello World...");
Console.ReadKey(true);
}
}
}
PS> .\csharp.ps1 helloworld.cs
Search "Path" in windows
Select "Edit the system environment.."
Click on "Environment Variable" right bottom
Double Click on Path in Variable Section
Click on
New and add the path (you Want to add)
Click Okay Okay Okay
for me to run csc from command Prompt
Added this "C:\Windows\Microsoft.NET\Framework\v4.0.30319" to path
then open command prompt where my file is located, and ran this
PS C:\Users\UserName\Downloads\Mouse> csc.exe Mouse.cs
dotnet
This is oooold. But since this is where you end up as a beginner when you ask questions to understand how to use C# like C or C++ in a console using compilers without Visual Studio CE (highly recommended for C# btw if you aren't already using it) you end up getting more confused within the lingo of .NET framework and libraries and SDKs.
If someone like you stumbles upon my answer as a complete beginner:
1. Understand the difference between Framework and SDK.
2. Understand what C# is and what .NET is.
3. THIS: https://dotnet.microsoft.com/learn/dotnet/hello-world-tutorial/intro
You'll pick up the rest along the way.
But instead of using framework I suggest using the SDK and mostly sticking to VS. As for me, I learned C# for unity and mostly game dev.
Also Google is your friend. Ask Questions, stay curious.