如何获取WPF datagrid列大小调整事件？

我想动态加载和存储ini文件中的Datagrid列宽。每次调整列宽时写入我的INI文件。我可以使用哪种事件进行此操作。任何人都可以对此给出任何建议或示例代码。

我在行为中使用应用程序设置来解决这些问题，并在应用程序退出时保存信息

用法

背景

[SettingsManageabilityAttribute(SettingsManageability.Roaming)]
public sealed class MySettings: ApplicationSettingsBase, IGridSettings
{
    private static readonly Lazy<MySettings> LazyInstance = new Lazy<MySettings>(() => new KadiaSettings());

    public static MySettingsInstance { get { return LazyInstance.Value; } }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, int> GridDisplayIndexList
    {
        get { return (SerializableDictionary<string, int>)this["GridDisplayIndexList"]; }
        set { this["GridDisplayIndexList"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, Visibility> GridColumnVisibilityList
    {
        get { return (SerializableDictionary<string, Visibility>)this["GridColumnVisibilityList"]; }
        set { this["GridColumnVisibilityList"] = value; }
    }

    [UserScopedSettingAttribute()]
    [DefaultSettingValue("")]
    [SettingsSerializeAs(SettingsSerializeAs.Xml)]
    public SerializableDictionary<string, double> GridColumnWidthList
    {
        get { return (SerializableDictionary<string, double>)this["GridColumnWidthList"]; }
        set { this["GridColumnWidthList"] = value; }
    }

    private MySettings()
    {
        Application.Current.Exit += OnExit;
    }

    private void OnExit(object sender, ExitEventArgs e)
    {
        this.Save();
    }
}

public interface IGridSettings: INotifyPropertyChanged
{
    SerializableDictionary<string, int> GridDisplayIndexList { get; }

    SerializableDictionary<string, Visibility> GridColumnVisibilityList { get; }

    SerializableDictionary<string, double> GridColumnWidthList { get; }
}

[XmlRoot("Dictionary")]
public class SerializableDictionary<TKey, TValue>: Dictionary<TKey, TValue>, IXmlSerializable 
{

    #region IXmlSerializable Members
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(System.Xml.XmlReader reader)
    {
        var keySerializer = new XmlSerializer(typeof(TKey));
        var valueSerializer = new XmlSerializer(typeof(TValue));

        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();

        if (wasEmpty)
            return;

        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
            reader.ReadStartElement("item");

            reader.ReadStartElement("key");
            var key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();

            reader.ReadStartElement("value");
            var value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();

            this.Add(key, value);

            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }

    public void WriteXml(System.Xml.XmlWriter writer)
    {
        var keySerializer = new XmlSerializer(typeof(TKey));
        var valueSerializer = new XmlSerializer(typeof(TValue));

        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");

            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();

            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();

            writer.WriteEndElement();
        }
    }
    #endregion
}

[SettingsManageabilityAttribute（SettingsManageability.Roaming）]
公共密封类MySettings:ApplicationSettingsBase、IGridSettings
{
private static readonly Lazy Lazy instance=new Lazy（（）=>new KadiaSettings（））；
公共静态MySettingsInstance{get{return LazyInstance.Value；}}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
public SerializableDictionary GridDisplayIndexList
{
获取{return（SerializableDictionary）this[“GridDisplayIndexList”]；}
设置{this[“GridDisplayIndexList”]=value；}
}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
public SerializableDictionary GridColumnVisibilityList
{
获取{return（SerializableDictionary）this[“GridColumnVisibilityList”]；}
设置{this[“GridColumnVisibilityList”]=value；}
}
[UserScopedSettingAttribute（）]
[默认设置值（“”）
[SettingsSerializeAs（SettingsSerializeAs.Xml）]
公共序列化字典GridColumnWidthList
{
获取{return（SerializableDictionary）this[“GridColumnWidthList”]；}
设置{this[“GridColumnWidthList”]=value；}
}
私人MySettings（）
{
Application.Current.Exit+=OnExit；
}
私有void OnExit（对象发送方，ExitEventArgs e）
{
这是Save（）；
}
}
公共接口IGridSettings:INotifyPropertyChanged
{
SerializableDictionary GridDisplayIndexList{get；}
SerializableDictionary GridColumnVisibilityList{get；}
SerializableDictionary GridColumnWidthList{get；}
}
[XmlRoot（“字典”）]
公共类SerializableDictionary:Dictionary，IXmlSerializable
{
#区域IXmlSerializable成员
public System.Xml.Schema.XmlSchema GetSchema（）
{
返回null；
}
public void ReadXml（System.Xml.XmlReader）
{
var keySerializer=新的XmlSerializer（typeof（TKey））；
var-valueSerializer=新的XmlSerializer（typeof（TValue））；
bool waspempy=reader.isemptyelment；
reader.Read（）；
如果（为空）
返回；
while（reader.NodeType！=System.Xml.XmlNodeType.EndElement）
{
reader.ReadStartElement（“项目”）；
reader.ReadStartElement（“密钥”）；
var key=（TKey）keySerializer.反序列化（reader）；
reader.ReadEndElement（）；
reader.ReadStartElement（“价值”）；
var value=（TValue）valueSerializer.Deserialize（reader）；
reader.ReadEndElement（）；
添加（键、值）；
reader.ReadEndElement（）；
reader.MoveToContent（）；
}
reader.ReadEndElement（）；
}
public void WriteXml（System.Xml.XmlWriter）
{
var keySerializer=新的XmlSerializer（typeof（TKey））；
var-valueSerializer=新的XmlSerializer（typeof（TValue））；
foreach（此.Keys中的TKey键）
{
编写人。书面启动项（“项目”）；
writer.writeStart元素（“键”）；
序列化（编写器，键）；
writer.writeedelement（）；
writer.writeStarteElement（“值”）；
t值=此[键]；
序列化（写入程序，值）；
writer.writeedelement（）；
writer.writeedelement（）；
}
}
#端区
}

行为

public class DataGridBehavior : Behavior<DataGrid>
{

    public static readonly DependencyProperty GridSettingsProperty =
        DependencyProperty.Register("GridSettings", typeof(IGridSettings), typeof(DataGridBehavior), null);


    public IGridSettings GridSettings
    {
        get { return (IGridSettings)GetValue(GridSettingsProperty); }
        set { SetValue(GridSettingsProperty, value); }
    }

    public DataGridICollectionViewSortMerkerBehavior()
    {
        Application.Current.Exit += CurrentExit;
    }

    private void CurrentExit(object sender, ExitEventArgs e)
    {
        SetSettings();
    }

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += AssociatedObjectLoaded;
        AssociatedObject.Unloaded += AssociatedObjectUnloaded;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.Loaded -= AssociatedObjectLoaded;
        AssociatedObject.Unloaded -= AssociatedObjectUnloaded;
    }

    private void AssociatedObjectUnloaded(object sender, RoutedEventArgs e)
    {
        SetSettings();
    }

    void AssociatedObjectLoaded(object sender, RoutedEventArgs e)
    {
        var settings = GridSettings;

        var columns = AssociatedObject.Columns.ToList();
        var colCount = columns.Count;
        foreach (var column in columns)
        {
            var key = column.Header.ToString();

            if (settings.GridDisplayIndexList.ContainsKey(key))
            {
                //manchmal wird -1 als index abgespeichert
                var index = settings.GridDisplayIndexList[key];
                if(index > 0 && index < colCount)
                    column.DisplayIndex = index;
            }

            if (settings.GridColumnVisibilityList.ContainsKey(key))
            {
                column.Visibility = settings.GridColumnVisibilityList[key];
            }

            if (settings.GridColumnWidthList.ContainsKey(key))
            {
                column.Width = new DataGridLength(settings.GridColumnWidthList[key]);
            }
        }           
    }


    private void SetSettings()
    {
        var settings = GridSettings;

        foreach (var column in AssociatedObject.Columns)
        {
            var key = column.Header.ToString();
            var displayindex = column.DisplayIndex;
            var visibility = column.Visibility;
            var width = column.ActualWidth;

            if (settings.GridDisplayIndexList.ContainsKey(key))
            {
                settings.GridDisplayIndexList[key] = displayindex;
            }
            else
            {
                settings.GridDisplayIndexList.Add(key, displayindex);
            }

            if (settings.GridColumnVisibilityList.ContainsKey(key))
            {
                settings.GridColumnVisibilityList[key] = visibility;
            }
            else
            {
                settings.GridColumnVisibilityList.Add(key, visibility);
            }

            if (settings.GridColumnWidthList.ContainsKey(key))
            {
                settings.GridColumnWidthList[key] = width;
            }
            else
            {
                settings.GridColumnWidthList.Add(key, width);
            }
        }
    }

}

公共类DataGridBehavior:行为
{
公共静态只读从属属性GridSettingsProperty=
DependencyProperty.Register（“GridSettings”、typeof（IGridSettings）、typeof（DataGridBehavior）、null）；
公共设置网格设置
{
get{return（IGridSettings）GetValue（GridSettingsProperty）；}
set{SetValue（GridSettingsProperty，value）；}
}
公共DataGridICollectionViewSortMerkerBehavior（）
{
Application.Current.Exit+=CurrentExit；
}
私有void CurrentExit（对象发送方，ExitEventArgs e）
{
设置设置（）；
}
受保护的覆盖无效附加（）
{
base.onatached（）；
AssociatedObject.Loaded+=AssociatedObjectLoaded；
AssociatedObject.Unload+=AssociatedObjectUnload；
}
附加时受保护的覆盖无效（）
{
base.OnDetaching（）；
AssociatedObject.Loaded-=AssociatedObjectLoaded；
AssociatedObject.Unload-=AssociatedObjectUnload；
}
private void AssociatedObjectUnload（对象发送方，RoutedEventArgs e）
{
设置设置（）；
}
已加载的关联对象无效（对象发送方，RoutedEventArgs e）
{
var设置=网格设置；
var columns=AssociatedObject.columns.ToList（）；
var colCount=columns.Count；
foreach（列中的var列）
{
var key=column.Header.ToString（）；
if（settings.GridDisplayIndexList.ContainsKey）
{
//manchmal wird-1 als指数abgespeichert
var index=settings.GridDisplayIndexList[key]；
如果（索引>0&&indexpublic class DataGridBehavior : Behavior<DataGrid>
{

    public static readonly DependencyProperty GridSettingsProperty =
        DependencyProperty.Register("GridSettings", typeof(IGridSettings), typeof(DataGridBehavior), null);


    public IGridSettings GridSettings
    {
        get { return (IGridSettings)GetValue(GridSettingsProperty); }
        set { SetValue(GridSettingsProperty, value); }
    }

    public DataGridICollectionViewSortMerkerBehavior()
    {
        Application.Current.Exit += CurrentExit;
    }

    private void CurrentExit(object sender, ExitEventArgs e)
    {
        SetSettings();
    }

    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += AssociatedObjectLoaded;
        AssociatedObject.Unloaded += AssociatedObjectUnloaded;
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.Loaded -= AssociatedObjectLoaded;
        AssociatedObject.Unloaded -= AssociatedObjectUnloaded;
    }

    private void AssociatedObjectUnloaded(object sender, RoutedEventArgs e)
    {
        SetSettings();
    }

    void AssociatedObjectLoaded(object sender, RoutedEventArgs e)
    {
        var settings = GridSettings;

        var columns = AssociatedObject.Columns.ToList();
        var colCount = columns.Count;
        foreach (var column in columns)
        {
            var key = column.Header.ToString();

            if (settings.GridDisplayIndexList.ContainsKey(key))
            {
                //manchmal wird -1 als index abgespeichert
                var index = settings.GridDisplayIndexList[key];
                if(index > 0 && index < colCount)
                    column.DisplayIndex = index;
            }

            if (settings.GridColumnVisibilityList.ContainsKey(key))
            {
                column.Visibility = settings.GridColumnVisibilityList[key];
            }

            if (settings.GridColumnWidthList.ContainsKey(key))
            {
                column.Width = new DataGridLength(settings.GridColumnWidthList[key]);
            }
        }           
    }


    private void SetSettings()
    {
        var settings = GridSettings;

        foreach (var column in AssociatedObject.Columns)
        {
            var key = column.Header.ToString();
            var displayindex = column.DisplayIndex;
            var visibility = column.Visibility;
            var width = column.ActualWidth;

            if (settings.GridDisplayIndexList.ContainsKey(key))
            {
                settings.GridDisplayIndexList[key] = displayindex;
            }
            else
            {
                settings.GridDisplayIndexList.Add(key, displayindex);
            }

            if (settings.GridColumnVisibilityList.ContainsKey(key))
            {
                settings.GridColumnVisibilityList[key] = visibility;
            }
            else
            {
                settings.GridColumnVisibilityList.Add(key, visibility);
            }

            if (settings.GridColumnWidthList.ContainsKey(key))
            {
                settings.GridColumnWidthList[key] = width;
            }
            else
            {
                settings.GridColumnWidthList.Add(key, width);
            }
        }
    }

}