enum  class SerialParity { None,Odd,Even};
SerialParity Parity;
Parity=SerialParity::Odd;

array<datatype>^ arrayVarName ;

//exemple de creation d'un array avec appel du contructeur :
using namespace stdcli ::language ;
array<double>^ ArrayDouble= gcnew array<double>(5);//5 double
array<String^>^ Arraystrings= gcnew array<String^>(10);

class NoManage{} ;
array< NoManage *>^ pNoManage = gcnew array< NoManage *>(10) ;
for(int i=0;i<pNoManage ->Length;i++)
pNoManage [i]=new NoManage();	
for(int i=0;i<pNoManage->Length;i++)
delete pNoManage[i];

array<String^>^ ArrayString= gcnew array<String^>{"1","2","3","4"};

array<int,1>^ TwoInts= gcnew array<int>(2);//2 entiers
array<int,2>^ TwoIntsx3= gcnew array<int,2>(2,3);// 2 X 3
for(int n=0;n<TwoIntsx3->GetLength(0);n++)
{
	for(int i=0;i<TwoIntsx3->GetLength(1);i++)
		TwoIntsx3[n,i]=((n*5)+i);
}

 array< array<datatype>^ >^

array<array<int>^ >^ varMulti= gcnew array<array<int>^ >(2);
for(int i=0;i<varMulti->Length;i++)
varMulti[i] = gcnew array <int>(10+(i*3));	// 2 tableaux un de 10 et un de 13 elements

variable[index1,index2,....]

value class Point
{
public 
int x,y ;
Point(int x,int y) :x(x),y(y){}
} ;
Point p1(1,2) ;
Object ^o =p1 ; 	// la conversion est implicite.
Point ^hp=p1; 		
Object ^o1 = 1024; // boxing implicite

Point p2=(Point)o ;
Point p1=(Point)hp ;

auto int normalinteger ;

const Int32 intergerconstant=32 ;

bool GetFlag() const {return true ;}

UInt16  n=45000 ;
Byte c=n ; // c vaut 175 et pas 45000.

safe_cast< type-de-donnée-pour-conversion >(expression).

char b= safe_cast<char>(a);
// ou
char b=(char )a;

Console ::WriteLine((12356).ToString()) ;
Console ::WriteLine((0xFF).ToString());

Console ::WriteLine(true.ToString());
Console ::WriteLine(false.ToString());

String ^ s1= " \x61 " ; //a 
String^ s2="\x612"; // ne vaut pas a2 mais la valeur hexa de la séquence escape Unicode 612

int intvar=10 ;
int  %intref =intvar ;
Console ::WriteLine(intref) ;
Intref=20 ;
Console ::WriteLine(intref) ;

ref class Indirectionclass
{
public :
int n ;
Indirectionclass(int x){n=x;}

} ;

Indirectionclass LocalObj(10) ;
Indirectionclass  ^p ;

p =%LocalObj ; // place une référence de LocalObj dans le handle p
Console ::WriteLine(p->n) ; // renvoie 10

int  %i=LocalObj.n ; // LocalObj.n a une reference, attention ne fonctionne pas sur une propriété ( property int n )

i=50;
Console ::WriteLine(p->n) ; // renvoie 50

int ^y= gcnew int(10); // attention c'est bien un int initialisé a 10 et pas un tableau de 10 int..
Console ::WriteLine(y) ;// 10
*y=500 ; // nouvelle valeur par indirection 
Console ::WriteLine(*y) ;

array <int>^ arraynumbers= gcnew array<int>{1,2,3} ;
for each (int i in arraynumbers)
{
Console ::WriteLine(i) ;
}

void function(int ^v)
{
      *v= *v + 100 ;
} 
int  ^nvar=5 ;
function(nvar) ; // nvar vaut 105.

void function(int %v)
{
	v= v + 100 ;
} 
int  nvar=5 ;
function(nvar) ; // nvar vaut 105.

ref class MyClass{} ;

MyClass ^ function()
{
MyClass var ;
return %var ; 
}

ref class MyClass{} ;

MyClass ^ function(MyClass ^ var)
{
return var ; // ok 
}

MyClass ^ function()
{
            MyClass ^ var= gcnew MyClass(); 
return var ; // ok 
}

ref class MyClass{} ;

MyClass % function()
{
MyClass var ;
return var ; 
}

ref class MyClass{} ;

MyClass % function(MyClass % var)
{
return var ; // ok 
}

MyClass % function()
{
            MyClass ^ var= gcnew MyClass(); 
return *var ; // ok 
}

ref class sampleclass
{
static int nvar=3 ;
} ;

protected :
  !MyClass() {}

virtual void function() override

ref class Tools 
{
public:
	virtual void InitTools()
	{
		Console::WriteLine("Tools:InitTools");
	}
};
ref class Brush : public Tools
{
	public:
	virtual void InitTools() override
	{	
		Console::WriteLine("Brush:InitTools");
	}
};
int main(array<System::String ^> ^args)
{    
	Tools ^p1= gcnew Tools;
	p1->InitTools();		 //Tools:InitTools
	Tools ^p2= gcnew Brush;
	p2->InitTools();		// Brush:InitTools
    return 0;
}

ref class Brush : public Tools
{
	public:
	virtual void InitTools() new
	{	
		Console::WriteLine("Brush:InitTools");
	}
};
int main(array<System::String ^> ^args)
{    
	Tools ^p1= gcnew Tools;
	p1->InitTools(); //Tools:InitTools
	Tools ^p2= gcnew Brush;
	p2->InitTools(); // Tools:InitTools
    return 0;
}

ref class Tools 
{
public:
	virtual void InitTools()
	{
		Console::WriteLine("Tools:InitTools");
	}
};
ref class Brush : public Tools
{
	public:
	virtual void CreateBrush() = Tools::InitTools
	{	
		Tools::InitTools();
		Console::WriteLine("Brush:CreateBrush");
	}
};
int main(array<System::String ^> ^args)
{    
    Tools ^p1= gcnew Tools;
    p1->InitTools(); //Tools:InitTools
    Tools ^p2= gcnew Brush;
    p2->InitTools();//Brush:CreateBrush
    return 0;
}

ref class Tools 
{
public:
	virtual void InitTools()
	{
		Console::WriteLine("Tools:InitTools");
	}
};

ref class ContextBar: public Tools
{
public:
	virtual void InitTools() new
	{
		Console::WriteLine("ContextBar:InitTools");
	}
};
ref class ToolBar : public ContextBar
{
public:
	virtual void InitTools() override = Tools::InitTools
	{
		Console::WriteLine("ToolBar:InitTools");
	}
};


int main(array<System::String ^> ^args)
{    
	Tools ^p1= gcnew ContextBar;
	p1->InitTools();
	ContextBar ^p2= gcnew ContextBar;
	p2->InitTools(); //ContextBar:InitTools

	Tools ^p3= gcnew ContextBar;
	p3->InitTools(); //Tools:InitTools

	ToolBar ^p4= gcnew ToolBar;
	p4->InitTools(); //ToolBar:InitTools
	Tools ^p5=gcnew ToolBar;
	p5->InitTools(); //ToolBar:InitTools

ContextBar ^p6=gcnew ToolBar;
	p6->InitTools(); //ToolBar:InitTools
    return 0;
}

ref class Tools 
{
public:
	virtual void InitTools() 
	{
		Console::WriteLine("Tools:InitTools");
	}
};
ref class ContextBar: public Tools
{
public:
	virtual void InitTools() new
	{
		Console::WriteLine("ContextBar:InitTools");
	}
};
ref class ToolBar : public ContextBar
{
public:
	virtual void InitToolBar() = Tools::InitTools,ContextBar::InitTools
	{
		Console::WriteLine("ToolBar:InitTools");
	}
};

void operator *=(const MyClass ^ righth); // syntaxe classique.
static void operator *=(const MyClass ^ lefth, const MyClass ^ righth); // syntaxe managée

static MyClass ^operator -(const MyClass ^lefth) // opérateur changement de signe en - 
{
	MyClass ^ ret=gcnew MyClass();
	ret->i=-(lefth->i);
return ret;
}

static MyClass ^operator -( MyClass ^lefth)
{
	lefth->i=-(lefth->i);
return lefth;
}

ref class MyClass
{
public:
	MyClass(int x){m_nx=x;}
	MyClass(){}
	static bool operator ==(const MyClass ^lefth,const MyClass ^righth)
	{
		return lefth->m_nx==righth->m_nx;
	}
	static bool operator ==(const MyClass ^lefth,int n)
	{
		return lefth->m_nx==n;
	}
	static bool operator !=(const MyClass ^lefth,const MyClass ^righth)
	{
		return lefth->m_nx!=righth->m_nx;
	}

	static MyClass ^ operator -=(const MyClass ^lefth,const MyClass ^righth)
	{
		MyClass ^ret=gcnew MyClass;
		ret->m_nx=(lefth->m_nx-righth->m_nx);
		return ret;
	}

	static void operator -=(MyClass ^lefth,int n)
	{
		lefth->m_nx-=n;		
	}
	void operator *=(const int n) 	// syntaxe classique.
	{
		m_nx*=n;
	}
	int m_nx;
};
int main(array<System::String ^> ^args)
{
	MyClass ^obj= gcnew MyClass(10);
	MyClass ^obj2= gcnew MyClass;
	Console ::WriteLine("obj==obj2 "+(obj==obj2).ToString()) ;
	Console ::WriteLine("obj==10 "+(obj==10).ToString()) ;
	obj2->m_nx=10;
	Console ::WriteLine("obj!=obj2 "+(obj!=obj2).ToString());
	obj2->m_nx=5;
	MyClass ^ obj3=obj2-=obj;
	obj-=8;
	obj*=2;
	Console ::WriteLine("obj "+(obj->m_nx).ToString());
	Console ::WriteLine("obj2 "+(obj2->m_nx).ToString());
	Console ::WriteLine("obj3 "+(obj3->m_nx).ToString());

	return 0;
}

property type PropertyVarName
{
type get(){}
void set(type value){}
}

ref class RefClass
{
public:
	RefClass(int x){m_x=x;}
	property int Intx
	{
		int get(){return m_x;}
		void set(int value){m_x=value;}
	}

	void Show()
	{
		Console::WriteLine(m_x);
	}
private:
	int m_x; // variable cachée pour l'utilisateur
};

RefClass r(8);
r.Intx=10;
Console::WriteLine(r.Intx);
r.Show();

ref class RefClass
{
public:
	RefClass(int x){ Intx =x;}
	property int Intx;
	
	void Show()
	{
		Console::WriteLine(Intx);
	}
};

RefClass ^p= gcnew RefClass(10);
p->Show();
p->Intx=20;
p->Show();

property static TypeVar  PropertyName
{
   TypeVar TypeVar get{}
   void set(TypeVar  value){}
}

property array < int >^ nArray
{
array < int >^ get{}
void set(array < int >^ value}
}

ref class MyClass
{
public:
	MyClass(int nSize)
	{
		m_nIntArray= gcnew array< int >(nSize);
	}
	property array < int >^ nIntArray
	{
		array < int >^ get()
		{
			return m_nIntArray;
		}
		void set(array < int >^ value
		{
	       m_nIntArray=value;
		}
	}

private:
	array < int >^ m_nIntArray; // variable cachée pour l'utilisateur
};
int main(array<System::String ^> ^args)
{
    MyClass Obj(10);
	for(int i=0;i< Obj.nIntArray->Length;i++) 	Obj.nIntArray[i]=(i*2);
	return 0;
}

Property TypeVar PropertyName [indexType,. . .,indexTypex]
{
	TypeVar get(indexType,. . .,indexTypex){};
	void set(indexType,. . .,indexTypex,TypeVar value){};
}

ref class MyClass
{
public:
	MyClass(int nSize)
	{
		m_nIntArray= gcnew array< int >(nSize);
	}
	property int nIntArray [ int ]
	{
		int get(int n)
		{
			if(n<0) n=0;
			else
			if(n>=m_nIntArray->Length) n=m_nIntArray->Length-1;
			
			return m_nIntArray[n];
		}
		void set(int nIndex,int nvalue)
		{
			if(nIndex<0) nIndex=0;
			else
			if(nIndex>=m_nIntArray->Length) nIndex=m_nIntArray->Length-1;
	        m_nIntArray[nIndex]=nvalue;
		}

	}
	int GetSizeArray(){return m_nIntArray->Length;}
private:
	array < int >^ m_nIntArray; // variable cachée pour l'utilisateur
};
int main(array<System::String ^> ^args)
{
	MyClass obj(10);
	for(int i=-1;i<12;i++) obj.nIntArray[i]=i*2;
	for(int i=0;i<obj.GetSizeArray();i++) Console ::WriteLine((i).ToString()+":="+obj.nIntArray[i].ToString());
    return 0;
}

ref class IndexedProperty
{
public:
	IndexedProperty()
	{
		m_array= gcnew array<int>{1,2,3,10,100,200};
	}
	property int ^ default [int]
	{
		int ^get(int index)
		{
			if(index<0) index=0;
			else if(index>m_array->Length) index=m_array->Length-1;
			return m_array[index];
		}
	}
private:
	array<int>^ m_array;
};

int main(array<System::String ^> ^args)
{    
	IndexedProperty TestIndex;

	Console::WriteLine(TestIndex[-10]);
	Console::WriteLine(TestIndex[2]);
	Console::WriteLine(TestIndex[10]);
      return 0;
}

ref class MySealClass sealed
{
};
ref class DerivedClass: public MySealClass //error C3246: 'DerivedClass' : ne peut pas hériter de 'MySealClass',
{					//  car il a été déclaré comme 'sealed'	
};

ref class AbstractClass abstract 
{
public:
	AbstractClass()
	{
		m_n=100;
	}
	virtual void function()=0;
	void GetNumber()
	{		
		Console::WriteLine(m_n.ToString());
	}
private:
	int m_n;
};

interface class MyInterfaceClass
{
	void Function();
};
ref class MyClass
{
	void OneFunction(){Console::WriteLine("OneFunction");}
};
ref class MyFinalClass: public MyClass, public MyInterfaceClass
{
public:
	void Function(){Console::WriteLine("Function");}
};

generic<typename T>
T Min(T a,T b)
{
	return(a<b?a:b); // error C2676
}

generic <class T>
ref class Point
{
public:
	Point(T x,T y){xCoord=x;yCoord=y;}
	void ShowCoord()
	{
		Console::WriteLine("XCoord:"+(xCoord)->ToString());
		Console::WriteLine("YCoord:"+(yCoord)->ToString());
	}
	static bool operator ==(Point ^lefth,Point ^righth)
	{
		// conversion en string ,ce n'est pas terrible c'est juste pour l'illustration...
		String ^lx=lefth->xCoord->ToString();
		String ^rx=righth->xCoord->ToString();
		String ^ly=lefth->yCoord->ToString();
		String ^ry=righth->yCoord->ToString();

		return (lx==rx && ly==ry);
	}
	static bool operator ==(Point %left,Point %right)
	{
		// conversion en string ,ce n'est pas terrible c'est juste pour l'illustration...
		String ^lx=left.xCoord->ToString();
		String ^rx=right.xCoord->ToString();
		String ^ly=left.yCoord->ToString();
		String ^ry=right.yCoord->ToString();

		return (lx==rx && ly==ry);
	}
property T xCoord;
property T yCoord;
};
int main(array<System::String ^> ^args)
{
	Point<int>^ pt= gcnew Point<int>(10,100);
	pt->ShowCoord();
	Point<int>^ pt2= gcnew Point<int>(10,100);
	Console::WriteLine("pt==pt2 "+(pt==pt2).ToString());

	Point<int> pt3(10,100);
	pt3.ShowCoord();
	Point<int> pt4(10,100);
	Console::WriteLine("pt3==pt4 "+((pt3)==(pt4)).ToString());
    return 0;
}

interface class IItem {};

generic <class ItemType> where ItemType : IItem
ref class Stack
{
};

generic <typename T>
ref class G1 {};

generic <typename Type1, typename Type2> where Type1 : G1<Type2>   // OK, G1 takes one type parameter
ref class G2
{
};

generic <class T> where T: IComparable
ref class Point 
{
public:
	Point(T x,T y){xCoord=x;yCoord=y;}
	void ShowCoord()
	{
		Console::WriteLine("XCoord:"+(xCoord)->ToString());
		Console::WriteLine("YCoord:"+(yCoord)->ToString());
	}
	
	static bool operator ==( Point ^lefth, Point ^righth)
	{
		return !lefth->xCoord->CompareTo(righth->xCoord) &&
			   !lefth->yCoord->CompareTo(righth->yCoord);
	}
	static bool operator ==(Point %left,Point %right)
	{
		return !left.xCoord->CompareTo(right.xCoord) &&
			   !left.yCoord->CompareTo(right.yCoord);
		
	}
property T xCoord;
property T yCoord;
};

int main(array<System::String ^> ^args)
{
	Point< int >^ pt= gcnew Point< Int32>(10,100); // j'ai utilisé un int classique pourquoi ça fonctionne ?
	pt->ShowCoord();
	Point< Int32 >^ pt2= gcnew Point< Int32 >(10,100);
	Console::WriteLine("pt==pt2 "+(pt==pt2).ToString());

	Point< Int32 > pt3(10,100);
	pt3.ShowCoord();
	Point< Int32> pt4(10,100);
	Console::WriteLine("pt3==pt4 "+((pt3)==(pt4)).ToString());
    return 0;
}
}

generic<class T> where T: IComparable
T Min(T a,T b)
{
	return(a->CompareTo(b)<0?a:b);
}
int main(array<System::String ^> ^args)
{
	int a=20;
	int b=10;
	Console::WriteLine(Min(a ,b).ToString());

	Console::WriteLine(Min<int>(20,10).ToString());

    return 0;
}

template<typename T>
T Min(T a,T b)
{
	return(a<b?a:b);
}
int main(array<System::String ^> ^args)
{
	int  n=10;
	int n2=20;
	Console::WriteLine(Min(n,n2));
}

template <class T>
ref class Point
{
public:
	Point(T x,T y){xCoord=x;yCoord=y;}
	void ShowCoord()
	{
		Console::WriteLine("XCoord:"+(xCoord).ToString());
		Console::WriteLine("YCoord:"+(yCoord).ToString());
	}
	static bool operator ==(Point ^lefth,Point ^righth)
	{
		return (lefth->xCoord==righth->xCoord && lefth->yCoord==righth->yCoord);
	}
	static bool operator ==(Point %left,Point %right)
	{
		return (left.xCoord==right.xCoord && left.yCoord==right.yCoord);
	}
property T xCoord;
property T yCoord;
};
int main(array<System::String ^> ^args)
{
	Point<int>^ pt= gcnew Point<int>(10,100);
	pt->ShowCoord();
	Point<int>^ pt2= gcnew Point<int>(10,100);
	Console::WriteLine("pt==pt2 "+(pt==pt2).ToString());

	Point<int> pt3(10,100);
	pt3.ShowCoord();
	Point<int> pt4(10,100);
	Console::WriteLine("pt3==pt4 "+(pt3==pt4).ToString());
    return 0;
}

try
{
// votre code qui doit être contrôlé
}
catch(ExceptionType e)
{
// code d'interception
}

ref class Employee 
{
public :
   static void PromoteEmployee(Object ^emp)
   {
   //Cast object to Employee.
   Employee ^e = (Employee ^) emp;
   // Increment employee level.
   e->EmLevel = e->EmLevel + 1; 
   }
	property int EmLevel;
};
try
  {
	Object ^o = gcnew Employee;
	DateTime ^newyears = gcnew DateTime(2001, 1, 1);
	//Promote the new employee.
	Employee::PromoteEmployee(o);
	//Promote DateTime; results in InvalidCastException as newyears is not an employee instance.
	Employee::PromoteEmployee(newyears);
   }
   catch (InvalidCastException ^e)
   {
	   Console::WriteLine("Error passing data to PromoteEmployee method. " + e);
   }

ref class EmployeeException : public ApplicationException
{
public:
	EmployeeException(System::String ^err):ApplicationException(err)
	{
	}
};

ref class Employee 
{
public :
   static void PromoteEmployee(Object ^emp)
   {
	   Employee ^e;
	   //Cast object to Employee.
	   try
	   {
		 e= safe_cast<Employee ^> (emp);
	   }
	   catch(InvalidCastException ^err)
	   {
		throw gcnew EmployeeException("\nErreur de conversion sur le type Employé "+err);
		return;
	   }
		// Increment employee level.
		e->EmLevel = e->EmLevel + 1; 
   }
	property int EmLevel;
};
int main(array<System::String ^> ^args)
{
      Object ^o = gcnew Employee;
	DateTime ^newyears = gcnew DateTime(2001, 1, 1);
	//Promote the new employee.
	Employee::PromoteEmployee(o);
	//Promote DateTime; results in InvalidCastException as newyears is not an employee instance.
	Employee::PromoteEmployee(newyears);
return 0;
} 

delegate void FuncMessDelegate(String ^mess);

void GlobalMess(String ^mess)
{
	Console::Write("Fonction Globale: ");
	Console::WriteLine(mess);
}
ref class OneClass
{
public:
	static void staticMethodeMess(String ^mess)
	{
		Console::Write("Fonction statique: ");
		Console::WriteLine(mess);
	}
};
ref class AnotherClass
{
	public:
	void MethodeMess(String ^mess)
	{
		Console::Write("Fonction d'une instance: ");
		Console::WriteLine(mess);
	}
};

int main(array<System::String ^> ^args)
{
// declaration du delegate
	FuncMessDelegate ^Global= gcnew FuncMessDelegate(&GlobalMess);
	// ajouter une fonction au delegate
	FuncMessDelegate ^statique= gcnew FuncMessDelegate(&OneClass::staticMethodeMess);

	AnotherClass ^pAnotherClass= gcnew AnotherClass;

	FuncMessDelegate ^instance= gcnew FuncMessDelegate(pAnotherClass,&AnotherClass::MethodeMess);

	// l'appel de la fonction…
	Global->Invoke("Hello");

	statique->Invoke("Hello");
	instance->Invoke("Hello");

    return 0;
}

FuncMessDelegate ^ChaineMess= gcnew FuncMessDelegate(&GlobalMess);

ChaineMess += gcnew FuncMessDelegate(&OneClass::staticMethodeMess);

AnotherClass ^pAnotherClass= gcnew AnotherClass;
ChaineMess += gcnew FuncMessDelegate(pAnotherClass,&AnotherClass::MethodeMess);

ChaineMess->Invoke("Hello");

ChaineMess -= gcnew FuncMessDelegate(&OneClass::staticMethodeMess);
ChaineMess->Invoke("Hello2");

using namespace System;

delegate void DelegateAnalyse(int %n); // la fonction de traitement recoit une reference sur un entier.

// classe declencheur de traitment
ref class AnalyseTrigger
{
public:
	event DelegateAnalyse ^OnWork;
	void RunWork(int %n)
	{
		OnWork(n);
	}
};

// classe effectuant un traitement
ref class Analyse
{
	public:
	AnalyseTrigger ^ m_AnalyseTrigger;
	Analyse(AnalyseTrigger ^src)
	{
		if(src==nullptr)
			throw gcnew ArgumentNullException("erreur argument non specifié");
		m_AnalyseTrigger=src;
		m_AnalyseTrigger->OnWork+= gcnew DelegateAnalyse(this,&Analyse::Treatment);
		m_AnalyseTrigger->OnWork+= gcnew DelegateAnalyse(this,&Analyse::TreatmentTwo);
	}
	void RemoveTreatmentTwo()
	{
		m_AnalyseTrigger->OnWork-=gcnew DelegateAnalyse(this,&Analyse::TreatmentTwo);
	}
	// traitement declenché
	void Treatment(int %n)
	{
		Console::Write("Class Analyse Treatment =+10 n:= ");
		Console::Write(n);
		n+=10;
		Console::Write(" -> n=");
		Console::WriteLine(n);
	}
	// traitement declenché
	void TreatmentTwo(int %n)
	{
		Console::Write("Class Analyse TreatmentTwo =*2 n:= ");
		Console::Write(n);
		n*=2;
		Console::Write(" -> n=");
		Console::WriteLine(n);
	}
};

// classe effectuant un traitement
ref class AnalyseTwo
{
	public:
	AnalyseTrigger ^m_AnalyseTrigger;

	AnalyseTwo(AnalyseTrigger ^src)
	{
		if(src==nullptr)
			throw gcnew ArgumentNullException("erreur argument non specifié");
		m_AnalyseTrigger=src;
		m_AnalyseTrigger->OnWork+= gcnew DelegateAnalyse(this,&AnalyseTwo::Treatment);
		
	}
	// traitement declenché
	void Treatment(int %n)
	{
		Console::Write("Class AnalyseTwo Treatment =+2 n:= ");
		Console::Write(n);
		n+=2;
		Console::Write(" -> n=");
		Console::WriteLine(n);
	}
};


int main(array<System::String ^> ^args)
{
	//element declecheur de l'action fixée par le delegate DelegateAnalyse 
	AnalyseTrigger ^Trigger = gcnew AnalyseTrigger();

	// classe traitements
	Analyse ^analyse = gcnew Analyse(Trigger);

	// classe traitements
	AnalyseTwo ^analyseTwo = gcnew AnalyseTwo(Trigger);

	int n=2;

	Trigger->RunWork(n);
	analyse->RemoveTreatmentTwo();

	Console::WriteLine("-----------------------");
	n=2;
	Trigger->RunWork(n);

    return 0;
}