We Keep Coding

C# from winform application how to open another winform application and send value to it?

I have 2 winform applications, say form1 and form2.
They are programmed through separate visual studio programs
form1 is programmed in WindowsFormsApplication1.sln
form2 is programmed in WindowsFormsApplication2.sln
I want to open form2(=WindowsFormApplication2.exe) by clicking a button in form1
I created a method in WindowsFormApplication1.sln
private void button3_Click(object sender, EventArgs e)
{
var p = new Process();
p.StartInfo.FileName ="WindowsFormsApplication2.exe";
p.StartInfo.Arguments = "10";
p.Start();
}
This method opens WindowsFormApplication2.exe
Then I need WindowsFormApplication2 MessageBox show the value got from WindowsFormApplication1.exe. Is this clear?
This should be clear... I cannot explain more simply than this
What other people have answered through comment or answerbox, is not what I want
If I want to pass a value from form1 to form2 that are in same .sln (That is, WindowsFormApplication1.sln has form1 and form2), this is so easy
I could just use
Form2 form2 = new Form2(textBox1.Text);
form2.Show();
Constructor Form2:
public Form2(string smth)
{
InitializeComponent();
label1.Text = smth;
}
But this is not what I want
I think everything is clear. Please tell me how to solve the problem

C# programs have a static void Main() method that is the entry point for the application. You should see something like this in your Program.cs file in your winform2 project:
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
If you want to enable your winform2 application to accept command-line arguments, you capture them from this method. But first you need to modify the method signature to take in a string[] of arguments:
// Add a string[] argument to the Main entry point method
static void Main(string[] args)
Now any command line arguments passed to this application will be in the args array.
Next, we need to modify your winform2 application's main form constructor to take in one or more string arguments, so we can pass them in the line that says Application.Run(new Form1()).
For example, you can modify your form's constructor to take in a string (I'm using Form1 as an example):
public partial class Form1 : Form
{
// Add a string argument to the form's constructor.
// If it's not empty, we'll use it for the form's title.
public Form1(string input)
{
InitializeComponent();
if (!string.IsNullOrEmpty(input)) this.Text = input;
}
}
After we enable the form to take a string input, we now modify the call to the constructor to pass a string to our form. In this case, I'm expecting a string like: /Title:"Some Form Title", so I'll look at the args array and try to find a match.
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Try to find the 'Title' argument
var titleArg = args?.FirstOrDefault(arg => arg.StartsWith("/Title:",
StringComparison.OrdinalIgnoreCase));
// Now strip off the beginning part of the argument
titleArg = titleArg?.Replace("/Title:", "");
// And now we can pass this to our form constructor
Application.Run(new Form1(titleArg));
}
Now you can launch your WinForm application from the command line and pass in a string, which will become the title. Here I'm running the .exe from the command line and passing /Title:"Custom Title From Command Line", but you could just assign this string to the Arguments property of your ProcessStartInfo instance if you're launching the application programmatically.:

Get Path on open ZIP [duplicate]

I'm an amateur at c# and I've been unable to locate the answer to this.
Perhaps I am not aware of the correct terms to use.
When a video file is dragged onto my exe application, I would like the application to know that it was launched with a file and be able to know the path and filename of that file. This way, the user does not have to use the file>open menu.
Hope that makes sense.
Thanks

You can check the command line arguments which were used to launch the application.
If your application was started by dropping a file on the .exe file, there will be a single command line argument with the path of the file.
string[] args = System.Environment.GetCommandLineArgs();
if(args.Length == 1)
{
// make sure it is a file and not some other command-line argument
if(System.IO.File.Exists(args[0])
{
string filePath = args[0];
// open file etc.
}
}
As your question title states, you want the path and the file name. You can get the file name using:
System.IO.Path.GetFileName(filePath); // returns file.ext

When you drag a file into a C# application, it will goes as an command-line argument to that application. Like console applications, you can catch it on the Main method on the Program class.
I'll explain it using Windows Forms application.
Open your Program class on the solution. Your program class should look like this.
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
By default, when you create Windows Forms applications, they don't treat command line arguments. You have to make a tiny change on the signature of the Main method, so it can receive arguments:
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
Now you can handle file name argument passed to the application. By default, Windows will put the file name as the first argument. Just do something like this:
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Before Application.Run method, treat the argument passed.
// I created an overload of the constructor of my Form1, so
// it can receive the File Name and load the file on some TextBox.
string fileName = null;
if (args != null && args.Length > 0)
fileName = args[0];
Application.Run(new Form1(fileName));
}
In case you want to know the constructor overload of my Form1, here it is. Hope it helps!
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
public Form1(string fileName) : this()
{
if (fileName == null)
return;
if (!File.Exists(fileName))
{
MessageBox.Show("Invalid file name.");
return;
}
textBox1.Text = File.ReadAllText(fileName);
}
}

You need your application's command-line arguments. When you drop a file on your application in Explorer, Explorer opens the application with the file you dropped on it. You can select as many files as you want, drop them on your application and using this line of code, files will be an array of those command line arguments.
string[] files = Environment.GetCommandLineArgs();

C#: Drag & Drop File on .exe (icon) and get filepath

I'm new to C# and I'm not getting around this trouble. Here is what I wanted to achieve.
Whenever I drag and drop a file on the .exe file (on the icon itself), the application should capture the filepath of dragged file.
Thanks.

If I understand correctly, you want to drop a file onto an icon of an exe, not an application itself. If that is so, it can be achieved easily using the parameters passed into the application. If you check your original boilerplate code when you make a console application it has the application entry point:
static void Main(string[] args)
If you drag drop a file onto the icon of the application, the args[0] will hold the name of the file being dropped. If the goal is to drop the file onto an EXE file, there are numerous tutorials on SO about that.

If you make this following code, then when you drag your file onto the exe icon, the args[0] will hold the path of it as an argument:
(I added the if statement that if you start the program without dragging anything
it shouldn't crash)
class Program
{
static void Main(string[] args)
{
if (args.Length > 0)
{
Console.WriteLine(args[0]);
}
Console.ReadLine();
}
}

I was able to add drag and drop onto an executable/shortcut created using Windows Forms by adding in the default string[] args to the Main function in Program. And then, add the same parameter to Form1's constructor function, and pass in the same args gathered from Main.
Program.cs
static class Program
{
[STAThread]
//add in the string[] args parameter
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//pass in the args to the form constructor
Application.Run(new Form1(args));
}
}
Form1.cs
//add in the string[] args parameter to the form constructor
public Form1(string[] args)
{
InitializeComponent();
//if there was a file dropped..
if (args.Length > 0)
{
var file = args[0];
//do something with the file now...
}
}

Application.Restart not passing arguments back

This is a ClickOnce application. According to the documentation, "If your application was originally supplied command-line options when it first executed, Restart will launch the application again with the same options.". But I don't know if this is supposed to work or not with ClickOnce applications. If so, what am I doing wrong?
Here is my code:
public Form1()
{
InitializeComponent();
textBox1.Text = string.Join(Environment.NewLine, GetCommandLineFile());
}
private static string[] GetCommandLineFile()
{
if (AppDomain.CurrentDomain != null &&
AppDomain.CurrentDomain.SetupInformation != null &&
AppDomain.CurrentDomain.SetupInformation.ActivationArguments != null &&
AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData != null &&
AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData.Any())
{
return AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData;
}
else return new string[] { };
}
private void button1_Click(object sender, EventArgs e)
{
Application.Restart();
}
I associated my application with the .abc extension and when I double click my .abc file, the application will launch with the file name as the only argument, but then when I restart (by pressing my button1), GetCommandLineFile() will return an empty array.

I believe Application.Restart was designed for standard command line arguments instead of how ClickOnce applications handle it.
Looking at Microsoft's code for Application.Restart, they explicitly check if the application is a ClickOnce application and then restart it without any arguments being passed. Any other application, gets Environment.GetCommandLineArgs() parsed and sent to a new process.
I think a better solution, instead of writing arguments to a file, is to simply start a new process as such :
"path\Application Name.appref-ms" arg1,arg2,arg3
That way, when your application starts up, GetCommandLineFile() should grab the arguments again.

C# external tool for SSMS - Reading from stdin

I am trying to write an app that makes use of the external tools functionality of SQL Server Management Studio.
To specify an external tool, you can enter a path to the app and specify some arguments to pass to the app via STDIN.
Currently I just have a form that displays the arguments. Every time I run the external tool I get a new instance of the application.
Ideally I would like for the first time I run the tool to load the application, and each subsequent running to take the arguments from STDIN and do something with them WITHOUT creating a new instance of the app.
Is there anything I can do that could allow this, or am I stuck with lots of windows?
Thanks in advance

As horrible as it sounds, you can leverage Microsoft.VisualBasic.ApplicationServices to make this really simple (you can add a reference to Microsoft.VisualBasic in your c# project).
As a quick example, you can create a new C# WinForms project and alter Program.cs to look something like this:
class Program : WindowsFormsApplicationBase
{
static Form1 mainForm = null;
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] commandline)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Program prog = new Program();
prog.MainForm = mainForm = new Form1();
prog.Run(commandline);
}
public Program()
{
this.IsSingleInstance = true;
}
protected override void OnStartupNextInstance(StartupNextInstanceEventArgs eventArgs)
{
base.OnStartupNextInstance(eventArgs);
mainForm.Startup(eventArgs.CommandLine.ToArray());
}
}
Then in the Form1 throw a label on there and a little code to show it's working:
public void Startup(string[] commandLine)
{
string output = "";
foreach (string arg in commandLine)
output += arg + "\n";
label1.Text = output;
}
public Form1()
{
InitializeComponent();
Startup(Environment.GetCommandLineArgs());
}
The only gotcha with this little snippet is that the command line arguments you get on first launch include the application name, but it's not included on subsequent launches.