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]