स्पलैशस्क्रीन.क्लोज़ (टाइम्सपैन.फ्रोमिलिसेकंड्स (int)): क्या टाइम्स पैन में एक इवेंट भेजा गया है?

Question

सी # WPF आवेदन

मैं एक SplashScreen

Thread.Sleep(int); //int = milliseconds to display splash screen 

का उपयोग करते समय है कि नींद समय तक पहुँच जाता है से समय की एक न्यूनतम राशि के लिए स्टार्टअप पर प्रदर्शित किया जा रहा है, कोड शुरू और SplashScreen फ़ेड आउट द्वारा बंद करने के लिए का उपयोग कर

SplashScreen.Close(Timespan.FromMilliseconds(int)); //int = milliseconds fade-out 

मैं इस बिंदु पर रोकने के लिए SplashScreen तक इंतजार करना चाहते हैं 100% पारदर्शी हो जाते हैं और पूरी तरह से बंद कर दिया है है, तो अन्य कार्यों के साथ जारी है, आईई कंसोल को लिखना या मेनविंडो प्रदर्शित करना।

क्या कोई ईवेंट निकाल दिया गया है जब (TimeSpan.FromMilliseconds (int)) पूरा हो गया है? कोई अन्य सुझाव?

namespace StartupSplash 
{ 
    public class SplashScreenStartup 
    { 
     //IMPORTANT:set image property to Resource and NOT Splash Screen 
     private SplashScreen Splash = new SplashScreen("Resources/SplashScreen.png"); 

     public void SplashScreenStartUp() 
     { 
      Splash.Show(false, true); 
      Thread.Sleep(3000); // Pause code, display splash screen 3 seconds 
      Splash.Close(TimeSpan.FromMilliseconds(3000)); // 3 second splash fade-out 
      // I want to wait until splash screen fadeOut has completed before 
      // this next console output is performed. 
      Console.WriteLine("Executes before Splash fadeOut completes."); 
     } 

    } 

Answer 1

मुझे टाइमस्पैन के पूरा होने पर सुनने के लिए कभी भी कोई घटना नहीं मिली। इसके अलावा, धागे को रोकने के लिए निर्णय लेने के बाद, मैंने इसके बजाय DispatcherTimers का उपयोग करना चुना।

(मैं पतला और संदर्भ उद्देश्यों के लिए यह एक वर्ग में तर्क की जा सकती है)

using System; 
using System.Windows; 
using System.Windows.Threading; 


namespace StartupSplash2 
{ 

public partial class MainWindow : Window 
{ 
    private DispatcherTimer visibleTimer; 
    private DispatcherTimer fadeoutTimer; 
    private SplashScreen splash; 
    private int visibleTime = (4000); //milliseconds of splash visible time 
    private int fadeoutTime = (1500); //milliseconds of splash fadeout time 

    public MainWindow() 
    { 
     //hide this MainWindow window until splash completes 
     this.Visibility = Visibility.Hidden; 
     InitializeComponent(); 
     splashIn(); //start the splash 
    } 

    private void splashIn() 
    { 
     splash = new SplashScreen("Resources/SplashScreen.png"); //ensure image property is set to Resource and not screen saver 
     visibleTimer = new DispatcherTimer(); //timer controlling how long splash is visible 
     visibleTimer.Interval = TimeSpan.FromMilliseconds(visibleTime); 
     visibleTimer.Tick += showTimer_Tick; //when timer time is reached, call 'showTimer_Tick" to begin fadeout 
     splash.Show(false, true); //display splash 
     visibleTimer.Start(); 
    } 

    private void showTimer_Tick(object sender, EventArgs e) 
    { 
     visibleTimer.Stop(); 
     visibleTimer = null; //clear the unused timer 
     fadeoutTimer = new DispatcherTimer(); 
     fadeoutTimer.Interval = TimeSpan.FromMilliseconds(fadeoutTime); //a timer that runs while splash fades out and controlls when main window is displayed 
     fadeoutTimer.Tick += fadeTimer_Tick; //when fadeout timer is reached, call 'fadeTimer_Tick' to show main window 
     splash.Close(TimeSpan.FromMilliseconds(fadeoutTime)); //begin splash fadeout to close 
     fadeoutTimer.Start(); 
    } 

    private void fadeTimer_Tick(object sender, EventArgs e) 
    { 
     fadeoutTimer.Stop(); 
     fadeoutTimer = null; //clear the unused timer 
     splash = null; //clear the splash var 
     MainWindowReady(); //call method to display main window 
    } 

    public void MainWindowReady() 
    { 
     this.Visibility = Visibility.Visible; 
     //Here is the start of the Main Window Code 
     this.Content = "Ok, the app is ready to roll"; 
    } 

    } 
} 

Answer 2

शायद यह कोड आपकी मदद कर सकता है। BackgroundWorker वर्ग का उपयोग करना:

BackgroundWorker worker = new BackgroundWorker(); 
worker.DoWork += (o, ea) => 
{ 
    // Dispatcher.Invoke commands the dispatcher to do something 
    Dispatcher.Invoke((Action)(() => Splash.Close(TimeSpan.FromMilliseconds(3000))); 
    // Sleeps this worker but NOT the UI 
    Thread.Sleep(3000); 
}; 
worker.RunWorkerCompleted += (o, ea) => 
{ 
    // Open your mainwindow sample 
    MainWindow w = new MainWindow(); 
    w.Show(); 
}; 

//Runs the worker on its own thread 
worker.RunWorkerAsync(); 

यह आपके splashscreen के समापन शुरू कर देना चाहिए, तो यह माध्यम से नींद आती है और इसके पूर्ण होने पर यह आपके MainWindow खोल देंगे। मैं वास्तव में एक लॉगिन लागू करने और मेरे डब्ल्यूपीएफ ऐप के लिए जानकारी लाने के लिए कुछ इसी तरह का उपयोग करता हूं, जबकि प्रगति पट्टी प्रदर्शित करता हूं और इसमें "सर्वर से कनेक्ट करना", "लॉग इन करना" और "डेटा लाने" जैसी सामग्री को टेक्स्ट अपडेट करना होता है।

Answer 3

मुझे पता चला कि निम्नलिखित कोड काम करता है। मैं बिल्कुल स्पष्ट नहीं हूं कि क्यों और मैं इसे बेहतर समझने के करीब आऊंगा।

कृपया आवश्यकतानुसार आलोचना करें, मैं यहां सीखने और साझा करने के लिए हूं। चीयर्स।

class Tester 
    { 
    // Create splash screen instance and reference the image location. 
    // IMPORTANT Ensure that the image properties are set to Resource and NOT Splash Screen 
    private SplashScreen Splash = new SplashScreen("Resources/SplashScreen.png"); 

    public void Display() 
    { 
     Splash.Show(false, true); 
     // pause the code, thus, displaying the splash for 3 seconds 
     Thread.Sleep(3000); 
     // close the splash 
     Close(); 
    } 

    private void Close() 
    { 
     // sets the fadeout time in milliseconds 
     int fadeOutTime = 1500; 

     // wait until the splash screen fadeOut has completed before writing to the console 
     BackgroundWorker worker = new BackgroundWorker(); 
     worker.DoWork += (o, ea) => 
     { 
      // Run background task (fade out and close the splash) 
      Splash.Close(TimeSpan.FromMilliseconds(fadeOutTime)); 
      // Sleep this worker but NOT the UI (for the same time as the fade out time) 
      Thread.Sleep(fadeOutTime); 
     }; 
     worker.RunWorkerCompleted += (o, ea) => 
     { 
      // Execute task after splash has closed completely 
      Console.WriteLine("This is after the splash screen fadeOut completes."); 
     }; 
     // start the background task, on it's own thread 
     worker.RunWorkerAsync(); 
    } 

} 

Answer 4

मैं अंत में निष्कर्ष यह है कि मैं अपने पिछले टिप्पणी में गलत पेड़ भौंकने था के लिए आया था। पृष्ठभूमि में स्प्लैशस्क्रीन प्रदर्शित करना समस्याग्रस्त दोनों है (यह स्वचालित रूप से बंद करने से इनकार कर दिया, चाहे मैंने कोशिश की हो) और अनैतिक। यहां मैं क्या समाप्त हुआ ... वास्तव में सरल!

using System; 
using System.Net; 
using System.Windows; 

namespace WpfApplication1 
{ 
    /// <summary> 
    /// Interaction logic for Window1.xaml 
    /// </summary> 
    public partial class Window1 : Window 
    { 
    public Window1() { 
     InitializeComponent(); 
    } 

    private void Window_Loaded(object sender, RoutedEventArgs e) { 
     // show the splash screen 
     // nb: Resources/SplashScreenImage.png file Properties ~ Build Action='Resource' 
     var splashScreen = new SplashScreen("Resources/SplashScreenImage.png"); 
     splashScreen.Show(false); // don't close automatically 
     // ... initialise my application ... 
     Initialise(); 
     // close the splash screen. 
     splashScreen.Close(TimeSpan.FromMilliseconds(250D)); 
    } 

    private void Initialise() { 
     // do my long-running application initialisation on the main thread. 
     // In reality you'd do this download asyncronously, but in this case 
     // it serves as a simple proxy for some "heavy" inititalisation work. 
     textBox1.Text = new WebClient().DownloadString("http://stackoverflow.com/questions/13213625/splashscreen-closetimespan-frommilliseconds-listen-for-closed-event"); 
    } 
    } 

} 

मुझे आशा है कि मदद करता है ... हालांकि मैं बिल्कुल भी विश्वास है कि यह होगा ;-)

चीयर्स नहीं हूँ। कीथ।

पीएस: मुझे आश्चर्य है कि स्पलैश ने क्यों बंद करने से इनकार कर दिया? मेरा अनुमान है कि यह आंतरिक रूप से उन घटनाओं पर निर्भर करता है जो WPF के इवेंट-प्रेषण-थ्रेड के बराबर (यानी जिसे भी कहा जाता है) पर उपलब्ध हैं (यानी सदस्यता लेने योग्य)।

Answer 5

मैं एक घटना है कि SplashScreen समाप्त होने के बाद आप अनुप्रयोग शुरू करने के लिए अनुमति देता है SplashScreen.Dismissed बुलाया पाया। हालांकि, न्यूनतम आवश्यक ओएस विंडोज 8 है और मैं इसका उपयोग नहीं कर सका। अधिक जानकारी यहां मिल सकती है MSDN