Commits

David Barker committed 3636952

Bit more dissertation, and also wrote a demo app where arrows are used in conjunction with WPF binding

  • Participants
  • Parent commits 4f1b612

Comments (0)

Files changed (55)

ArrowDataBinding.sln

 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CaseStudyListBinding-Arrows", "CaseStudyListBinding-Arrows\CaseStudyListBinding-Arrows.csproj", "{BBE4BEFF-B4EE-42A7-B0BC-A0854D74D8EE}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WPFIntegrationDemo", "WPFIntegrationDemo\WPFIntegrationDemo.csproj", "{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		{BBE4BEFF-B4EE-42A7-B0BC-A0854D74D8EE}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{BBE4BEFF-B4EE-42A7-B0BC-A0854D74D8EE}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{BBE4BEFF-B4EE-42A7-B0BC-A0854D74D8EE}.Release|x86.ActiveCfg = Release|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

ArrowDataBinding.v11.suo

Binary file modified.

CaseStudyListBinding-WPF/bin/Debug/CaseStudyListBinding-WPF.vshost.exe.manifest

+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <requestedExecutionLevel level="asInvoker" uiAccess="false"/>
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+</assembly>

Dissertation/Dissertation.aux

 \@writefile{lof}{\contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{28}}
 \newlabel{fig:case_study_name}{{4.1}{28}}
 \@writefile{toc}{\contentsline {subsubsection}{List binding from a mock database}{29}}
-\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{29}}
-\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{29}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{29}}
-\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{29}}
-\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{30}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{31}}
-\newlabel{fig:simple_function_performance}{{4.2}{31}}
-\@writefile{toc}{\contentsline {subsubsection}{List function results}{31}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{32}}
-\newlabel{fig:list_function_performance}{{4.3}{32}}
-\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{32}}
-\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{32}}
-\@writefile{lof}{\contentsline {figure}{\numberline {4.4}{\ignorespaces Execution times of chains of identity functions}}{33}}
-\newlabel{fig:arrow_chaining_overhead}{{4.4}{33}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{33}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{29}}
+\newlabel{fig:case_study_list}{{4.2}{29}}
+\@writefile{toc}{\contentsline {subsubsection}{Some other demo}{30}}
+\@writefile{toc}{\contentsline {section}{\numberline {4.3}Performance testing}{30}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{30}}
+\@writefile{toc}{\contentsline {subsubsection}{Measuring technique}{30}}
+\@writefile{toc}{\contentsline {subsubsection}{Simple function results}{31}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{32}}
+\newlabel{fig:simple_function_performance}{{4.3}{32}}
+\@writefile{toc}{\contentsline {subsubsection}{List function results}{32}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{33}}
+\newlabel{fig:list_function_performance}{{4.4}{33}}
+\@writefile{toc}{\contentsline {subsubsection}{Overhead due to arrow chaining}{34}}
+\newlabel{sec:arrow_chaining_overhead}{{4.3.1}{34}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{34}}
+\newlabel{fig:arrow_chaining_overhead}{{4.5}{34}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3.2}Binding performance}{34}}
 \@writefile{toc}{\contentsline {chapter}{\numberline {5}Conclusion}{35}}
 \@writefile{lof}{\addvspace {10\p@ }}
 \@writefile{lot}{\addvspace {10\p@ }}
 \@writefile{toc}{\contentsline {section}{\numberline {B.1}Username two-way binding}{39}}
 \newlabel{sec:case_study_name}{{B.1}{39}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {B.1.1}Creating the bindable data source}{39}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {B.1.2}Creating the functionality for splitting the name}{41}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {B.1.3}Creating the binding}{43}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {B.1.2}Creating the functionality for splitting the name}{40}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {B.1.3}Creating the binding}{41}}
+\@writefile{toc}{\contentsline {section}{\numberline {B.2}List binding from a mock database}{43}}
+\newlabel{sec:case_study_list}{{B.2}{43}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {B.2.1}Creating the bindable `database'}{43}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {B.2.2}Filtering and mapping the list}{43}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {B.2.3}Creating the binding}{44}}
+\@writefile{toc}{\contentsline {section}{\numberline {B.3}Some other demo}{45}}
 \citation{arrow_calculus}
-\@writefile{toc}{\contentsline {section}{\numberline {B.2}List binding from a mock database}{45}}
-\newlabel{sec:case_study_list}{{B.2}{45}}
-\@writefile{toc}{\contentsline {section}{\numberline {B.3}Some other demo}{47}}
 \citation{hughes_arrows}
 \citation{arrows_robots_frp}
 \citation{frp_first_principles}

Dissertation/Dissertation.lof

 \contentsline {figure}{\numberline {3.7}{\ignorespaces Marshalling a list of BindPoint sources to pass to an arrow and unmarshalling the result}}{23}
 \addvspace {10\p@ }
 \contentsline {figure}{\numberline {4.1}{\ignorespaces The username two-way binding application}}{28}
-\contentsline {figure}{\numberline {4.2}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{31}
-\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{32}
-\contentsline {figure}{\numberline {4.4}{\ignorespaces Execution times of chains of identity functions}}{33}
+\contentsline {figure}{\numberline {4.2}{\ignorespaces The list binding application}}{29}
+\contentsline {figure}{\numberline {4.3}{\ignorespaces Performance of arrows, Funcs and normal functions in implementing simple functionality}}{32}
+\contentsline {figure}{\numberline {4.4}{\ignorespaces Performance of arrows, Linq queries and normal (loop-based) functions in implementing simple list functionality}}{33}
+\contentsline {figure}{\numberline {4.5}{\ignorespaces Execution times of chains of identity functions}}{34}
 \addvspace {10\p@ }
 \addvspace {10\p@ }
 \addvspace {10\p@ }

Dissertation/Dissertation.log

-This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  24 APR 2013 13:42
+This is pdfTeX, Version 3.1415926-2.3-1.40.12 (MiKTeX 2.9 64-bit) (preloaded format=pdflatex 2012.10.5)  28 APR 2013 13:29
 entering extended mode
 **Dissertation.tex
 
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.toc" [5
 
-])
+] [6])
 \tf@toc=\write3
- [6]
+ [7]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.lof")
 \tf@lof=\write4
- [7
-
-] [8
+ [8
 
 ]
 Chapter 1.
 [1
 
+
 ]
 Missing character: There is no � in font cmr12!
 Missing character: There is no � in font cmr12!
 Package pdftex.def Info: fig/CaseStudyNameBinding.png used on input line 612.
 (pdftex.def)             Requested size: 283.0568pt x 210.78699pt.
  [27] [28 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
-g/Dissertation/fig/CaseStudyNameBinding.png>] [29]
-<fig/SimpleFunctionPerformanceChart.pdf, id=214, 496.44887pt x 258.75552pt>
+g/Dissertation/fig/CaseStudyNameBinding.png>] <fig/CaseStudyListBinding.png, id
+=211, 596.2275pt x 423.5825pt>
+File: fig/CaseStudyListBinding.png Graphic file (type png)
+
+<use fig/CaseStudyListBinding.png>
+Package pdftex.def Info: fig/CaseStudyListBinding.png used on input line 633.
+(pdftex.def)             Requested size: 411.93877pt x 292.66003pt.
+ [29 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/CaseStudyListBinding.png>]
+[30] [31]
+<fig/SimpleFunctionPerformanceChart.pdf, id=221, 496.44887pt x 258.75552pt>
 File: fig/SimpleFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/SimpleFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/SimpleFunctionPerformanceChart.pdf used on input l
-ine 678.
+ine 691.
 (pdftex.def)             Requested size: 411.93877pt x 214.71175pt.
- [30] [31 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBindin
-g/Dissertation/fig/SimpleFunctionPerformanceChart.pdf>]
-<fig/ListFunctionPerformanceChart.pdf, id=291, 496.4172pt x 244.72725pt>
+ [32 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/SimpleFunctionPerformanceChart.pdf>]
+<fig/ListFunctionPerformanceChart.pdf, id=295, 496.4172pt x 244.72725pt>
 File: fig/ListFunctionPerformanceChart.pdf Graphic file (type pdf)
 
 <use fig/ListFunctionPerformanceChart.pdf>
 Package pdftex.def Info: fig/ListFunctionPerformanceChart.pdf used on input lin
-e 697.
+e 710.
 (pdftex.def)             Requested size: 411.93877pt x 203.08247pt.
- [32 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/ListFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=35
-9, 496.51498pt x 216.57913pt>
+ [33 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/ListFunctionPerformanceChart.pdf>] <fig/IdentityChains.pdf, id=36
+4, 496.51498pt x 216.57913pt>
 File: fig/IdentityChains.pdf Graphic file (type pdf)
 
 <use fig/IdentityChains.pdf>
-Package pdftex.def Info: fig/IdentityChains.pdf used on input line 711.
+Package pdftex.def Info: fig/IdentityChains.pdf used on input line 724.
 (pdftex.def)             Requested size: 411.93877pt x 179.69122pt.
- [33 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
-sertation/fig/IdentityChains.pdf>] [34
-
-]
+ [34 <C:/Users/David/Documents/Visual Studio 2010/Projects/ArrowDataBinding/Dis
+sertation/fig/IdentityChains.pdf>]
 Chapter 5.
 [35
 
+
 ] [36
 
 ]
 \pc@column@2=\box30
 \pc@column@width@2=\dimen120
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 818.
+ne 831.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 818.
+ne 831.
 [39
 
 
-] [40]
+]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 875.
+ne 886.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 875.
- [41
-
-] [42]
+ne 886.
+ [40]
+Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
+ne 931.
+Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
+ne 931.
+ [41] [42]
 Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
-ne 922.
+ne 973.
 Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
-ne 922.
+ne 973.
  [43
 
-] [44
-
-] [45] [46
+]
+Package parcolumns Info: Width of column 1 calculated as 194.2195pt on input li
+ne 1015.
+Package parcolumns Info: Width of column 2 calculated as 194.2195pt on input li
+ne 1015.
+ [44] [45
 
-] [47] [48
+] [46
 
 ]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 a-tion.
  []
 
-[49
+[47
 
-]) [50]
+]) [48]
 ("C:\Users\David\Documents\Visual Studio 2010\Projects\ArrowDataBinding\Dissert
 ation\Dissertation.aux") ) 
 Here is how much of TeX's memory you used:
- 2899 strings out of 494045
- 42566 string characters out of 3148387
+ 2926 strings out of 494045
+ 43033 string characters out of 3148387
  216622 words of memory out of 3000000
- 6171 multiletter control sequences out of 15000+200000
+ 6197 multiletter control sequences out of 15000+200000
  12938 words of font info for 46 fonts, out of 3000000 for 9000
  715 hyphenation exceptions out of 8191
  27i,8n,40p,1132b,1520s stack positions out of 5000i,500n,10000p,200000b,50000s
 ogram Files/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt10.pfb><C:/Program Fi
 les/MiKTeX 2.9/fonts/type1/public/amsfonts/cm/cmtt12.pfb><C:/Program Files/MiKT
 eX 2.9/fonts/type1/public/amsfonts/cm/cmtt8.pfb>
-Output written on Dissertation.pdf (60 pages, 495326 bytes).
+Output written on Dissertation.pdf (58 pages, 521897 bytes).
 PDF statistics:
- 610 PDF objects out of 1000 (max. 8388607)
+ 605 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 500000)
- 51 words of extra memory for PDF output out of 10000 (max. 10000000)
+ 56 words of extra memory for PDF output out of 10000 (max. 10000000)
 

Dissertation/Dissertation.pdf

Binary file modified.

Dissertation/Dissertation.synctex.gz

Binary file modified.

Dissertation/Dissertation.tex

 
 All the original goals were met: a general-purpose data binding framework based on arrows has been implemented, and an extensive arrow implementation has been completed. As well as the standard operators, a series of more complex extra operators have also been added, and some additional arrow types have been included -- for instance, 'list arrows' which map between enumerable data types. The framework allows bindings in both directions, between multiple sources and multiple destinations, and the arrows can be used in conjunction with WPF data binding with reasonable ease.
 
-[Continue this?]
+%Continue this?
 
 \section*{Special Difficulties}
 
 comparable purpose.
 
 \bigskip
-\leftline{Signed [signature]}
+\leftline{Signed}
 
 \medskip
-\leftline{Date [date]}
+\leftline{Date}
 
 \cleardoublepage
 
 
 \subsubsection{List binding from a mock database}
 
-Todo
+For a second case study, a simple `database' (a \texttt{List} of data for simplicity) containing information on orders placed for certain products was created. The objective for this was to bind this data to a list view, filtering it to only the orders with volume greater than one and mapping the result to a list of user-friendly strings describing the order (of the form ``Order from [name] in [location] for [volume] `[product]' from [supplier]''). The simple application is pictured in Figure \ref{fig:case_study_list}, and its source code is given in Appendix \ref{sec:case_study_list}.
+
+%Should sort too?
+
+\begin{figure}[!ht]
+  \centering
+  \includegraphics[width=\textwidth]{fig/CaseStudyListBinding.png}
+  \caption{The list binding application}
+  \label{fig:case_study_list}
+\end{figure}
+
+As with the last example, the arrow syntax is a lot more concise than the value converter. Filtering and mapping is done by calling \texttt{Filter} and \texttt{Map} on a base list arrow and passing in the appropriate lambda functions for each. The value converter, meanwhile, has to convert its input to the correct type and then manually cycle through each element, adding a string version of it to the result if its volume exceeds one. However, it could be argued that with more complex bindings like this the value converter is easier to debug than arrows: breakpoints can be conveniently set up inside the filtering loop and the code can be stepped through, whereas if the arrow gives unexpected results a lot of the work will be done by `behind the scenes' methods which the user cannot step through (this is more of an issue for list arrows as they are built up with the map, filter and sort operators).
+
+The code for creating the binding is much simpler this time, and the arrow-based code is very short: only a single line calling the \texttt{GetBindPoint} methods of the source and destination and passing in the arrow. The WPF binding is again more verbose, requiring the programmer to create a new \texttt{Binding}; individually set the \texttt{Source}, \texttt{Path} and \texttt{Converter} properties\footnote{\texttt{Source} is the object to bind to, \texttt{Path} is the name of the property being bound and \texttt{Converter} is the \texttt{IValueConverter} used to convert the source value into the destination value} and attach it to the list view. The main advantage of arrow data binding here is the \texttt{GetBindPoint} method provided by \texttt{Bindable} objects, which simplifies specifying the bound variable to one call and means the variable name is `attached' to the object it belongs to.
 
 \subsubsection{Some other demo}
 
 	}
 \end{parcolumns}
 
-\clearpage
-
 \subsection{Creating the functionality for splitting the name}
 
 \begin{parcolumns}{2}
 }
 \end{parcolumns}
 
-\clearpage
-
 \subsection{Creating the binding}
 
 \begin{parcolumns}{2}
 
 \section{List binding from a mock database} \label{sec:case_study_list}
 
-Todo\cite{arrow_calculus}
+\subsection{Creating the bindable `database'}
+
+This was much the same as creating the data source for the username binding case study, with the main additional difference between the two being that the WPF version used an \texttt{ObservableCollection} rather than a plain \texttt{List}.
+
+\subsection{Filtering and mapping the list}
+
+\begin{parcolumns}{2}
+\colchunk {
+\begin{lstlisting}
+public class ListFilterConverter : IValueConverter
+{
+  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+  {
+    ObservableCollection<Order> list = (ObservableCollection<Order>)value;
+    List<string> resultsList = new List<string>();
+
+    foreach (Order order in list)
+    {
+      if (order.Volume > 1)
+      {
+        resultsList.Add(String.Format("Order from {0} in {1} for {2} '{3}' from {4}", order.Customer.Name, order.Customer.Location, order.Volume, order.Product, order.Supplier.Name));
+      }
+    }
+
+    return resultsList;
+  }
+
+  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+  {
+    throw new NotImplementedException();
+  }
+}
+\end{lstlisting}
+}
+
+\colchunk {
+\begin{lstlisting}
+arrow = ListArrow.Filter<Order>
+  ((Order o) => o.Volume > 1)
+  .Map((Order o) =>
+    String.Format("Order from {0} in {1} for {2} {3}s from {4}",
+    o.Customer.Name, o.Customer.Location, o.Volume, o.Product, o.Supplier.Name));
+\end{lstlisting}
+}
+\end{parcolumns}
+
+\subsection{Creating the binding}
+
+\begin{parcolumns}{2}
+\colchunk {
+\begin{lstlisting}
+Binding listBinding = new Binding();
+listBinding.Source = ordersDB;
+listBinding.Path = new PropertyPath("Orders");
+listBinding.Converter = new ListFilterConverter();
+BoundListBox.SetBinding(ListBox.ItemsSourceProperty, listBinding);
+\end{lstlisting}
+}
+
+\colchunk {
+\begin{lstlisting}
+BindingsManager.CreateBinding(
+  ordersDB.GetBindPoint("Orders"),
+  arrow,
+  arrowResult.GetBindPoint("Result"));
+\end{lstlisting}
+}
+\end{parcolumns}
 
 \cleardoublepage
 
 \cleardoublepage
 
 
+\nocite{arrow_calculus}
 \nocite{hughes_arrows}
 \nocite{arrows_robots_frp}
 \nocite{frp_first_principles}

Dissertation/Dissertation.toc

 \contentsline {subsection}{\numberline {4.2.2}Binding syntax}{27}
 \contentsline {subsubsection}{Username two-way binding}{27}
 \contentsline {subsubsection}{List binding from a mock database}{29}
-\contentsline {subsubsection}{Some other demo}{29}
-\contentsline {section}{\numberline {4.3}Performance testing}{29}
-\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{29}
-\contentsline {subsubsection}{Measuring technique}{29}
-\contentsline {subsubsection}{Simple function results}{30}
-\contentsline {subsubsection}{List function results}{31}
-\contentsline {subsubsection}{Overhead due to arrow chaining}{32}
-\contentsline {subsection}{\numberline {4.3.2}Binding performance}{33}
+\contentsline {subsubsection}{Some other demo}{30}
+\contentsline {section}{\numberline {4.3}Performance testing}{30}
+\contentsline {subsection}{\numberline {4.3.1}Arrow performance}{30}
+\contentsline {subsubsection}{Measuring technique}{30}
+\contentsline {subsubsection}{Simple function results}{31}
+\contentsline {subsubsection}{List function results}{32}
+\contentsline {subsubsection}{Overhead due to arrow chaining}{34}
+\contentsline {subsection}{\numberline {4.3.2}Binding performance}{34}
 \contentsline {chapter}{\numberline {5}Conclusion}{35}
 \contentsline {section}{\numberline {5.1}Future work}{35}
 \contentsline {subsection}{\numberline {5.1.1}Performance enhancements}{35}
 \contentsline {chapter}{\numberline {B}Code samples for case studies}{39}
 \contentsline {section}{\numberline {B.1}Username two-way binding}{39}
 \contentsline {subsection}{\numberline {B.1.1}Creating the bindable data source}{39}
-\contentsline {subsection}{\numberline {B.1.2}Creating the functionality for splitting the name}{41}
-\contentsline {subsection}{\numberline {B.1.3}Creating the binding}{43}
-\contentsline {section}{\numberline {B.2}List binding from a mock database}{45}
-\contentsline {section}{\numberline {B.3}Some other demo}{47}
+\contentsline {subsection}{\numberline {B.1.2}Creating the functionality for splitting the name}{40}
+\contentsline {subsection}{\numberline {B.1.3}Creating the binding}{41}
+\contentsline {section}{\numberline {B.2}List binding from a mock database}{43}
+\contentsline {subsection}{\numberline {B.2.1}Creating the bindable `database'}{43}
+\contentsline {subsection}{\numberline {B.2.2}Filtering and mapping the list}{43}
+\contentsline {subsection}{\numberline {B.2.3}Creating the binding}{44}
+\contentsline {section}{\numberline {B.3}Some other demo}{45}

WPFIntegrationDemo/App.config

+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+</configuration>

WPFIntegrationDemo/App.xaml

+<Application x:Class="WPFIntegrationDemo.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

WPFIntegrationDemo/App.xaml.cs

+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace WPFIntegrationDemo
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}

WPFIntegrationDemo/MainWindow.xaml

+<Window x:Class="WPFIntegrationDemo.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="MainWindow" Height="350" Width="525">
+    <Grid>
+        <TextBlock x:Name="TextBox" HorizontalAlignment="Left" Margin="23,27,0,0" TextWrapping="Wrap" Text="TextBlock" VerticalAlignment="Top" Height="48" Width="458"/>
+
+    </Grid>
+</Window>

WPFIntegrationDemo/MainWindow.xaml.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using System.Threading;
+using ArrowDataBinding.Arrows;
+using ArrowDataBinding.Bindings;
+using ArrowDataBinding.Combinators;
+
+namespace WPFIntegrationDemo
+{
+    public partial class MainWindow : Window
+    {
+        private Arrow<int, string> arrow;
+        private Time time;
+
+        public MainWindow()
+        {
+            InitializeComponent();
+            InitialiseTime();
+            InitialiseArrow();
+            InitialiseBinding();
+        }
+
+        public void InitialiseTime()
+        {
+            time = new Time();
+        }
+
+        public void InitialiseArrow()
+        {
+            var sinArrow = Op.Arr((int x) => 50 + (int)(50.0*Math.Sin(x / 30.0)));
+            var textSizeArrow = Op.Arr((int length) => new String('|', length));
+            arrow = sinArrow.Combine(textSizeArrow);
+        }
+
+        public void InitialiseBinding()
+        {
+            Binding binding = new Binding();
+            binding.Source = time;
+            binding.Mode = BindingMode.OneWay;
+            binding.Path = new PropertyPath("CurrentTime");
+            binding.Converter = new ArrowValueConverter(arrow);
+            TextBox.SetBinding(TextBlock.TextProperty, binding);
+        }
+    }
+
+    public class Time : Bindable
+    {
+        [Bindable]
+        public int CurrentTime { get; set; }
+
+        private Timer timer;
+
+        public Time()
+        {
+            CurrentTime = 0;
+            timer = new Timer(state => CurrentTime++, null, 25, 25);
+        }
+    }
+}

WPFIntegrationDemo/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("WPFIntegrationDemo")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("WPFIntegrationDemo")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+//In order to begin building localizable applications, set 
+//<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
+//inside a <PropertyGroup>.  For example, if you are using US english
+//in your source files, set the <UICulture> to en-US.  Then uncomment
+//the NeutralResourceLanguage attribute below.  Update the "en-US" in
+//the line below to match the UICulture setting in the project file.
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+    //(used if a resource is not found in the page, 
+    // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+    //(used if a resource is not found in the page, 
+    // app, or any theme specific resource dictionaries)
+)]
+
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

WPFIntegrationDemo/Properties/Resources.Designer.cs

+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.18034
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WPFIntegrationDemo.Properties
+{
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if ((resourceMan == null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WPFIntegrationDemo.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+    }
+}

WPFIntegrationDemo/Properties/Resources.resx

+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

WPFIntegrationDemo/Properties/Settings.Designer.cs

+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.18034
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WPFIntegrationDemo.Properties
+{
+
+
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}

WPFIntegrationDemo/Properties/Settings.settings

+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

WPFIntegrationDemo/WPFIntegrationDemo.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{132E0087-B3DB-4FBE-9A9A-08AE51C2BBBE}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>WPFIntegrationDemo</RootNamespace>
+    <AssemblyName>WPFIntegrationDemo</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="PostSharp, Version=2.1.0.0, Culture=neutral, PublicKeyToken=b13fd38b8f9c99d7, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="MainWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MainWindow.xaml.cs">
+      <DependentUpon>MainWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <AppDesigner Include="Properties\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ArrowDataBinding\ArrowDataBinding.csproj">
+      <Project>{1936143a-3b13-42bf-8bdd-3f9073cfa728}</Project>
+      <Name>ArrowDataBinding</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

WPFIntegrationDemo/bin/Debug/ArrowDataBinding.exe

Binary file added.

WPFIntegrationDemo/bin/Debug/ArrowDataBinding.pdb

Binary file added.

WPFIntegrationDemo/bin/Debug/PostSharp.dll

Binary file added.

WPFIntegrationDemo/bin/Debug/PostSharp.xml

+<?xml version="1.0" encoding="utf-8"?>
+<doc>
+  <assembly>
+    <name>PostSharp</name>
+  </assembly>
+  <members>
+    <member name="T:PostSharp.IgnoreWarningAttribute">
+      <summary>
+            Instructs PostSharp to ignore warnings and information messages. Errors cannot be ignored.
+            </summary>
+    </member>
+    <member name="M:PostSharp.IgnoreWarningAttribute.#ctor(System.String)">
+      <summary>
+            Creates a new instance of <see cref="T:PostSharp.IgnoreWarningAttribute" />.
+            </summary>
+      <param name="messageId">Identifier of the ignored warning.</param>
+    </member>
+    <member name="P:PostSharp.IgnoreWarningAttribute.MessageId">
+      <summary>
+            Gets the identifier of the ignored warning.
+            </summary>
+    </member>
+    <member name="P:PostSharp.IgnoreWarningAttribute.Reason">
+      <summary>
+            Gets or set the reason (a human-readable text) why the warning must be ignored.
+            </summary>
+    </member>
+    <member name="T:PostSharp.MessageLocation">
+      <summary>
+            Represents the location of a message, which means, for the end-user, a line in a file of source code.
+            From the aspect developer, the location can be known as an object representing an element of code
+            (for instance a <see cref="T:System.Type" /> or <see cref="T:System.Reflection.MethodInfo" />). Such implicit locations are resolved
+            by PostSharp to a file and line number.
+            </summary>
+    </member>
+    <member name="P:PostSharp.MessageLocation.CodeElement">
+      <summary>
+            Element of code (reflection object or <c>Declaration</c>) from which the location must be resolved.
+            </summary>
+    </member>
+    <member name="P:PostSharp.MessageLocation.Column">
+      <summary>
+              Gets the column in the file that caused the
+              message.
+            </summary>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Explicit(System.String)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> explicitely by specifying a filename, when the
+            </summary>
+      <param name="file">File name.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Explicit(System.String,System.Int32,System.Int32)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> explicitely by specifying a filename, line, and column.
+            </summary>
+      <param name="file">File name.</param>
+      <param name="line">Line number.</param>
+      <param name="column">Column number.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="P:PostSharp.MessageLocation.File">
+      <summary>
+              Gets the name of the file that caused the message.
+            </summary>
+    </member>
+    <member name="P:PostSharp.MessageLocation.Line">
+      <summary>
+              Gets the line in the file that caused the   message.
+            </summary>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(PostSharp.Reflection.LocationInfo)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from a <see cref="T:PostSharp.Reflection.LocationInfo" />.
+            </summary>
+      <param name="location">A <see cref="T:PostSharp.Reflection.LocationInfo" />.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(PostSharp.Reflection.SymbolSequencePoint)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from a <see cref="T:PostSharp.Reflection.SymbolSequencePoint" />.
+            </summary>
+      <param name="symbolSequencePoint">A <see cref="T:PostSharp.Reflection.SymbolSequencePoint" />.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" /> corresponding to <paramref name="symbolSequencePoint" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(System.Object)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from an object representing an
+            element of code (<see cref="T:System.Type" />, <see cref="T:System.Reflection.MethodInfo" />, <see cref="T:System.Reflection.ConstructorInfo" />,
+            <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Reflection.ParameterInfo" />, <see cref="T:System.Reflection.EventInfo" />,
+            <see cref="T:System.Reflection.PropertyInfo" /> or, if
+            you are using PostSharp SDK, any <c>Declaration</c>).
+            </summary>
+      <param name="codeElement">an object representing an
+            element of code (<see cref="T:System.Type" />, <see cref="T:System.Reflection.MethodInfo" />, <see cref="T:System.Reflection.ConstructorInfo" />,
+            <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Reflection.ParameterInfo" />, <see cref="T:System.Reflection.EventInfo" />,
+            <see cref="T:System.Reflection.PropertyInfo" /> or, if you are using PostSharp SDK, any <c>Declaration</c>.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" /> representing <paramref name="codeElement" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(System.Reflection.MemberInfo)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from a <see cref="T:System.Reflection.MemberInfo" /> (<see cref="T:System.Type" />, 
+            <see cref="T:System.Reflection.MethodInfo" />, <see cref="T:System.Reflection.ConstructorInfo" />, <see cref="T:System.Reflection.FieldInfo" />,
+            <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />).
+            </summary>
+      <param name="member">An element of code (<see cref="T:System.Type" />, 
+            <see cref="T:System.Reflection.MethodInfo" />, <see cref="T:System.Reflection.ConstructorInfo" />, <see cref="T:System.Reflection.FieldInfo" />,
+            <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />).</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(System.Reflection.ParameterInfo)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from a <see cref="T:System.Reflection.ParameterInfo" />.
+            </summary>
+      <param name="parameter">A <see cref="T:System.Reflection.ParameterInfo" />.</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="M:PostSharp.MessageLocation.Of(System.Runtime.InteropServices._Assembly)">
+      <summary>
+            Builds a <see cref="T:PostSharp.MessageLocation" /> from an <see cref="T:System.Runtime.InteropServices._Assembly" />.
+            </summary>
+      <param name="assembly">An <see cref="T:System.Runtime.InteropServices._Assembly" /> (<see cref="T:System.Reflection.Assembly" /> or its wrapper).</param>
+      <returns>A <see cref="T:PostSharp.MessageLocation" />.</returns>
+    </member>
+    <member name="F:PostSharp.MessageLocation.Unknown">
+      <summary>
+            Represents an unknown or undeterminate location of the error message.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Post">
+      <summary>
+              Provides some methods that are transformed during post-compilation.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Post.Cast``2(``0)">
+      <summary>
+              At post-compile time, casts an instance of a type into another.
+              A post-compile time error is reported if the source type cannot be
+              assigned to the target type.
+            </summary>
+      <param name="o">Instance to be casted.</param>
+      <typeparam name="SourceType">Source type.</typeparam>
+      <typeparam name="TargetType">Target type.</typeparam>
+      <returns>The object <paramref name="o" /> casted as <typeparamref name="TargetType" />.</returns>
+    </member>
+    <member name="M:PostSharp.Post.GetValue``1(``0)">
+      <summary>
+              When used to retrieve the value of a field, forces the compiler to retrieve a copy
+              of the field value instead of an address to this field. This allows to call
+              instance methods of value-type fields without loading the field address.
+            </summary>
+      <param name="value">Value.</param>
+      <typeparam name="T">Type of the value to retrieve (this type parameter can generally be omitted).</typeparam>
+      <returns>
+        <paramref name="value" />, exactly.</returns>
+    </member>
+    <member name="P:PostSharp.Post.IsTransformed">
+      <summary>
+              Determines whether the calling program has been transformed by PostSharp.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.AdviceArgs">
+      <summary>
+              Base class for arguments of all advices.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AdviceArgs.#ctor(System.Object)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.AdviceArgs" />.
+            </summary>
+      <param name="instance">The instance related to the advice invocation, or
+              <c>null</c> if the advice is associated to a static element of code.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.AdviceArgs.Instance">
+      <summary>
+              Gets or sets the object instance on which the method is being executed.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.Arguments">
+      <summary>
+              Encapsulation of method arguments.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.Clone">
+      <summary>
+              Returns a shallow copy of the current object.
+            </summary>
+      <returns>A shallow copy of the current object.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.CopyFrom(System.Object[],System.Int32)">
+      <summary>
+              Copies all the argument values from the elements of <see cref="T:System.Array" />.
+            </summary>
+      <param name="array">The array that is the source of the argument values copied into the current <see cref="T:PostSharp.Aspects.Arguments" />.</param>
+      <param name="index">An integer that represents the index in <paramref name="array" /> at which copying begins.</param>
+      <exception cref="T:System.ArgumentNullException">
+        <paramref name="array" /> is <c>null</c>.</exception>
+      <exception cref="T:System.ArgumentOutOfRangeException">
+        <paramref name="index" /> is lower than zero.</exception>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.CopyTo(System.Object[],System.Int32)">
+      <summary>
+              Copies all arguments values to the specified <see cref="T:System.Array" /> starting at the specified destination <see cref="T:System.Array" /> index.
+            </summary>
+      <param name="array">The array that is the destination of argument values copied from the current <see cref="T:PostSharp.Aspects.Arguments" />.</param>
+      <param name="index">An integer that represents the index in <paramref name="array" /> at which copying begins</param>
+    </member>
+    <member name="P:PostSharp.Aspects.Arguments.Count">
+      <summary>
+              Gets the number of arguments encapsulated by the current object.
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.Arguments.Empty">
+      <summary>
+              Empty list of <see cref="T:PostSharp.Aspects.Arguments" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.GetArgument(System.Int32)">
+      <summary>
+              Gets the value of the argument at a given index.
+            </summary>
+      <param name="index">Argument index.</param>
+      <returns>The value of the argument at position <paramref name="index" />.</returns>
+      <exception cref="T:System.ArgumentOutOfRangeException">
+        <paramref name="index" /> is lower than zero or greater or equal than <see cref="P:PostSharp.Aspects.Arguments.Count" />.</exception>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.GetEnumerator">
+      <summary>Returns an enumerator that iterates through the collection.</summary>
+      <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.</returns>
+    </member>
+    <member name="P:PostSharp.Aspects.Arguments.Item(System.Int32)">
+      <summary>
+              Gets or sets the value of an argument.
+            </summary>
+      <param name="index">Argument index.</param>
+      <returns>The argument value.</returns>
+      <exception cref="T:System.ArgumentOutOfRangeException">
+        <paramref name="index" /> is lower than zero or greater or equal than <see cref="P:PostSharp.Aspects.Arguments.Count" />.</exception>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.SetArgument(System.Int32,System.Object)">
+      <summary>
+              Sets the value of the argument at a given index.
+            </summary>
+      <param name="index">Argument index.</param>
+      <param name="value">New value of the argument at position <paramref name="index" />.</param>
+      <exception cref="T:System.InvalidCastException">
+        <paramref name="value" /> is not assignable to parameter
+              at position <paramref name="index" />.</exception>
+      <exception cref="T:System.ArgumentOutOfRangeException">
+        <paramref name="index" /> is lower than zero or greater or equal than <see cref="P:PostSharp.Aspects.Arguments.Count" />.</exception>
+    </member>
+    <member name="M:PostSharp.Aspects.Arguments.ToArray">
+      <summary>
+              Converts the current argument list into an <see cref="T:System.Array" />.
+            </summary>
+      <returns>An <see cref="T:System.Array" /> whose elements are equal to the values encapsulated by the current <see cref="T:PostSharp.Aspects.Arguments" />.</returns>
+    </member>
+    <member name="T:PostSharp.Aspects.Aspect">
+      <summary>
+            Base class for all aspects that are declared using multicast custom attributes (<see cref="T:PostSharp.Extensibility.MulticastAttribute" />).
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.Aspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.Aspect" /> class</summary>
+    </member>
+    <member name="P:PostSharp.Aspects.Aspect.AspectPriority">
+      <summary>
+              Gets or sets the weaving priority of the aspect.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.Aspect.CompileTimeValidate(System.Object)">
+      <summary>
+              Method invoked at build time to ensure that the aspect has been applied to the right target.
+            </summary>
+      <param name="target">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the aspect has been applied.</param>
+      <returns>
+        <c>true</c> if the aspect was applied to an acceptable target, otherwise
+              <c>false</c>.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.Aspect.CreateAspectConfiguration">
+      <summary>
+              Method invoked at build time to create a concrete <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> instance specifically
+              for the current <see cref="T:PostSharp.Aspects.Aspect" /> type.
+            </summary>
+      <returns>A new and empty instance of <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />, whose concrete type corresponds to
+              the concrete type of the <see cref="T:PostSharp.Aspects.Aspect" />.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.Aspect.GetAspectConfiguration(System.Object)">
+      <summary>
+              Method invoked at build tome to get the imperative configuration of the current <see cref="T:PostSharp.Aspects.Aspect" />.
+            </summary>
+      <param name="targetElement">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.Aspect" />
+              has been applied.
+            </param>
+      <returns>An <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> representing the imperative configuration
+              of the current <see cref="T:PostSharp.Aspects.Aspect" />.</returns>
+    </member>
+    <member name="P:PostSharp.Aspects.Aspect.SerializerType">
+      <summary>
+              Gets or sets the <see cref="T:System.Type" /> of the serializer (a type derived
+              from <see cref="T:PostSharp.Aspects.Serialization.AspectSerializer" />) used to serialize the aspect instance
+              at build time and deserialize it at runtime.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.Aspect.SetAspectConfiguration(PostSharp.Aspects.Configuration.AspectConfiguration,System.Object)">
+      <summary>
+              Method invoked at build time to set up an <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> object according to the current 
+              <see cref="T:PostSharp.Aspects.Aspect" /> instance and a specified target element of the current aspect.
+            </summary>
+      <param name="aspectConfiguration">The <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> instance previously returned  by the
+              <see cref="M:PostSharp.Aspects.Aspect.CreateAspectConfiguration" /> method.</param>
+      <param name="targetElement">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.Aspect" />
+              has been applied.
+            </param>
+    </member>
+    <member name="T:PostSharp.Aspects.AspectInfo">
+      <summary>
+              Reserved for future usage.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectInfo.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.AspectInfo" /> class</summary>
+    </member>
+    <member name="T:PostSharp.Aspects.AspectInstance">
+      <summary>
+              Completely specifies an aspect instance, including its target code element. An <see cref="T:PostSharp.Aspects.AspectInstance" />
+              contains either the aspect instance itself (<see cref="T:PostSharp.Aspects.Aspect" /> property), either information allowing to construct the aspect 
+              (<see cref="P:PostSharp.Aspects.AspectSpecification.AspectConstruction" />) and configure the weaver (<see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />).
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectInstance.#ctor(System.Object,PostSharp.Aspects.IAspect)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.AspectInstance" /> from a runtime aspect instance (<see cref="T:PostSharp.Aspects.IAspect" />).
+            </summary>
+      <param name="targetElement">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.AspectInstance" />
+              is applied.</param>
+      <param name="aspect">The aspect runtime instance.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectInstance.#ctor(System.Object,PostSharp.Aspects.IAspect,PostSharp.Aspects.Configuration.AspectConfiguration)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.AspectInstance" /> from a runtime aspect instance (<see cref="T:PostSharp.Aspects.IAspect" />)
+              and its <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />.
+            </summary>
+      <param name="targetElement">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.AspectInstance" />
+              is applied.</param>
+      <param name="aspect">The aspect runtime instance.</param>
+      <param name="aspectConfiguration">The aspect configuration (the type of this parameter should be equal to the
+              type configuration objects expected by the concrete <paramref name="aspect" />).</param>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectInstance.#ctor(System.Object,PostSharp.Reflection.ObjectConstruction,PostSharp.Aspects.Configuration.AspectConfiguration)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.AspectInstance" /> from
+            </summary>
+      <param name="targetElement">Code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.AspectInstance" />
+              is applied.</param>
+      <param name="aspectConstruction">An <see cref="T:PostSharp.Reflection.ObjectConstruction" /> instructing how the aspect instance
+              should be constructed.</param>
+      <param name="aspectConfiguration">An optional configuration object whose type corresponds to 
+              the the aspect type.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectInstance.TargetElement">
+      <summary>
+              Gets the code element (<see cref="T:System.Runtime.InteropServices._Assembly" />, <see cref="T:System.Type" />, 
+              <see cref="T:System.Reflection.FieldInfo" />, <see cref="T:System.Reflection.MethodBase" />, <see cref="T:System.Reflection.PropertyInfo" />, <see cref="T:System.Reflection.EventInfo" />, 
+              <see cref="T:System.Reflection.ParameterInfo" />, or <see cref="T:PostSharp.Reflection.LocationInfo" />) to which the current <see cref="T:PostSharp.Aspects.AspectInstance" />
+              is applied.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.AspectSpecification">
+      <summary>
+              Completely specifies an aspect instance (but not its target). An <see cref="T:PostSharp.Aspects.AspectSpecification" /> either the aspect instance itself 
+              (<see cref="P:PostSharp.Aspects.AspectSpecification.Aspect" /> property), either information allowing to construct the aspect (<see cref="P:PostSharp.Aspects.AspectSpecification.AspectConstruction" />) and configure the weaver (<see cref="P:PostSharp.Aspects.AspectSpecification.AspectConfiguration" />).
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectSpecification.#ctor(PostSharp.Reflection.ObjectConstruction,PostSharp.Aspects.Configuration.AspectConfiguration)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.AspectSpecification" /> when one cannot provide an aspect instance,
+              i.e. from an <see cref="T:PostSharp.Reflection.ObjectConstruction" /> and a <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />.
+            </summary>
+      <param name="aspectConstruction">Aspect construction.</param>
+      <param name="aspectConfiguration">Aspect configuration.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectSpecification.Aspect">
+      <summary>
+              Gets the aspect instance.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectSpecification.AspectAssemblyQualifiedTypeName">
+      <summary>
+              Gets the assembly-qualified type name of the aspect.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectSpecification.AspectConfiguration">
+      <summary>
+              Gets the aspect configuration.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectSpecification.AspectConstruction">
+      <summary>
+              Gets the aspect construction.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.AspectSpecification.AspectTypeName">
+      <summary>
+              Gets the type name of the aspect.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.AspectUtilities">
+      <summary>
+              Utility methods for <c>PostSharp.Aspects</c>.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectUtilities.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.AspectUtilities" /> class</summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectUtilities.GetCurrentInstanceCredentials">
+      <summary>
+              Gets the <see cref="T:PostSharp.Aspects.InstanceCredentials" /> of the calling instance. This method must be
+              invoked from an instance method (not a static method) of a type that has been enhanced
+              by an aspect.
+            </summary>
+      <returns>The <see cref="T:PostSharp.Aspects.InstanceCredentials" /> of the calling instance.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.AspectUtilities.InitializeCurrentAspects">
+      <summary>
+              Initializes the all the aspects of the calling instance. This method must be
+              invoked from an instance method (not a static method) of a type that has been enhanced
+              by an aspect.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.AssemblyLevelAspect">
+      <summary>
+            Base class for all aspects applied on assemblies.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AssemblyLevelAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.AssemblyLevelAspect" /> class</summary>
+    </member>
+    <member name="M:PostSharp.Aspects.AssemblyLevelAspect.CompileTimeInitialize(System.Runtime.InteropServices._Assembly,PostSharp.Aspects.AspectInfo)">
+      <summary>
+              Method invoked at build time to initialize the instance fields of the current aspect. This method is invoked
+              before any other build-time method.
+            </summary>
+      <param name="assembly">Assembly to which the current aspect is applied</param>
+      <param name="aspectInfo">Reserved for future usage.</param>
+    </member>
+    <member name="T:PostSharp.Aspects.CompositionAspect">
+      <summary>
+            Aspect that, when applied on a type, introduces one or many new interfaces
+            into that type. 
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.CompositionAspect" /> class</summary>
+    </member>
+    <member name="P:PostSharp.Aspects.CompositionAspect.AncestorOverrideAction">
+      <summary>
+              Specifies the action (<see cref="F:PostSharp.Aspects.Advices.InterfaceOverrideAction.Fail" /> or <see cref="F:PostSharp.Aspects.Advices.InterfaceOverrideAction.Ignore" />)
+              to be overtaken when an <i>ancestor</i> of one of the interfaces returned by <see cref="M:PostSharp.Aspects.CompositionAspect.GetPublicInterfaces(System.Type)" />
+              is already implemented by the type to which the current aspect is applied.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.CreateAspectConfiguration">
+      <summary>
+              Method invoked at build time to create a concrete <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> instance specifically
+              for the current <see cref="T:PostSharp.Aspects.Aspect" /> type.
+            </summary>
+      <returns>A new and empty instance of <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />, whose concrete type corresponds to
+              the concrete type of the <see cref="T:PostSharp.Aspects.Aspect" />.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.CreateImplementationObject(PostSharp.Aspects.AdviceArgs)">
+      <summary>
+              Method invoked at runtime, during the initialization of instances of the target type,
+              to create the composed object.
+            </summary>
+      <param name="args">
+        <p style="color: #dc143c; font-size: 8.5pt; font-weight: bold;">[Missing &lt;param name="args"/&gt; documentation for "M:PostSharp.Aspects.CompositionAspect.CreateImplementationObject(PostSharp.Aspects.AdviceArgs)"]</p>
+      </param>
+      <returns>The composed object. This interface should implement the interfaces specified
+              by the <see cref="M:PostSharp.Aspects.CompositionAspect.GetPublicInterfaces(System.Type)" /> and 
+              <see cref="M:PostSharp.Aspects.CompositionAspect.GetProtectedInterfaces(System.Type)" /> methods.</returns>
+    </member>
+    <member name="P:PostSharp.Aspects.CompositionAspect.GenerateImplementationAccessor">
+      <summary>
+              Determines whether the interface <see cref="T:PostSharp.Aspects.IComposed`1" /> should be introduced into the type to which the aspect
+              is applied for each interface returned by the <see cref="M:PostSharp.Aspects.CompositionAspect.GetPublicInterfaces(System.Type)" /> method.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.GetProtectedInterfaces(System.Type)">
+      <summary>
+              Gets the array of interfaces to be introduced indirectly into
+              the target type of the current aspect. These interfaces will
+              become accessible through the <see cref="T:PostSharp.Aspects.IProtectedInterface`1" /> 
+              interface.
+            </summary>
+      <param name="targetType">
+        <see cref="T:System.Type" /> to which the current aspect is applied.</param>
+      <returns>The array of interfaces that should be introduced indirectly into <see cref="T:System.Type" /><paramref name="targetType" />, or <c>null</c> if no interface should be introduced indirectly.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.GetPublicInterfaces(System.Type)">
+      <summary>
+              Gets the array of interfaces that should be introduced publicly into
+              the target type of the current aspect.
+            </summary>
+      <param name="targetType">
+        <see cref="T:System.Type" /> to which the current aspect is applied.</param>
+      <returns>The array of interfaces that should be introduced publicly into <see cref="T:System.Type" /><paramref name="targetType" />, or <c>null</c> if no interface should
+              be introduced publicly.</returns>
+    </member>
+    <member name="P:PostSharp.Aspects.CompositionAspect.NonSerializedImplementation">
+      <summary>
+              Determines whether the field containing the interface implementation (and storing the object returned by
+              <see cref="M:PostSharp.Aspects.CompositionAspect.CreateImplementationObject(PostSharp.Aspects.AdviceArgs)" />) should be excluded from serialization by <see cref="T:System.Runtime.Serialization.Formatters.Binary.BinaryFormatter" />.
+              The same effect is typically obtained by applying the <see cref="T:System.NonSerializedAttribute" /> custom attribute to the field.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.CompositionAspect.OverrideAction">
+      <summary>
+              Specifies the action (<see cref="F:PostSharp.Aspects.Advices.InterfaceOverrideAction.Fail" /> or <see cref="F:PostSharp.Aspects.Advices.InterfaceOverrideAction.Ignore" />)
+              to be overtaken when one of the interfaces returned by <see cref="M:PostSharp.Aspects.CompositionAspect.GetPublicInterfaces(System.Type)" /> or <see cref="M:PostSharp.Aspects.CompositionAspect.GetProtectedInterfaces(System.Type)" />
+              is already implemented by the type to which the current aspect is applied.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.CompositionAspect.SetAspectConfiguration(PostSharp.Aspects.Configuration.AspectConfiguration,System.Type)">
+      <summary>
+              Method invoked at build time to set up an <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> object according to the current 
+              <see cref="T:PostSharp.Aspects.Aspect" /> instance and a specified target element of the current aspect.
+            </summary>
+      <param name="aspectConfiguration">The <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> instance previously returned  by the
+              <see cref="M:PostSharp.Aspects.Aspect.CreateAspectConfiguration" /> method.</param>
+      <param name="targetType">Type to which the current aspect has been applied.</param>
+    </member>
+    <member name="T:PostSharp.Aspects.CustomAttributeIntroductionAspect">
+      <summary>
+              Aspect that, when applied to a target, adds a custom attribute to this target.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.CustomAttributeIntroductionAspect.#ctor(PostSharp.Reflection.ObjectConstruction)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.CustomAttributeIntroductionAspect" /> by specifying an <see cref="T:PostSharp.Reflection.ObjectConstruction" />.
+            </summary>
+      <param name="attribute">Construction of the custom attribute to be added to the target.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.CustomAttributeIntroductionAspect.#ctor(System.Reflection.CustomAttributeData)">
+      <summary>
+              Initializes a new <see cref="T:PostSharp.Aspects.CustomAttributeIntroductionAspect" /> by specifying a
+              <see cref="T:System.Reflection.CustomAttributeData" />.
+            </summary>
+      <param name="customAttributeData">Construction of the custom attribute to be added to the target.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.CustomAttributeIntroductionAspect.CustomAttribute">
+      <summary>
+              Gets the construction of the custom attribute that must be applied to the target of this aspect.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.EventInterceptionArgs">
+      <summary>
+              Arguments of handlers of aspects of the type <see cref="T:PostSharp.Aspects.EventInterceptionAspect" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.AddHandler(System.Delegate)">
+      <summary>
+              Adds a handler to the event by invoking the <c>Add</c> semantic of the next node in the chain of invocation.
+            </summary>
+      <param name="handler">The handler to add to the event.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.EventInterceptionArgs.Arguments">
+      <summary>
+              Gets the delegate arguments.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.EventInterceptionArgs.Binding">
+      <summary>
+              Gets an interface that allows to invoke the next node in the chain of invocation of the intercepted method.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.EventInterceptionArgs.Event">
+      <summary>
+              Gets the event to which the current aspect has been applied.
+            </summary>
+    </member>
+    <member name="P:PostSharp.Aspects.EventInterceptionArgs.Handler">
+      <summary>
+              Gets the delegate being added, removed, or invoked.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.InvokeHandler(System.Delegate,PostSharp.Aspects.Arguments)">
+      <summary>
+              Invokes a handler by calling the <c>Invoke</c> semantic of the next node in the chain of invocation.
+            </summary>
+      <param name="handler">Handler to be invoked.</param>
+      <param name="arguments">Arguments passed to the handler.</param>
+      <returns>Return value of the handler.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.ProceedAddHandler">
+      <summary>
+              Proceeds with adding the <see cref="T:System.Delegate" /> to the event to which the current aspect. 
+              This method invokes the next handler in chain. 
+              It is typically invoked from the implementation of <see cref="M:PostSharp.Aspects.IEventInterceptionAspect.OnAddHandler(PostSharp.Aspects.EventInterceptionArgs)" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.ProceedInvokeHandler">
+      <summary>
+              Proceeds with invoking the <see cref="T:System.Delegate" /> with the arguments specified in the <see cref="P:PostSharp.Aspects.EventInterceptionArgs.Arguments" /> property.
+              The delegate may change the <see cref="P:PostSharp.Aspects.EventInterceptionArgs.Arguments" /> and set the <see cref="P:PostSharp.Aspects.EventInterceptionArgs.ReturnValue" />.
+              This method invokes the next handler in chain. 
+              It is typically invoked from the implementation of <see cref="M:PostSharp.Aspects.IEventInterceptionAspect.OnInvokeHandler(PostSharp.Aspects.EventInterceptionArgs)" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.ProceedRemoveHandler">
+      <summary>
+              Proceeds with removing the <see cref="T:System.Delegate" /> from the event to which the current aspect. 
+              This method invokes the next handler in chain. 
+              It is typically invoked from the implementation of <see cref="M:PostSharp.Aspects.IEventInterceptionAspect.OnRemoveHandler(PostSharp.Aspects.EventInterceptionArgs)" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionArgs.RemoveHandler(System.Delegate)">
+      <summary>
+              Removes a handler from the event by invoking the <c>Remove</c> semantic of the next node in the chain of invocation.
+            </summary>
+      <param name="handler">Handler to be removed.</param>
+    </member>
+    <member name="P:PostSharp.Aspects.EventInterceptionArgs.ReturnValue">
+      <summary>
+              Gets the return value of the delegate.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.EventInterceptionAspect">
+      <summary>
+            Aspect that, when applied on an event, intercepts invocations of its semantics <c>Add</c> (<see cref="M:PostSharp.Aspects.EventInterceptionAspect.OnAddHandler(PostSharp.Aspects.EventInterceptionArgs)" />), 
+            <c>Remove</c> (<see cref="M:PostSharp.Aspects.EventInterceptionAspect.OnRemoveHandler(PostSharp.Aspects.EventInterceptionArgs)" />) and <c>Invoke</c> (<see cref="M:PostSharp.Aspects.EventInterceptionAspect.OnInvokeHandler(PostSharp.Aspects.EventInterceptionArgs)" />).
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.EventInterceptionAspect" /> class</summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionAspect.CreateAspectConfiguration">
+      <summary>
+              Method invoked at build time to create a concrete <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" /> instance specifically
+              for the current <see cref="T:PostSharp.Aspects.Aspect" /> type.
+            </summary>
+      <returns>A new and empty instance of <see cref="T:PostSharp.Aspects.Configuration.AspectConfiguration" />, whose concrete type corresponds to
+              the concrete type of the <see cref="T:PostSharp.Aspects.Aspect" />.</returns>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionAspect.OnAddHandler(PostSharp.Aspects.EventInterceptionArgs)">
+      <summary>
+              Method invoked <i>instead</i> of the <c>Add</c> semantic of the event to which the current aspect is applied,
+              i.e. when a new delegate is added to this event.
+            </summary>
+      <param name="args">Handler arguments.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionAspect.OnInvokeHandler(PostSharp.Aspects.EventInterceptionArgs)">
+      <summary>
+              Method invoked when the event to which the current aspect is applied is fired, <i>for each</i> delegate
+              of this event, and <i>instead of</i> invoking this delegate.
+            </summary>
+      <param name="args">Handler arguments.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.EventInterceptionAspect.OnRemoveHandler(PostSharp.Aspects.EventInterceptionArgs)">
+      <summary>
+              Method invoked <i>instead</i> of the <c>Remove</c> semantic of the event to which the current aspect is applied,
+              i.e. when a delegate is removed from this event.
+            </summary>
+      <param name="args">Handler arguments.</param>
+    </member>
+    <member name="T:PostSharp.Aspects.EventLevelAspect">
+      <summary>
+            Base class for all aspects applied on events.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventLevelAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.EventLevelAspect" /> class</summary>
+    </member>
+    <member name="M:PostSharp.Aspects.EventLevelAspect.CompileTimeInitialize(System.Reflection.EventInfo,PostSharp.Aspects.AspectInfo)">
+      <summary>
+              Method invoked at build time to initialize the instance fields of the current aspect. This method is invoked
+              before any other build-time method.
+            </summary>
+      <param name="targetEvent">Event to which the current aspect is applied</param>
+      <param name="aspectInfo">Reserved for future usage.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.EventLevelAspect.RuntimeInitialize(System.Reflection.EventInfo)">
+      <summary>
+              Initializes the current aspect.
+            </summary>
+      <param name="eventInfo">Event to which the current aspect is applied.</param>
+    </member>
+    <member name="T:PostSharp.Aspects.ExternalAspect">
+      <summary>
+              Aspect implemented in a different type (implementing the <see cref="T:PostSharp.Aspects.IExternalAspectImplementation" />
+              interface), typically contained in an external assembly. Classes derived from <see cref="T:PostSharp.Aspects.ExternalAspect" />
+              must be annotated by the custom attribute <see cref="T:PostSharp.Aspects.Configuration.ExternalAspectConfigurationAttribute" />.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.ExternalAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.ExternalAspect" /> class</summary>
+    </member>
+    <member name="T:PostSharp.Aspects.FieldLevelAspect">
+      <summary>
+            Base class for all aspects applied on fields.
+            </summary>
+    </member>
+    <member name="M:PostSharp.Aspects.FieldLevelAspect.#ctor">
+      <summary>Initializes a new instance of the <see cref="T:PostSharp.Aspects.FieldLevelAspect" /> class</summary>
+    </member>
+    <member name="M:PostSharp.Aspects.FieldLevelAspect.CompileTimeInitialize(System.Reflection.FieldInfo,PostSharp.Aspects.AspectInfo)">
+      <summary>
+              Method invoked at build time to initialize the instance fields of the current aspect. This method is invoked
+              before any other build-time method.
+            </summary>
+      <param name="field">Field to which the current aspect is applied</param>
+      <param name="aspectInfo">Reserved for future usage.</param>
+    </member>
+    <member name="M:PostSharp.Aspects.FieldLevelAspect.RuntimeInitialize(System.Reflection.FieldInfo)">
+      <summary>
+              Method invoked at runtime before any other method of the aspect is invoked.
+            </summary>
+      <param name="field">Field on which this instance is applied.</param>
+    </member>
+    <member name="T:PostSharp.Aspects.FlowBehavior">
+      <summary>
+              Enumerates the possible behaviors of the calling method after the calling method has returned.
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.FlowBehavior.Default">
+      <summary>
+              Default flow behavior for the current method. For <b>OnEntry</b> or <b>OnExit</b>, the fault flow is
+              <see cref="F:PostSharp.Aspects.FlowBehavior.Continue" />, for <b>OnException</b> it is <see cref="F:PostSharp.Aspects.FlowBehavior.RethrowException" />.
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.FlowBehavior.Continue">
+      <summary>
+              Continue normally (in an <b>OnException</b> advice, does not rethrow the exception).
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.FlowBehavior.RethrowException">
+      <summary>
+              The current exception will be rethrown. Available only for <b>OnException</b>.
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.FlowBehavior.Return">
+      <summary>
+              Return immediately from the current method. Available only for <b>OnEntry</b> and
+              <b>OnException</b>. Note that you may want to set the <see cref="P:PostSharp.Aspects.MethodExecutionArgs.ReturnValue" />
+              property, otherwise you may get a <see cref="T:System.NullReferenceException" />.
+            </summary>
+    </member>
+    <member name="F:PostSharp.Aspects.FlowBehavior.ThrowException">
+      <summary>
+            Throws the exception contained in <see cref="P:PostSharp.Aspects.MethodExecutionArgs.Exception" />. Available only for <c>OnException</c>.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.IAspect">
+      <summary>
+              Base interface for run-time semantics of all aspects.
+            </summary>
+    </member>
+    <member name="T:PostSharp.Aspects.IAspectBuildSemantics">
+      <summary>
+              Compile-time semantics of <see cref="T:PostSharp.Aspects.IAspect" />.
+            </summary>
+    </member>