Geht es darum, dass du so etwas selbst implementierst ... Ja, darum geht es.

So wie es hypersurf in seinem Beitrag vom 04.02.2011, 11:54 Uhr beschrieben hat, habe ich ebenfalls UserControls innerhalb eines MainWindows zur Anzeige gebracht.

Ich möchte jetzt noch den UserControls beim Aufruf durch einen MainWindow-Button Parameter mitgeben?

Dazu habe ich Folgendes gemacht:
In dem an den Button gebundenen Command steht

InputViewModel viewModel = new InputViewModel(SelectedGroup);
this.CurrentContent = viewModel;

Der Aufruf klappt noch.

Jetzt wird aber danach noch der Konstruktor InputViewModel() gerufen. Ich vermute, dass das passiert, weil ich in InputView.xaml den DataContext auf InputViewModel setze. Denn wenn ich das Statement weglasse, bekomme ich eine Fehlermeldung.

Wie muss ich es nun richtig machen, damit der Parameter ankommt?

Der obige Link lautet jetzt http://www.lab49.com/wp-content/uploads/2011/12/Jason_Dolinger_MVVM.wmv

Der passende Beitrag dazu ist wie folgt zu erreichen: http://blog.lab49.com/archives/2650

Ich denke er ignoriert eine der aus meine Sicht sinnvollen Regeln der neuen Rechtschreibung, indem er weiterhin permanet das 'ß' benutzt.

@MrSparkle:
Warum gehst Du eigentlich nicht selbst mit einem guten Beispiel voran?

Um mich weiter in C# (VS 2012 Express, SQL Server 2012 Express) einzuarbeiten, sehe ich mir im Augenblick einige Beispiele an und versuche sie nachzuvollziehen.

(1) Dabei habe ich ein erstes Problem mit diesem Beispiel, das ich Schritt für Schritt übernommen habe:

var departmentQuery = from d in schoolContext.Departments.Include("Courses")
                                  orderby d.Name
                                  select d;
...
this.departmentList.DisplayMember = "Name";
this.departmentList.DataSource = ((ObjectQuery)departmentQuery).Execute(MergeOption.AppendOnly);

Beim Ausführen der Zuweisung zur DataSource der ComboBox wird folgende Exeption angezeigt:

Fehlermeldung:
"Das Objekt des Typs "System.Data.Entity.Infrastructure.DbQuery`1[CourseManager.Department]" kann nicht in Typ "System.Data.Objects.ObjectQuery" umgewandelt werden."

Leider weiß ich nicht wirklich, warum die Fehlermeldung kommt, zumal so ein Beispiel doch eigentlich funktionieren sollte.

Gelöst habe ich das dann wie folgt:

//this.departmentList.DataSource = ((ObjectQuery)departmentQuery).Execute(MergeOption.AppendOnly);
this.departmentList.DataSource = departmentQuery.ToList();

(2) Ein weiteres Problem ergibt sich an dieser Stelle:

Department department = (Department)this.departmentList.SelectedItem;

courseGridView.DataSource = department.Courses;
courseGridView.Columns["Department"].Visible = false;

Wenn false zugewiesen werden soll, lautet die Exeption:

Fehlermeldung:
"Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt."

Auch das habe ich wie folgt gelöst:

// courseGridView.DataSource = department.Courses;
   courseGridView.DataSource = department.Courses.ToList();

Auch hier würde ich - wenn möglich - um etwas Erläuterung bitten.

Sind meine Lösungen eigentlich ok?

Leider hatte ich in den letzten Monaten keine Zeit mich um mein Control zu kümmern. Jetzt soll es weitergehen.

@tala:

Die Usability ist grauenhaft.

Was würdest Du grundsätzlich anders machen?

Ich habe den Screenshot neu hochgeladen, weil ich ihn etwas überarbeitet habe.

Vielen Dank für weitere Tipps!

Danke für Deine schnelle Antwort, Th69!

Die Links zu den Kalender-Controls sind schon sehr hilfreich. Auch ist mir klar, dass ich da - wie bisher ja auch - selbst Hand anlegen muss.

Das Panel-Control unter WinForms habe ich durch die Beispiele schon bestätigt bekommen. Aber was würde ich unter WPF zweckmäßigerweise nehmen?

Für die Umstellung eines "etwas" betagten Programms, das in Visual Objects geschrieben wurde, suche ich nach dem passenden Control in C#. Ich habe einen Screenshot mit einer etwas ausführlicheren Beschreibung angehängt.

Das bisherige Verfahren war wenig objektorientiert und basierte auf einem CustomControl, das nur den Rahmen zur Verfügung stellte. Alles was darauf zu sehen ist, ist einzeln selbstgemalt. Richtige Objekte gibt es nicht. D. h., wenn man mit der Maus irgendwo hinklickt, ermittelt das Programm anhand der Mauskoordinaten, wo man hingeklickt hat. Dann untersucht es, welcher Bereich angeklickt wurde und ob ggf. eine Datenzelle erwischt wurde oder nicht etc. Das Ganze ist heute leider nur noch sehr schwer wartbar. Daher möchte ich es neuschreiben.

Ich hätte z. B. sowas Ähnliches wie ein DataGridView genommen, aber ich habe ja mehrere Zeilen mit Spaltenüberschriften, und außerdem machen mir die "frei über dem Gitter schwebenden" Datenzellen dabei Sorgen.

Bislang scheint mir das WinForms-Objekt 'Panel' geeignet zu sein. Eventuell kann man mehrere Panel-Objekte in- oder aneinanderbauen. In WPF scheint es so ein Control nicht zu geben, oder?

Mir würden ein paar Hinweise, welches Control ich in WinForms bzw. WPF nehmen sollte sehr weiterhelfen!

Vielen Dank im Voraus!

Noch einmal herzlichen Dank für die Informationen!

Ich denke, dass ich jetzt erst einmal mit einem Beispiel beginne, um auch die Git-Handhabung kennenzulernen. Dann werde ich sehen, wie weit ich komme und mich dann noch einmal hier melden.

Danke für die Rückmeldungen!

@herbivore:

Nun, die beteiligten Enwickler befinden sich nicht innerhalb eines gemeinsamen Netzwerkes. Sie können sich nur über das Internet per E-Mail und FTP austauschen, oder ggf. falls mal per USB-Stick.

@thomas.at:

So, wie Du es beschreibst, habe ich es bislang ja auch verstanden. In meiner besonderen Situation ist es aber eben so, dass nur Entwickler A an seinem Standort auf das "Master-Repository" zugreifen kann bzw. soll.

Weiß den Git bei B und C (ohne auf das "Master-Repository" zugreifen zu können), was dort alles seit dem letzten Abgleich geändert wurde? Falls ja, dann schicken sie es halt an alle Beteiligten und jeder packt alles in sein lokales Repository. Nur A schiebt die Änderungen zusätzlich noch in das "Master-Repository". Wäre das möglich?
Wichtig wäre dabei, dass Git bei B und C "weiß", was alles noch nicht verschickt wurde, weil Menschen ja so schrecklich vergesslich sind.

Danke für Deine Antworten!

...in einer verteilten Versionsverwaltung gibt es kein "zentrales" Repository in dem Sinne. ...
In den meisten Fällen wird man ein Repository auf einen zentralen Server legen und sich mündlich darauf einigen daß das das "zentrale" ist ...

Das ist ein Punkt, den ich bislang zwar schon mehrfach gelesen, aber nicht wirklich verstanden habe: Wozu dient denn überhaupt das zentrale Repository? Vielleicht um die Unterschiede des zentralen gegenüber dem lokalen Repository zu kennen - und diese in der Folge dann anderen zur Verfügung zu stellen?

... Um bei Deinem Beispiel zu bleiben, würde Entwickler A am Anfang 1x das zentrale Repository weitergeben, Entwickler B und C würden ihm dann irgendwann ihre veränderten Versionen zurückschicken, und er würde ihre Änderungen per **Pull **in sein Repository holen und dort ggf. mergen.

Woher wissen B und C, welche Änderungen Sie noch nicht an A geliefert haben? Müssen sie sich das z. B. an einem Datum merken, oder "weiß" es das Git? "Pull" würde dann bedeuten, dass A sich die von B und C weitergeleiteten Differenzen(?) in sein lokales(?) Repository holen würde? Macht er sich dabei nichts kaputt?

Zu welchem Zeitpunkt gibt denn A seine Änderungen weiter? "Weiß" das lokale(?) Repository, welche Änderungen A noch nicht weitergereicht hat, und stören zwischenzeitliche "Pull"- und /oder "Merge"-Aktionen dabei nicht?

Dann noch zum "Mergen": Sollten A und B dieselben Dateien bearbeitet haben und es zu Konflikten kommen, dann hat der Mergende die Arbeit mit dem fremden Code? Nicht, dass ich davon "Angst" hätte; ich will 's nur wissen und verstehen.

Ach ja, "die Cloud" scheidet als Speicherort für die Daten aus. Da ist das Vertrauen noch nicht so weit ...

Hallo!

Bei meiner Suche nach einer für meinen Fall für SharpDevelop 4 geeigneten Versionsverwaltung bin ich auf Git gestoßen. Leider weiß ich noch nicht so recht, ob es das ist, was ich suche.

Ich suche eine Versionsverwaltung, die ohne Zugriff auf einen gemeinsamen Server betrieben werden kann. Die beteiligten Entwickler werden Daten nur per E-Mail, FTP oder USB-Stick austauschen können.
*Wäre das mit Git machbar? *Würde man das zentrale Repository an genau einem Standort halten? *Wie könnte man die verteilten lokalen Repositorys gegen das zentrale abgleichen? *Wie könnte man die Änderungen untereinander verteilen?

Beispiel:
Wenn ich es bislang richtig verstanden habe, erstellt Entwickler A ein Main-Repository und macht sich davon eine lokale Kopie. Wie kommt nun Entwickler B an ein lokales Repository? Kann A das erstellen und ihm zusenden? Oder muss A das Main-Repository weitergeben?

A und B machen Änderungen und spielen sie in ihr jeweiliges Repository zurück. Nach einigen Tagen sollen diese Änderungen untereinander und mit dem Main-Repository ausgetauscht werden, sodass alle Repositorys wieder auf dem neuesten Stand sind. Wie geht man dabei genau vor?

Für ein paar Tipps und Hinweise wäre ich sehr dankbar!

Halo Tom!

Index-Dateien sind zum schnellen Suchen innerhalb von DBF-Dateien.

Enthält eine DBF-Datei z.B. eine Spalte mit Artikelnummern und sucht man jetzt nach einer ganz bestimmten Artikelnummer, so muss man nicht die ganze DBF-Datei lesen, sondern schaut im Index nach, wo genau der Datensatz ist.

Dazu gibt es unter dBase(-Dialekten) den SEEK-Befehl (SEEK('4711')). In SQL, aber das weißt Du selber, wäre es ein SELECT * WHERE ARTIKEL='4711'.

Bei dBase-Datenbanken werden aktuell keine Index-Dateien (CDX) berücksichtigt. Wird das noch ergänzt werden?

Wird man auf dBase-Datenbanken auch schreibend zugreifen können?

Hat niemand eine Idee zu meinem geschilderten Problem? Ich will doch nur lernen ... 🙂

Ich hatte mal wieder etwas Zeit und wollte meine Update-Methode etwas anders gestalten. Das Folgende funktioniert bereits gut:

		
private void btnSpeichern_Click(object sender, EventArgs e) {
int inxChOrder = _dataTable.Columns["ch_order"].Ordinal;
int inxChId = _dataTable.Columns["ch_id"].Ordinal;

	this.Cursor = Cursors.WaitCursor;

	Validate();
	// alle Eingaben beenden
	_bindingSource.EndEdit();

	// DB-Connection aufbauen
	using (SQLiteCommand cmd = new SQLiteCommand("UPDATE ChannelInfo SET ch_order = @ch_order WHERE ch_id = @ch_id", _sqlConnection)) {

		SQLiteParameter pChOrder = new SQLiteParameter("@ch_order");
		SQLiteParameter pChId = new SQLiteParameter("@ch_id");

		cmd.Parameters.Add(pChOrder);
		cmd.Parameters.Add(pChId);

		_sqlConnection.Open();

		foreach (DataRow row in _dataTable.GetChanges().Rows) {
			cmd.Parameters["@ch_order"].Value = row[inxChOrder];
			cmd.Parameters["@ch_id"].Value = row[inxChId];
			cmd.ExecuteNonQuery();
	}

	_sqlConnection.Close();	
}

Jetzt wollte ich es etwas besser strukturieren und so das Update so machen:

private void btnSpeichern_Click(object sender, EventArgs e) {

	_bindingSource.EndEdit();

	_sqlDataAdapter.UpdateCommand = CreateUpdateCommand(_sqlConnection);
	_sqlDataAdapter.InsertCommand = CreateInsertCommand(_sqlConnection);
	_sqlDataAdapter.DeleteCommand = CreateDeleteCommand(_sqlConnection);

	this.Cursor = Cursors.WaitCursor;

	_sqlConnection.Open();
	_sqlDataAdapter.Update(_dataSet.Tables[0]);
	_sqlConnection.Close();

	this.Cursor = Cursors.Default;

}

Der Update-Befehl wird dabei wie folgt erstellt:

public static SQLiteCommand CreateUpdateCommand(SQLiteConnection con) {
	
	SQLiteCommand cmd = new SQLiteCommand("UPDATE ChannelInfo SET ch_order = @ch_order WHERE ch_id = @ch_id", con);

	SQLiteParameter pChOrder = new SQLiteParameter("@ch_order", SqlDbType.Int);
	SQLiteParameter pChId = new SQLiteParameter("@ch_id", SqlDbType.Int);

	cmd.Parameters.Add(pChOrder);
	cmd.Parameters.Add(pChId);
	pChId.SourceVersion = DataRowVersion.Original;

	return cmd;
	
}

Leider werden aber so keine Veränderungen in die Tabelle geschrieben. Woran liegt das?

Da ich mal wieder etwas Zeit habe, hier noch eine Frage zu meiner Speicher-Methode aus dem Beitrag vom 05.01.2010 11:23 Uhr.

So wie ich das dort programmiert habe, ist das total langsam. Ich vermute, dass es daran liegt, dass cmd.ExecuteNonQuery(); innerhalb einer Schleife ausgeführt wird.

Wie kann ich das anders machen, um das Speichern drastisch zu beschleunigen?

Wenn du es nicht mit AddWithValue machst - und das passt bei einer Schleife nicht -, dann muss der Typ angegeben werden.

Das will ich ja auch gerne tun. Aber man wird den Typ einer Spalte doch auslesen können, oder?

Gut, ich habe noch mal was geändert:

// DB-Connection aufbauen
using (SQLiteConnection sqlConn = new SQLiteConnection("Data Source=db.dat;Version=3;New=False;Compress=True;"))
using (SQLiteCommand cmd = new SQLiteCommand("UPDATE ChannelInfo SET ch_order = @ch_order WHERE ch_id = @ch_id", sqlConn)) {
	sqlConn.Open();
...
	cmd.ExecuteNonQuery();
				}
	//sqlConn.Close();	nicht erforderlich, da das im Finalyzer mit Dispose erledigt wird.
}

Dann noch einmal zu #1:

Mich stört, dass ich hier den Typ explizit angebe. Wenn ich den mal ändere, muss ich auch an diese Stelle denken. Daher würde ich das gern anders machen.

Die Verwendung von SQLiteDbType wird bei mir als "im aktuellen Kontext nicht vorhanden" angemeckert. Welche using-Anweisung müsste ich da ergänzen?

Mittlerweile sieht meine Methode zum Speichern wie folgt aus:

private void btnSpeichern_Click(object sender, EventArgs e) {
	int inxChOrder = _dataTable.Columns["ch_order"].Ordinal;
	int inxChId = _dataTable.Columns["ch_id"].Ordinal;

	this.Cursor = Cursors.WaitCursor;
			
	// alle Eingaben beenden
	_bindingSource.EndEdit();

	// DB-Connection aufbauen
	using (SQLiteCommand cmd = new SQLiteCommand("UPDATE ChannelInfo SET ch_order = @ch_order WHERE ch_id = @ch_id", _sqlConnection)) {
		_sqlConnection.Open();
		cmd.Parameters.Add("@ch_order", DbType.Int32);
		cmd.Parameters.Add("@ch_id", DbType.Int32);

		// Werte in die DB speichern
		foreach (DataRow row in _dataTable.Rows) {
			cmd.Parameters["@ch_order"].Value = row[inxChOrder];
			cmd.Parameters["@ch_id"].Value = row[inxChId];
			cmd.ExecuteNonQuery();
		}
		_sqlConnection.Close();
	}
	this.Cursor = Cursors.Default;
}

1. Was mich persönlich noch stört, sind die beiden Ausdrücke "DbType.Int32". Wie kann ich das besser machen?

2. Bringt es etwas z. B. an Performance oder Übersicht, wenn ich wie oben inxChOrder und inxChId in der Schleife verwende?

3. Wie hält man es mit der Verwendung von "this"? Sollte man es wann immer möglich verwenden? Ich habe es aber in der Methode häufig vergessen. (Leider?) funktioniert es auch ohne "this".

Vielen Dank für die vielen Informationen!

Ich werde sie mir ansehen und versuchen, alles richtig zu verstehen! Falls ich nähere Informationen brauche, werde ich mich hierzu wieder melden.

Jetzt weiß ich aber dank Deiner Hinweise schon mal, wie der richtige Weg aussieht und stochere nicht nur im Nebel des Neuen herum.

Jetzt speichere ich die Änderungen wie folgt:

private void btnSpeichern_Click(object sender, EventArgs e) {
	int inxChOrder = _dgv.Columns["ch_order"].Index;
	int inxChId = _dgv.Columns["ch_id"].Index;
	DataTable tbl = _dgv.DataSource;

	using (SQLiteCommand cmd = new SQLiteCommand("UPDATE ChannelInfo SET ch_order = @ch_order WHERE ch_id = @ch_id", _sqlConnection)) {
		_sqlConnection.Open();
		for (int r = 0; r < tbl.Rows.Count; r++) {
			cmd.Parameters.AddWithValue("@ch_order", tbl.Rows[r][inxChOrder]);
			cmd.Parameters.AddWithValue("@ch_id", tbl.Rows[r][inxChId]);
			cmd.ExecuteNonQuery();
		}
		_sqlConnection.Close();
	}
}

Zuvor hatte ich es so gemacht:

...
		for (int r = 0; r < _dgv.RowCount; r++) {
			cmd.Parameters.AddWithValue("@ch_order", _dgv.Rows[r].Cells[inxChOrder].Value);
			cmd.Parameters.AddWithValue("@ch_id", _dgv.Rows[r].Cells[inxChId].Value);
			cmd.ExecuteNonQuery();
		}
...

Ich sehe da noch nicht so den Riesenunterschied, aber wenn es empfohlen wird, werde ich gerne versuchen, mich daran zu orientieren.

Bis hierhin zunächst einmal ein großes DANKE für die Geduld und die hilfreichen Tipps!

So, es klappt jetzt. Ich habe die zweite Lösungsmöglichkeit gewählt.

Ob ich nun eine DataTable verwende, weiß ich nicht. Ich glaube wohl eher nicht, denn ich verwende ja sowas wie "_dgv.Rows[r].Cells[c].Value", um die Werte aus dem DataGridView in die DB zurückzuschreiben. _dgv ist dabei ein DataGridView-Object. Aber ich war erst einmal froh, dass ich auf die Werte zugreifen konnte ... 😉

Eine DataTable habe ich aber irgendwie auch:

	private SQLiteConnection _sqlConnection;
	private SQLiteCommand _sqlCommand;
	private SQLiteDataAdapter _sqlDataAdapter;
	private DataSet _dataSet = new DataSet();
	private DataTable _dataTable = new DataTable();
	private DataGridView _dgv;
	private BindingSource _bindingSource;
	private SQLiteCommandBuilder _sqlCmdBuilder;
...
	_sqlCommand = _sqlConnection.CreateCommand();
	string CommandText = "select * from ChannelInfo";
	_sqlDataAdapter = new SQLiteDataAdapter(CommandText, _sqlConnection);
	_sqlCmdBuilder = new SQLiteCommandBuilder(_sqlDataAdapter);
	_sqlCmdBuilder.SetAllValues = false;

	_dataSet.Reset();
	_sqlDataAdapter.Fill(_dataSet);
	_dataTable = _dataSet.Tables[0];
			
	//BindingSource to sync DataTable and DataGridView
	_bindingSource = new BindingSource();

	//set the BindingSource DataSource
	_bindingSource.DataSource = _dataTable;

	//set the DataGridView DataSource
	_dataGridView.DataSource = _bindingSource;

(Wie) soll ich die jetzt verwenden anstatt "_dgv.Rows[r].Cells[c].Value"?

Das Speichern der Änderungen klappt nicht.

Die Ausgangstabelle sieht im DGV wie folgt aus:

ID     name     order
1       VW        1
2       Opel      2
3       Benz      3

Per drag&drop mache ich daraus

ID     name     order
2       Opel      2
3       Benz      3
1       VW        1

Durch Umnummerierung mache ich daraus

ID     name     order
2       Opel      1
3       Benz      2
1       VW        3

Wenn ich das jetzt so speichere

	private void btnSpeichern_Click(object sender, EventArgs e) {
		// Update the database with the user's changes.
		dataAdapter.Update((DataTable)bindingSource1.DataSource);
	}

bekomme ich diesen Fehler: "Abort due to constraint violation PRIMARY KEY must be unique"

Wenn ich aber die Tabelle vor dem Speichern nochmals per drag&drop wie folgt umsortiere:

ID     name     order
1       VW        3
2       Opel      1
3       Benz      2

klappt das Sepichern.

Fragen dazu:

1. Woher kommt der Fehler?
2. Wie kann ich das Speichern richtig machen?

Es ist doch erstaunlich: Man muss es nur mal klar durchdenken.

Ich hatte eine komplette row per drag&drop verschoben und danach eine Spalte neu durchnummeriert.

Das Verschieben war inklusive des primary keys erfolgt, und so kam es natürlich zu dem o.g. Fehler beim Update.

Wenn ich vor dem Update die Reihenfolge der Daten wieder anhand des primary keys wiederherstelle, klappt auch das Update.

Ohh, da werde ich noch einiges hier fragen und noch mehr lernen müssen ...

Es ist halt schwierig, wenn man von einer gewohnten Umgebung eine ganz neue Welt kennenlernen will: War früher nur die Programmlogik zu beachten, muss man jetzt auch noch die neue IDE und die neue Sprache erlernen und bedenken. Das ist nicht so enfach, wie ich gedacht hatte. Aber jeder winzige erfolgreiche Schritt macht mir Mut, den Weg weiterzugehen.

Das hatte ich bereits versucht, aber SQLCommandBuilder passte nicht zu meinnem SQLite-Adapter. Etwas googeln hat dann SQLiteCommandBuilder hervorgebracht.

Damit ist die o.g. Fehlermeldung jetzt weg. Dafür kommt eine neue: "Abort due to constraint violation PRIMARY KEY must be unique"

Da muss ich aber erst einmal schauen, was ich dagegen machen kann, bevor ich dazu etwas fragen werde. Denn eigentlich sollte diese Fehler nicht kommen.

Eine weitere Frage in meiner Lernphase:

Ich wollte die Änderungen in meinem DGV wie folgt speichern:

	private void btnSpeichern_Click(object sender, EventArgs e) {
		// Update the database with the user's changes.
		dataAdapter.Update((DataTable)bindingSource1.DataSource);
	}

Zur Laufzeit bekam ich dann die Meldung: "Aktualisieren erfordert einen gültigen UpdateCommand, wenn eine DataRow-Auflistung mit modifizierten Zeilen weitergegeben wird."

Nun ist dataAdapter vom Typ SQLiteDataAdapter. Wie erstelle ich denn so ein UpdateCommand?

Danke für eine Antwort!

Hmm, das ist jetzt blöd. Ich hatte gerade meinen Beitrag um die Lösung erweitert, die ich gefunden hatte. Also versuche ich es noch einmal:

Ich habe folgende Lösung für mein Problem gefunden:

		private void btnNeuNummerieren_Click(object sender, EventArgs e) {
			int inx = dgv.Columns["ch_order"].Index;
			int i = 1;

			for (int r = 0; r < dgv.RowCount; r++)
				dgv.Rows[r].Cells[inx].Value = i++; 

		}

Vielleicht gibt es ja noch eine bessere Variante.

Jetzt habe ich mal wieder etwas Zeit, mich mit C# auseinanderzusetzen. Ich stehe dabei noch immer am Anfang. Seht mit daher "dumme Fragen" bitte nach.

Zur Situation: Ich habe eine SQLite Tabelle in ein DataGridView verfrachtet. Die einzelnen Zeilen kann ich per drag & drop neu anordnen.

Zum Problem: Wenn die Ordnung so ist, wie ich sie haben will, möchte in einer bestimmten Spalte, von der ich den Namen kenne, eine Durchnummerierung starten. Wie geht das?

Danke für eine Antwort!

Danke für die hilfreiche Antwort.

...Das gehört aber zu den Grundlagen, ...

Ich hatte "Assembly" markiert und F1 gedrückt, aber dann nichts Brauchbares erhalten. Deshalb hatte ich hier gefragt.

Hallo!

Anhand einer Beispiel-Anwendung bin ich dabei, C# zu lernen. In der Projektmappe kann ich unter dem Orner "Projekt" die Datei namens "AssemblyInfo.cs" sehen, auf die ich gerne zugreifen möchte. Jetzt bin ich dabei auf folgendes Problem gestoßen:

Die Anweiung

Assembly oAssembly = Assembly.GetEntryAssembly();
Attribute oAttribute;
...
oAttribute = Attribute.GetCustomAttribute(oAssembly, typeof(AssemblyProductAttribute));
lblTitle.Text = ((AssemblyProductAttribute)oAttribute).Product;

führt bezogen auf die erste Code-Zeile zu der Fehlermeldung: Der Typ- oder Namespacename "Assembly" konnte nicht gefunden werden. (Fehlt eine Using-Direktive oder ein Assemblyverweis?)

Wie kann ich das Problem beheben?