यदि मैं मुख्य रूप लोड नहीं करना चाहता हूं तो मैं Winforms में कमांड लाइन तर्क कैसे संभाल सकता हूं?

Question

मैं एक ऐप्लिकेशन है जो प्रकार कार्य करता है बनाना चाहते हैं: कोई तर्क पर

1. यह मुख्य रूप
2. तर्क पर प्रदर्शित करता है "एक" एक नौकरी है, लेकिन मुख्य रूप से लोड नहीं है करता है।
3. तर्क "बी" तर्क पारित कर का उपयोग कर प्रपत्र लोड पर (जो दस्तावेज़ लोड)

1 के लिए और 3 के रूप में निम्नानुसार मैं प्रपत्र के निर्माता में तर्क संभाल कर सकते हैं:

public ConfigurationActionManagerForm() 
{ 
    InitializeComponent(); 
    Environment.GetCommandLineArgs(); 
    // do stuff with that argument 
} 

लेकिन यह दृष्टिकोण मुझे सूची में 2 के व्यवहार को लागू करने की अनुमति नहीं देता है।

program.cs में मैं फ़ॉर्म को बनाने से पहले तर्कों को संभालने के लिए इसे संपादित कर सकता हूं, लेकिन Application.Run() का उपयोग करने पर सही दृष्टिकोण क्या है यदि मैं कोई फॉर्म पास नहीं करना चाहता हूं? मैं Program क्लास इंस्टेंस को सूचित करने जा रहा हूं कि मुझे एक संदेश को समाप्त या दिखाने की ज़रूरत है कि कुछ गलत हो गया है या यहां तक ​​कि थोड़ा टास्कबार आइकन भी दिखा रहा है कि प्रक्रिया सामग्री कर रही है (इसके बारे में सोचें अनजिपिंग प्रक्रिया की तरह)।

[STAThread] 
static void Main() 
{ 
    Application.EnableVisualStyles(); 
    Application.SetCompatibleTextRenderingDefault(false); 
    Application.Run(new ConfigurationActionManagerForm()); 
} 

this एमएसडीएन से दृष्टिकोण मेरे आवेदन के लिए सही होगा?

Answer 1

मैं एक स्वच्छ और सरल लागू करने के लिए समाधान में उदाहरण का उपयोग कर पाया

यहाँ कैसे शुरुआत की जाए, तो डिफ़ॉल्ट aboutbox वर्ग का उपयोग करने का एक उदाहरण है मेरा प्रश्न माइक्रोसॉफ्ट द्वारा प्रदान किया गया।

मैंने इस एप्लिकेशन संदर्भ वर्ग को बनाया है जो एप्लिकेशन में सबकुछ के लिए ज़िम्मेदार है और मैं नीचे दिखाए गए Application.Run() में एक फॉर्म के बजाय इसका उपयोग करता हूं। प्रश्न में व्यवहार प्राप्त करने के लिए, मैं एक दूसरा रूप उपयोग कर रहा हूं जो छुपा हुआ है और केवल टास्कबार आइकन दिखाया गया है। यदि उपयोगकर्ता देखना चाहता है कि प्रक्रिया कैसा चल रही है, तो वे टास्कबार आइकन पर क्लिक कर सकते हैं और लॉगिंग विंडो देख सकते हैं, जो वास्तव में उदाहरण में ConfigurationApplierForm है।

class AnApplicationContext: ApplicationContext 
{ 
private Form _currentForm; 

नोट निर्माता निजी है, इस वर्ग के भीतर मुख्य है और स्थिर घोषित कर दिया।

private AnApplicationContext() 
{ 
    Application.ApplicationExit += new EventHandler(this.OnApplicationExit); 

    // choose which form to show based on arguments 
    if(Environment.GetCommandLineArgs().Contains("-apply")) 
    { 
     _currentForm = new ConfigurationApplierForm(); 
    } 
    else 
    { 
     _currentForm = new ConfigurationActionManagerForm(); 
    } 

    // initialize the form and attach event handlers 
    _currentForm.FormClosed += new FormClosedEventHandler(this.OnCurrentFormClosed); 
    _currentForm.ShowDialog(); 
} 

मुख्य मूल से थोड़ा अलग है। Run विधि

[STAThread] 
static void Main() 
{ 
    Application.EnableVisualStyles(); 
    Application.SetCompatibleTextRenderingDefault(false); 
    // context is passed instead of a form 
    Application.Run(new AnApplicationContext()); 
} 

private void OnCurrentFormClosed(object sender, EventArgs e) 
{ 
    ExitThread(); 
} 

private void OnApplicationExit(object sender, EventArgs e) 
{ 
    /* is there anything to do when all forms are closed 
    and the application is going to die?*/ 
} 
} 

इसके अलावा, हम परियोजना इस स्टार्टअप परियोजना है कि बताने के लिए की जरूरत है तर्क नोटिस।

Project Properties -> Application -> Startup Project 

Answer 2

आप आवेदन पत्र के बिना एप्लिकेशन.रुन() को कॉल कर सकते हैं।

इस तरह, यह एक फॉर्म खोलने के बिना संदेश पाश शुरू करेगा।

आप कॉल करने से पहले MessageBox.Show() को कॉल कर सकते हैं। Run() भी।

आप एक फॉर्म भी बना और खोल सकते हैं, और फिर तर्क निर्दिष्ट किए बिना रन() को कॉल कर सकते हैं - इसका मतलब यह है कि फ़ॉर्म को बंद करना स्वचालित रूप से एप्लिकेशन से बाहर नहीं निकलता है।

उदा।

 MessageBox.Show("Messaage!"); 

     Form1 f = new Form1(); 
     f.Show(); 

     Application.Run(); 

ऊपर बताए अनुसार, रन() करने का यह अर्थ है कि फॉर्म बंद करना स्वचालित रूप से एप्लिकेशन को बंद नहीं करता है। आपको फ़ॉर्म के बंद ईवेंट हैंडलर में इसे संभालने की आवश्यकता है। (आवेदन। एक्सिट())

एमएसडीएन ऑनलाइन इस के साथ आपकी मदद कर सकता है - एप्लिकेशन.रुन() के लिए सहायता प्रविष्टि की जांच करें।

Answer 3

क्या आपका मतलब है कि विजुअल स्टूडियो काम करता है?

यदि ऐसा है तो आप इसे सामान्य विंडोज एप्लिकेशन में नहीं कर सकते - विजुअल स्टूडियो चीट्स।

समस्या यह है कि एक विंडोज़ एप्लिकेशन या तो विंडोज फॉर्म एप्लिकेशन या कंसोल एप्लिकेशन हो सकता है, लेकिन यह दोनों नहीं हो सकता - यह संकलन समय पर तय किया गया है (.NET अनुप्रयोगों के लिए यह प्रोजेक्ट गुण विंडो में है)। आपके विकल्प हैं:

अपने आवेदन करें एक Windows Forms आवेदन

इस मामले # 1 और # 3 perfecty काम करेंगे में, लेकिन # 2 के लिए तो आप पाएंगे कि आप से नहीं पढ़ सकते हैं/पर लिखें कंसोल (क्योंकि कोई नहीं है!)।अपने appliction किसी भी प्रतिक्रिया देने की जरूरत नहीं है तो यह ठीक हो सकता है - सामान्य रूप से अपना काम करो और बस एक रूप से प्रदर्शित न करें:

[STAThread] 
static void Main(string[] args) 
{ 
    if (args.Length > 0) 
    { 
     // Handle #2 here 
    } 
    else 
    { 
     Application.EnableVisualStyles(); 
     Application.SetCompatibleTextRenderingDefault(false); 
     Application.Run(new ConfigurationActionManagerForm()); 
    } 
} 

आपके आवेदन एक सांत्वना आवेदन करें

इस मामले में # 2 पूरी तरह से काम करेगा, हालांकि # 1 और # 3 ठीक काम करेंगे, फिर भी आपके पास पृष्ठभूमि में कंसोल विंडो खुली होगी - अगर आप कंसोल विंडो बंद करते हैं तो आपका एप्लिकेशन समाप्त हो जाएगा।

फिर यह ठीक हो सकता है, लेकिन व्यक्तिगत रूप से मुझे यह एक हैक होने लगता है।

Cheat (कर क्या दृश्य स्टूडियो करता है) 2 अलग आवेदन होने से

दृश्य स्टूडियो धोखा - एक एक कंसोल अनुप्रयोग है और अन्य एक Windows Forms अनुप्रयोग है। आसान समाधान इसे छोड़ना है और कमांड लाइन संस्करण (उदा। myprogram_g.exe और myprogram_w.exe) चलाते समय उपयोगकर्ताओं को एक अलग निष्पादन योग्य प्रारंभ करना आवश्यक है।

विजुअल स्टूडियो एक कदम आगे चला जाता है और इसमें एक एकल प्रविष्टि बिंदु है, devenv। यह इस तथ्य का उपयोग करके करता है कि संगतता के कारण विंडोज शैल की बजाय .com फ़ाइल चलाएगा यदि कोई अस्पष्टता है। वेरास सभी शॉर्टकट इत्यादि। निष्पादन योग्य को इंगित करें, यदि आप devenv कमांड लाइन पर devenv.com एप्लिकेशन चलाएंगे, तो इसके बजाए यह जादू का उपयोग करेगा कि यह कंसोल या विंडोज एप्लिकेशन के रूप में चलता है या नहीं।

मेरी सलाह दो अलग-अलग अनुप्रयोगों को बनाने और इसे छोड़ने के लिए होगी।

अधिक जानकारी के लिए How do I write a program that can be run either as a console or a GUI application? देखें (उन टिप्पणियों को पढ़ना सुनिश्चित करें जिनमें अतिरिक्त उपयोगी सुझाव हैं)।

ildasm कैसे How to make an application as both GUI and Console application? देखें।

Answer 4

असल में आप कुछ बदलावों के साथ एक कंसोल applcation चाहते हैं।

using System; 
using System.Windows.Forms; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      if (args.Length == 0) 
      { 
       Console.WriteLine("No Arguments"); 
      } 
      else 
      { 
       if (args[0] == "a") 
       { 
        Application.EnableVisualStyles(); 
        Application.SetCompatibleTextRenderingDefault(false); 
        Application.Run(new AboutBox1()); 

       } 
      } 

     } 
    } 
} 

और AboutBox1 वर्ग:

using System.Reflection; 
using System.Windows.Forms; 

namespace ConsoleApplication1 
{ 
    partial class AboutBox1 : Form 
    { 
     public AboutBox1() 
     { 
      InitializeComponent(); 
      this.Text = String.Format("About {0} {0}", AssemblyTitle); 
      this.labelProductName.Text = AssemblyProduct; 
      this.labelVersion.Text = String.Format("Version {0} {0}", AssemblyVersion); 
      this.labelCopyright.Text = AssemblyCopyright; 
      this.labelCompanyName.Text = AssemblyCompany; 
      this.textBoxDescription.Text = AssemblyDescription; 
     } 

     #region Assembly Attribute Accessors 

     public string AssemblyTitle 
     { 
      get 
      { 
       object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); 
       if (attributes.Length > 0) 
       { 
        AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; 
        if (titleAttribute.Title != "") 
        { 
         return titleAttribute.Title; 
        } 
       } 
       return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); 
      } 
     } 

     public string AssemblyVersion 
     { 
      get 
      { 
       return Assembly.GetExecutingAssembly().GetName().Version.ToString(); 
      } 
     } 

     public string AssemblyDescription 
     { 
      get 
      { 
       object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); 
       if (attributes.Length == 0) 
       { 
        return ""; 
       } 
       return ((AssemblyDescriptionAttribute)attributes[0]).Description; 
      } 
     } 

     public string AssemblyProduct 
     { 
      get 
      { 
       object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); 
       if (attributes.Length == 0) 
       { 
        return ""; 
       } 
       return ((AssemblyProductAttribute)attributes[0]).Product; 
      } 
     } 

     public string AssemblyCopyright 
     { 
      get 
      { 
       object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); 
       if (attributes.Length == 0) 
       { 
        return ""; 
       } 
       return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; 
      } 
     } 

     public string AssemblyCompany 
     { 
      get 
      { 
       object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); 
       if (attributes.Length == 0) 
       { 
        return ""; 
       } 
       return ((AssemblyCompanyAttribute)attributes[0]).Company; 
      } 
     } 
     #endregion 

     private void okButton_Click(object sender, EventArgs e) 
     { 
      Close(); 
     } 
    } 
}