Develop Reference

How to Debug a .NET Core Console App When Using dotnet run

So I'm working on a custom dotnet cli tool as described here. I'm getting started with it and can run my console app using dotnet run, but it's going right past my breakpoints when trying to debug. It does work when running from VS, but I want to be able to play around with passing various arguments and doing that from the application arguments box is not really practical. Any thoughts?

You have multiple options:
Debugger.Launch
This is a function which will pop up a window where you can attach a Visual Studio Debugger. See: Debugger.Launch. This has one theoretical downside (which does not apply to you) it is only usable in Visual Studio and not for example in Rider as the API is not open. (But you when this window pops up you could attach Rider to the process)
"Wait" the first seconds in your program
You could just pass an argument to your cli which indicates it should wait x seconds so that you can attach your Debugger.
public static void Main(string[] args)
{
if(args[0] == "waitfordebugger")
{
Thread.Sleep(10000); // Wait 10 Seconds
}
// Do stuff here
You then call your program like this: dotnet run -- waitfordebugger

For what it's worth, it seems like the best way is unfortunately to pass them in as arguments.
You can do this by clicking on the arrow next to Run button in Visual Studio and selecting 'Project Debug Properties'. From there, you can go to 'Application Arguments' and enter the arguments you want. For example, something like --list all would pass in an array with a length of two where index 0 is --list and index 1 is all.
If someone comes up with a less invasive way, let me know!
Edit: You can also do it from command prompt/powershell by using dotnet run and attaching to the associated process in VS (Debug>Attach to Process)

Visual Studio clears output file at end of debugging

I am experiencing a weird behaviour from Visual Studio 2013. I've got a C# program which writes to the standard output, let's say
using System;
using System.Threading;
namespace CsSandbox
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello world!");
Thread.Sleep(10000);
}
}
}
In the Debug tab of the project's properties I have redirected the output to a file, like this:
If I open the file within those 10s when my application is still running, the file does contain "Hello world!". However, as soon as the program exits, the file is cleared. This does not happen when I run the program from the command line.
Is there a rationale why Visual Studio does it? Is there a way to bypass this behaviour?

I believe this is due to the way Visual Studio hosts your application, in order to reduce startup time when debugging.
What happens is that your application (Program.exe) will actually be hosted in another process (Program.vshost.exe), which is started with the same command line arguments. When your application ends, this process is immediately restarted. You should be able to see this within Task Manager - look in the details tab so you can see the PID of the processes, and run your app - you'll see one Program.vshost.exe instance which ends when your app finishes, and another one come up immediately. That's then overwriting your output file.
One fix for this is to give your application a command line argument for the file to write to - and open that file within your Main method. You won't get there until you start running the app again.
Another option would be to simply stop using the hosting process - in the Debug part of your project properties, at the bottom you should see a checkbox for "Enable the Visual Studio hosting process". Uncheck this and I think your problem will go away - but it'll take longer to start debugging.
See this blog post for more information about the hosting process.

Outputing text to command line when using C# and Visual Studio

I am running Visual Studio 2010 and using C#.
I want to be able to launch an executable from the command line and be able to output text to the command window I launched from.
I tried these but they did not work at all.
Anybody have any ideas?
System.Diagnostics.Debug.WriteLine("diag text");
Console.WriteLine("text");
Thank you very much!

First, make sure you are running a Console Application. Once you've confirmed that, at the end add this line:
Console.ReadLine();
without it your application will run, and close before you are able to see the console. Adding that line will make the application wait till you press a key to close.

Compiling C# Code in Visual C# 2010 Express

I just have one question regarding C#.
I have downloaded Microsoft Visual C# 2010 Express to write the C# code.
Now, I want to compile the code using the same visual C#. Can I?
I have searched for a method to compile the code but all of the methods I founded are talking about command line 'cmd'.
I tried using it but it gives me that "csc is not recognized as an internal or external command ....." although that the directory I was in is the same as the C# code directory
I want to compile and see the results in the output.
This is the original code to compile:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Project1
{
class Example1_1
{
public static void Main()
{
// display “Hello World!” on the screen
System.Console.WriteLine("Hello World!");
// display the current date and time
System.Console.WriteLine("The current date and time is " +
System.DateTime.Now);
}
}
}
and the result of pressing F6 'build' is:
------ Build started: Project: Project1, Configuration: Release x86 ------
Project1 -> C:\Users\Ali Alnufaili\AppData\Local\Temporary Projects\Project1\bin\Release\Project1.exe
========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========
If you have any suggestion, till me please. ^_^

Just press this button:
or hit F5 to compile and run your code.
EDIT:
So you are running a console application and write some text to the console. Maybe your problem is that the console window pops up and closes immediately?
Try adding System.Console.ReadKey(); at the bottom of your Main method. Then the console window will stay open until you hit a key.
Or go the directory where your compiled program is (looks like it is C:\Users\Ali Alnufaili\AppData\Local\Temporary Projects\Project1\bin\Release), open a command prompt (in windows explorer, hold down SHIFT and press the right mouse button and choose Open command prompt here), and run the executable in the command prompt (just type Project1.exe and hit enter)

If you've created a project in Visual Studio, you should be able to simply use the "build" option from the menus/toolbars.
If you've got the default C# key bindings, I believe F6 is a shortcut to start under the debugger.

I'm sure you have used some tutorial for the example. Did the tutorial not mention pressing F5 to compile and run the application?
Your Build output says your program has compiled successfully, but to start your application, too, you need to press F5.
Also, currently your program will immediately exit when done. To make it wait, add the following line at the end:
Console.ReadLine();
That will let you see your output and then the program will wait until you press enter.

How does VS compile console applications to show "Press any key to continue"?

When I develop a C# console application (which will run on a server) and I run it using Visual Studio, I get a "Press any key to continue" message before the program terminates.
However, when I compile the very same C# code file manually using CSC, my program doesn't show that message and it terminates immediately after finishing its logic.
Does anyone know how I can make the same feature when compiling the code without using VS and WITHOUT changing the C# code any adding a ReadLine()?
UPDATE : The same message used to appear when I learned C#, I used to use TextPad with CSC, and that message used to appear without adding any Write(Line)/Read(Line) callings

It's nothing to do with the compiler - if you press F5 to debug it rather than Ctrl-F5 to run without debugging, then VS doesn't show the prompt. This is presumably so that you don't miss whatever output it's producing.
In order to do this, Visual Studio runs cmd.exe telling it to run your executable and then pause:
"C:\WINDOWS\system32\cmd.exe" /c ""...\ConsoleApplication1.exe" & pause"
It probably doesn't do it when you debug as it's a bit harder to get the process ID of a child of a child process.
To add a similar option to your program, either use a command line switch to tell the application itself to pause, or use a batch file to run it then pause, or use a shortcut with them cmd.exe /c.

That's not possible. The prompt to press any key is generated by Visual Studio when running a console app. It's not part of your program.
The only way is by using Console.Read() in your code
UPDATE: concerning your remark on using TextPad: I'm not familiar with TextPad, but I wouldn't be surprised if TextPad did the same thing as Visual Studio when running a console app.

You could do this...
static void Main(string[] args)
{
#if DEBUG
Console.Read();
#endif
}
That way the program will not wait for the console input when you build your application as a 'Release'.

You could write a batch script that runs the exe for you and prompts the user to press a key.
The batch script would look something like this:
echo off
YourApp.exe
pause

You could do this, if you want the same functionality when debugging.
if (Debugger.IsAttached)
{
Console.WriteLine("Press any key to continue . . . ");
Console.ReadKey(true);
}

This behavior has nothing to do with the compiler you are using. When you compile with Visual Studio, running the executable outside of Visual Studio actually will perform exactly the same as when you compile with CSC on the command line. Visual Studio (and TextPad) is adding the logic to add the "Press any key to continue" message on the console.
If you want your application to stay open, you will need to do something like Console.ReadLine() to block execution so that your application does not complete its execution.

The question is why would you want to have this behaviour? The Press any key to continue feature is there so that you can see the output of your application. If on the other hand you build your code and run it from a command prompt (console), this will not close when the application finishes, so you can see the output.
As noted above, the Press any key to continue is a feature of the IDE and not related to the code you are writing. The purpose of that feature is to allow you to see the output of you console application.