Verständnisfrage zu Try Catch

solick

Asche auf mein Haupt!!!

Danke für den Hinweis, natürlich lag es daran... ich hatte in der Zeile das array noch einmal deklariert...

So jetzt geht es mit arrays.

Was ich noch nicht hinbekommen habe, ist das ganze mit Listen zu machen. Wenn ich die Arrays durch Listen ersetze, bekomme ich folgende Fehlermeldung:

Der index Lag ausserhalb des Bereichs. Er muss nicht negativ und kleiner als die Auflistung sein. Parametername: Index.

Das ganze wird bei folgender Zeile ausgelöst:

dbf[aktDatensatz] = gcnew dbFields(leser->GetInt32(0), leser->GetString(1),leser->GetFloat(2), aktDatensatz);

Gruß Solick

solick

Habs hinbekommen...

mit dbf->add() konnte ich das Objekt hinzufügen. Vielen Dank nochmal für die Hilfe!

Gruß Solick

solick

Noch ne Zusatzfrage:

Ich habe gelesen, dass man auch direkt arrays / listen etc. in Klassen unterbringen kann und dann über einen Klassenindexer auf die einzelnen Elemente zugreift. In meinem Buch ist das aber nur so mit 3 Sätzen erwähnt ich werde daraus nicht schlau. Hast du mir einen Link wo ich das nochmal nachlesen kann oder einen kurzen Hinweis, wie man das macht?

LG Solick

*rant*

solick schrieb:

Noch ne Zusatzfrage:

Ich habe gelesen, dass man auch direkt arrays / listen etc. in Klassen unterbringen kann und dann über einen Klassenindexer auf die einzelnen Elemente zugreift. In meinem Buch ist das aber nur so mit 3 Sätzen erwähnt ich werde daraus nicht schlau. Hast du mir einen Link wo ich das nochmal nachlesen kann oder einen kurzen Hinweis, wie man das macht?

LG Solick

Direkt unterbringen? Das geht wohl kaum, sind doch die Dimensionen eines CLI-Arrays erst zur Laufzeit bekannt. Jedoch weiss ich was zum Klassenindexer, oder vielmehr über die Properties, welche es nach einem Indexer aussehen lassen:

property T default[U]
{
    T get(U);
    void set(U, T);
}

Definiere eine solche Eigenschaft für deine Klasse, und du kannst wie beim normalen C++-Subscriptoperator [] beliebige Operationen ausführen.

MfG

solick

Also meine Idee ist folgende:

Im Sinne der Datenkapselung alles in eine Klasse unterzubringen:

Einlesen der Daten im Konstruktor
Verteilt auf die einzelnen Datenbankfelder, die als Eigenschaften und List-Elemente definiert sind.

Dann entsprechende Methoden zum speichern, updaten etc...

was genau würde denn die von Dir gepostete Indexdefinition adressieren? Ein Array über die Klasse, die Eigenschaften oder was?

Grüße Solick

*rant*

Hmm okay

Nur damit wir uns richtig verstehen: willst du über eine Art Subscriptoperator auf alle möglichen Daten in deiner Klasse zugreifen, oder redest du von etwas völlig anderem? Ich verstehe deinen letzten Beitrag irgendwie nicht so recht

MfG

solick

Also von der Idee her so:

public class dbKlasse {

List<int> Rang;
List<String ^> ^Bundesland;
List<float> Einwohner;

dbKlasse(Rang, Bundesland, Einwohner)
{
// hier dann die Werte aus der Datenbank auslesen und nacheinander den Eigenschaften zuweisen.

}

// weitere Methoden, zb. Update, delete etc...

--------------

Und der Klassenindexer soll nun ermöglichen, dass ich ebend auf die einzelnen Daten zugreife.

Also dbKlasse ^dat = gcnew dbKlasse();

dat[0]->Rang = // Erster Eintrag der Liste Rang
dat[1]->Bundesland = // Zweiter Eintrag der Liste Bundesland

usw...

Ich hoffe, ich konnte es etwas klarer machen... ist wie gesagt eine Idee in meinem Kopf und dachte der Klassenindexer könnte das einfacher machen...

Gruß Solick

Knuddlbaer

Codetags

public class dbKlasse {

List<int> Rang;
List<String ^> ^Bundesland;
List<float> Einwohner;

dbKlasse(Rang, Bundesland, Einwohner)
{
// hier dann die Werte aus der Datenbank auslesen und nacheinander den Eigenschaften zuweisen.

}

// weitere Methoden, zb. Update, delete etc...

--------------

Und der Klassenindexer soll nun ermöglichen, dass ich ebend auf die einzelnen Daten zugreife.

Also dbKlasse ^dat = gcnew dbKlasse();

dat[0]->Rang = // Erster Eintrag der Liste Rang
dat[1]->Bundesland = // Zweiter Eintrag der Liste Bundesland

*rant*

Ja, das ist natürlich machbar, genau mit der default-property die ich bereits erwähnt habe. Allerdings musst du, um dieses Verhalten zu bekommen, eine Art Proxy zurückgeben, in welchem du den Index, sowie einen Verweis auf die Hauptinstanz speicherst. Dem Proxy gibtst du dann weitere Properties, welche über den Index auf einen Eintrag in der Hauptinstanz zugreifen...

public ref class dbKlasse
{
    List<...> ^foobar;
    // ...
public:
    ref class Proxy
    {
        dbKlasse ^haupt; 
        int index;
    public:
        Proxy(dbKlasse ^, int);
        property ... foobar()
        {
            ... get()
            {
                return haupt->foobar[index];
            }
        }
    };
    property Proxy default[int]
    {
        Proxy ^get(int index)
        {
            return gcnew Proxy(this, index);
        }
    }
};

Nur schnell zusammengeklimpert, aber im Prinzip funktioniert das so^^

MfG

solick

Ah. Danke.

Verstehe ich das richtig:

Innerhalb der dbKlasse wird die Proxy-Klasse definiert.

Die Eigenschaften werden in der dbKlasse definiert.

Die Zugriffe erfolgen aber aus der Proxy-Klasse durch die dort erzeugte Instanz der dbKlasse.

Frage:

Gibt es dann überhaupt Methoden in der dbKlasse oder wird das alles über die Proxy-Klasse gesteuert?

der default property wird neben der Proxy-Klasse aber in der dbKlasse definiert?

Gruß Solick

*rant*

Du implementierst in der dbKlasse die Methoden für alle deine Funktionalität; in der Proxyklasse speicherst du das Indexargument, mit welchem du alle diese Methoden in der Hauptklasse aufrufst. Auf diese Weise sparst du dir die explizite Angabe der Indices - und kannst, da die meisten Methoden dann keine explizite Argumente mehr brauch, die Funktionen durch Properties ersetzen.

MfG

solick

Ich habs mal probiert, komme aber mit den Rückgabetypen der getter nicht weiter, da meckert er immer rum das das nicht dem Typ List<T> entspricht...

#pragma once

ref class dbwrap
{
	System::Collections::Generic::List<System::String ^> ^dbBundesland;
	System::Collections::Generic::List<int> dbRang, dbAktData;
	System::Collections::Generic::List<float> dbEinwohner;

public:
	ref class Proxy
	{
		dbwrap ^haupt;
		int index;
	public:
		Proxy(dbwrap ^, int);

		property System::Collections::Generic::List<System::String ^> Bundesland
		{
			System::Collections::Generic::List<System::String ^> get()
			{
				return(haupt->dbBundesland[index];)
			}
			void set(System::Collections::Generic::List<System::String ^> ^s)
			{
				haupt->dbBundesland[index] = s;
			}
		}

		property System::Collections::Generic::List<int> Rang
		{
			System::Collections::Generic::List<int> get()
			{
				return(haupt->dbRang[index];)
			}
			void set(System::Collections::Generic::List<int> i)
			{
				haupt->dbRang[index] = i;
			}
		}

		property System::Collections::Generic::List<float> Einwohner
		{
			System::Collections::Generic::List<float> get()
			{
				return haupt->dbEinwohner[index];
			}
			void set(System::Collections::Generic::List<float> f)
			{
				haupt->dbEinwohner[index] = f;
			}
		}

		property System::Collections::Generic::List<int> CountDB
		{
			System::Collections::Generic::List<int> get()
			{
				return haupt->dbAktData[index];
			}
			void set(System::Collections::Generic::List<int> i)
			{
				haupt->dbAktData[index] = i;
			}
		}

		property Proxy default[int]
		{
			dbwrap::Proxy^ get(int index)
			{
				return gcnew Proxy(this,index);
			}
		}

	};
}

*rant*

Richtig. Du gibst ja im Proxy auch nicht mehr Listen, sondern deren Elemente zurück. Das Proxy benutzt den Index, welchen du in der default-property angegeben hast, um die Listen in der Hauptklasse zu indizieren. Du bist schon nahe dran gewesen...:

ref class Proxy
    {
        dbwrap ^haupt;
        int index;
    public:
        Proxy(dbwrap ^, int);

        property System::String ^Bundesland
        {
            System::String ^get()
            {
                return(haupt->dbBundesland[index];)
            }
            void set(System::String ^s)
            {
                haupt->dbBundesland[index] = s;
            }
        }
        // etc...

solick

So, ich nähere mich langsam...

#pragma once

ref class dbwrap
{
	System::Collections::Generic::List<System::String ^> ^dbBundesland;
	System::Collections::Generic::List<int> dbRang, dbAktData;
	System::Collections::Generic::List<float> dbEinwohner;

public:
	ref class Proxy
	{
		dbwrap ^haupt;
		int index;

	public:
		Proxy(dbwrap ^, int);

		property System::String ^Bundesland
		{
			System::String ^ get()
			{
				return haupt->dbBundesland[index];
			}
			void set(System::String ^s)
			{
				haupt->dbBundesland[index] = s;
			}
		}

		property int Rang
		{
			int get()
			{
				return haupt->dbRang[index];
			}
			void set(int i)
			{
				haupt->dbRang[index] = i;
			}
		}

		property float Einwohner
		{
			float get()
			{
				return haupt->dbEinwohner[index];
			}
			void set(float f)
			{
				haupt->dbEinwohner[index] = f;
			}
		}

		property int CountDB
		{
			int get()
			{
				return haupt->dbAktData[index];
			}
			void set(int i)
			{
				haupt->dbAktData[index] = i;
			}
		}

		property Proxy default[int]
		{
			Proxy ^get(int index)
			{
				return gcnew Proxy(this,index);
			}

		void set(dbwrap ^h,int index)
			{

			}
		}

	};
}

Was noch nicht geht ist der default property für Proxy, da meckert er, dass get und set nicht definiert sei und dass Proxy ^ nicht dem Rückgabewert dbwrap::Proxy entspricht...

solick

Ich hab nochmal etwas dran gearbeitet, aber die Fehlermeldungen bleiben.

Soweit bin ich bis jetzt:

.h-Datei:

#pragma once

ref class dbwrap
{
	System::Collections::Generic::List<System::String ^> ^dbBundesland;
	System::Collections::Generic::List<int> dbRang, dbAktData;
	System::Collections::Generic::List<float> dbEinwohner;

public:

	ref class Proxy
	{
		dbwrap ^haupt;
		int index;

	public:
		Proxy(dbwrap ^, int);

		property System::String ^Bundesland
		{
			System::String ^ get()
			{
				return haupt->dbBundesland[index];
			}
			void set(System::String ^s)
			{
				haupt->dbBundesland[index] = s;
			}
		}

		property int Rang
		{
			int get()
			{
				return haupt->dbRang[index];
			}
			void set(int i)
			{
				haupt->dbRang[index] = i;
			}
		}

		property float Einwohner
		{
			float get()
			{
				return haupt->dbEinwohner[index];
			}
			void set(float f)
			{
				haupt->dbEinwohner[index] = f;
			}
		}

		property int CountDB
		{
			int get()
			{
				return haupt->dbAktData[index];
			}
			void set(int i)
			{
				haupt->dbAktData[index] = i;
			}
		}

		property Proxy default[int]
		{
			Proxy ^get(int i)
			{
				return gcnew Proxy(this,i);
			}

		void set(dbwrap ^h ,int i)
			{
				for(y = 0; y<i+1; y++)
				{
					haupt[i] = h[i];
				}			

			}
		}

	};
}

.cpp Datei:

#include "StdAfx.h"
#include "dbwrap.h"

dbwrap::Proxy::Proxy(dbwrap ^ h, int i) : haupt(h), index(i)
	{

	}

Fehlermeldungen:

1>------ Erstellen gestartet: Projekt: DB_Editor2, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>dbwrap.cpp
1>c:\users\matten\documents\visual studio 2008\projects\db_editor2\db_editor2\dbwrap.h(73) : error C3901: "get": Muss den Rückgabetyp "dbwrap::Proxy" aufweisen.
1>c:\users\matten\documents\visual studio 2008\projects\db_editor2\db_editor2\dbwrap.h(78) : error C3902: "set": Der Typ des letzten Parameters muss "dbwrap::Proxy" sein.
1>c:\users\matten\documents\visual studio 2008\projects\db_editor2\db_editor2\dbwrap.h(78) : error C2192: Parameterdeklaration '1' ist unterschiedlich
1>c:\users\matten\documents\visual studio 2008\projects\db_editor2\db_editor2\dbwrap.h(86) : error C3903: "dbwrap::Proxy::default": Hat keine set-Methode oder get-Methode.
1>.\dbwrap.cpp(5) : error C2533: 'dbwrap::Proxy::{ctor}': Ergebnistyp für Konstruktoren nicht zulässig
1>Das Buildprotokoll wurde unter "file://c:\Users\Matten\Documents\Visual Studio 2008\Projects\DB_Editor2\DB_Editor2\Debug\BuildLog.htm" gespeichert.
1>DB_Editor2 - 5 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

Es muss was mit den get und set methoden des default indexers zu tun haben, aber ich komm leider nicht drauf was das Problem ist. Ebenso versehe ich nicht, warum die Parameterdeklaration 1 (der int index) unterschiedlich sein soll.

Vielleicht hat mir jemand noch einen Hinweis?

GRuß Solick