Visual Studio 2010 공식 팀 블로그 @vsts2010

namespace TestServer_HFNetworkNET

{

    class Program

    {

        static void Main(string[] args)

        {

            HFServer Server = new HFServer();

            // 서버 초기화 및 설정 후 Port를 연다

Server.Init();

            short nRet = Server.Open();

            if (HalfNetwork_NET.ERRORCODE.NONE != nRet)

            {

                Console.WriteLine("Failed Server Open!");

                return;

            }

            Console.WriteLine("Server Start !!!");

            // 네트웍 처리를 한다.

            while (true)

            {

                Server.Run();

            }

            Console.WriteLine("End Server");

            // 서버 종료 처리를 한다

            Server.End();

        }

    }

}

static void Init_ACE();

static void End_ACE();

server_port=15001;

client_port=25251;

workerthread=0;

receivebufferlength=2048;

updateterm=20;

server_receive_buff_size=65536;

client_receive_buff_size=4096;

client_init_accept_count=126;

if( false == NetworkInstance->Create<HalfNetwork::ProactorFactory>() )

{

          return ERRORCODE::CREATE_PROACTORFACTORY;

}

if( false == NetworkInstance->Open(&config) ) {

        return ERRORCODE::SERVER_OPEN;

}

virtual void OnAccept_Client( unsigned int StreamID, String^ IP ) abstract;

virtual void OnRead_Client( unsigned int StreamID, array<Byte>^ RecvData ) abstract;

virtual void OnDisConnect_Client( unsigned int StreamID ) abstract;

virtual void OnRead_Server( unsigned int StreamID, array<Byte>^ RecvData ) abstract;

virtual void OnDisConnect_Server( unsigned int StreamID ) abstract;

// 보내기

char* pPacket;

…

Send(pPacket, nLength);

// 받기

char* pBuffer = new char[MAX_BUFFER];

int nLength = Receive( pBuffer );

// 비관리코드

int nPacketSize = 34;

char* pPacket = new char[34];

// 관리코드

array< Byte >^ byteArray = gcnew array< Byte >(nPacketSize);

System::Runtime::InteropServices::Marshal::Copy( (IntPtr)pPacket, byteArray,

0, nPacketSize );

// 관리코드

array<Byte>^ SendData;

….

// 비관리코드

int nLength = SendData->Length;

pin_ptr<Byte> pData = &SendData[0];

char* pBuffer = new char[ nLength ];

CopyMemory( pBuffer, pData, nLength );

class Server

{

  .....

  virtual void OnAccept() = 0;

};

public ref class Server

{

   .....

   virtual void OnAccept() abstract;

};

public ref class Server abstract

{

   .....

   virtual void OnAccept() abstract;

};

#pragma unmanaged

extern "C" void printf(const char*, ...);

class A {

public:

   static void func(char* s) {

      printf(s);

   }

};

#pragma managed

public delegate void func(char*);

ref class B {

   A* ap;

public:

   B(A* ap):ap(ap) {}

   void func(char* s) {

      ap->func(s);

   }

};

int main() {

   A* a = new A;

   B^ b = gcnew B(a);

   func^ f = gcnew func(b, &B::func);

   f("hello");

   delete a;

}

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

int main(array<System::String ^> ^args)

{

           array<CNative>^ arr = gcnew array<CNative>(2);

           return 0;

}

#include <iostream>

using namespace System;

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

int main(array<System::String ^> ^args)

{

           array<CNative*>^ arr = gcnew array<CNative*>(2);

           for(int i=0; i<arr->Length; i++)

           {

                     arr[i] = new CNative();

           }

           getchar();

           return 0;

}

#include "stdafx.h"

#include <iostream>

using namespace System;

class CNative

{

public:

           CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

           ~CNative()

           {

                     Console::WriteLine(__FUNCTION__);

           }

};

int main(array<System::String ^> ^args)

{

           array<CNative*>^ arr = gcnew array<CNative*>(2);

           for(int i=0; i<arr->Length; i++)

           {

                     arr[i] = new CNative();

           }

           for(int i=0; i<arr->Length; i++)

           {

                     delete arr[i];

           }

           getchar();

           return 0;

}

함수

프로퍼티

이벤트

interface class IA {

public:

    void funcIA();

};

interface class IB {

public:

    void funcIB();

};

interface class IC {

public:

    void funcIC();

};

ref class A {

    int i;

};

ref class B : A, IA, IB, IC {

public:

    virtual void funcIA() {   }

    virtual void funcIB() {   }

    virtual void funcIC() {   }

};

int main() {

    B^ b = gcnew B;

    IA^ ia = b;

    IB^ ib = b;

    IC^ ic = b;

    b->funcIA();

    ia->funcIA();

    ib->funcIB();

    ic->funcIC();

    return 0;

}

#include "stdafx.h"

#include <iostream>

using namespace System;

ref class A {

public:

    static int a_;

    static A()

    {

        a_ += 10;

    }

};

ref class B {

public:

    static int b_;

    static B()

    {

//        a_ += 10; // error

        b_ += 10;

    }

};

ref class C {

public:

    static int c_ = 100;

    static C()

    {

        c_ = 10;

    }

};

int main()

{

    Console::WriteLine(A::a_);

    A::A();

    Console::WriteLine(A::a_);

    Console::WriteLine(B::b_);

 
    Console::WriteLine(C::c_);

    return 0;

}

ref class C

{

public:

    initonly static int x;

    initonly static int y;

    initonly int z;

    static C()

    {

        x = 1;

        y = 2;

        // z = 3; // Error

    }

    C()

    {

        // A = 2; // Error

        z = 3;

    }

    void sfunc()

    {

        // x = 5; // Error

        // z = 5; // Error

    }

};

int main()

{

    System::Console::WriteLine(C::x);

    System::Console::WriteLine(C::y);

    C c;

    System::Console::WriteLine(c.z);

    return 0;

}

using namespace System;

ref class C

{

public:

    literal String^ S = "Hello";

    literal int I = 100;

};

int main()

{

    Console::WriteLine(C::S);

    Console::WriteLine(C::I);

    return 0;

}

void LOG( char* szText, ... )

{

}

void LOG( … array<Object^>^ Values )

{

for each( Object^ value in Values )

{

   ….

}

}

int main()

{

LOG( 23 );

LOG( 2, 1, “error” );

return 0;

}

void LOG( int nLogLevel, … array<Object^>^ Values )

{

}

#include "stdafx.h"

#include <iostream>

#include <vector>

#include <map>

using namespace std;

using namespace System;

using namespace System::Collections;

int main(array<System::String ^> ^args)

{

     // 배열

     array< int >^ Nums = { 0, 1, 2, 3, 4, 5 };

     for each(int value in Nums)

     {

          value = 2;

          Console::WriteLine( value );

     }

    // 위에서 for each 내부에서 요소의 값을 바꾸었지만 아래의 출력 값을 보면

    // 바뀌지 않은 것을 알 수 있습니다.

    for each(int value in Nums)

    {

          Console::WriteLine( value );

    }

    // 리스트

    ArrayList^ NumList = gcnew ArrayList();

    NumList->Add(1);

    NumList->Add(2);

    NumList->Add(3);

    for each(int value in NumList)

    {

        Console::WriteLine(value);

    }

    // vector

    vector<int> vi;

    vi.push_back(3);

    vi.push_back(4);

    for each(int i in vi)

    {

        Console::WriteLine(i);

    }

    // map

    map<const char*, int> num;

    num["ten"] = 10;

    num["hundred"] = 100;

    for each( pair<const char*, int> c in num )

    {

        Console::WriteLine(gcnew String(c.first) + c.second.ToString());

    }

    // 해쉬 테이블

    Hashtable^ ht = gcnew Hashtable();

    ht["aaa"] = "111";

    ht["bbb"] = "222";

    for each(DictionaryEntry^ dic in ht)

    {

        Console::WriteLine(dic->Key->ToString() + dic->Value->ToString());

    }

    getchar();

    return 0;

}

enum WEAPON_TYPE

{

GUN = 1,

SWORD = 2,

BOW = 3

};

struct WEAPON

{

enum TYPE

{

GUN = 1,

SWORD = 2,

BOW = 3

};

};

int nUsedWeapon = WEAPON::GUN;

enum class WEAPON

{

   GUN = 1,

SWORD = 2,

BOW = 3

};

int nUsedWeapon = static_cast<int>(WEAPON::GUN);

enum class WEAPON : short

{

   GUN = 1,

SWORD = 2,

BOW = 3

};

public ref class WEAPON
{
public:
        literal short GUN = 1;
        literal short SWORD = 2;

        literal short BOW = 3;

};

ref class button {

public:

    event ClickHandler^ Clicked;

    button() {

        btnForTest = this;

    }

public:

    void someoneclicked() {

        Clicked();

    }

    static button^ btnForTest;

};

ref class Client {

private:

    button^ btn;

public:

    Client() {

        btn = gcnew button;

        btn->Clicked += gcnew ClickHandler(this, &Client::OnClick);

    }

private:

    void OnClick() {

        Console::WriteLine("someone clicked.");

    }

};

int main()

{

    Client^ client = gcnew Client;

    button::btnForTest->someoneclicked();

    return 0;

}

#include <iostream>

delegate void TestDelegate();

ref class TEST

{

public:

void TestMethod()

{

  System::Console::WriteLine(“TEST::TestMethod()”);

}

};

int main()

{

TEST^ test = gcnew TEST();

TestDelegate^ testDelegate = gcnew TestDelegate( test, &TEST::TestMethod );

 testDelegate();

 getchar();

    return 0;

};

#include <iostream>

 delegate void TestDelegate();

 ref class TEST

{

public:

static void TestMethod()

{

  System::Console::WriteLine(“TEST::TestMethod()”);

}

};

int main()

{

TestDelegate^ testDelegate = gcnew TestDelegate( &TEST::TestMethod );

testDelegate();

getchar();

return 0;

};

#include <iostream>

delegate void TestDelegate();

ref class TESTA

{

public:

void TestMethod()

{

  System::Console::WriteLine(“TESTA::TestMethod()”);

}

};

ref class TESTB

{

public:

static void TestMethod()

{

  System::Console::WriteLine(“TESTB::TestMethod()”);

}

};

ref class TESTC

{

public:

void operator()()

{

  System::Console::WriteLine(“TESTC::operator()”);

}

};

int main()

{

TestDelegate^ testDelegate;

TESTA testA;

TESTC testC;

testDelegate = gcnew TestDelegate( testA, &TESTA::TestMethod );

testDelegate += gcnew TestDelegate(&TESTB::TestMethod );

testDelegate += gcnew TestDelegate( testC, &TESTC::operator );

testDelegate();

getchar();

return 0;

};

using namespace System;

delegate void MyDele(int);

void func1(int i)

{

    Console::WriteLine("func1");

}

void func2(int j)

{

    Console::WriteLine("func2");

}

int main()

{

    MyDele^ dele;

    dele += gcnew MyDele(&func1);

    dele += gcnew MyDele(&func2);

    MyDele^ dele2 = gcnew MyDele(func1);

    dele2 += gcnew MyDele(&func2);

    if ( dele == dele2 )  {

        Console::WriteLine("TRUE");

    } else {

        Console::WriteLine("FALSE");

    }

    dele -= gcnew MyDele(&func1); 

    dele(1); 

   return 0;

}

#include "stdafx.h"

#include <iostream>

using namespace System;

delegate void MyDele(void);

void myfunc(void)

{

    System::Threading::Thread::Sleep(3000);

}

int main(array<System::String ^> ^args)

{

     MyDele^ dele = gcnew MyDele(&myfunc);

            Console::WriteLine(L"1");

     IAsyncResult^ result = dele->BeginInvoke(nullptr,nullptr);

            Console::WriteLine(L"2");

    dele->EndInvoke(result);

            Console::WriteLine(L"3");

    getchar();

    return 0;

}

class Character

{

public:

…….

   void SetCharCd( const int nCharCd ) { m_nCharCd = nCharCd; }

   int GetCharCd() { return m_nCharCd; }

…….

private:

   int m_nCharCd;

   …….

};

ref class Character

{

public:

…….

    property int CharCd

{

   void set( int nCharCd ) { m_nCharCd = nCharCd; }

   int get() { return m_nCharCd; }

}  

…….

private:

   int m_nCharCd;

   …….

};

ref class Character

{

public:

…….

    property int CharCd

{

   void set( int nCharCd )

{

  if( nCharCd < 0 ) {

     m_nCharCd = 0;

  } else {

     m_nCharCd = nCharCd;

  }

}

   int get() { return m_nCharCd; }

}  

…….

private:

   int m_nCharCd;

   …….

};

ref class Character

{

public:

…….

    property int CharCd

{

   void set( int nCharCd );

   int get();

}  

…….

private:

   int m_nCharCd;

   …….

};

void Character::CharCd::set( int nCharCd )

{

if( nCharCd < 0 ) {

m_nCharCd = 0;

} else {

   m_nCharCd = nCharCd;

  }

}

void Character::CharCd::get()

{

return m_nCharCd;

}

ref class Character

{

public:

…….

    property int CharCd

{

protected:

   void set( int nCharCd )

{

  if( nCharCd < 0 ) {

     m_nCharCd = 0;

  } else {

     m_nCharCd = nCharCd;

  }

}

    public:

   int get() { return m_nCharCd; }

}  

…….

private:

   int m_nCharCd;

   …….

};

#include "stdafx.h"

#include <iostream>

#include <vcclr.h>

using namespace System;

class TEST

{

public:

   TEST() {}

   ~TEST() {}

   gcroot< String^ > m_str;

};

int main(array<System::String ^> ^args)

{

    TEST test;

    test.m_str = gcnew String("Hello VSTS 2010");

    Console::WriteLine( test.m_str);

    getchar();

    return 0;

}

#include <vcclr.h>

test.m_str = gcnew String("Hello VSTS 2010");

#include "stdafx.h"

#include <iostream>

#include <vcclr.h>

using namespace System;

class TEST

{

public:

       TEST() {}

       ~TEST() {}

};

ref class refTEST

{

public:

       refTEST() {}

       ~refTEST() {}

       TEST* test;

};

int main()

{

       refTEST^ refTest = gcnew refTEST();

       refTest->test = new TEST;

       return 0;

}

#include <string>

#include <msclr\marshal_cppstd.h>

using namespace System;

using namespace msclr::interop;

int main()

{

           System::String^ s0 = L"비주얼스튜디오2010 팀블로그";

           // 방법 1

           std::string tmp = marshal_as<std::string>(s0);

           const char* s1 = tmp.c_str();

           std::cout << "String^ -> string : " << s1 << std::endl;

           // 방법 2

           const char* s2;

           const wchar_t* s3;

           {

                     marshal_context ctx;

                     s2 = ctx.marshal_as<const char*>(s0);

                     s3 = ctx.marshal_as<const wchar_t*>(s0);

                     std::cout << "String^ -> char* : " << s2 << std::endl;

                     setlocale(LC_ALL, "");

                     std::wcout << "String^ -> wchar_t : " << s3 << std::endl;

           }

           getchar();

           return 0;

}

std::string tmp = marshal_as<std::string>(s0);

const char* s1 = tmp.c_str();

std::cout << "String^ -> string : " << s1 << std::endl;

const char* s2;

const wchar_t* s3;

{

           marshal_context ctx;

           s2 = ctx.marshal_as<const char*>(s0);

           s3 = ctx.marshal_as<const wchar_t*>(s0);

}