Managed C++/CLI

public ref struct HostSetting
	{
		static String ^HName;
		static String ^HAddr;
		static Collections::ArrayList ^cardType = gcnew System::Collections::ArrayList(); 
		static String ^HCommtype;
		static String ^HMsgType;
		static String ^HPriority;
		static String ^oldHostName;
	};

array <hostsetting^>^ hostList = gcnew array<hostsetting^>(5); //create an array of structures

ref class MySettings
{
public:
	static property MySettings^ Instance
	{
		MySettings^ get()
		{
			if(!instance)
				LoadSetting();
			return instance;
		}
	}

private:
	static void LoadSetting()
	{
		instance = gcnew MySettings();
		// read registry and set properties of instance
	}

	static MySettings^ instance;
};

MySettings^ currentSettings =  MySettings::Instance;

naveen_bij wrote:

but how can i have an array of class and how to access a particular array element

array<Foo^>^ fooArray = gcnew array<Foo^> {gcnew Foo(),gcnew Foo()};

Foo^ first = fooArray[0];

naveen_bij wrote:

i am new to c++/cli i am not able to understand the code u have written, i had posted the code, can u please explain it in that terms.

 public ref class HostSettings
{
public:
        static String ^HName;
	static String ^HAddr;
	static Collections::ArrayList ^cardType = gcnew System::Collections::ArrayList(); 
	static String ^HCommtype;
	static String ^HMsgType;
	static String ^HPriority;
	static String ^oldHostName;

	static property HostSettings^ Instance
	{		

		HostSettings^ get()
		{
			if(!instance)
				LoadSetting();
			return instance;
		}
	}

private:
	static void LoadSetting()
	{
		instance = gcnew HostSettings();
		// read registry and set properties of instance
	}

	static HostSettings^ instance;
};

array<HostSettings^>^ HostList = gcnew array<HostSettings^> (5);

'HostList' : global or static variable may not have managed type 'cli::array<type> ^'<br />
1>        with<br />
1>        [<br />
1>            Type=HostSettings ^<br />
1>        ]<br />
1>        may not declare a global or static variable, or a member of a native type that refers to objects in the gc heap</type>

KASR1 wrote:

Any solution for this problem?

Mark Salsbery
Microsoft MVP - Visual C++

Bitmap bm=new Bitmap(otherBitmap);
for (int x=0; x< bm.Width; x++) {
    for (int y=0; y< bm.Height; y++) {
        // do something with or to pixel(x,y)
    }
}

Bitmap bm=new Bitmap(otherBitmap);
int height=bm.Height;
for (int x=0; x< bm.Width; x++) {
    for (int y=0; y< height; y++) {
        // do something with or to pixel(x,y)
    }
}

void AddText( FileStream^ fs, String^ value )
{
   array<Byte>^info = (gcnew UTF8Encoding( true ))->GetBytes( value );
   fs->Write( info, 0, info->Length );
}

System::IO::

FileStream

array<Byte>^ info = System::Text::Encoding::UTF8->GetBytes(value);

Yanshof wrote:

1 - Is not managed class is actually native ?

Yanshof wrote:

2 - I don't know when to choose managed class and when to choose not managed class.

Yanshof wrote:

3 - What about virtual destructor ? is Garbage collector work like in C# in those cases ?

Mark Salsbery
Microsoft MVP - Visual C++

Yanshof wrote:

Is not managed class is actually native

Yanshof wrote:

I don't know when to choose managed class and when to choose not managed class.

Yanshof wrote:

What about virtual destructor ? is Garbage collector work like in C# in those cases ?

ref class ManagedFoo
{
};

class UnmanagedFoo
{
};

int main(array<System::String ^> ^args)
{
	ManagedFoo^ managedFoo = gcnew ManagedFoo(); // no need to delete it as this is garbage collected
	UnmanagedFoo* unmanagedFoo = new UnmanagedFoo();
	delete unmanagedFoo;	// explicitly deleting as this is not garbage collected
     return 0;
}

private bool loadFlag;

public bool LoadFlag
{
    get { return loadFlag; }
    set { loadFlag = value; }
}

extern "C" BOOL __stdcall testFunction(HWND hWnd, void* pVoid, LPSTR pszProcess)
{
    String ^caseId = "ABC12345678";

    Dialogs::TestDialog ^testDialog = gcnew Dialogs::TestDialog(caseId);

    testDialog->LoadFlag = true;

    testDialog->ShowDialog();

    return true;
}