public class DelegateCommand : ICommand
    {
        private readonly Predicate<object> _canExecute;
        private readonly Action<object> _execute;

        public event EventHandler CanExecuteChanged;

        public DelegateCommand(Action<object> execute)
                       : this(execute, null)
        {
        }

        public DelegateCommand(Action<object> execute,
                       Predicate<object> canExecute)
        {
            _execute = execute;
            _canExecute = canExecute;
        }

        public bool CanExecute(object parameter)
        {
            if (_canExecute == null)
            {
                return true;
            }

            return _canExecute(parameter);
        }

        public void Execute(object parameter)
        {
            _execute(parameter);
        }

        public void RaiseCanExecuteChanged()
        {
            if (CanExecuteChanged != null)
            {
                CanExecuteChanged(this, EventArgs.Empty);
            }
        }
    }

利用 DelegateCommand Implement ICommand, 並於constructor 中加入Execute() 及CanExecute().

而叫用時, 在ViewModel 中則使用方法如下: 

public DelegateCommand SaveCommand;
        protected void SaveCommandExecute(object parameter)
        {
            // Command action.
        }
        protected bool SaveCommandCanExecute(object parameter)
        {
            // Command can execute or not.
            return true;
        }
        

        public MainWindowViewModel() : base()
        {
            // Define command and set property change handling.
            SaveCommand = new DelegateCommand(SaveCommandExecute, SaveCommandCanExecute);
            this.PropertyChanged += MainWindowViewModel_PropertyChanged;
        }

        private void MainWindowViewModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            // Fire event to execute CanExecute().
            SaveCommand.RaiseCanExecuteChanged();
        }

在示範中, 利用DataTrigger 來決定ViewModel 是否valid 及warning. 因為沒有利用WPF 內建的INotifyError 關係, 故直接不用直內置的Validation object.

MainWindow.xaml

<Window x:Class="PoC.WpfWarning.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:PoC.WpfWarning"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:User />
    </Window.DataContext>
    <StackPanel>
        <TextBlock Text="User Name" />
        <TextBox Text="{Binding Name, Mode=TwoWay}" Validation.ErrorTemplate="{x:Null}">
            <TextBox.Style>
                <Style TargetType="TextBox">
                    <Style.Triggers>
                        <DataTrigger Binding="{Binding HasWarnings}" Value="True">
                            <Setter Property="Background" Value="Yellow" />
                        </DataTrigger>
                        <DataTrigger Binding="{Binding Errors}" Value="True">
                            <Setter Property="Background" Value="Pink" />
                        </DataTrigger>
                    </Style.Triggers>
                </Style>
            </TextBox.Style>
        </TextBox>
        <TextBox />
    </StackPanel>
</Window>

User.cs

public class User : ObservableObject
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set {
                if (_name != value)
                {
                    SetField(ref _name, value);
                    ValidateProperty(new NameValidor());
                }
            }
        }
    }

NameValidator.cs

 public class NameValidor : ValidationRule
    {
        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            ValidationResult result = new WarnedValidationResult(true, false, null);
            User source = value as User;
            if (source != null)
            {
                if (string.IsNullOrEmpty(source.Name))
                    result = new ValidationResult(false, "Name could not be empty.");
                else if (source.Name == "aaa")
                    result = new WarnedValidationResult(true, true, "Message cannot be " + source.Name);
            }            
            return result;
        }
    }

IDataWarningInfo.cs

public interface IDataWarningInfo
    {
        event EventHandler<DataErrorsChangedEventArgs> WarningsChanged;

        System.Collections.IEnumerable GetWarnings(string propertyName);

        bool HasWarnings { get; }
    }

ObservableObject.cs

 public class ObservableObject : INotifyPropertyChanged, INotifyDataErrorInfo, IDataWarningInfo
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
        protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
        {
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }

        #region Implementation of Interfaces.
        protected Dictionary<string, ICollection<string>> _validationErrors = new Dictionary<string, ICollection<string>>();
        protected Dictionary<string, ICollection<string>> _validationWarnings = new Dictionary<string, ICollection<string>>();

        public bool HasErrors
        {
            get { return _errors; }
            set { SetField(ref _errors, value); }
        }

        private bool _errors;

        public bool Errors
        {
            get { return _errors; }
            set { SetField(ref _errors, value); }
        }
        private bool _hasWarnings;
        public bool HasWarnings
        {
            get { return _hasWarnings; }
            set { SetField(ref _hasWarnings, value); }
        }

        public event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
        public event EventHandler<DataErrorsChangedEventArgs> WarningsChanged;

        public virtual void OnErrorsChanged(string propertyName)
        {
            if (ErrorsChanged != null)
                ErrorsChanged(this, new DataErrorsChangedEventArgs(propertyName));
        }
        public virtual void OnWarningsChanged(string propertyName)
        {
            if (WarningsChanged != null)
                WarningsChanged(this, new DataErrorsChangedEventArgs(propertyName));
        }
        protected void UpdateValidationErrors(string propertyName, ICollection<string> errorMessage)
        {
            if (errorMessage.Count > 0)
            {
                /* Update the collection in the dictionary returned by the GetErrors method */
                _validationErrors[propertyName] = errorMessage;
                Errors = true;
            }
            else if (_validationErrors.ContainsKey(propertyName))
            {
                /* Remove all errors for this property */
                _validationErrors.Remove(propertyName);
                Errors = false;
            }
            /* Raise event to tell WPF to execute the GetErrors method */
            OnErrorsChanged(propertyName);
            OnPropertyChanged(propertyName);
        }

        public IEnumerable GetWarnings(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName) || !_validationWarnings.ContainsKey(propertyName))
                return null;
            return _validationWarnings[propertyName];
        }
        protected void UpdateValidationWarnings(string propertyName, ICollection<string> warningMessage)
        {
            if (warningMessage.Count > 0)
            {
                /* Update the collection in the dictionary returned by the GetErrors method */
                _validationWarnings[propertyName] = warningMessage;
                HasWarnings = true;
            }
            else if (_validationWarnings.ContainsKey(propertyName))
            {
                /* Remove all errors for this property */
                _validationWarnings.Remove(propertyName);
                HasWarnings = false;
            }
            /* Raise event to tell WPF to execute the GetErrors method */
            OnWarningsChanged(propertyName);
            OnPropertyChanged(propertyName);
        }

        IEnumerable INotifyDataErrorInfo.GetErrors(string propertyName)
        {
            if (string.IsNullOrEmpty(propertyName) || !_validationErrors.ContainsKey(propertyName))
                return null;
            return _validationErrors[propertyName];
        }
        #endregion

        public bool ValidateProperty(ValidationRule validator, [CallerMemberName] string propertyName = null)
        {
            /* Call service asynchronously */
            bool result = false;
            ValidationResult validationResult = validator.Validate(this, null);
            if (validationResult != null)
            {
                ICollection<string> validationErrors = new List<string>();
                ICollection<string> warningMessages = new List<string>();
                if (validationResult.IsValid == false)
                {
                    validationErrors.Add(validationResult.ErrorContent.ToString());
                    result = validationResult.IsValid;
                }
                else if (validationResult is WarnedValidationResult)
                {
                    WarnedValidationResult warnedValidationResult = validationResult as WarnedValidationResult;
                    if (warnedValidationResult.IsWarned)
                    {       
                        warningMessages.Add(warnedValidationResult.ErrorContent.ToString());
                        result = false;
                    }
                    else
                    {
                        result = true;
                    }
                }
                UpdateValidationErrors(propertyName, validationErrors);
                UpdateValidationWarnings(propertyName, warningMessages);
            }
            return result;
        }
    }

加入 System.Windows.InterActivity 作reference 後, 再於需要叫用的form 加入以下xml namespace 作叫用.

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

使用範例:

<DataGrid>
<i:Interaction.Triggers>
                        <i:EventTrigger EventName="SourceUpdated">
                            <i:InvokeCommandAction Command="{Binding SelectedExternalDataUpdated}" />
                        </i:EventTrigger>
                        <i:EventTrigger EventName="SelectionChanged">
                            <i:InvokeCommandAction Command="{Binding SelectedExternalDataChanged}" />
                        </i:EventTrigger>
                    </i:Interaction.Triggers>
                <DataGrid>

在這裡, 會建立兩個DataGird column來分別存取數字和日期. 

建立DataGrid column 時, 只須要建立一個class 並inherit DataGridBoundColumn 或其sub class 便可. 之後再implement method 分別建立View 及Edit 時的DataTemplate 便可.

DateGridDateTimeColumn.cs

public class DataGridDateTimeColumn : DataGridBoundColumn
    {
        protected override FrameworkElement GenerateEditingElement(DataGridCell cell, object dataItem)
        {
            return GenerateDatePicker(dataItem);
        }

        protected override FrameworkElement GenerateElement(DataGridCell cell, object dataItem)
        {
            return GenerateTextBlock(dataItem);
        }

        private DatePicker GenerateDatePicker(object source)
        {
            DatePicker result = new DatePicker()
            {
                Margin = new Thickness() { Bottom = 0, Left = 0, Right = 0, Top = 0 },
                Padding = new Thickness() { Bottom = -2, Left = -2, Right = -2, Top = -2 }
            };
            Binding baseBinding = this.Binding as Binding;
            Binding binding = new Binding()
            {
                Path = baseBinding.Path,
                Source = source,
                Mode = BindingMode.TwoWay,
                StringFormat = Properties.Settings.Default.DisplayDateFormat
            };
            result.SetBinding(DatePicker.SelectedDateProperty, binding);
            return result;
        }

        private TextBlock GenerateTextBlock(object source)
        {
            TextBlock result = new TextBlock()
            {
                Margin = new Thickness() { Bottom = 0, Left = 0, Right = 0, Top = 0 },
                TextAlignment = TextAlignment.Left,
                VerticalAlignment = VerticalAlignment.Top
            };
            Binding baseBinding = this.Binding as Binding;
            Binding binding = new Binding()
            {
                Path = baseBinding.Path,
                Source = source,
                Mode = BindingMode.TwoWay,
                StringFormat = Properties.Settings.Default.DisplayDateFormat
            };
            result.SetBinding(TextBlock.TextProperty, binding);
            return result;
        }
    }

DataGridNumericColumn.cs

public class DataGridNumericColumn : DataGridTextColumn
    {
        protected override object PrepareCellForEdit(System.Windows.FrameworkElement editingElement, System.Windows.RoutedEventArgs editingEventArgs)
        {
            TextBox edit = editingElement as TextBox;
            edit.PreviewTextInput += OnPreviewTextInput;

            return base.PrepareCellForEdit(editingElement, editingEventArgs);
        }

        private void OnPreviewTextInput(object sender, System.Windows.Input.TextCompositionEventArgs e)
        {
            e.Handled = (!IsDataValid(e.Text));
        }

        private void OnPaste(object sender, DataObjectPastingEventArgs e)
        {
            var data = e.SourceDataObject.GetData(DataFormats.Text);
            if (!IsDataValid(data)) e.CancelCommand();
        }

        private bool IsDataValid(object data)
        {
            return ((string)data).IsNumeric();
        }
    }

叫用時, 只須設定好xml namesapace 後, 像平時用user control 般便可. 例如:

<DataGrid.Columns>
                <local:DataGridNumericColumn Header="Number" Binding="{Binding NumericProperty, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
                <local:DataGridDateTimeColumn Header="Date" Binding="{Binding DateTimeProperty, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</DataGrid.Columns>

XAML 設定, 當欄更新時觸發事件.

<DataGrid AutoGenerateColumns="True" LoadingRow="DataGrid_LoadingRow">
</DataGrid>

Code-behind, 將DataContext 每個property 重新放到UI 中.

private void DataGrid_LoadingRow(object sender, DataGridRowEventArgs e)
        {
            var dg = sender as DataGrid;
            var pis = e.Row.DataContext.GetType().GetProperties();
            foreach (var pi in pis)
            {
                // Check if this property already has a column in the datagrid
                string name = pi.Name;
                var q = dg.Columns.Where(_ => _.SortMemberPath == name);
                if (!q.Any())
                {
                    // No column matches, so add one
                    DataGridTextColumn c = new DataGridTextColumn();
                    c.Header = name;
                    c.SortMemberPath = name;
                    System.Windows.Data.Binding b = new Binding(name);
                    c.Binding = b;

                    // All columns don't apply to all items in the list
                    // So, we need to disable the cells that aren't applicable
                    // We'll use a converter on the IsEnabled property of the cell
                    b = new Binding();
                    b.Converter = new ReadOnlyConverter();
                    b.ConverterParameter = name;
                    // aa
                    b.ValidatesOnDataErrors = true;

                    // Can't apply it directly, so we have to make a style that applies it
                    Style s = new Style(typeof(DataGridCell));
                    s.Setters.Add(new Setter(DataGridCell.IsEnabledProperty, b));
                    // Add a trigger to the style to color the background when disabled
                    var dt = new DataTrigger() { Binding = b, Value = false };
                    dt.Setters.Add(new Setter(DataGridCell.BackgroundProperty, Brushes.Silver));
                    s.Triggers.Add(dt);
                    c.CellStyle = s;

                    // Add the column to the datagrid
                    dg.Columns.Add(c);
                }
            }
        }

Resource Dictionary style.xaml

  <Style TargetType="fa:ImageAwesome" x:Key="ToolBarIcon">
        <Setter Property="Width" Value="12" />
        <Setter Property="Margin" Value="6" />
    </Style>

因為Visual Studio 的XAML design 的root tag 預設只支援<Window>, <Page> 和<UserControl>, 故沒有用<Button> 作Root tag, 而為了令按鈕變得更似Toolbar Button, 故將其border 及background 都透明化.

ToolbarButton.xaml

<UserControl x:Class="Test.UserControls.ToolBarButton"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:Test.UserControls"
             xmlns:fa="http://schemas.fontawesome.io/icons/"
             mc:Ignorable="d" 
             d:DesignHeight="30" d:DesignWidth="70">
    <UserControl.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="../style.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </UserControl.Resources>
    <Button Command="{Binding Command, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=UserControl}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Background="Transparent" BorderBrush="Transparent">
        <StackPanel Orientation="Horizontal">
            <fa:ImageAwesome Icon="{Binding Icon, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=UserControl}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" 
                             Style="{StaticResource ToolBarIcon}"
                             />
            <TextBlock Text="{Binding Text, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=UserControl}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        </StackPanel>
    </Button>
</UserControl>

ToolbarButton.xaml.cs

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace Test.UserControls
{
    /// <summary>
    /// Interaction logic for ToolBarButton.xaml
    /// </summary>
    public partial class ToolBarButton : UserControl
    {
        public object Text
        {
            get { return GetValue(TextProperty) as object; }
            set { SetValue(TextProperty, value); }
        }
        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register("Text", typeof(object), typeof(ToolBarButton));

        public object Icon
        {
            get { return GetValue(IconProperty) as object; }
            set { SetValue(IconProperty, value); }
        }
        public static readonly DependencyProperty IconProperty =
            DependencyProperty.Register("Icon", typeof(object), typeof(ToolBarButton));

        public ICommand Command
        {
            get { return GetValue(CommandProperty) as ICommand; }
            set { SetValue(CommandProperty, value); }
        }
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(ToolBarButton));

        public ToolBarButton()
        {
            InitializeComponent();
        }
    }
}

叫用時與正常手法如下:

 <ToolBarTray>
            <ToolBar>
                <Button>
                    <StackPanel Orientation="Horizontal">
                        <fa:ImageAwesome Icon="FileOutline" Style="{StaticResource ToolBarIcon}" />
                        <TextBlock Text="Import" />
                    </StackPanel>
                </Button>
                <userControls:ToolBarButton Icon="FileOutline" Text="Import" />
            </ToolBar>
        </ToolBarTray>

用戶群

用戶(End-user) 即是系統的最終使用者. 其實分幾種層面:

對外 (External), 用家是客戶, 重點是要方便使用, 非必要的話不用安裝軟件到”衪們”的裝置上, 而且其使用平台亦相當多變. 要覆蓋最大範圍的話, 都會選擇用Web-based 平台, 只要有瀏覽器(Browser)便可以給用家使用. 所以ASP.net MVC 會是首選.

對內 (Internal), 用家通常是公司內員工, 或者說是自己以外, 公司以內的任何人. 通常已經有一套標準, 較容易控制, 數量相對External 比較亦較小, 所以使用WPF MVVM 會是較佳的選擇. 然而, 若果在大企業, 多國之間都有其IT department, 而亦有workflow 須要跨國進行的話, ASP.net MVC 反而值得考慮; 總之在internal 環境中, 的確須要視乎情況決定.

自己 (self), 這個是自己加入的. 有時候為了加快delivery, 可能部份configuration DIY tools 未能提供, 只會加入到database / xml config 中, 這種情況就須要靠自己了. 為了不讓自己遺臭萬年以及方便將工作推卸出去, 自己都會建立一個介面去進行維護. 當然, 這個是什麼都不太重要了, 通常決定方針都嫁雞隨雞, 跟回application. 當然做in-house 有時須要維護不同模組, 自建簡陋的 MMC snap-in反而會是不錯的選擇.

是否需要跨平台

這裡的跨平台, 其實是用戶群的衍生, 決策重點是自己是否能夠預估End-user 是怎樣使用系統. 現在公司常用的系統都是Windows (當然, 部份公司會用Mac); 然而, 流動平台的興起也令End-user environment 出現變數. Android / iOS / Blackberry 不同的操作平台, 即使用自詡跨平台的Java 也吃不消, 這個時候, 反而 Web-based 平台將所有東西中央管理可以發揮到; WPF 的話, Linux 的Mono 也只支援WinForm, 而相類似的Silverlight 連Microsoft 也depreciated, 支援mobile device 亦因此變了場夢.

硬件配套

部份系統運作, 用戶端須要配合硬件, 例如醫療儀器須要透過COM / LPT / port 與電腦溝通, 生物認證須要用指模/瞳孔等傳送認證資料. 若有這種關聯的話, 則非WPF MVVM 莫屬. 若ASP.net MVC 這類web 平台須要運用的話, 則須要安裝ActiveX control / WebUSB API, 但這類則限制了用戶端平台, 而且ActiveX control 亦已depreciated 及WebUSB 仍未成熟, 暫時Web 平台, 即係ASP.net MVC 不是一個好選擇.

Standalone / Multi-tier

Standalone 即是單一系統, 所有東西(包括Database) 都放在自身系統中, 好處是方便部署(Deployment), 只須copy and paste 便完成. 在WPF MVVM 中, 亦具備此功能. 只要確定用戶端有安裝相對應的.net Platform 版本便可; 然而在ASP.net MVC 中, 即使使用Local DB, 但它仍須要在client 中安裝及設定IIS才可使用, 故這方面它較為輸蝕.

Multi-tier 是早年興起的系統架構 (Application Architecture), 即是將系統模組化 (Modulize), 並將不同模組部署在不同伺服器中(鐵 / VM / Container)執行. 從而做到管理上的 SoC (Separation of Concern). 而WPF MVVM 中, 即使用接駁 remote Database, 也只是2 tiers, 若須要設計的話, 則須要將其Controller 搬離至application server 中; 而ViewModel 和 View, 則只是控制UI部份; 而ASP.net MVC 中, 本身寄居在Web server 中的特性也使它天生支援multi-tier (包括用戶的Browser 和remote database, 已經3 tiers), 然而, 若想將View 和Controller 硬件分離的話, 則與WPF一樣, 建立web service 並配置於另外的伺服器中.

總結

總括而言, 其實選擇WPF MVVM 還是ASP.net MVC, 已變得像Form-based vs Web-based, 在決定時, 最重要是知道用戶條件及規劃的長遠性. 引用一句: 沒有最好的裝備, 只有最適合的裝備.

參考資料

• WPF Mono,
  http://www.mono-project.com/docs/gui/wpf/
• A break from the past, part 2: Saying goodbye to ActiveX, VBScript, attachEvent…, Microsoft, 
  https://blogs.windows.com/msedgedev/2015/05/06/a-break-from-the-past-part-2-saying-goodbye-to-activex-vbscript-attachevent/#RSzVEg7mXGFegkfK.97
• Access USB Devices on the Web, Google Developer, 
  https://developers.google.com/web/updates/2016/03/access-usb-devices-on-the-web

在WPF中, 無須特別去加code 作customize search, 只須於XAML 中指定attribute 便可.

例子: 

<ListView 
    TextSearch.TextPath="FirstName"
/>

Font-Awesome-WPF 是一套將fontawesome 轉至WPF 的library, 於 XMAL 中叫用方法如下:

<Window x:Class="Example.FontAwesome.WPF.Single"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:fa="http://schemas.fontawesome.io/icons/"
        Title="Single" Height="300" Width="300">
    <Grid  Margin="20">
        <fa:ImageAwesome Icon="Flag" VerticalAlignment="Center" HorizontalAlignment="Center" />
    </Grid>
</Window>

參考資料

Font-Awesome-WPF, Github, https://github.com/charri/Font-Awesome-WPF

在示範中, 會建立一個user control inherit 原廠DataGrid 去設定標題.

CommonDataGrid.xaml

<DataGrid x:Class="WPF.CommonDataGrid.CommonDataGrid"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:WPF.CommonDataGrid"
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300"
             AutoGenerateColumns="True" AutoGeneratingColumn="OnAutoGeneratingColumn" />

CommonDataGrid.xaml.cs

 public partial class CommonDataGrid : DataGrid
    {
        public CommonDataGrid()
        {
            InitializeComponent();
        }

        private void OnAutoGeneratingColumn(object sender, DataGridAutoGeneratingColumnEventArgs e)
        {
            string displayName = GetPropertyDisplayName(e.PropertyDescriptor);
            if (!string.IsNullOrEmpty(displayName))
            {
                e.Column.Header = displayName;
            }

        }

        public static string GetPropertyDisplayName(object descriptor)
        {
            PropertyDescriptor pd = descriptor as PropertyDescriptor;
            if (pd != null)
            {
                // Check for DisplayName attribute and set the column header accordingly
                DisplayNameAttribute displayName = pd.Attributes[typeof(DisplayNameAttribute)] as DisplayNameAttribute;

                if (displayName != null && displayName != DisplayNameAttribute.Default)
                {
                    return displayName.DisplayName;
                }

            }
            else
            {
                PropertyInfo pi = descriptor as PropertyInfo;
                if (pi != null)
                {
                    // Check for DisplayName attribute and set the column header accordingly
                    Object[] attributes = pi.GetCustomAttributes(typeof(DisplayNameAttribute), true);
                    for (int i = 0; i < attributes.Length; ++i)
                    {
                        DisplayNameAttribute displayName = attributes[i] as DisplayNameAttribute;
                        if (displayName != null && displayName != DisplayNameAttribute.Default)
                        {
                            return displayName.DisplayName;
                        }
                    }
                }
            }
            return null;
        }
    }

在這裡, 應用了MVVM, 為了處理PropertyChanged, 建立了Base class ObservableProperty 去實現 INotifyPropertyChanged.

 public class ObservableProperty : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
        protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
        {
            //if (EqualityComparer<T>.Default.Equals(field, value)) return false;
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }
    }

為了測試, 建立了一個WPF Window作叫用:

<Window x:Class="WPF.TestUI.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WPF.TestUI"
        xmlns:Common="clr-namespace:WPF.CommonDataGrid;assembly=WPF.CommonDataGrid"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:MainWindowViewModel />
    </Window.DataContext>
    <Grid>
        <Common:CommonDataGrid ItemsSource="{Binding TestClasses, Mode=TwoWay}" />
    </Grid>
</Window>

MainWindow.xaml.cs

using System.Windows;

namespace WPF.TestUI
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }
}

TestClass.cs

using System.ComponentModel;

namespace WPF.CommonDataGrid
{
    public class TestClass : ObservableProperty
    {
        private int _testID;
        [DisplayName("Test ID")]
        public int TestID
        {
            get { return _testID; }
            set
            {
                _testID = value;
                SetField(ref _testID, value);
            }
        }
        private string _testStringValue;
        [DisplayName("Test string value")]
        public string TestStringValue
        {
            get { return _testStringValue; }
            set
            {
                _testStringValue = value;
                SetField(ref _testStringValue, value);
            }
        }
    }
}

MainWindowViewModel.cs

using System.Collections.ObjectModel;
using WPF.CommonDataGrid;

namespace WPF.TestUI
{
    public class MainWindowViewModel
    {
        public ObservableCollection<TestClass> TestClasses { get; set; }
        public MainWindowViewModel()
        {
            TestClasses = new ObservableCollection<TestClass>();
            TestClasses.Add(new TestClass() { TestID = 1, TestStringValue = "aaa" });
            TestClasses.Add(new TestClass() { TestID = 2, TestStringValue = "bbb" });
        }
    }
}