C++/CLI quoi de neuf ?

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

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

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 
}

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 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;
}

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;
}

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);
   }