DataGridView als User die Spaltenbreiten in Einstellungen festlegen

Haudruferzappeltnoch · 11. November 2021, 16:55

Hallo,

ich würde in einem DataGridView gerne die Spaltenbreiten abspeichern. Im Moment setzte ich im Control die Spaltenbreiten fest, aber das kann sich ja auch mal wieder ändern.
Wäre schön wenn man im laufenden Programm eine Spalte so groß macht wie man möchte und dann ist die beim nächsten Start auch wieder so.
Jetzt dachte ich mache ich ein Array mit Width Werten und eine List mit den jeweiligen DatagridviewColumns und kann das dann entsprechend zuordnen und in den Einstellungen hinterlegen.

Aber mein DGV hat ja eigentlich gar keine Spalten, sondern bildet ja die Spalten einer dahinterliegenden DataTable ab. Deswegen weiß ich nicht ob ich da eigentlich an der falschen Stelle rumwurstel.

Viele Grüße

mrMo · 11. November 2021, 18:19

Haudruferzappeltnoch schrieb:

ein Array mit Width Werten und eine List mit den jeweiligen DatagridviewColumns und kann das dann entsprechend zuordnen und in den Einstellungen hinterlegen.

Ja so in der art täte (und hab ich auch schon) ich das auch machen. Spaltenbreiten + Spaltennamen speichern.

VaporiZed · 11. November 2021, 20:55

Haudruferzappeltnoch schrieb:

Aber mein DGV hat ja eigentlich gar keine Spalten, sondern bildet ja die Spalten einer dahinterliegenden DataTable ab.

Macht doch nix. Trotzdem hat doch Dein DGV Spalten und Spaltenbreiten. Die kannst Du festlegen. Natürlich am besten, nachdem die Daten geladen wurden.

ErfinderDesRades · 11. November 2021, 23:06

layout-Infomationen persistiere ich gerne mit ComplexConverter: alles in einen String und zurück?
Das kann alles mögliche, natürlich auch DGV-Spalten

Haudruferzappeltnoch · 12. November 2021, 10:03

Wirkt schon wie ein schweres Geschütz, ich werd ihn mal abspeichern, versuchs aber erstmal mit minimalem Ansatz.

Kann man eine List(Of T) als Einstellung abspeichern? Ich finde dort nur Dinge wie SortedList oder ArrayList

RodFromGermany · 12. November 2021, 10:19

@Haudruferzappeltnoch Mach Dir eine eigene Settings-Klasse, da geht auch eine List(Of Integer), diese Settings kannst Du speichern wo immer Du willst.
Hier mal ne C#-Variante:

Spoiler anzeigen

C#-Quellcode

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;
namespace SettingsBinAndXml
{
/// <summary>
/// Klasse, die die Settings hält, speichert und lädt
/// </summary>
[Serializable]
public class Settings
{
/// <summary>Settings-Member</summary>
public int Port { get; set; }
/// <summary>Settings-Member</summary>
public string User { get; set; }
/// <summary>Settings-Member</summary>
public List<int> Values { get; set; }
/// <summary>
/// Pfad zur Settings-Datei,
/// wird nicht mit abgespeichert
/// </summary>
[NonSerialized]
[XmlIgnore]
private string Path;
/// <summary>
/// parameterloser Konstruktor zur Serialisierung
/// </summary>
public Settings()
{
this.Values = new List<int>();
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="path">Pfad zur Datei</param>
public Settings(string path)
: this()
{
this.Path = path;
}
/// <summary>
/// Überschrieben zur Test-Ausgabe
/// </summary>
/// <returns></returns>
public override string ToString()
{
return string.Format("{0}, {1}, {2}", this.User, this.Port, this.Values.Count);
}
/// <summary>
/// Speichern der Settings als XML-Datei
/// </summary>
internal void SaveXml()
{
// Serialize object to a XML file.
using (StreamWriter sw = new StreamWriter(this.Path))
{
XmlSerializer x = new XmlSerializer(this.GetType());
x.Serialize(sw, this);
}
}
/// <summary>
/// Laden der Settings
/// </summary>
/// <param name="path">Pfad der XML-Datei</param>
/// <returns>die geladenen DataAll</returns>
internal static Settings LoadXml(string path)
{
Settings settings = new Settings();
try
{
// Deserialize text file to a new object.
using (StreamReader sr = new StreamReader(path))
{
XmlSerializer x = new XmlSerializer(settings.GetType());
settings = (Settings)x.Deserialize(sr);
}
}
catch
{
// nix tun, die Settings-Instanz ist nicht valid,
// es werden die Default-Werte zurückgegeben
}
settings.Path = path;
return settings;
}
/// <summary>
/// Speichern der Settings
/// </summary>
internal void WriteToBin()
{
// Serialize object to a bin file.
using (FileStream fs = new FileStream(this.Path, FileMode.Create))
{
BinaryFormatter binFormatter = new BinaryFormatter();
using (GZipStream fs2 = new GZipStream(fs, CompressionMode.Compress))
{
binFormatter.Serialize(fs2, this);
}
}
}
/// <summary>
/// Einlesen der Settings
/// </summary>
/// <param name="path">der Dateiname</param>
/// <returns>die gelesene oder die neue Settingsinstanz</returns>
internal static Settings ReadFromBin(string path)
{
// Serialize settings to a bin file.
Settings settings = new Settings();
try
{
using (FileStream fs = new FileStream(path, FileMode.Open))
{
BinaryFormatter binFormatter = new BinaryFormatter();
using (GZipStream fs2 = new GZipStream(fs, CompressionMode.Decompress))
{
settings = (Settings)binFormatter.Deserialize(fs2);
}
}
}
catch
{
}
settings.Path = path;
return settings;
}
}
}

C#-Quellcode

private void btnTemp_Click(object sender, EventArgs e)
{
string path = "D:\\Temp\\Settings.xml";
Settings data = Settings.LoadXml(path);
data.User = "Ich";
data.Port = 44;
data.Values.Add(19);
data.SaveXml();
MessageBox.Show(data.ToString());
}
private void btnBinaryOut_Click(object sender, EventArgs e)
{
Settings data = new Settings("D:\\Temp\\Settings.bin");
data.User = "Ich";
data.Port = 45;
data.Values.Add(20);
data.WriteToBin();
MessageBox.Show(data.ToString());
}

Haudruferzappeltnoch · 12. November 2021, 10:30

Das ist alles für eine Settings Klasse? Oder ist das soviel, weil du es aus einer Datei lädst? Mit C# bin ich nicht so vertraut.

RodFromGermany · 12. November 2021, 11:01

@Haudruferzappeltnoch Diese Settings haben nix zu tun mit den Settings, die Dir in den Projekteigenschaften angeboten werden.
Dies ist eine eigene Klasse, in die Du reinschreiben kannst, was immer Du benötigst.
Im Beispiel tragen sie den Kommentar Settings-Member.
Erweitere lediglich die Properties oben im Code.

Spoiler anzeigen

VB.NET-Quellcode

Imports System.IO
Imports System.IO.Compression
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Xml.Serialization
''' <summary>
''' Klasse, die die Settings hält, speichert und lädt
''' </summary>
<Serializable>
Public Class Settings
''' <summary>Settings-Member</summary>
Public Property Port As Integer
''' <summary>Settings-Member</summary>
Public Property User As String
''' <summary>Settings-Member</summary>
Public Property Values As List(Of Integer)
''' <summary>
''' Pfad zur Settings-Datei,
''' wird nicht mit abgespeichert
''' </summary>
<NonSerialized>
<XmlIgnore>
Private Path As String
''' <summary>
''' parameterloser Konstruktor zur Serialisierung
''' </summary>
Public Sub New()
Values = New List(Of Integer)()
End Sub
''' <summary>
''' Konstruktor
''' </summary>
''' <param name="path">Pfad zur Datei</param>
Public Sub New(ByVal path As String)
Me.New()
Me.Path = path
End Sub
''' <summary>
''' Überschrieben zur Test-Ausgabe
''' </summary>
''' <returns></returns>
Public Overrides Function ToString() As String
Return String.Format("{0}, {1}, {2}", User, Port, Values.Count)
End Function
''' <summary>
''' Speichern der Settings als XML-Datei
''' </summary>
Friend Sub SaveXml()
' Serialize object to a XML file.
Using sw As StreamWriter = New StreamWriter(Path)
Dim x As XmlSerializer = New XmlSerializer([GetType]())
x.Serialize(sw, Me)
End Using
End Sub
''' <summary>
''' Laden der Settings
''' </summary>
''' <param name="path">Pfad der XML-Datei</param>
''' <returns>die geladenen DataAll</returns>
Friend Shared Function LoadXml(ByVal path As String) As Settings
Dim settings = New Settings()
Try
' Deserialize text file to a new object.
Using sr As StreamReader = New StreamReader(path)
Dim x As XmlSerializer = New XmlSerializer(settings.GetType())
settings = CType(x.Deserialize(sr), Settings)
End Using
Catch
' nix tun, die Settings-Instanz ist nicht valid,
' es werden die Default-Werte zurückgegeben
End Try
settings.Path = path
Return settings
End Function
''' <summary>
''' Speichern der Settings
''' </summary>
Friend Sub WriteToBin()
' Serialize object to a bin file.
Using fs As FileStream = New FileStream(Path, FileMode.Create)
Dim binFormatter As BinaryFormatter = New BinaryFormatter()
Using fs2 As GZipStream = New GZipStream(fs, CompressionMode.Compress)
binFormatter.Serialize(fs2, Me)
End Using
End Using
End Sub
''' <summary>
''' Einlesen der Settings
''' </summary>
''' <param name="path">der Dateiname</param>
''' <returns>die gelesene oder die neue Settingsinstanz</returns>
Friend Shared Function ReadFromBin(ByVal path As String) As Settings
' Serialize settings to a bin file.
Dim settings As Settings = New Settings()
Try
Using fs As FileStream = New FileStream(path, FileMode.Open)
Dim binFormatter As BinaryFormatter = New BinaryFormatter()
Using fs2 As GZipStream = New GZipStream(fs, CompressionMode.Decompress)
settings = CType(binFormatter.Deserialize(fs2), Settings)
End Using
End Using
Catch
End Try
settings.Path = path
Return settings
End Function
End Class

VB.NET-Quellcode

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim path As String = "D:\Temp\Settings.xml"
Dim data As Settings = Settings.LoadXml(path)
data.User = "Ich"
data.Port = 44
data.Values.Add(19)
data.SaveXml()
MessageBox.Show(data.ToString())
End Sub
Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
Dim data As Settings = New Settings("D:\Temp\Settings.bin")
data.User = "Ich"
data.Port = 45
data.Values.Add(20)
data.WriteToBin()
MessageBox.Show(data.ToString())
End Sub

VaporiZed · 12. November 2021, 11:33

Wenn Du nur die Spaltenbreiten in den "normalen" Settings speichern willst, kannst Du sie notfalls auch zu einem String mergen und später wieder auseinanderpfriemeln.
Also

VB.NET-Quellcode

'speichern
Dim ColumnWidths = DeinDGV.Columns.Cast(Of DataGridViewColumn).Select(Function(x) x.Width)
Dim StringForSettings = String.Join(";"c, ColumnWidths)
My.Settings.DerNameDerEinstellung = StringForSettings
'[…]
'laden
Dim SavedData = My.Settings.DerNameDerEinstellung
Dim ColumnWidths = SavedData.Split(";"c).Select(Function(x) Integer.Parse(x))
For i = 0 To ColumnWidths.Count - 1
DeinDGV.Columns(i).Width = ColumnWidths(i)
Next

Haudruferzappeltnoch · 12. November 2021, 13:35

Ich hab das Gefühl für genau sowas gibt es die .Join Funktion. Ist das um Ressourcen zu schonen, dass man da keine Arrays speichern kann?

Danke euch

RodFromGermany · 12. November 2021, 13:47

@Haudruferzappeltnoch Mit meinem Code kannst Du auch ein Array speichern.
Du musst es nur deklarieren und instanziieren (ihm Werte zuweisen).

Haudruferzappeltnoch · 12. November 2021, 14:15

Ja das ist dann quasi als Datei abgelegt. Mit Xml und Serialisierung hab ich mich noch nicht beschäftigt, es wäre sicherlich sehr nützlich das zu tun.

RodFromGermany · 12. November 2021, 14:41

Haudruferzappeltnoch schrieb:

es wäre sicherlich sehr nützlich das zu tun.

Dann füge die Settings-Datei einem neuen Projekt hinzu und spiele ein wernig damit herum, um ein Gefühl für zu bekommen.
In meinen Programmen nutze ich ausschließlich "eigene" Settings.

VB1963 · 13. November 2021, 09:14

@Haudruferzappeltnoch
Man kann auch eine List(Of...) in den Settings speichern --> benutzerdefinierte Liste in den Settings speichern

tragl · 13. November 2021, 12:55

Läuft die Anwendung nur auf einem PC?
Meine läuft z.B. in einem Netzwerk mit mehreren Usern und ich selbst melde mich auch mal an einem anderen PC an. Ich persistiere die DGV-Spaltenbreiten mit in der Datenbank
und mach das so, wie @VaporiZed das schon vorgeschlagen hat. Da der User bei mir die anzuzeigenden Spalten auswählen kann, ist das ganze komplexer - ist die Frage ob du sowas auch mal vor hast.
Ich speicher das mit Namen der Column, der Width und ob die Visible ist oder nicht. Sieht dann in etwa so aus:

Ich kann damit also auf jedem PC meine persönlichen "Einstellungen" abspeichern und abrufen.

Haudruferzappeltnoch · 14. November 2021, 20:40

@tragl
Das klingt auf jeden fall sehr interessant. Vielleicht wenn ich mal eine eigene Datenbank baue.

Haudruferzappeltnoch · 15. November 2021, 11:45

Ich hoffe es passt noch ins Thema rein:

An sich nutze ich das DGV nur zur Anzeige. Man kann jedoch obwohl ich nichts in der Richtung programmiere,
die Spalte des DGVs sortieren wenn man den Spaltenkopf anklickt. Da ich das wie gesagt nicht selbst eingebaut habe, weiß ich garnicht wo diese Sortierung stattfindet und auch nicht wie ich sie beeinflussen kann.
~~Denn momentan sortiert er auch numerische Werte alphabetisch. Vielleicht ist das ja der Standard?~~
Sry es war die DataTable, die hatte ich noch nicht auf den richtigen Typ umgestellt.

VaporiZed · 15. November 2021, 11:48

Das kann man im DGV einstellen: Wähle es im Designer, dann oben rechts auf den kleinen SmartTag [>] klicken, dann Spalten bearbeiten… und dann kannst Du bei jeder Spalte im PropertyFenster fast ganz unten das Sortierverhalten einstellen (SortMode). Ich bin da meist ziemlich rigoros und deaktiviere das. Meine User müssen nehmen, was ich vorgebe :evil:

Haudruferzappeltnoch · 15. November 2021, 12:37

Uff, trickreich versteckt muss ich mal ausnahmsweise sagen^^

ErfinderDesRades · 15. November 2021, 17:36

VaporiZed schrieb:

(SortMode). Ich bin da meist ziemlich rigoros und deaktiviere das. Meine User müssen nehmen, was ich vorgebe

Findich ich nicht empfehlenswert.
Fast immer ist das Sortieren von Daten dem User eine nützliche Hilfe.

Ansonsten kann man die Sortierung auch an der BindingSource.Sort-Property einstellen.

DataGridView als User die Spaltenbreiten in Einstellungen festlegen

DataGridView als User die Spaltenbreiten in Einstellungen festlegen

Haudruferzappeltnoch schrieb:

Haudruferzappeltnoch schrieb:

C#-Quellcode

C#-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

Haudruferzappeltnoch schrieb:

VaporiZed schrieb:

Ähnliche Themen

7 Benutzer haben hier geschrieben