Jain's 學習之路

Android – Activity / Service 的生命狀態

2018-01-04T14:26:00.001+08:00

之前在學習 android app 開發所做的筆記，在此記錄一下.

每個Activity有四個生命狀態：

Active／Running：當一個Activity在螢幕的最上層時(堆疊的最頂端)，它就是屬於Active或Running的狀態

Paused：如果一個Activity失去焦點(focus)但還看得到它的畫面，那失去焦點的這個Activity則處在Paused的狀態。失去焦點的Activity它還是完全活著的，並沒有消失。(活著的意思是指Activity自已本身所有的狀態及資料都還是存在的也跟視窗管理程式window manager保持連繫著)像這種Paused的Activity，可能在系統的記憶體不足的時後，被系統自動移除掉

Stopped：如果一個Activity被其它的Activity完全的遮住時，這個被遮的Activity處於stop的狀態，它仍然保有全部的狀態及資料，但因為它已不再被使用者看見，所以它的畫面是被隱藏起來的(畫面不需要更新)。當系統記憶體不足時，這種Stop狀態的Activity是最先被系統考慮拿來釋放記憶體的

Finished：當一個Activity處於Pause或Stop的狀態時，系統可以要求Activity結束(Finish)或直接移除(Kill)它。當它需要再度呈現在使用者面前時，它必需要能完整的重新啟動及回復先前的狀態

每個Service有兩種生命狀態：

Started：當一個組件(例如：一個Activity)呼叫startService()的時候，Service就進入Started狀態。一個Service一旦被啟動，就會一直在背景運行，就算啟動的組件被關閉還是繼續運行。

一般而言，一個被啟動的Service只會執行一個功能，執行完畢後並不會回傳結果給啟動的組件。例如：某個Service會透過網路下載或上傳一個檔案。當傳輸工作結束，該Service應該自動關閉。

Bound：當一個組件(例如：一個Activity)呼叫bindService()的時候，Service就進入Bound狀態。
處於Bound狀態的Service，和呼叫的組件的關係類似client-server介面，讓組件和Service互相溝通、傳送與接收信息，甚至可以透過IPC跨process交換信息。

一個處於Bound狀態的Service，只要有一個對應的組件就會運行。多個組件可以同時bind到同一個Service，但當所有的組件unbind的話，該Service也會關閉。

Vue.js – vuex 狀態管理

2018-01-02T09:10:00.001+08:00

入門前最後需了解的一個 library ，vuex 這集中式存儲管理所有組件的資料狀態. 當一個 app 在做非同步處理時，我們希望可以有個 Loading 的畫面可以讓使用者知道 app 是有在 work 的，一般都是把這個功能做在主頁面上，其它的子頁面都是呼叫主頁面的 method 來 enable/disable，這個時候就是 vuex 上場的時機了.

Vuex 這個部份網路上已有很多的介紹了，請自行善用 Google 大神吧.

Vuex 觀念

首先我們依照官網的步驟安裝 vuex

在來在 src 下新增一個 store 的資料夾，裡面分別有 5 隻 js 檔案

分別在各個 js 檔案中撰寫相對應的程式碼.

mutations_types.js

mutations.js

getters.js

actions.js

index.js

按著在 main.js 中引用 store 中的 js 檔案.

接著我們修改 App.vue 這個 main page

接著修改 component 的程式碼

如此就可以在切換頁面時出現 Loading 的效果.

PS : 這個時候在 run 時會有 error 的問題， “ …mapActions “ 這個 method 無法 compile，需安裝Stage 2 preset 來 bypass 這個錯誤訊息.相關的訊息如下:

https://forum-archive.vuejs.org/topic/5023/i-am-getting-an-error-when-i-use-mapgetters-on-vuex-2-0

https://babeljs.io/docs/plugins/preset-stage-2/

.babelrc file

Vue.js - 基礎介紹教學

2017-12-29T19:15:00.000+08:00

今年的 iT邦幫忙鐵人賽中剛好就有位鐵人利用了 30 天的時間，天天一篇文章從頭到尾來介紹 vue.js 的基礎教學，這真的是太佛心來了，在此記錄一下也方便以後有需要的時候可以直接取得相關的訊息.

Vue.js – Vue Router 的介紹

2017-12-26T13:49:00.001+08:00

在看到 Router 時也是第一次接觸到 SPA (Single Page Application) 這個名詞 . 簡單的說就是把 Web Application 變成是 Desktop Application 來開發. 基本上傳統的 Web Site 採取多頁式 ( Multi-Page ) 做法，而是如何把 UI 從 Server-side 移到 Client-side，資料的部份整合 REST API ，做到真正的前後端分離.

Router 的工作就是為了把 Server 的路由變成是 Client 端，頁面的切換全部交給 Client 來處理.

vue 在 init project 時會詢問是否要使用 vue router library，在建立 project 時幫你加入 router 的功能.這個檔案就是在配置路由來取代 hyperlink 回 Server 的部份.

試著修改路由的配置及加入 element-ui 的 NavMenu 的 library 做過簡單的範例.

首先在其 components folder 中加入 SayHi.vue，做其簡單的輸出.

再來修改 router folder 中的 index.js，定義 Path 所要載入的 component 組件( UI ) 為何.

最後修改 App.vue，加入 router-view 這個 Tag，來定義所要顯示的區域 .

最基本的 router 功能就完成. 來看一下最後的畫面.

Vue.js - 使用 babel-plugin-component 減少 File Size

2017-12-25T13:58:00.001+08:00

雖然已成功使用 element-ui 來開發，但其 build 出來的 file size 還真的有夠大. 再來就依官網所說的使用 babel-plugin-component 來減少 file size . 使用 npm 來按裝 babel-plugin-component.

再來修改 main.js

重點是 .babelrc 這個 file，我依官網的來修改在執行時會有錯誤訊息，可能是版本新舊的關係，故做點小修改才沒有錯誤訊息.

比較一下使用 babel-plugin-component 前後 build 出來的 file size 二者的差異，檔案的大小對瀏覽器載入的時間是正相關啊．

Vue.js - 加入 Element Component

2017-12-25T11:54:00.001+08:00

工欲善其事，必先利其器，awesome-vue ( https://github.com/vuejs/awesome-vue )幫我們收集了很多的關於 Vue.js 的 resource ，有好的材料當然也要配上好的料理才行. 在選取技術最重要的不外乎 resource 的多寡，當有問題時可以取得解答和大量的 component 可以加速你的開發是我列入選取的重要選取條件之一.

Vue.js 的 UI Framework 的部份我選擇使用 Element 來當做我之後開發的 library.最快上手不外乎是官方文件 ( http://element.eleme.io/#/zh-CN ) .

接著之前的範例，加入其 Element library ，一樣透過 npm 來安裝 element-ui

接著在 main.js 中宣告使用 element-ui

最後修改一下 App.vue 來測試是否可正常執行.

執行畫面如下，可以看到 Button 可正常的顯示.

Vue.js 初體驗

2017-12-25T10:42:00.001+08:00

開始學 Vue.js 時，發現這幾年的 Web UI 真的變化很大. 由其是從 node.js 出來之後由其明顯.只好惡補一下 npm, webpack 這些技術好得以入門. 但其細節的設定還是要慢慢的深入.沒辦法一口吃不成胖子啊.

在寫 Vue.js 中其官方文件 ( https://cn.vuejs.org/v2/guide/installation.html ) 真的幫助很大.依官方文件步驟一個基本上的 vue project基本上的配置都幫你搞定了.

最後依其步驟執執行是否建立成功.

接著試修改一下其內容. 開始 App.vue file.

再來查看一下畫面，即可看到大大的 “ Hello World ”，第一個 vue project 完成了….

Java’s Hibernate – Timestamp 造成 performance slow 的問題

2014-01-09T10:24:00.001+08:00

Oracle 在使用 Hibernate 時, 其 Condition 中有 Timestamp 時會造成 performance slow 的問題, 從官網上看到這篇在此記錄一下.

Simple Data Types

What is going on with DATE and TIMESTAMP?

This section is on simple data types. :-)

Prior to 9.2, the Oracle JDBC drivers mapped the DATE SQL type to java.sql.Timestamp. This made a certain amount of sense because the Oracle DATE SQL type contains both date and time information as does java.sql.Timestamp. The more obvious mapping to java.sql.Date was somewhat problematic as java.sql.Date does not include time information. It was also the case that the RDBMS did not support the TIMESTAMP SQL type, so there was no problem with mapping DATE to Timestamp.

In 9.2 TIMESTAMP support was added to the RDBMS. The difference between DATE and TIMESTAMP is that TIMESTAMP includes nanoseconds and DATE does not. So, beginning in 9.2, DATE is mapped to Date and TIMESTAMP is mapped to Timestamp. Unfortunately if you were relying on DATE values to contain time information, there is a problem.

There are several ways to address this problem in the 9.2 through 10.2 drivers:

Alter your tables to use TIMESTAMP instead of DATE. This is probably rarely possible, but it is the best solution when it is.
Alter your application to use defineColumnType to define the columns as TIMESTAMP rather than DATE. There are problems with this because you really don't want to use defineColumnType unless you have to (see What is defineColumnType and when should I use it? ).
Alter you application to use getTimestamp rather than getObject. This is a good solution when possible, however many applications contain generic code that relies on getObject, so it isn't always possible.
Set the V8Compatible connection property. This tells the JDBC drivers to use the old mapping rather than the new one. You can set this flag either as a connection property or a system property. You set the connection property by adding it to the java.util.Properties object passed to DriverManager.getConnection or to OracleDataSource.setConnectionProperties. You set the system property by including a -D option in your java command line.
java -Doracle.jdbc.V8Compatible="true" MyApp

Oracle JDBC 11.1 fixes this problem. Beginning with this release the driver maps SQL DATE columns to java.sql.Timestamp by default. There is no need to set V8Compatible to get the correct mapping. V8Compatible is strongly deprecated. You should not use it at all. If you do set it to true it won't hurt anything, but you should stop using it.

Although it was rarely used that way, V8Compatible existed not to fix the DATE to Date issue but to support compatibility with 8i databases. 8i (and older) databases did not support the TIMESTAMP type. Setting V8Compatible not only caused SQL DATE to be mapped to Timestamp when read from the database, it also caused all Timestamps to be converted to SQL DATE when written to the database. Since 8i is desupported, the 11.1 JDBC drivers do not support this compatibility mode. For this reason V8Compatible is desupported.

As mentioned above, the 11.1 drivers by default convert SQL DATE to Timestamp when reading from the database. This always was the right thing to do and the change in 9i was a mistake. The 11.1 drivers have reverted to the correct behavior. Even if you didn't set V8Compatible in your application you shouldn't see any difference in behavior in most cases. You may notice a difference if you use getObject to read a DATE column. The result will be a Timestamp rather than a Date. Since Timestamp is a subclass of Date this generally isn't a problem. Where you might notice a difference is if you relied on the conversion from DATE to Date to truncate the time component or if you do toString on the value. Otherwise the change should be transparent.

If for some reason your app is very sensitive to this change and you simply must have the 9i-10g behavior, there is a connection property you can set. Set mapDateToTimestamp to false and the driver will revert to the default 9i-10g behavior and map DATE to Date.

Hadoop 的介紹

2013-10-28T11:33:00.001+08:00

最近開始接觸 Hadoop 及 MapReduce 的部份! 好吧~剛好看到不錯的 vedio 在做介紹,把它記錄一下, 以備不時之需.

Introduction to Hadoop

Destributed System Overview

來源 : http://www.wretch.cc/blog/trendnop09/21756796

WPF – InvokeCommandAction 的使用

2013-08-29T15:34:00.001+08:00

在使用 MVVM 的架構時, 都會使用 Command 來 Handle 所觸發的 Event, 但如果其控制項沒有提供 Command 時, 此時又該如何呢？在 WPF 中提供了 InvokeCommandAction 這個 Class, 它提供控制項在觸發其 Event 時所需的 Handle，讓 develper 人員可以任意的 hanlde 所需的 Event. 下面的例如使用 InvokeCommandAction handle ComboBox 控制項當 select item changed 所觸發 SelectionChanged 的 Event.

<ComboBox Width="180" Margin="3" HorizontalAlignment="Left" VerticalAlignment="Top">
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="SelectionChanged">
            <i:InvokeCommandAction Command="{Binding StepIdChangedCommand}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</ComboBox>

C# – 統計 Percentile 函數

2013-08-21T09:17:00.001+08:00

最近一直聽到 P25, P50, P75, P95 這種統計數值, 那在 .NET 中並沒有相對映的函數可以使用, 故在網路上看到了有人提供的此函數的寫法, 故在此記錄一下.

public double Percentile(double[] sequence, double excelPercentile)
{
    Array.Sort(sequence);
    int N = sequence.Length;
    double n = (N - 1) * excelPercentile + 1;
    // Another method: double n = (N + 1) * excelPercentile;
    if (n == 1d) return sequence[0];
    else if (n == N) return sequence[N - 1];
    else
    {
         int k = (int)n;
         double d = n - k;
         return sequence[k - 1] + d * (sequence[k] - sequence[k - 1]);
    }
}

WPF – Getting Started with MVVM

2013-06-13T15:20:00.001+08:00

I've been working with MVVM and WPF for a couple of weeks now. I decided to log what I've learned here. Here goes a getting started tutorial with MVVM.

Download the source code.

The Model-View-ViewModel pattern was introduced by John Gossman to effectively utilize the functionality of WPF. Since then, MVVM has been used in a number of WPF applications with very impressive results. MVVM has three components:

Model: It is your data or classes that represent entities in your application. It normally contains no WPF-specific code.
View: This is the User Interface element visible to the user. Its DataContext is its ViewModel.
ViewModel: It contains all the data that needs to be displayed and procedures to modify the model at will. The magic about MVVM is that the ViewModel knows nothing about the View.

You see that this is very loosely coupled. The View knows the ViewModel but the ViewModel does not know the View. You can very easily replace the View without affecting the ViewModel. This is very useful in Developer/Designer teams where the Developer improves the ViewModel and the Designer enhances the View.

The fact that the ViewModel does not know anything about the View comes as a bit of surprise. There is one more surprise: a typical View in MVVM does not need a code-behind (except for the general boiler-plate code that calls the InitializeComponent() method from the constructor)!

You may be wondering how the view updates itself when the ViewModel changes and how it handles user interaction like button clicks etc. This is what makes MVVM specific to WPF.

The controls in the View bind themselves to the corresponding properties in the ViewModel. The changes in ViewModel will be reflected in the view, thanks to Data Binding in WPF. (Otherwise we would have had to handle every event and then update the view accordingly.)

As for user interaction, we always have had commands in WPF. MVVM leverages on this feature. Instead of writing event handling code for button clicks, we bind the buttons (or MenuItems) to Commands in the ViewModel. Every button (even the SaveCustomer, CloseTab etc.) binds itself to a command which the ViewModel exposes. This command delegates its job to a method in the ViewModel that gets the work done. But the problem is that there is no built-in command in WPF that does that. We have a RoutedCommand that targets UIElements but not methods. Here comes to the scene a new command that targets methods, the DelegateCommand or the RelayCommand. Controls can bind the RelayCommand (that the ViewModel exposes) and invoke methods in the ViewModel.

The DelegateCommand implements the ICommand interface and delegates the Execute and CanExecute methods in the interface to methods in the ViewModel.

using System;
using System.Windows.Input;

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

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

        public DelegateCommand(Action<object> execute, Predicate<object> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");

            _execute = execute;
            _canExecute = canExecute;
        }

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

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

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
    }
}

Now we are going to create a simple tabbed interface. When you File->New Tab, a new tab opens up. When you click File->Exit, the application closes. You may think that this is very simple but achieving this in MVVM needs a lot of ground on it.

Open a new WPF application. Change the Window1 to MainWindow (I just hate Window1). Replace the Grid element in the MainWindow with the following markup.

<DockPanel>
    <Menu DockPanel.Dock="Top">
        <MenuItem Header="_File">
            <MenuItem Header="New _Tab" />
            <Separator />
            <MenuItem Header="E_xit" />
        </MenuItem>
    </Menu>
    <TabControl />
</DockPanel>

You know it simply adds a menu to the top and a tab control. Now we create a simple MainWindowViewModel class. Since the View binds its controls to the Properties in the ViewModel, we need to implement the INotifyPropertyChanged interface. But in this example we are not going to need it. Create an empty class MainWindowViewModel.

We know that the view sets its DataContext to the ViewModel. We'll use the Application class to set it for the view. Remove the StartupUri attribute from the Application.xaml file and override the OnStartup method to initialize a new MainWindow and a new MainWindowViewModel, set the DataContext of the MainWindow to the MainViewModel, set the MainWindow property of Application class this MainWindow and finally show the MainWindow.

protected override void OnStartup(StartupEventArgs e)
{
    MainWindow mainWindow = new MainWindow();
    MainWindowViewModel mainWindowViewModel = new MainWindowViewModel();
    mainWindow.DataContext = mainWindowViewModel;
    base.MainWindow = mainWindow;
    mainWindow.Show();
}

Now we have setup the base for MVVM. But our application does nothing. When we click New Tab or Exit nothing happens. To hook this up, we need a command. Let's first implement the Exit Command. In the MainWindowViewModel, add a new DelegateCommand, ExitCommand.

private DelegateCommand exitCommand;
public ICommand ExitCommand
{
    get
    {
        if(exitCommand == null)
            exitCommand = new DelegateCommand(Exit);
        return exitCommand;
    }
}

private void Exit(object obj) 
{
    Application.Current.Shutdown();
}

Now when the Execute() method on ExitCommand is called, Exit method is invoked. We use the Exit method to shutdown the application. Now all we have to do is bind the Exit menu item to this command. When you click Exit, the Exit method is called and the application shuts down.

<MenuItem Header="E_xit" Command="{Binding ExitCommand}" />

Now, let's implement the Add Tab functionality. Obviously, we need a new command, AddTabCommand.

private DelegateCommand addTabCommand;
public ICommand AddTabCommand
{
    get
    {
        if (addTabCommand == null)
            addTabCommand = new DelegateCommand(AddTab);
        return addTabCommand;
    }
}

private void AddTab(object obj)
{
    throw new NotImplementedException();
}

Here we have a problem. The ViewModel does not know the View and does not know the TabControl in it. How is it going to add a tab into that TabControl? If it were a simple code-behind, we would have given the tab control a name and hooked up an event handler to add a new tab to the control. But what do we do now? Any guesses?

Let's use a trick. We know the View can modify itself to reflect changes in the ViewModel. Let's exploit this. We will maintain a list of tabs in the ViewModel and the TabControl binds itself to this list. Now if we add a new item in the list, a new tab is added in the view! Wonderful!

public ObservableCollection<TabItem> Tabs { get; set; }

public MainWindowViewModel()
{
    Tabs = new ObservableCollection<TabItem>();
}

We need an observable collection to bind lists (It's why we did not need to implement the INotifyPropertyChanged explicitly here). Now, we need to bind the TabControl to this collection.

<TabControl ItemsSource="{Binding Tabs}" />

Now, the AddTab method adds a new TabItem into the list and the View updates itself.

private void AddTab(object obj)
{
    TabItem tab = new TabItem();
    tab.Header = "New Tab";
    Tabs.Add(tab);
    tab.Focus();
}

The last thing to do is to hook up the Add Tab MenuItem to the AddTabCommand.

<MenuItem Header="New _Tab" Command="{Binding AddTabCommand}" />

Excellent! It's all working very well. This is all about MVVM in its simplest way. You can see how easy it is to have everything separated and implement a very loosely coupled application. MVVM lets you unit test your software and change the views very easily.

You can notice that in this example, the ViewModel does know something about the View. It knows that the view contains a TabControl and adds TabItems to it. You must remove this dependency. I wanted this post to be as simple as it could be. However, that will be part of my upcoming posts. Now that you have set for yourself a base, explore the fantastic world of WPF and MVVM. Good Luck!

轉貼 : Getting Started With MVVM in WPF.

WPF - 深入 Style

2013-06-13T14:23:00.001+08:00

Style 用來在類型的不同實例之間共享屬性、資源和事件處理程序，您可以將 Style 看作是將一組屬性值應用到多個元素的捷徑。

　　這是MSDN上對Style的描述，翻譯的還算中規中矩。Style（樣式），簡單來說，就是一種對屬性值的批處理，類似于Html的CSS，可以快速的設置一系列屬性值到UI元素。

示例

　　一個最簡單的Style的例子：

<Window>
    <Grid>
        <Grid.Resources>
            <Style TargetType="{x:Type Button}" x:Key="ButtonStyle">
                <Setter Property="Height" Value="22"/>
                <Setter Property="Width" Value="60"/>
            </Style>
        </Grid.Resources>
        <Button Content="Button" Style="{StaticResource ButtonStyle}"/>
        <Button Content="Button" Style="{StaticResource ButtonStyle}" Margin="156,144,286,145" />
    </Grid>
</Window>

　　關于Resources的知識，請參見MSDN，這里創建了一個目標類型為Button的ButtonStyle，兩個Button使用靜態資源（StaticResource）的查找方式來找到這個Style。Style中定義了Button的高度（Height）和寬度（Width），當使用了這個Style后，兩個Button無需手動設置，即可自動設置它們的高度和寬度為ButtonStyle的預設值22和60。

　　Style作為屬性，資源，事件的批處理，它提供了一種捷徑來對控件進行快速設置，使用Style的好處有二：

把一些控件的通用設置抽出來變成Style，使這些控件具有統一的風格，修改Style中的屬性值可以方便的作用在所有應用該Style的控件上。
可以對同一類型控件定義多個Style，通過替換Style來方便的更改控件的樣式。

Style的元素

　　上面Style的例子中，Style內部使用了Setter來定義控件屬性的預設值，Style不僅支持對屬性的批處理，也可以共享資源和事件處理，如：

<Window>
    <Window.Resources>
        <Style TargetType="{x:Type Button}" x:Key="ButtonStyle">
            <Style.Resources>
                <SolidColorBrush x:Key="brush" Color="Yellow"/>
            </Style.Resources>
            <Setter Property="Height" Value="22"/>
            <Setter Property="Width" Value="60"/>
            <EventSetter Event="Loaded" Handler="Button_Loaded"/>
        </Style>
    </Window.Resources>
    <x:Code>
        <![CDATA[
            void Button_Loaded(object sender, RoutedEventArgs e)
            {
                MessageBox.Show((sender as Button).Name + " Loaded");
            }
        ]]>
    </x:Code>
    <Grid>
        <Button x:Name="button1" Style="{StaticResource ButtonStyle}" Background="{DynamicResource brush}"/>
        <Button x:Name="button2" Style="{StaticResource ButtonStyle}" Background="{DynamicResource brush}" Margin="156,144,286,145" />
    </Grid>
</Window>

　　Style中定義了資源SolidColorBrush，定義了屬性Height和Width，以及使用了EventSetter來定義了Loaded事件的處理。

Trigger

　　Style使用了Setter和EventSetter來分別設置控件的屬性和事件處理，Setter這個單詞的含義是設置。Style在設計好了這兩種設置后，又引入了更先進的思路：條件設置。

　　對于單純的Setter：<Setter Property=”Height” Value=”22”>來說，含義淺顯易懂：設置高度為22。條件設置的含義是，在某種條件下，去設置某個對象的某個值。

　　WPF引入了Trigger（触發器）來触發這個條件，它的寫法是：

<Style TargetType="{x:Type Button}" x:Key="ButtonStyle">
    <Setter Property="Width" Value="60"/>
    <Style.Triggers>
        <Trigger Property="IsMouseOver" Value="True">
            <Setter Property="Width" Value="80"/>
        </Trigger>
    </Style.Triggers>
</Style>

　　這里Trigger的含義是，在Button的IsMouseOver屬性被設置為True的條件下，設置Button的寬度（Width）為80。

　　在Style中，不需要指定Setter作用的對象（TargetName），默認作用的對象就是使用該Style的控件。Trigger，作為触發器，當触發時設置寬度為80，當IsMouseOver屬性為False，也就是触發條件失效時，寬度回到默認Setter的設置值60。

　　WPF定義了五種Trigger來作為触發條件，分別是：Trigger，DataTrigger，MultiTrigger，MultiDataTrigger，EventTrigger，他們的触發條件分別是：

Trigger：以控件的屬性作為触發條件，如前面的IsMouseOver為True的時候触發。
DataTrigger：以控件DataContext的屬性作為触發條件。
MultiTrigger：以控件的多個屬性作為触發條件。
MultiDataTrigger：以控件DataContext的多個屬性作為触發條件。
EventTrigger：以RoutedEvent作為触發條件，當指定的路由事件Raise時触發。

　　關于這5種Trigger的具體使用，請參見MSDN，這里就不詳細介紹了。

Implicit Style

　　上面的例子中，都是使用StaticResource來設置Style的，當然，你也可以使用DynamicResource來設置Style。這兩種方式都需要你在XAML或者后台代碼中手動注明，為了使用方便，WPF提出了隱式（Implicit） Style的方式允許自動設置Style到控件，如：

<Window>
    <Grid>
        <Grid.Resources>
            <Style TargetType="{x:Type Button}">
                <Setter Property="Height" Value="22"/>
                <Setter Property="Width" Value="60"/>
            </Style>
        </Grid.Resources>
        <Button x:Name="button1" Style="{x:Null}"/>
        <Button x:Name="button2" Margin="156,144,286,145" />
        <Button x:Name="button3" Margin="196,144,0,145" />
    </Grid>
</Window>

　　在Gird的Resource中定義Style時，沒有給Style起名字（Key），這個Style會自動應用在Grid的所有子Button中，如果像button1一樣在Button中顯式定義了Style（這里設置了一個空值Null），那麼這種隱式（Implicit）的Style會不起作用。

深入Style

　　Style是一個不錯的概念，作為一個Presentation的框架，把UI對象的結构，樣式和行為分離這是一種很好的設計。Style也比較容易上手，像它的隱式（Implicit）Style的設計也是水到渠成的想法，但實際使用中也會出現一些問題。這些問題在WPF中也會經常遇見：概念不錯，描述簡單，前景美好，Bug稀奇古怪，要把這些問題說清楚，就要從根本來看，Style是個什麼東西？

　　按照通常的想法，Style應該類似于一個Dictionary<string, object> setters，預存了屬性的名字和預設值，然后作用到UI對象上。WPF在Style處的想法很多，圍繞著几個關鍵技朮也加入了很多功能，詳細的介紹一下：

Style & Dependency Property

　　Dependency Property（簡稱DP）是WPF的核心，Style就是基于Dependency Property的，關于DP的內幕，請參見深入WPF--依賴屬性。Style中的Setter就是作用在DP上的，如果你在控件中定義了一個CLR屬性，Style是不能設置的。Dependency Property設計的精髓在于把字段的存取和對象（Dependency Object）剝離開，一個屬性值內部用多個字段來存儲，根据取值條件的優先級來決定當前屬性應該取哪個字段。

　　Dependency Property取值條件的優先級是（從上到下優先級從低到高）：

public enum BaseValueSource
{
    Unknown,
    Default,
    Inherited,
    DefaultStyle,
    DefaultStyleTrigger,
    Style,
    TemplateTrigger,
    StyleTrigger
    ImplicitStyleReference,
    ParentTemplate,
    ParentTemplateTrigger,
    Local
}

　　對于一個具體例子來說：

<Window>
    <Window.Resources>
        <Style TargetType="{x:Type Button}" x:Key="ButtonStyle">
            <Setter Property="Width" Value="60"/>
            <Style.Triggers>
                <Trigger Property="IsMouseOver" Value="True">
                    <Setter Property="Width" Value="80"/>
                </Trigger>
            </Style.Triggers>
        </Style>
    </Window.Resources>
    <Grid>
        <Button x:Name="button1" Style="{StaticResource ButtonStyle}" Background="{DynamicResource brush}" Width="20"/>
    </Grid>
</Window>

　　第4行用Style的Setter設置Width=60，這個優先級是Style；第6行當IsMouseOver為True時設置Width=80，這個優先級是StyleTrigger；第13行使用Style的Button定義Width=20，這個優先級是Local。Local具有最高的優先級，所以即使鼠標移到Button上，第6行的Trigger也會因為優先級不夠高而不起作用。如果去掉了第13行中的Width=20，那麼鼠標移到Button上時Width會變為80，鼠標移開后會回到第4行的設置的60來。

Style & FrameworkElement

　　Style作為一個屬性定義在FrameworkElement上，所有繼承自FrameworkElement的控件都可以使用Style。FrameworkElement定義了多個Style：Style，ThemeStyle，FocusVisualStyle：

FocusVisualStyle：是當控件獲得鍵盤焦點時，顯示在外面的一個虛線框，這個Style並沒有直接作用在對應的FrameworkElement上，而是當控件獲得鍵盤焦點時使用AdornLayer創建了一個新的Control，然后再這個Control上使用FocusVisualStyle，再把它遮蓋在對應的FrameworkElement上形成一個虛線框的效果。
Style：就是我們前面一直設置的Style。
ThemeStyle：這里引入了一個Theme的概念，具體來談一下它。

　　Windows定了很多Theme（主題），你可以在控制面板中切換Theme，如圖：

　　最上面的兩排都屬于Aero主題，當從Aero主題切換到Windows Classic主題后，任務欄，窗口以及窗口內的控件外觀都會發生變化。為了更好的切換主題，WPF引入了ThemeStyle這個概念。當我們使用VS2010的模板生成一個自定義控件（Custom Control）后，會自動添加一個Themes的文件夾以及一個Generic.xaml的文件，如圖：

　　這里的Aero.NormalColor.xaml是手動添加的，先略去不談，來談談控件（Control）的默認樣式。

　　WPF默認提供了很多控件，Button，ListBox，TabControl等等，我們使用這些控件時，是沒有指定它的樣式（Style）的，WPF為我們提供了默認Style，這個默認Style是與Windows主題相關的。比如我們切換Windows的主題從Aero到Classic，WPF窗口里的控件外觀也會發生變化。這些默認的Style是以ResourceDictionary的形式保存在PresentationFramework.Aero.dll，PresentationFramework.Classic.dll等dll中的，這里的命名規則是：程序集名稱+Theme名稱+.dll。

　　那麼WPF又是如何根据Windows的Theme找到對應的ThemeStyle呢？WPF提出了ThemeInfo這個Attribute來指定Theme信息。ThemeInfo一般定義在Properties/AssemblyInfo.cs中，如：

[assembly: ThemeInfo(
    ResourceDictionaryLocation.SourceAssembly,
    ResourceDictionaryLocation.SourceAssembly)
)]

　　ThemeInfo有兩個參數，第一個參數指的是ThemeResource，第二個參數指的是GenericResource，它們的類型是ResourceDictionaryLocation：

public enum ResourceDictionaryLocation
{
    None = 0,
    SourceAssembly = 1,
    ExternalAssembly = 2
}

　　ResourceDictionaryLocation的None指不存在對應的Resource，SourceAssembly指該程序集（Assembly）中存在對應的Resource，ExternalAssembly指對應的Resource保存在外部的程序集（Assembly）中，這個外部程序集的查找規則就是我們前面看到的：程序集名稱+Theme名稱+.dll。

　　對于一個控件，無論是系統自帶的控件還是我們自定義的控件，WPF啟動時都會通過當前Windows系統的Theme查找它對應的ThemeStyle。這個查找規則是：

先通過控件的類型（Type）找到它對應的程序集（Assembly），然后獲取程序集中的ThemeInfo，看看它的ThemeResource和GenericResource在哪里。如果ThemeResource的值不是None，系統會讀取到ThemeResource對應的ResourceDictionary，在這個ResourceDictionary中查找是否定義了TargetType={x:Type 控件類型}，如果有，把控件的ThemeStyle指定為這個Style。
如果第一步的查找失敗，那麼GenericResource派上用場，Generic這個詞表示一般。WPF會查看ThemeInfo的第二個參數GenericResource來查找它的ThemeStyle，查找規則同第一步，如果查找成功，把這個Style指定為控件的ThemeStyle。

　　任意一個控件，如果不顯式指定它的Style，並且查不到默認的ThemeStyle，這個控件是沒有外觀的。為了編程方便，當我們使用VS添加自定義控件時，VS默認幫我們生成了Generic.xaml，如果我們希望自定義的控件也要支持系統的Theme變化，可以在Themes這個文件夾下加入對應的ResourceDictionary，比如上面的Aero.NormalColor.xaml，並且指定程序集ThemeInfo的第一個參數為SourceAssembly，表明該程序集支持系統Theme變化並且對應的資源文件在該程序集中。當然，ResourceDictionary一定要放在Themes文件夾下，因為WPF查找ResourceDictionary時使用的是類似：

string relativePackUriForResources = "/" +
    themeAssemblyName.FullName +
    ";component/themes/" +
    themeName + "." +
    colorScheme + ".xaml";

這樣的方法。

Style & ResourceDictionary

　　前面提到了很多次ResourceDictionary，關于WPF的Resource系統，以后再來細談。WPF的Resource系統使用ResourceDictionary來儲存Resource，ResourceDictionary，顧名思義，也是一個Dictionary，既然是Dictionary，就是按鍵/值對來存儲的。我們最前面在Window的Resource中創建Style時，指定了Style對應的鍵值（x:Key），后面又用StaticResource來引用這個鍵值。

　　如果在ResourceDictionary中添加一個對象Button，不指定它的鍵值（x:Key），是不能通過編譯的。我們前面介紹的隱式（Implicit）Style，只指定了一個TargetType={x:Type 類型}，並沒有指定鍵值，為什麼它可以通過編譯呢？

　　對于在ResourceDictionary中添加Style，如果我們沒有指定鍵值（x:Key），WPF會默認幫我們生成鍵值，這個鍵值不是一個String，而是一個類型object（具體來說是Type實例），也就是說相當于：

<Style TargetType="{x:Type Button}" x:Key="{x:Type Button}">

后面的x:Key可以省略掉。

　　Appliation以及FrameworkElement類都定義了Resources屬性，內部都持有一個ResourceDictionary，Resource查找遵循的最基本原則是就近原則，如：

<Window>
    <Window.Resources>
        <Style TargetType="{x:Type Button}">
            <Setter Property="Background" Value="Yellow"/>
        </Style>
        <Style TargetType="{x:Type ToggleButton}" x:Key="toggleBtnStyle">
            <Setter Property="Background" Value="Red"/>
        </Style>
    </Window.Resources>
    <StackPanel>
        <StackPanel.Resources>
            <Style TargetType="{x:Type Button}">
                <Setter Property="Background" Value="Blue"/>
            </Style>
            <Style TargetType="{x:Type ToggleButton}" x:Key="toggleBtnStyle">
                <Setter Property="Background" Value="Green"/>
            </Style>
        </StackPanel.Resources>
        <ToggleButton Width="80" Height="20" Style="{DynamicResource toggleBtnStyle}"/>
        <Button Width="80" Height="20"  Content="button2" Click="Button_Click"/>
    </StackPanel>
</Window>

　　Window和StackPanel的Resources中都分別定義了toggleBtnStyle以及隱式Style（Button），根据就近原則，StackPanel內部的ToggleButton和Button會應用StackPanel的Resource而不會使用Window的。

Style Merge

　　這里要提到本篇的重點也是不被人注意卻經常出錯的地方，Style的合並（Merge）。

　　前面提到了很多Style，ThemeStyle，Style，隱式Style。我們提過，Style相當于一個屬性值的批處理，那麼對于一個屬性，只能有一個預設值而不能多個，這些Style在運行時要進行合並，然后作用在FrameworkElement上。

　　Style的合並，要分兩步進行：

找到所有Style。
确定Style的優先級，根据優先級來合並Style。

　　以Button來說：

如果當前Windows的Theme是Aero，啟動后會從PresentationFramework.Aero.dll中找到對應的ThemeStyle。
如果在Button上使用StaticResource或者DynamicResource指定了Style，會通過鍵值在Resource系統中找到對應的Style。
如果沒有在Button上顯式指定Style，會通過Resource系統查找隱式Style（x:Type Button）。
第二步和第三步是排他的，這兩步只能确定一個Style，然后把這個Style和ThemeStyle進行合並（Merge）得到Button最終的效果。

　　先從合並來說，顯式或者隱式Style的優先級是高于ThemeStyle的，如果Style和ThemeStyle的Setter中都對同一屬性進行了預設，那麼會取Style里面的Setter而忽略ThemeStyle。這里比較特殊的是EventSetter，EventSetter使用的是RoutedEvent，如果兩個Style的EventSetter對同一個RoutedEvent進行了設置，兩個都會注冊到RoutedEvent上。

　　前面看到，顯式和隱式Style是排他的，兩者只能取一，在實際項目中，在全局定義好Button的基本樣式，然后具體使用上再根据基本樣式做一些特殊處理，這種需求是很常見的。為了解決這種需求，Style提出了BasedOn屬性，來表示繼承關系，如：

<Window>
    <Window.Resources>
        <Style TargetType="{x:Type Button}">
            <Setter Property="Width" Value="80"/>
            <Setter Property="Height" Value="20"/>
            <EventSetter Event="Click" Handler="btnBase_Click"/>
        </Style>
        <Style TargetType="{x:Type ButtonBase}" x:Key="toggleBtnStyle">
            <Setter Property="Width" Value="80"/>
            <Setter Property="Height" Value="20"/>
            <Setter Property="Background" Value="Red"/>
        </Style>
    </Window.Resources>
    <StackPanel>
        <StackPanel.Resources>
            <Style TargetType="{x:Type Button}" BasedOn="{StaticResource {x:Type Button}}">
                <Setter Property="Background" Value="Blue"/>
                <EventSetter Event="Click" Handler="btn_Click"/>
            </Style>
            <Style TargetType="{x:Type ToggleButton}" x:Key="toggleBtnStyle" BasedOn="{StaticResource toggleBtnStyle}">
                <Setter Property="Background" Value="Green"/>
            </Style>
        </StackPanel.Resources>
        <ToggleButton Style="{DynamicResource toggleBtnStyle}"/>
        <Button Content="button2"/>
    </StackPanel>
</Window>

　　為了更清晰的解釋，給出了一個不太常見的例子。第16行創建了一個隱式Style（Button），它的BasedOn屬性仍然是隱式Style（Button），Resource系統會向上查找找到Window的Resorces中的隱式Style（Button），然后把兩者合並。對于同一個ResourceDictionary，是不允許有重復鍵值的，StackPanel和Window各有各自的ResourceDictionary，他們的鍵值不受干擾，查找時會通過就近原則來找到優先級最高的Resource。第20行ToggleButton的例子和Button是一樣的，只是它查找到的第8行toggleBtnStyle的TargetStyle是ButtonBase，ButtonBase是ToggleButton的基類，BasedOn屬性也可以作用。

　　WPF的Style机制是一個密封（Seal）机制，它的書寫方式很靈活，可以支持合並等，當最后合並后，Style就被密封（Seal），內部的Setter等不允許再被修改。這種密封的設計有它的道理，但在Style的動態性上就稍顯不足。

　　以自定義控件為例，自定義一個Button，名字叫MyButton，它繼承自Button，在自定義控件中，經常可以看到這樣的代碼：

static MyButton()
{
    DefaultStyleKeyProperty.OverrideMetadata(typeof(MyButton), new FrameworkPropertyMetadata(typeof(MyButton)));
}

　　這里出現了DefaultStyle，這個是WPF對ThemeStyle的另一個說法，ThemeStyle就是用來确定默認的Style的，后來包括BaseValueSource中也使用了DefaultStyle來表示ThemeStyle。在MyButton的靜態函數中重載DefaultStyleKeyProperty內部Metadata的含義是告訴WPF系統，查找MyButton的ThemeStyle使用的鍵值從{x:Type Button}被改成了{x:Type MyButton}。

　　如果像上述代碼一樣修改了DefaultStyleKeyProperty，那麼需要我們在Themes/Generic.xaml中定義好MyButton的默認（Theme）Style，否則MyButton是沒有外觀的，因為查找ThemeStyle的鍵值已經被修改，PresentationFramework.Aero.dll等dll中是沒有定義{x:Type MyButton}的。

　　前面是關于ThemeStyle的用法，那麼回到隱式Style上來，如果我們在Application的Resources中定義了Button的隱式Style（TargetType={x:Type Button}），即使沒有顯式設置MyButton的Style，所有的MyButton控件也不會使用這個隱式Style的。需要你在Application的Resources中，在定義Button隱式Style的下面定義

<Style TargetType="{x:Type local:MyButton}" BasedOn="{StaticResource {x:Type Button}}"/>

　　這里就回到Style的合並（Merge）上來了，Style的Merge是很基本（很傻）的合並（Merge），它不具備Auto性。具體來說，就是：

基類控件的隱式Style不會作用到派生類控件上。
像前面在Window和StackPanel中分別定義了隱式Style（Button），這兩個隱式Style不會智能合並后再作用到Button上，而是通過就近原則只選其一。
Style的BasedOn屬性只支持StaticResource方式引用，因為Style繼承自DispatcherObject而不是DependencyObject，DynamicResource只支持DP。

　　這些問題都需要通過Style的BasedOn來解決，因為BasedOn用的是靜態引用（StaticResource），當隱式Style發生變化時就有麻煩了。

換膚

　　UI程序的換膚是很炫的玩意，換膚分兩種：1，更換整個控件的Style；2，更換Style中的顏色畫刷（Brush）。后者的實現很簡單，定義好顏色畫刷的資源文件（ResourceDictionary），使用畫刷的時候使用DynamicResource綁定，換膚的時候替換畫刷的資源文件就可以了。

　　很多公司都有自己皮膚庫，這些皮膚庫一般都是隱式的Style，定義了所有控件的隱式Style，使用時把這個皮膚資源Merge到Application的Resources中。換膚時把舊的皮膚資源從Application的Resources中刪除，替換成新的皮膚資源ResourceDictionary。

　　這種做法很好理解，但是碰到Style的BasedOn屬性就不起作用了，BasedOn屬性使用是StaticResource，是靜態的一次性的。新的皮膚庫被添加到Application資源文件后，如果在Application的資源文件中已經定義過<Style TargetType=“{x:Type Button}” BasedOn=“{StaticResource {x:Type Button}}”/>這樣隱式的Style，控件是不會更新皮膚的。如果有這方面的需求，需要手動合並（Merge）Style來解決問題，類似：

public static void Merge(this Style style, Style otherStyle)
{
    foreach (SetterBase currentSetter in otherStyle.Setters)
    {
        style.Setters.Add(currentSetter);
    }
    
    foreach (TriggerBase currentTrigger in otherStyle.Triggers)
    {
        style.Triggers.Add(currentTrigger);
    }
    
    foreach (object key in otherStyle.Resources.Keys)
    {
        style.Resources[key] = otherStyle.Resources[key];
    }
}

　　這里還需要加上一些條件判斷，以及決定是否要遞歸合並otherStyle的BasedOn，回到前面，程序需要使用DynamicResource來監听Application資源中隱式Style的變化，用一個附加屬性來解決：

public static readonly DependencyProperty AutoMergeStyleProperty =
    DependencyProperty.RegisterAttached("AutoMergeStyle", typeof(Type), typeof(Behavior),
    new FrameworkPropertyMetadata((Type)null,
    new PropertyChangedCallback(OnAutoMergeStyleChanged)));
    
private static void OnAutoMergeStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    if (e.OldValue == e.NewValue)
    {
        return;
    }
    
    FrameworkElement control = d as FrameworkElement;
    if (control == null)
    {
        throw new NotSupportedException("AutoMergeStyle can only used in FrameworkElement");
    }
    
    Type type = e.NewValue as Type;
    if (type != null)
    {
        control.SetResourceReference(Behavior.BaseOnStyleProperty, type);
    }
    else
    {
        control.ClearValue(Behavior.BaseOnStyleProperty);
    }
}

　　SetResourceReference是XAML中DynamicResource的代碼表示，相當于Behavior.BaseOnStyle={DynamicResource type}。對控件使用SetResourceReference，監听的鍵值是type，監听的屬性是一個我們自定義的附加屬性BaseOnStyleProperty。當換膚替換Application的資源文件時，BaseOnStyle屬性被更新，在BaseOnStyleProperty的Changed事件中可以讀取控件的Style屬性和新的ThemeStyle，調用Merge方法Merge兩者然后再設置到控件的Style屬性上。

總結

　　WPF中Style的設計中規中矩，把UI對象樣式和結构分離是它的最初想法，其中也加入了Trigger等一些好的設計，但在使用中還是會出現一些問題，它本身也不是那麼智能完美。希望朋友們都能從內到外的看待Style，更好的玩轉它。

閑話

　　這個深入WPF系列也寫了好几篇了，比起用嘴上白話一通，寫文章需要更多的耐心和細致。講解有很多境界：把簡單的東西講復雜；把復雜的東西講復雜；把復雜的東西講簡單；把復雜的東西講簡單，而且還有詩情哲理。我達不到那麼高的境界，希望能做到直接不回避的把技朮主線講清楚，也希望能更多的听到朋友們的反饋，我會繼續補充，爭取把這個系列寫好。

　　謝謝支持，謝謝您頂一下。　^_^

作者：周永恆
出處：http://www.cnblogs.com/Zhouyongh

WPF – 使用 DrawingVisual 描繪圖形

2013-06-03T10:07:00.001+08:00

在 WPF 中有很多種方式來描繪圖形, 其 DrawingVisual 是一個輕量級的 Class, 它需一個 container 來承接, 並不提供 Layout, Hit-Testing 及 Event-Handling.

那來實作一下如何使用 DrawingVisual 來描繪圖形.

建立一個 class, 它繼承 FrameworkElement Class, 並描繪一個 Rectangle .

    public class MyVisualHost : FrameworkElement
    {

        private VisualCollection childern;

        public MyVisualHost() {
            childern = new VisualCollection(this);
            childern.Add(CreateDrawingVisualRectangle());
        }

        protected override int VisualChildrenCount
        {
            get
            {
                return childern.Count;
            }
        }

        protected override Visual GetVisualChild(int index)
        {
            return childern[index];
        }

        private DrawingVisual CreateDrawingVisualRectangle()
        {
            DrawingVisual drawing = new DrawingVisual();
            using (DrawingContext content = drawing.RenderOpen())
            {
                content.DrawRectangle(Brushes.Red, new Pen(Brushes.Blue, 3), new Rect(new Point(100, 100), new Size(30, 30)));
                content.Close();
            }
            return drawing;
        }

    }

結果如下所示 :

WPF - 性能優化

2013-05-31T10:53:00.001+08:00

WPF性能優化一 - Rendering Tier

根据硬件配置的不同，WPF采用不同的Rendering Tier做渲染。下列情況請特別注意，因為在這些情況下，即使是處于Rendering Tier 2的情況下也不會硬件加速。(不全，其余請查閱SDK)

WPF性能優化二 - 布局和設計

盡量多使用Canvas等簡單的布局元素，少使用Grid或者StackPanel等復雜的，越復雜性能開銷越大。
建立邏輯樹或者視覺樹的時候，遵循Top-Down的原則。

WPF性能優化三 - 圖像

對Image做動畫處理的時候（如調整大小等），可以使用這條語句RenderOptions.SetBitmapScalingMode(MyImage,BitmapScalingMode.LowQuality)，以改善性能。
用TileBrush的時候，可以CachingHint。

WPF性能優化四 - 對象行為

訪問CLR對象和CLR屬性的效率會比訪問DependencyObject/DependencyProperty高。注意這里指的是訪問，不要和前面的綁定混淆了。但是，把屬性注冊為DependencyProperty會有很多的優點：比如繼承、數据綁定和Style。

WPF性能優化五 - 應用程序資源

在自定義控件，盡量不要在控件的ResourceDictionary定義資源，而應該放在Window或者Application級。因為放在控件中會使每個實例都保留一份資源的拷貝。
盡量使用Static Resources,但不能盲目使用。

WPF性能優化六 - 文本

文字少的時候用TextBlock或者label,長的時候用FlowDocument.
使用元素TextFlow和TextBlock時，如果不需要TextFlow的某些特性，就應該考慮使用TextBlock，因為它的效率更高。
在TextFlow中使用UIElement（比如TextBlock）所需的代价要比使用TextElement（比如Run）的代价高.在FlowDocument中盡量避免使用TextBlock，要用Run替代。
在TextBlock中顯式的使用Run命令比不使用Run命名的代碼要高。
把Label（標簽）元素的ContentProperty和一個字符串（String）綁定的效率要比把字符串和TextBlock的Text屬性綁定的效率低。因為Label在更新字符串是會丟棄原來的字符串，全部重新顯示內容。如果字符串不需要更新，用Label就無所謂性能問題。
在TextBlock塊使用HyperLinks時，把多個HyperLinks組合在一起效率會更高。
顯示超鏈接的時候，盡量只在IsMouseOver為True的時候顯示下划線，一直顯示下划線的代碼高很多
盡量不使用不必要的字符串連接。

WPF性能優化七 - 數据綁定

在使用數据綁定的過程中，如果綁定的數据源是一個CLR對象，屬性也是一個CLR屬性，那麼在綁定的時候對象CLR對象所實現的机制不同，綁定的效率也不同。

數据源是一個CLR對象，屬性也是一個CLR屬性。對象通過TypeDescriptor/PropertyChanged模式實現通知功能。此時綁定引擎用TypeDescriptor來反射源對象。效率最低。
數据源是一個CLR對象，屬性也是一個CLR屬性。對象通過INotifyPropertyChanged實現通知功能。此時綁定引擎直接反射源對象。效率稍微提高。
數据源是一個DependencyObject，而且屬性是一個DependencyProperty。此時不需要反射，直接綁定。效率最高。

當一個CLR對象很大時，比如有1000個屬性時，盡量把這個對象分解成很多很小的CLR對象。比如分成1000個只有一個屬性的CLR對象。
當我們在列表（比如ListBox）顯示了一個CLR對象列表（比如List）時，如果想在修改List對象后，ListBox也動態的反映這種變化。此時，我們應該使用動態的ObservableCollection對象綁定。而不是直接的更新ItemSource。兩者的區別在于直接更新ItemSource會使WPF拋棄ListBox已有的所有數据，然后全部重新從List加載。而使用ObservableCollection可以避免這種先全部刪除再重載的過程，效率更高。
盡量綁定IList而不是IEnumerable到ItemsControl。

WPF性能優化八 - 其它性能建議

如果需要修改元素的Opacity屬性，最后修改一個Brush的屬性，然后用這個Brush來填充元素。
用NavigationWindow的時候，盡量Update the client area by object,而不是URI
盡量不要使用ScrollBarVisibility=Auto

C# - NHibernate Queries Examples (轉貼)

2013-05-14T14:42:00.001+08:00

Today was the first day of my NHibernate course, and I think that it might be good to point out a few of the samples that we worked with. Those are pretty basic NHibernate queries, but they are probably going to be useful for beginners.

Let us take my usual Blog model, and see what kind of queries (and results) we can come up with:

Let us find a blog by its identifier:

var blog = s.Get<Blog>(1);

Which results in:

We can also try:

var blog = s.Load<Blog>(1);

Which would result in… absolutely no SQL queries. You can look at a more deep discussion of that here.

Now, let us try to search by a property:

var blogs = s.CreateCriteria<Blog>()
    .Add(Restrictions.Eq("Title", "Ayende @ Rahien"))
    .List<Blog>();

Which results in:

If we try to make the same with HQL, it would look:
var blogs = s.CreateQuery("from Blog b where b.Title = :title")
    .SetParameter("title","Ayende @ Rahien")
    .List<Blog>();
Which results in slight different SQL than using the criteria:

What about trying a more complex conditional? Let us try to see comparing two properties:
var blogs = s.CreateCriteria<Blog>()
    .Add(Restrictions.Eq("Title","Ayende @ Rahien"))
    .Add(Restrictions.Eq("Subtitle", "Send me a patch for that"))
    .List<Blog>();
Which results in:

Let us do that again, but using two properties using an OR:
var blogs = s.CreateCriteria<Blog>()
    .Add(Restrictions.Disjunction()
             .Add(Restrictions.Eq("Title", "Ayende @ Rahien"))
             .Add(Restrictions.Eq("Subtitle", "Send me a patch for that")))
    .List<Blog>();
Which would result in:

We can also execute the same SQL using the following syntax:
var blogs = s.CreateCriteria<Blog>()
    .Add(
            Restrictions.Eq("Title", "Ayende @ Rahien") || 
            Restrictions.Eq("Subtitle", "Send me a patch for that")
        )
    .List<Blog>();
Doing the same using HQL would be:
var blogs = s.CreateQuery("from Blog b where b.Title = :title and b.Subtitle = :subtitle")
    .SetParameter("title","Ayende @ Rahien")
    .SetParameter("subtitle", "Send me a patch for that")
    .List<Blog>();
Which results in:

And changing that to an OR is pretty self explanatory :-)
var blogs = s.CreateQuery("from Blog b where b.Title = :title or b.Subtitle = :subtitle")
    .SetParameter("title","Ayende @ Rahien")
    .SetParameter("subtitle", "Send me a patch for that")
    .List<Blog>();
Giving us:

Let us try something a bit more complex, finding a blog by a post title:
var blogs = s.CreateCriteria<Blog>()
    .CreateCriteria("Posts")
    .Add(Restrictions.Eq("Title","NHibernate Rocks"))
    .List<Blog>();
That gives us:

You will note that we force a load of the Posts collection. We can try something else, though:
var blogs = s.CreateCriteria<Blog>()
    .Add(Subqueries.PropertyIn("id",
        DetachedCriteria.For<Post>()
            .Add(Restrictions.Eq("Title","NHibernate Rocks"))
            .SetProjection(Projections.Property("Blog.id"))
        ))
    .List<Blog>();
Which would give us the same result, but without loading the Posts collection:

This is a pretty common example of changing the way that we compute complex conditionals when we want to avoid wide result sets.
Let us do the same with HQL:
var blogs = s.CreateQuery("from Blog b join b.Posts p where p.Title = :title")
    .SetParameter("title", "NHibernate Rocks")
    .List<Blog>();
Which would result:

We have the same issue as with the first Criteria API, and we can resolve it in the same way:
var blogs = s.CreateQuery("from Blog b where b.id in (from Post p where p.Title = :title)")
    .SetParameter("title", "NHibernate Rocks")
    .List<Blog>();
And the same result as in the Criteria API show us:

And the final test, let us try to find a blog that has a post posted by a specific user:
var blogs = s.CreateCriteria<Blog>()
    .Add(Subqueries.PropertyIn("id",
        DetachedCriteria.For<Post>()
            .SetProjection(Projections.Property("Blog.id"))
            .CreateCriteria("User")
            .Add(Restrictions.Eq("Username","Ayende"))
        ))
    .List<Blog>();
And this give us:

The same thing with HQL will give us:
var blogs = s.CreateQuery("from Blog b where b.id in (from Post p where p.User.Username = :user)")
    .SetParameter("user","Ayende")
    .List<Blog>();
And that results:

來源 : http://ayende.com/blog/4023/nhibernate-queries-examples

Flex – Cairngorm 之初體驗

2013-02-25T15:06:00.001+08:00

最近在看 Flex 的 Framework, 以 Adobe 官方建議的 Cairngorm 做為開始.

1. ModelLocator :

此部份提供了 Model 的功能, 使用Signleton design pattern 的設計把所有的資料都收集到這邊.

2. Command, Event, FrontController:

在 Front Controller 註冊 Command 與對應的 Event, Event Dispatcher 監聽 Event, 爾後操作過程中 dispatch event 觸發 Command 執行動作, 最後 Update Model 更新 View 顯示.

3. Interact with a server :

ServiceLocator : 此 Class 提供了 application 將使用的所有 services, 它包含了 HTTPService, WebService, RemoteObject 呼叫.

Business Delegate : 此 Class 有三個 Function
    to locate the service that is needed
    to call a method on the service
    to route the result to the specified responder

Value Object : 此 Class 一般定義 property 並不需要任何的 methods, 使用來跟 Server 做 transfer strongly-typed complex data object.

4. Responders, Commands, Delegates :

Responders : Responders should deal only in strongly-typed application objects. Responders may set values on the model.
Commands : Commands never deal directly with server interaction.Commands may set values on the model.
Delegates : Delegates should pass strongly typed strongly-typed application objects to the Responder. If the Delegate don’t receive strongly-styped application objects, it must parse and convert the data into that format.

Reference :

C# – 得知 Server 上 Protocol 是否已開啟

2013-02-21T13:44:00.001+08:00

當程式要得知 Server 上的 Protocol 是否已開啟, 可以試著去連接來查看, 下面的程式碼即可得知 Server 上其 Protocol 是否已開啟.下面提供一個簡單的範例.

            TcpClient client = new TcpClient();
            bool isPortExist = false;
            Random rnd = new Random();
            int portId = rnd.Next(10000, 60000);
            
            try
            {
                client.Connect("localhost", portId);
                isPortExist = true;
            }
            catch (Exception ex)
            {
                isPortExist = false;
            }
            finally {
                Console.WriteLine(string.Format("Port Id : {0},protocol  {1}", portId, isPortExist ? "opened." : "closed."));
            }
            Console.Read();

WPF - 窺探 Flow Diagram Designer 的設計

2013-02-01T10:02:00.001+08:00

最近收到一個很好玩的 Requirement，提供 Data Sources, Charts, Filters 等組件可讓 User 隨意組合這些元件為一個 Flow 並執行取得結果, 這讓我回想到三年前 WPF 出來時在網路上看到有好心人士提供了其作法和 Source Code, 想不到現在有這 Requirement 需要它了, 真的是太感謝這些好心人士了，那在此記錄一下這些相關的文章, 以防之後還有類似的需求時, 好方便瀏覽.

Javascript – easy UI 的 datetimebox 自定日期時間格式

2013-02-01T09:12:00.001+08:00

在做 Web 的 UI 時, 其 easyUI 這個免費的 Javascript Framework 提供了很多好用的組件,來幫助我們建立豐富及美觀的 Web 畫面, 在日期組件中提供了 datebox, datetimebox 這二種組件, 並提供相對映的 member 讓我們可以自定日期(日期時間)格式, 提供一個 yyyy-MM-dd HH:mm: ss 的時間格式

    $("#startDate, #endDate").datetimebox({
        formatter: function (date) {
            return date.getFullYear()
                + "-" + (date.getMonth() + 1).toString().leftPad("0", 2)
                + "-" + date.getDate().toString().leftPad("0", 2)
                + " " + date.getHours().toString().leftPad("0", 2)
                + ":" + date.getMinutes().toString().leftPad("0", 2)
                + ":" + date.getSeconds().toString().leftPad("0", 2);
        },
        parser: function (date) {
            return new Date(Date.parse(date.replace(/-/g, "/"))); 
        }
    });

其顯示如下所示：

C# – M$ Chart Control 自定 ToolTip 的顯示

2013-01-31T17:51:00.001+08:00

在使用 M$ Chart Control 來顯示 Chart 時, 一般的 Requirments 其 ToolTip 在顯示一般都為 X/Y Value，可是當有特別的資料需顯示時，那又該如何呢？在其 DataPoint Class 中提供一個SetCustomProperty Member 讓 User 可以設定其 Custom Property Value，那只需在 Series Class 中設定 ToolTipProperty 後，其 ToolTip 即可顯示 Custom Property.

    Series s = new Series();
    s.Name = "SeriesName";
    s.ChartType = SeriesChartType.Line;
    s.MarkerStyle = MarkerStyle.Circle;
    s.MarkerSize = 8;
    s.BorderWidth = 3;
    s.ToolTip = "Wafer Id: #AXISLABEL\n" + 
    "Time: #CUSTOMPROPERTY(TIME)\n" +
    "Y Value: #VALY";

C# – M$ Chart Control 顯示 Stacked Bar Chart.

2013-01-31T17:39:00.001+08:00

最近因 Requirement 的需要, 需 Drawing stacked bar chart，之前的文章已有寫過如何在 ASP.NET MVC 中使用 MS Chart Control 這個元件了, 那其 Stacked Bar Chart 需在 Series 中加入一個自訂的 Attributes (StackedGroupName) 來控制，故在此記錄一下其 Code 的部份，以防後續時間一久又忘了如何使用.

    Series s = new Series();
    s.Name = "SeriesName";
    s.ChartArea = "ChartArea1";
    s.ChartType = SeriesChartType.StackedColumn;
    s["StackedGroupName"] = "Group1";
    chart.Series.Add(s);

Javascript – String 增加 LeftPad 的 Function

2013-01-17T16:05:00.001+08:00

在 C# 中其 String 當其 Length 不足時可在前方補上所需的字元, 那在 Javascript 中並沒有此 Function 可以使用, 那使用擴充的方式來增加所需的 Function. 那如下所示：

String.prototype.leftPad = function (padString, length) {
    var str = this;
    while (str.length < length)
        str = padString + str;
    return str;
}

[WPF] – Debugging DataBindings

2012-11-28T15:59:00.001+08:00

最近從頭開始學習 WPF 其 DataBinding，那其如何 Dbugging DataBindings 的部份是我之前並沒有接觸過的，那記錄一下以後有需要時就可以拿來使用，以防跟之前一樣都是用土法鍊鋼的方式一直測試到 Binding 成功為止，也不知道那裡有問題.

按照上面所述的部份做設定即可 Debugging DataBindings 了.

[Windows] – Registering an Application to a URL Protocol

2012-11-26T14:06:00.001+08:00

有些應用程式可以在 Web 按下 Hyper Link 後會開啟應用程式並傳入參數, 那此部份是如何達成的呢？在此記錄一下, 以防以後有需要時還要再重新找尋資料.

Registering the Application Handling the Custom Protocol

To register an application to handle a particular URL protocol, add a new key, along with the appropriate subkeys and values, to HKEY_CLASSES_ROOT. The root key must match the protocol scheme that is being added. For instance, to add an "alert:" protocol, add an alert key to HKEY_CLASSES_ROOT, as follows:

HKEY_CLASSES_ROOT
alert
URL Protocol = ""

Under this new key, the URL Protocol string value indicates that this key declares a custom protocol handler. Without this key, the handler application will not launch. The value should be an empty string.

Keys should also be added for DefaultIcon and shell. The Default string value of the DefaultIcon key must be the file name to use as an icon for this new URL protocol. The string takes the form "path, iconindex" with a maximum length of MAX_PATH. The name of the first key under the shell key should be an action verb, such as open. Under this key, a command key or a DDEEXEC key indicate how the handler should be invoked. The values under the command and DDEEXEC keys describe how to launch the application handling the new protocol.

Finally, the Default string value should contain the display name of the new protocol. The following example shows how to register an application, alert.exe in this case, to handle the alert protocol.

HKEY_CLASSES_ROOT
alert
(Default) = "URL:Alert Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "alert.exe,1"
shell
open
command
(Default) = "C:\Program Files\Alert\alert.exe" "%1"

When a user clicks a link registered to your custom URL protocol, Internet Explorer launches the registered URL protocol handler. If the specified open command specified in the registry contains a %1 parameter, Internet Explorer passes the URI to the registered protocol handler application.

詳細內容請參考 : http://msdn.microsoft.com/zh-tw/library/aa767914(v=vs.85).aspx …