Ouvrir un fichier avec son applicationRésolu

Question

J'ai une application qui utilise le composant windows media player, j'ouvre un fichier avec mon appli tout marche nikel, mais lorsque j'en ouvre un autre sans quitter mon appli, qui est deja en train de lire l'autre fichier audio, sa me lance une deuxième fois mon application, du coup j'ai deux mon appli qui jou deux fichiers differents.

J'ouvre montre mon code qui recupère le fichier et le lit au lancement de l'appli :

string[] arg = Environment.GetCommandLineArgs();
            if (arg.Length > 0)
            {
                try
                {
                    if (arg[1] != "")
                    {
                        axWMP.URL = arg[1];    //axWMP est le composant windows media player
                    }
                }
                catch{}
            }

Est ce que quelqu'un a une solution?

Lutinore · Accepted Answer

Salut, tu veux donc une seule instance de ton applucation c'est ça !?

mutex :
http://www.csharpfr.com/code.aspx?ID=11548

processus :
http://www.csharpfr.com/codes/EMPECHER-APPLIC-LANCER-FOIS_20698.aspx

romagny13 · Answer

avec GetCommandLineArgs() on recupere le chemin complet vers le fichier (ex : c:\....\mavideo.avi)

if (Environment.GetCommandLineArgs().Length == 2)

                {

               
                }

++

wald39 · Answer

Vos deux réponses sont bonnes mais comment je fais pour que mon application arrete de jouer le premier fichier et récupère le chemin de l'autre pour ensuite le jouer ?

Lutinore · Answer

Une solution qu'on voit souvent sur le web c'est de passer par le .Net-remoting mais je ne suis pas trop fan du Net-remoting, l'autre soluce c'est d'envoyer un message à la première instance via l'API Win32. Si je trouve le temps j'essayerai de te donner un exemple.

wald39 · Answer

En tous cas merci, et un exemple m'aiderais bien !

Lutinore · Answer

à tester..

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Diagnostics;


namespace Lutinore
{
    // Une seule instance de l'application, la ligne de commande est passée à l'instance active.
    // C'était également possible de faire ça avec un mutex nommé et le .NET remoting.
    // Le code unsafe peut être remplacé par des GCHandle pinned ou en copiant les données
    // dans le tas non managé avec Marshal.StringToHGlobalAuto, Marshal.StructureToPtr etc..
    internal class MainForm : Form
    {
        #region Win32


        [ StructLayout( LayoutKind.Sequential ) ]
        private struct COPYDATASTRUCT
        {
            public UIntPtr dwData;
            public uint cbData;
            public IntPtr lpData;
        }


        [ DllImport( "User32.dll" ) ]
        private static extern IntPtr SendMessage( IntPtr hWnd, uint msg, UIntPtr wParam, IntPtr lParam );


        private const int WM_COPYDATA = 0x004A;
        private const int CMDLINEARGS = 0x1001; // user value.


        #endregion // Win32


        private MainForm( ) : base( )
        {
            ProcessCommandLine( Environment.CommandLine );
        }


        protected override void WndProc( ref Message m )
        {
            if ( m.Msg == WM_COPYDATA )
            {
                unsafe // Compile with -unsafe.
                {
                    COPYDATASTRUCT* pDataStruct = ( COPYDATASTRUCT* )m.LParam;


                    if ( ( int )pDataStruct->dwData == CMDLINEARGS )
                    {
                        string cmdLine = new string( ( char* )pDataStruct->lpData );
                        ProcessCommandLine( cmdLine );
                        m.Result = ( IntPtr )1;
                        return;
                    }
                }
            }


            base.WndProc( ref m );
        }


        private void ProcessCommandLine( string cmdLine )
        {
            MessageBox.Show( cmdLine );
        }


        [ STAThread ]
        private static void Main( /* string[ ] args */ )
        {
            IntPtr hWnd = IntPtr.Zero;


            try
            {
                Process process = Process.GetCurrentProcess( );


                foreach( Process p in Process.GetProcessesByName( process.ProcessName ) )
                {                    if ( p.Id !process.Id && p.MainModule.FileName process.MainModule.FileName )
                    {
                        hWnd = p.MainWindowHandle;
                        break;
                    }
                }
            }
            catch
            {
                // ..
            }


            if ( hWnd != IntPtr.Zero )
            {
                string cmdLine = Environment.CommandLine + '\0';
                COPYDATASTRUCT dataStruct = new COPYDATASTRUCT( );


                unsafe // Compile with -unsafe.
                {
                    fixed ( char* pCmdLine = cmdLine )
                    {
                        COPYDATASTRUCT* pDataStruct = &dataStruct;
                        pDataStruct->dwData = ( UIntPtr )CMDLINEARGS;
                        pDataStruct->cbData = ( uint )cmdLine.Length * 2U; // Size in bytes.
                        pDataStruct->lpData = ( IntPtr )pCmdLine;


                        SendMessage( hWnd, WM_COPYDATA, UIntPtr.Zero, ( IntPtr )pDataStruct );
                    }
                }


                return; // Quitte cette instance de l'application.
            }


            // Lance l'unique instance de l'application.
            Application.EnableVisualStyles( );
            Application.SetCompatibleTextRenderingDefault( false );
            Application.Run( new MainForm( ) );
        }
    }
}

ShareVB · Answer

salut,

par exemple : http://www.csharpfr.com/codes/OUVRIR-DOCUMENTS-DANS-MEME-INSTANCE-APPLICATION-SANS-RELANCEMENT_41097.aspx

il faut effectivement ensuite rajouter la gestion de Environment.CommandLine

ShareVB

Ouvrir un fichier avec son application

7 réponses

Votre réponse

Discussions similaires