none
Threading: comment démarrer RRS feed

  • Question

  • bonjour,

    je veux démarrer un thread; j'ai donc créer:

    public ref class CWManager
    	{
    	
    	public:
    		CWManager::CWManager();
    		CWManager::~CWManager();
    		void CWManager::OnDocumentOpen(void);
    		static Word::Application^ objApplication = gcnew Word::Application;
    		static Word::Document^ objDocument = gcnew Word::Document;
    		static Word::Documents^ objDocuments = objApplication->Documents;
    		static Word::Paragraphs^ objParagraphs;
    		static Word::Paragraph^ objParagraph;
    		static Word::ParagraphFormat^ objFormat;
    		static Word::Words^ objWords;
    		static Word::Font^ objFont;
    		static System::Threading::Thread^ NewThread;

    et j'ai essayé de crée le thread

    System::Threading::Thread( NewThread);

    le compilateur me répond

    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(226): error C2512: 'System::Threading::Thread::Thread' : aucun constructeur par défaut approprié disponible

    pourtant le site msdn dit ceci


    Jean Noël Martin

    • Type modifié Aurel Bera vendredi 1 mars 2013 07:08 Discussion
    • Type modifié JeanNoel53 vendredi 1 mars 2013 18:53
    dimanche 10 février 2013 11:44

Réponses

  • Merci pour cette réponse. je vais m'en servir et je reviens donner des nouvelles;

    Donc :  J'ai essayé, et j'ai intégré la parti du main dans mon projet, mais ça ne compile pas.

    Je met mon code et le résultat de la compilation:

    #pragma managed 
    // SpecificationLoader.cpp : fichier projet principal.
    #include "stdafx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Enumerations.hpp"
    #include "Layout.h"
    #include "ClassesAligner.hpp"
    #include "LinkDescription.h"
    #include "Manager.h"
    #include "WordManager.h"
    #include "MainMenue.h"
    extern SpecificationLoader::CSoftwareManager SpecificationLoader::objSoftwareManager;
    using namespace System;
    using namespace System::Threading;
    using namespace System::Windows::Forms;
    using namespace SpecificationLoader;
    // On déclare une signature de fonction
    // int pour le nombre de paragraphe.
    public delegate void ThreadDelegate(int);
    
    // On déclare une classe, que l'on pourra passer en paramètre à un thread.
    // On peut ajouter autant de données que nécessaire.
    public ref class ThreadParam
    {
      public:
    	ThreadParam(ThreadDelegate^ ThreadDlg) : m_ThreadDlg(ThreadDlg){}
    	// Cette classe contient un pointeur sur une fonction
    	// Ce sera la fonction EndOfThread, qui nous signale la fin du thread
    	ThreadDelegate^ m_ThreadDlg;
    };
    
    [STAThreadAttribute]
    int main(array<System::String ^> ^args)
    {
    	// Activation des effets visuels de Windows XP avant la création de tout contrôle
    	Application::EnableVisualStyles();
    	Application::SetCompatibleTextRenderingDefault(false);
    	// On déclare un pointeur sur la fonction EndOfThread
    	ThreadDelegate^ Handle = gcnew ThreadDelegate(EndOfThread);
    	// On initialise une classe avec le pointeur ci-dessus
    	ThreadParam^ param = gcnew ThreadParam(Handle);
    	// On déclenche le thread et on lui transmet le paramètre ci-dessus
    	ThreadPool::QueueUserWorkItem(gcnew WaitCallback(ThreadFunction), param);
    	SpecificationLoader::objSoftwareManager.Initialization( true);
    	// Créer la fenêtre principale et l'exécuter
    	Application::Run(gcnew MainMenue());
    	return 0;
    }

    le résultat de la compilation suit:

    1>  SpecificationLoader.cpp
    1>SpecificationLoader.cpp(43): error C2065: 'EndOfThread' : identificateur non déclaré
    1>SpecificationLoader.cpp(43): error C3350: 'ThreadDelegate' : un constructeur délégué attend 2 argument(s)
    1>SpecificationLoader.cpp(47): error C2065: 'ThreadFunction' : identificateur non déclaré
    1>SpecificationLoader.cpp(47): error C3350: 'System::Threading::WaitCallback' : un constructeur délégué attend 2 argument(s)
    Je suppose que les élément EndOfTread et ThreadFunction ne sont pas bien déclarés.

    Quoi qu'il en soit, j'ai contourné mon problème comme je l'explique dans le thread les points clefs du lecteur de word. Je clos donc ce thread dans l'état. Je peux reprendre cette recherche à temps perdu, mais ce n'est pas critique


    Jean Noël Martin



    • Modifié JeanNoel53 mardi 11 juin 2013 14:29
    • Marqué comme réponse JeanNoel53 mardi 11 juin 2013 14:29
    mercredi 5 juin 2013 19:24

Toutes les réponses

  • Bonjour

    Regardez quelques minutes l’exemple en C++ sur le site MSDN (dans le lien que vous l’avez mis).

    Pour la création de l’objet Thread vous avez :

    Thread^ oThread = gcnew Thread( gcnew ThreadStart( &ThreadExample::ThreadProc ) );

     Le constructeur reçoit comme paramètre un autre objet de type ThreadStart, crée dans cet exemple avec le code

      gcnew ThreadStart( &ThreadExample::ThreadProc)

    Pour la création de l’objet ThreadStart, son constructeur reçoit comme paramètre  « &ThreadExample::ThreadProc » qui en effet c’est l’adresse d’une fonction statique qui sera exécutée dans le nouvel thread.

    Cordialement,


    Aurel BERA, Microsoft
    Microsoft propose ce service gratuitement, dans le but d'aider les utilisateurs et d'élargir les connaissances générales liées aux produits et technologies Microsoft. Ce contenu est fourni "tel quel" et il n'implique aucune responsabilité de la part de Microsoft.

    lundi 11 février 2013 09:25
  • Je crois que je n'ai pas tout compris

    j'ai codé:

    Thread^ objThread = gcnew Thread( gcnew ThreadStart( (ulTotalNbWords = objSchedulerGlobal.AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc))));

    je n'ai pas codé

    gcnew ThreadStart( &ThreadExample::ThreadProc) 
    je peu faire passer la fonction en static , mais:
    je ne sais pas très bien faire la correspondance: j'ai deux besoin concernant le thread

    - lui passer le paramètre pBloc;

    - récupérer à la fin de l’exécution:

    ulTotalNbWords


    Jean Noël Martin


    • Modifié JeanNoel53 lundi 11 février 2013 17:44
    lundi 11 février 2013 17:43
  • Bonjour

    Ca complique un peu le problème :

    J’ai trouvé cet article avec 3 exemples. Ce qui vous intéresse c’est le deuxième et le troisième :

    Passage de données aux threads et récupération de données à partir de threads

    Récupération de données avec les méthodes de rappel

    http://msdn.microsoft.com/fr-fr/library/ts553s52.aspx

    Faites attention à la définition des classes.

    Cordialement,


    Aurel BERA, Microsoft
    Microsoft propose ce service gratuitement, dans le but d'aider les utilisateurs et d'élargir les connaissances générales liées aux produits et technologies Microsoft. Ce contenu est fourni "tel quel" et il n'implique aucune responsabilité de la part de Microsoft.

    mardi 12 février 2013 07:54
  • bonjour

    Je continue mes recherches sur ce sujet

    J'ai mis le code du nouveau thread dans un module managé. il compile correctement

    je met la déclaration des objets de ce thread ci dessous:

    #ifndef SCHEDULERGLOBALMANAGE_H
    #define SCHEDULERGLOBALMANAGE_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    #define GLOBAL_ANALYSE_MANAGE  1
    
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/
    /*_____GLOBAL-MACROS__________________________________________________________*/
    /*_____GLOBAL-FUNCTIONS-PROTOTYPES____________________________________________*/
    /*_____CLASS-DEFINITION_______________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
    	using namespace System::Threading;
    	using namespace System::ComponentModel;
    	using namespace System::Collections;
    	using namespace System::Windows::Forms;
    	using namespace System::Data;
    	using namespace System::Drawing;
    	using namespace System::IO;
    	namespace Word = Microsoft::Office::Interop::Word;
    	using namespace Runtime::InteropServices;
    
    	public ref class CSchedulerGlobalManage
    	{
    		public:
    			static CSchedulerGlobalManage^ objSchedulerGlobalManage;
    			CSchedulerGlobalManage::CSchedulerGlobalManage();
    			CSchedulerGlobalManage::~CSchedulerGlobalManage();
    			static erc CSchedulerGlobalManage::AnalyseBlocText(CBloc* pBloc, erc ulTotalNbWords, bool bIsNewDoc);
    	};
    	
    }
    #endif


    et je veux adresser la méthode AnalyseBlocText à partir de word:

    mais je n'arrive pas à l'adresser:

    					if( iSize > 2)
    					{
    						ulTotalNbWords = objSchedulerGlobalManage->AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc);
    						Thread^ objThread = gcnew Thread( gcnew ThreadStart());
    					}
    

    J'ai ressortie la méthode pour bien faire ressortir les problèmes de compilation

    Le thread est incomplet, mais je n'arrive pas à adresser AnalyseBlocText

    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2065: 'objSchedulerGlobalManage' : identificateur non déclaré
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2227: la partie gauche de '->AnalyseBlocText' doit pointer vers un type class/struct/union/générique
    1>          le type est ''unknown-type''
    et je pense que c'est un problème bête.....


    Jean Noël Martin

    jeudi 14 février 2013 12:29
  • Bonjour

    Vous essayez de utilizer une function statique.

    Donc en place de   ulTotalNbWords = objSchedulerGlobalManage->AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc);
        

    utilisez quelque chose  de type

    ulTotalNbWords = CSchedulerGlobalManage->AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc);

    Cordialement,


    Aurel BERA, Microsoft
    Microsoft propose ce service gratuitement, dans le but d'aider les utilisateurs et d'élargir les connaissances générales liées aux produits et technologies Microsoft. Ce contenu est fourni "tel quel" et il n'implique aucune responsabilité de la part de Microsoft.

    jeudi 14 février 2013 12:55
  • J'ai retenu votre suggestion. Je vous donne la réponse du compilateur

    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2275: 'SpecificationLoader::CSchedulerGlobalManage' : utilisation non conforme de ce type comme expression
    1>          E:\usr\Memoria\dev\Linguistic\Analyser\com\SchedulerGlobalManage.h(26) : voir la déclaration de 'SpecificationLoader::CSchedulerGlobalManage'
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2227: la partie gauche de '->AnalyseBlocText' doit pointer vers un type class/struct/union/générique


    Jean Noël Martin

    jeudi 14 février 2013 18:37
  • Ca dépend de votre structure mais

    ulTotalNbWords =  SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc);

    peut vous aider.


    Aurel BERA, Microsoft
    Microsoft propose ce service gratuitement, dans le but d'aider les utilisateurs et d'élargir les connaissances générales liées aux produits et technologies Microsoft. Ce contenu est fourni "tel quel" et il n'implique aucune responsabilité de la part de Microsoft.


    • Modifié Aurel Bera vendredi 15 février 2013 11:10 Modif Code
    vendredi 15 février 2013 10:56
  • Sur ce conseil le compilateur répond:

    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2275: 'SpecificationLoader::CSchedulerGlobalManage' : utilisation non conforme de ce type comme expression
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(275): error C2227: la partie gauche de '->AnalyseBlocText' doit pointer vers un type class/struct/union/générique


    Jean Noël Martin

    vendredi 15 février 2013 12:35
  • J'ai modifié mon réponse initial, tout de suite après le poster:

    ulTotalNbWords =  SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc);

    Aurel


    Aurel BERA, Microsoft
    Microsoft propose ce service gratuitement, dans le but d'aider les utilisateurs et d'élargir les connaissances générales liées aux produits et technologies Microsoft. Ce contenu est fourni "tel quel" et il n'implique aucune responsabilité de la part de Microsoft.

    vendredi 15 février 2013 12:56
  • C'est bon: on va passer au threading

    pour le faire j'ai codé à partir de l'exemple(mis en commentaire au dessus):

            void CWManager::StartDocAnalysis( System::ComponentModel::BackgroundWorker^  backgroundWorker1, long ulNbWord, bool bNewDoc/*, Word::Application^ objApplication, Word::Document^ objDocument, Word::Documents^ objDocuments*/)
            {                
                CBloc* pBloc;
                int iTextWasTitle;
                int i;
                Thread^ objThread;
                SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText^ tws;

                nParagraph = 0;
                ulTotalNbWords = 0;
                try
                {
                    objParagraphs = objDocument->Paragraphs;
                    // il faut swapper les fichiers de backup
                    bool bStatus = CopyFile( (LPCTSTR)sLogFile.c_str(), (LPCTSTR)sSavedLogFile.c_str(), false);
                    int iStatus = remove( sLogFile.c_str());
                    for each( Word::Paragraph^ objParagraph in objParagraphs)
                    {
                        System::String^ wsText = objParagraph->default->default;
                        const wchar_t* chars = (const wchar_t*)(Marshal::StringToHGlobalUni( wsText)).ToPointer();
                        char* c = objStrConv.awcstombs( (wchar_t*)chars);
                        iSize= strlen( c);
                        len = iSize;
                        Marshal::FreeHGlobal(IntPtr((void*)chars));
                        wchar_t* cha = objStrConv.ambstowcs( c);
                        iSize = wcslen( cha);
                        objStrConv.StrFreeA( c);
                        pBloc = new CBloc;
                        pBloc->wsBlocText.append( cha);
                        // CSchedulerGlobal::AnalyseBlocText(CBloc* pBloc)
                        // appeler SchedulerGlobal pour traiter le paragraph.
                        if( iSize > 2)
                        {
                            // Supply the state information required by the task.
                            // ThreadWithState^ tws = gcnew ThreadWithState( "This report displays the number {0}.", 42);
                            // gcnew ExampleCallback(&Example::ResultCallback)
                            // Thread^ t = gcnew Thread(gcnew ThreadStart(tws, &ThreadWithState::ThreadProc));
                            // t->Start();
                            // t->Join();
                            tws = gcnew( SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText( pBloc, ulTotalNbWords, bNewDoc));
                            gcnew CSchedulerGlobalManage::ReturnCallback( & CSchedulerGlobalManage::ReturnCallback());
                            objThread = gcnew Thread( gcnew ThreadStart( tws, &SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText));
                            objThread->Start();
                            ulTotalNbWords;
                        }
                        // Récupérer les informations de Layout
                        i = oldlen;
                        while( len != oldlen);
                        oldlen = len;
                        i = len;
                        objFormat = objParagraph->Format;
                        //objWords = objParagraph->First;
                        iTextWasTitle = 0;
                        Word::WdBaselineAlignment Align = objParagraph->BaseLineAlignment;
                        float LeftIndent = objFormat->LeftIndent;
                        float LineSpacing = objFormat->LineSpacing;
                        float SpaceAfter = objFormat->SpaceAfter;
                        if( SpaceAfter > 6)
                            iTextWasTitle++;
                        if( len < 45)
                            iTextWasTitle++;
                        float SpaceBefore = objFormat->SpaceBefore;
                        Word::WdColor BCouleur = objFormat->Shading->BackgroundPatternColor;
                        Word::WdColor FCouleur = objFormat->Shading->ForegroundPatternColor;
                        Word::WdTextureIndex Texture = objFormat->Shading->Texture;
                        objWords = objDocument->Words;//retourne une liste avec tous les mots d'un document d'un paragraph
                        //un mot = un objet de type Range
                        objWords = objDocument->Words;//retourne une liste avec tous les mots d'un document d'un document
                        for each( Word::Range^ objWord in objWords)//pour chaque mot dans la liste
                        {    // on ne s'intéresse que à la partie correspondante au paragraphe courant
                            len = iSize;
                            int offset = ulTotalNbWords;
                            int iCurrentPos = len + offset;
                            if( i < iCurrentPos)
                            {    
                                Word::ParagraphFormat^ FWords = objWord->ParagraphFormat;//recupere le ParagraphFormat du mot
                                // Récupèrer le text dans l'élément
                                // Récupérer les informations de Layout et les mettre dans l'élément
                                Word::WdColor BackgroundColor = FWords->Shading->BackgroundPatternColor;
                                Word::WdColor ForegroundColor = FWords->Shading->ForegroundPatternColor;
                                objFont = objWord->Font;
                                float FontSize = objFont->Size;
                                if( FontSize > 12)
                                    iTextWasTitle++;
                                int Bold = objFont->Bold;
                                if( Bold < 0)
                                    iTextWasTitle++;
                                System::String^ FontName = objFont->Name;
                                int Italic = objFont->Italic;
                                if( Italic < 0)
                                    iTextWasTitle++;
                                Word::WdUnderline Underline = objFont->Underline;
                            }
                            i++;
                        }
                        if( iTextWasTitle > 2)
                            bTitle = true;
                        bLayout = true;
                        // pour chaque mot du paragraph on enregistre le Layout dans la list Elements avec le mot correspondant.
                        objThread->Join();
                        // il faut appeler le backgroundWorker1_ProgressChanged( System::Object^ sender, ProgressChangedEventArgs^ e)
                        erc ProgressPercentage = 100 * ulTotalNbWords / ulNbWord;
                        backgroundWorker1->ReportProgress( ProgressPercentage);
                        objStrConv.StrFreeW( cha);
                    }
                }    
                finally
                {
                    CloseDocument( backgroundWorker1, objApplication, objDocument, objDocuments);
                }
            }
    et j'ai récupéré auprès du compilateur une bordée d'injures;
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(251): error C2065: 'tws' : identificateur non déclaré
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(251): error C3867: &'SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText' : liste d'arguments manquante dans l'appel de fonction ; utilisez 'SpecificationLoader::CSchedulerGlobalManage::AnalyseBlocText' pour créer un pointeur vers membre
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(259): warning C4800: 'BOOL' : valeur forcée à la valeur booléenne 'true' ou 'false' (avertissement sur les performances)
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(284): error C2065: 'tws' : identificateur non déclaré
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(284): error C2059: erreur de syntaxe : ';'
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(286): error C2065: 'tws' : identificateur non déclaré
    1>..\..\..\..\Linguistic\WordReader\src\WordManager.cpp(286): error C3350: 'System::Threading::ThreadStart' : un constructeur délégué attend 2 argument(s)


    Jean Noël Martin



    • Modifié JeanNoel53 samedi 16 février 2013 00:06
    vendredi 15 février 2013 15:21
  • J'attends toujours la réponse

    Jean Noël Martin

    jeudi 21 février 2013 07:43
  • Non: mon sujet est de récupérer le nombre de mots du paragraphe et je ne le connais que après sa segmentation. J'ai donc entrepris de mettre l'analyse du document dans un thread qui tournerait concurament au lecteur de word avec une synchro entre les deux en fonction de la disponibilité des résultats

    Jean Noël Martin

    lundi 4 mars 2013 15:17
  • Ce problème est très important: il ne permet pas de finir le thread: Les points clefs du lecteur de word

    Jean Noël Martin

    dimanche 21 avril 2013 07:48
  • Bonjour.

    Ce problème est-il toujours d'actualité ?

    Si c'est le cas,et que votre problème n'est que de récupérer les informations de traitement d'un thread dans un autre thread. les solutions sont connues (delegate, invoke).

    • Modifié Miaou77 vendredi 24 mai 2013 02:16
    vendredi 24 mai 2013 02:08
  • Je ne comprend pas votre réponse.

    Jean Noël Martin

    vendredi 24 mai 2013 08:12
  • Bonjour.

    Ma première question était : "Ce problème est-il toujours d'actualité ?"

    Vous me répondez, donc pour moi la réponse est oui.

    Ma deuxième question : si j'ai bien compris les différents messages ci-dessus, souhaitez-vous récupérer les informations d'un thread à partir d'un autre thread ?

    Je veux juste la confirmation que j'ai bien compris votre problématique, et je vous fournis une solution.


    • Modifié Miaou77 vendredi 24 mai 2013 23:34
    vendredi 24 mai 2013 23:32
  • bonjour,

    Mon besoin est de récupérer le nombre de mot d'un paragraph qui est connu par la fonction startDocAnalyse et qui doit être utilisé par la fonction du driver de word qui est activé par le BackgroundWorker


    Jean Noël Martin

    lundi 27 mai 2013 11:24
  • Bonjour.

    Vous dîtes vouloir récupérer le nombre de mots d'un paragraphe lorsque le thread se termine. Est-ce que ce nombre est simplement un unsigned long, au niveau de votre code ? 



    • Modifié Miaou77 mardi 28 mai 2013 20:22
    mardi 28 mai 2013 20:19
  • bonjour,

    Ça peut être un entier ou  un unsigned long


    Jean Noël Martin

    mercredi 29 mai 2013 10:31
  • Bonjour.

    Void un code qui explique le concept pour récupérer les données d'un thread. Il faudra le comprendre et l'adapter à votre situation (le code est commenté). C'est en mode console. Ajouter la référence à System::Windows::Forms dans le projet, pour une compilation corrrecte. Dans un projet console la référence n'y est pas par défaut.

    Comme vous le verrez, avec le framework, on peut faire du multithread sans utiliser les threads directement.

    //--------------------------------------------------------------------------------
    // Main.cpp
    //--------------------------------------------------------------------------------
    using namespace System;
    using namespace System::Threading;
    
    // Ne pas oublier d'ajouter la référence à System::Windows::Forms
    // dans les références du projet. C'est un projet console à la base.
    using namespace System::Windows::Forms;
    
    // On déclare une signature de fonction
    // int pour le nombre de paragraphe.
    public delegate void ThreadDelegate(int);
    
    // On déclare une classe, que l'on pourra passer en paramètre à un thread.
    // On peut ajouter autant de données que nécessaire.
    public ref class ThreadParam{
    
      public:
    
    	ThreadParam(ThreadDelegate^ ThreadDlg) : m_ThreadDlg(ThreadDlg){}
    
    	// Cette classe contient un pointeur sur une fonction
    	// Ce sera la fonction EndOfThread, qui nous signale la fin du thread
    	ThreadDelegate^ m_ThreadDlg;
    };
    
    // Le thread en lui-même, il compte les paragraphes, enfin vite fait...
    static void ThreadFunction(Object^ obj){
    
    	// On récupère les paramètres
    	ThreadParam^ param = (ThreadParam^)obj;
    
    	// Ici tout le code qui compte les paragraphes. Du vite fait, c'est 500.
    	// Remplacer par votre code.
    	int iNumParagraphe = 500;
    
    	// Le thread est terminé, on invoke le pointeur de fonction
    	// pour dire que c'est terminé.
    	param->m_ThreadDlg(iNumParagraphe);
    }
    
    static void EndOfThread(int iNumParagraphe){
    
    	// Le thread est terminé
    	// Le paramètre nous donne le nombre de paragraphe.
    	MessageBox::Show(iNumParagraphe.ToString() + " paragraphes", "EndOfThread");
    }
    
    int main(array<System::String ^> ^args){
    		
    	// On déclare un pointeur sur la fonction EndOfThread
    	ThreadDelegate^ Handle = gcnew ThreadDelegate(EndOfThread);
    
    	// On initialise une classe avec le pointeur ci-dessus
    	ThreadParam^ param = gcnew ThreadParam(Handle);
    
    	// On déclenche le thread et on lui transmet le paramètre ci-dessus
    	ThreadPool::QueueUserWorkItem(gcnew WaitCallback(ThreadFunction), param);
    
    	// La on triche un peu.
    	// Normalement, avant les 3 secondes, le thread se termine
    	// et une boîte de dialogue affiche 500 paragraphes.
    	::Thread::Sleep(3000);
    
    	return 0;
    }



    • Modifié Miaou77 lundi 3 juin 2013 19:10
    dimanche 2 juin 2013 22:29
  • Merci pour cette réponse. je vais m'en servir et je reviens donner des nouvelles;

    Donc :  J'ai essayé, et j'ai intégré la parti du main dans mon projet, mais ça ne compile pas.

    Je met mon code et le résultat de la compilation:

    #pragma managed 
    // SpecificationLoader.cpp : fichier projet principal.
    #include "stdafx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Enumerations.hpp"
    #include "Layout.h"
    #include "ClassesAligner.hpp"
    #include "LinkDescription.h"
    #include "Manager.h"
    #include "WordManager.h"
    #include "MainMenue.h"
    extern SpecificationLoader::CSoftwareManager SpecificationLoader::objSoftwareManager;
    using namespace System;
    using namespace System::Threading;
    using namespace System::Windows::Forms;
    using namespace SpecificationLoader;
    // On déclare une signature de fonction
    // int pour le nombre de paragraphe.
    public delegate void ThreadDelegate(int);
    
    // On déclare une classe, que l'on pourra passer en paramètre à un thread.
    // On peut ajouter autant de données que nécessaire.
    public ref class ThreadParam
    {
      public:
    	ThreadParam(ThreadDelegate^ ThreadDlg) : m_ThreadDlg(ThreadDlg){}
    	// Cette classe contient un pointeur sur une fonction
    	// Ce sera la fonction EndOfThread, qui nous signale la fin du thread
    	ThreadDelegate^ m_ThreadDlg;
    };
    
    [STAThreadAttribute]
    int main(array<System::String ^> ^args)
    {
    	// Activation des effets visuels de Windows XP avant la création de tout contrôle
    	Application::EnableVisualStyles();
    	Application::SetCompatibleTextRenderingDefault(false);
    	// On déclare un pointeur sur la fonction EndOfThread
    	ThreadDelegate^ Handle = gcnew ThreadDelegate(EndOfThread);
    	// On initialise une classe avec le pointeur ci-dessus
    	ThreadParam^ param = gcnew ThreadParam(Handle);
    	// On déclenche le thread et on lui transmet le paramètre ci-dessus
    	ThreadPool::QueueUserWorkItem(gcnew WaitCallback(ThreadFunction), param);
    	SpecificationLoader::objSoftwareManager.Initialization( true);
    	// Créer la fenêtre principale et l'exécuter
    	Application::Run(gcnew MainMenue());
    	return 0;
    }

    le résultat de la compilation suit:

    1>  SpecificationLoader.cpp
    1>SpecificationLoader.cpp(43): error C2065: 'EndOfThread' : identificateur non déclaré
    1>SpecificationLoader.cpp(43): error C3350: 'ThreadDelegate' : un constructeur délégué attend 2 argument(s)
    1>SpecificationLoader.cpp(47): error C2065: 'ThreadFunction' : identificateur non déclaré
    1>SpecificationLoader.cpp(47): error C3350: 'System::Threading::WaitCallback' : un constructeur délégué attend 2 argument(s)
    Je suppose que les élément EndOfTread et ThreadFunction ne sont pas bien déclarés.

    Quoi qu'il en soit, j'ai contourné mon problème comme je l'explique dans le thread les points clefs du lecteur de word. Je clos donc ce thread dans l'état. Je peux reprendre cette recherche à temps perdu, mais ce n'est pas critique


    Jean Noël Martin



    • Modifié JeanNoel53 mardi 11 juin 2013 14:29
    • Marqué comme réponse JeanNoel53 mardi 11 juin 2013 14:29
    mercredi 5 juin 2013 19:24