The Curious Engineer

All blogs / C# / .NET

Eric White's Blog

learn.microsoft.com/en-us/archive/blogs/ericwhite

C# / .NETDev tools / editors / IDEsCompilersMicrosoft blogsMSDN archive

’10’15’20’25
Posts
421 from 25 Apr 2006 to 19 Jan 2011
Posting
archived, read-only
Kind
personal blog
Feed
https://learn.microsoft.com/en-us/archive/blogs/ericwhite/feed.xml

2011 1

  1. Leaving Microsoft, Blog Moving to EricWhite.com

2010 88

  1. Using the OData Rest API for CRUD Operations on a SharePoint List
  2. Comparing Excel Automation to Excel Services
  3. Microsoft Word 2010 Developer Building Blocks
  4. How to Install and Activate the IW Demo/Evaluation Hyper-V Machine
  5. Getting Started using the OData REST API to Query a SharePoint List
  6. Understanding the Difference between Custom Task Panes and Action Panes
  7. Understanding the Architecture of Office 2010 Managed Add-Ins and Customizations
  8. What is the Difference between ‘Word Automation’ and ‘Word Automation Services’?
  9. Understanding the Three Approaches to Office Development using VSTO
  10. Office Application Scenarios
  11. Overview of Office 2010 Application Development
  12. Office/SharePoint Building Blocks and Developer Stories
  13. Easy SharePoint 2010 Setup for Developers on Windows 7
  14. SharePoint Developer Building Blocks: Technologies for Creating SharePoint Applications
  15. Building a Simple Recursive Descent Parser (Completed Simple Parser)
  16. Building a Simple Recursive Descent Parser (continued)
  17. Building a Simple Recursive Descent Parser
  18. Table Markup in Open XML SpreadsheetML
  19. Writing and Hosting a Web Service in the SharePoint 2010 Demo Virtual Machine
  20. Creating a Collection from Singletons and Collections using LINQ
  21. Recursive Descent Parser: A Simple Grammar
  22. Exploring the BCS Metadata Schema
  23. Great Video on JavaScript by Douglas Crockford
  24. Recursive Descent Parser using LINQ: The Augmented Backus-Naur Form Grammar
  25. Processing all Content Parts in an Open XML WordprocessingML Document
  26. Microsoft patterns and practices: Developing Applications for SharePoint 2010
  27. Writing a Recursive Descent Parser using C# and LINQ
  28. Khan Academy: Free Lectures on Math, Physics, Biology, Economics, and History
  29. Open XML Package Editor Power Tool for Visual Studio 2010
  30. Consuming a Claims-Enabled WCF Web Service as a SharePoint 2010 External Content Type
  31. Establishing Trust between a WCF Web Service and the SharePoint 2010 Security Token Service
  32. Access denied by Business Data Connectivity
  33. Job Opening in our Group at Microsoft
  34. MSDN Blog Platform Upgrade
  35. Determining Caller Identity within a WCF Web Service
  36. Getting Started Building a WCF Web Service
  37. Removing Speaker Notes from a set of PowerPoint Presentations
  38. SharePoint Interoperability Event
  39. Searching External Data in SharePoint 2010 Using Business Connectivity Services
  40. Office 2010 Reaches RTM
  41. Controlling Namespace Serialization of LINQ to XML
  42. Using the Open XML SDK from within a Managed Add-In
  43. Determining if an Open XML WordprocessingML Document contains Tracked Changes
  44. Support for ISO/IEC 29500 Strict in Microsoft Office
  45. Using Content Controls to give Semantic Meaning to Content in Open XML WordprocessingML Documents
  46. SharePoint 2010 and Office 2010 Videos from the SharePoint Conference 2009
  47. Testing for Base Styles in Open XML WordprocessingML Documents
  48. Assembling Documents on SharePoint 2010 Sites by Merging Content from Excel, PowerPoint, and Word
  49. Bandwidth-Adjusting Videos on MSDN
  50. Modifying an Open XML Document in a SharePoint Document Library
  51. Developing with SharePoint 2010 Word Automation Services
  52. Using Word Automation Services with the Open XML SDK using VB
  53. Using Word Automation Services with the Open XML SDK using C#
  54. Word Automation Services: Deleting Source Files after Conversion using VB
  55. Word Automation Services: Deleting Source Files after Conversion using C#
  56. Word Automation Services: Determining Which Documents Failed to Convert using VB
  57. Word Automation Services: Determining Which Documents Failed to Convert using C#
  58. Word Automation Services: Monitoring Status of Conversion Jobs using VB
  59. Word Automation Services: Monitoring Status of Conversion Jobs using C#
  60. Claims-based Identity and Access Control Resources
  61. Release of the Open XML SDK 2.0 for Microsoft Office
  62. Hex Dump using LINQ (in 7 Lines of Code)
  63. Formats Supported for altChunk
  64. Ad-Hoc String Concatenation using LINQ
  65. Reducing Connaissance (Interconnectedness) and Increasing Robustness using LINQ
  66. Serializing Encoded XML Documents using LINQ to XML
  67. Convert XDocument to XmlDocument (and Convert XmlDocument to XDocument)
  68. Validate Open XML Documents using the Open XML SDK 2.0
  69. Using Nested Content Controls for Data and Content Extraction from Open XML WordprocessingML Documents
  70. Transforming WordprocessingML to Simpler XML for Easier Processing
  71. ListItemRetriever: Accurately Retrieving Text of a Open XML WordprocessingML Paragraph
  72. Rollup Extension Method: Create Running Totals using LINQ to Objects
  73. Retrieving the Default Style Name of an Open XML WordprocessingML Document
  74. Office 2010 Application Compatibility Tools Bug Hunt
  75. Enabling Better Transformations by Simplifying Open XML WordprocessingML Markup
  76. Increasing Performance of Word Automation for large amount of data using Open Xml SDK
  77. HtmlConverter: Transform Open XML WordprocessingML to XHtml
  78. Programmatically Limiting Styles in Word
  79. Links - January 25, 2010
  80. Inserting Content That Contains Images Using altChunk
  81. Writing Entity References using LINQ to XML
  82. LogicalChildrenContent Axis Methods - Open XML SDK V2 Strongly Typed Object Model
  83. LogicalChildrenContent Axis Methods - LINQ to XML
  84. Mastering Text in Open XML Word-Processing Documents
  85. Simplifying Open XML WordprocessingML Queries by First Accepting Revisions
  86. Updated DocumentBuilder to work with Dec09 CTP of Open XML SDK V2
  87. How to Control Sections when using OpenXml.PowerTools.DocumentBuilder
  88. Fifty SharePoint 2010 End User / Site Administrator Training Videos

2009 96

  1. Accepting Revisions in Open XML WordprocessingML Documents
  2. Working with Numbering in Open XML WordprocessingML
  3. Implementing 'Inheritance' in XML
  4. Using the SharePoint 2010 Client OM with Open XML – Convert Wiki Page to Open XML Document
  5. Using the SharePoint 2010 Client OM with Open XML – Extract Contents of a Wiki Page
  6. Using the SharePoint 2010 Client OM with Open XML – Processing all Documents in a Document Library
  7. Using the SharePoint 2010 Client OM with Open XML - Creating a Document
  8. Using the SharePoint 2010 Client OM with Open XML - Uploading a Document
  9. Using the SharePoint 2010 Client OM with Open XML - Modifying a Document
  10. Using the SharePoint 2010 Client OM with Open XML - Retrieving a Document
  11. Using the SharePoint 2010 Client Object Model with Open XML
  12. Using the SharePoint 2010 Managed Client Object Model – Asynchronous Processing
  13. Using the SharePoint 2010 Managed Client Object Model – Accessing Large Lists
  14. Using the SharePoint 2010 Managed Client Object Model – Discovering the Schema for Fields
  15. Using the SharePoint 2010 Managed Client Object Model – Delete a List
  16. Using the SharePoint 2010 Managed Client Object Model – Deleting Client Objects
  17. Using the SharePoint 2010 Managed Client Object Model – Updating Client Objects
  18. Using the SharePoint 2010 Managed Client Object Model – Filtering the Child Collection returned by LoadQuery using LINQ
  19. Using the SharePoint 2010 Managed Client Object Model – Increasing Performance by Nesting Includes in LoadQuery
  20. Using the SharePoint 2010 Managed Client Object Model – Using the LoadQuery Method
  21. Using the SharePoint 2010 Managed Client Object Model – Filtering the Child Collection returned by Load using LINQ
  22. Using the SharePoint 2010 Managed Client Object Model – Using CAML to Query a List
  23. Using the SharePoint 2010 Managed Client Object Model – Creating and Populating a List
  24. Using the SharePoint 2010 Managed Client Object Model – Trimming Result Sets using Lambda Expressions
  25. Using the SharePoint 2010 Managed Client Object Model – Object Identity Second Example
  26. Using the SharePoint 2010 Managed Client Object Model – Object Identity
  27. Using the SharePoint 2010 Managed Client Object Model – First Example
  28. Using the SharePoint 2010 Managed Client Object Model
  29. Availability of Public Office 2010 and SharePoint 2010 Betas
  30. Assembling Paragraph and Run Properties for Cells in an Open XML WordprocessingML Table
  31. SharePoint 2010 and Office 2010 Developer Training Courses Launched on Channel 9
  32. Comparison of Html/CSS Tables to WordprocessingML Tables (Post #5)
  33. Open XML WordprocessingML Style Inheritance (Post #4)
  34. Transforming Open XML Word-Processing Documents to Html (Post #3)
  35. Transforming Open XML Word-Processing Documents to XHtml (Post #2)
  36. Generating Documents from SharePoint Lists using Open XML Content Controls
  37. Transforming Open XML Word-Processing Documents to XHtml
  38. New Open XML Developer Center on MSDN
  39. Source Code Available: Complete Implementation of 'Accept All Changes (Tracked Revisions) in Open XML Documents'
  40. Essentials of the Open Packaging Conventions (OPC), and other Open XML Links
  41. DescendantsAndSelfTrimmed LINQ to XML Axis Method
  42. XML Element and Attribute Name Guidelines
  43. Update to CommentMerger.MergeComments Method
  44. Merging Comments from Multiple Open XML Documents into a Single Document
  45. "Object library invalid or contains references to object definitions that could not be found" or "Element not found"
  46. Recursive Approach to Pure Functional Transformations of XML
  47. Document-Centric Transforms using LINQ to XML
  48. Microsoft Promises No Patent Prosecution for the MONO Project
  49. Empty Elements and Self-Closing Tags
  50. Comparing Two Open XML Documents using the Zip Extension Method
  51. Binary to Open XML Translator, and Freeform Shapes in the Office Drawing Format
  52. Links – July 1, 2009
  53. Splitting Runs in Open XML Word Processing Document Paragraphs
  54. Querying LINQ to XML Nodes in Reverse Document Order with Better Performance
  55. Two Interesting Open XML Articles on OpenXmlDeveloper.org
  56. Links – May 28, 2009
  57. Links – May 15, 2009
  58. Working with Optional Elements and Attributes in LINQ to XML Queries
  59. Comparison of LINQ to XM and the Open XML SDK Strongly Typed OM
  60. Comparison of Navigating Parts between System.IO.Packaging and the Open XML SDK
  61. Comparison of Navigating Parts between System.IO.Packaging and the Open XML SDK
  62. Using PHP with Open XML Spreadsheet Documents
  63. Advanced Business User Promotion Content
  64. Links – April 29, 2009
  65. The Use of Extension Methods to Manage Open XML Document Changes in PowerTools for Open XML
  66. Using DocumentBuilder with Content Controls for Document Assembly
  67. Getting Started with PowerTools for Open XML Development
  68. Release of PowerTools for Open XML v1.1.1
  69. Comparison of altChunk to the DocumentBuilder Class
  70. Generalized Approach to Open XML Markup References
  71. Why I Don’t Use the ForEach Extension Method
  72. Generating a Custom Letter using PowerTools for Open XML and PowerShell
  73. SAVO Innovates with Open XML
  74. Interoperability at Microsoft
  75. Interrelated Markup in Open XML Word Processing Documents
  76. TextGlow: Silverlight Viewer for Open XML Word Processing Documents
  77. Announcing the Release of PowerTools for Open XML V1.1
  78. Two New Articles on Open XML: Using XSLT with Open XML Documents, and an Open XML Crawler
  79. DocX – Interesting Code for Manipulating Open XML Documents using the Open XML SDK V2
  80. Creating a Template Open XML Document in Memory
  81. Ease of Maintenance of LINQ Code (2)
  82. Computing Deep Hash Codes using LINQ to XML
  83. Ease of Maintenance of LINQ Code
  84. The Composability Thought Process for LINQ
  85. Finding Paragraphs by Style Name or Content in an Open XML Word Processing Document
  86. Seven Key Benefits of Open XML
  87. Office 2003 Support for Open XML
  88. Move/Insert/Delete Paragraphs in Word Processing Documents using the Open XML SDK
  89. Equality Semantics of LINQ to XML Trees
  90. Manually Cloning LINQ to XML Trees
  91. Microsoft Releases ECMA-376 Implementation Notes
  92. More SharePoint and Silverlight Samples
  93. Accepting Revisions, Removing Comments, and Removing Personal Info from a SharePoint Document Library using Web Services
  94. Modifying Open XML Documents that are in SharePoint Document Libraries using Web Services
  95. Getting Started with SharePoint Web Services using LINQ to XML
  96. Writing Succinct Code to move XElement and XAttribute Objects from One LINQ to XML Tree to Another

2008 167

  1. Align Attributes when Formatting XML using LINQ to XML
  2. Convert XElement to XmlNode (and Convert XmlNode to XElement)
  3. Ecma General Assembly Ratifies IS29500 as Ecma 376 v.2 Standard
  4. Microsoft Releases ODF Implementation Notes for Office 2007 SP2
  5. A More Robust Approach for Handling XName Objects in LINQ to XML
  6. Modifying Open XML Documents using the SharePoint Object Model
  7. Working with In-Memory Open XML Documents
  8. Assembling Multiple Word Documents into a Single Document using the Open XML SDK V2
  9. Architecture and Design of Windows Forms Custom Controls
  10. Joining LINQ to SQL and LINQ to Excel
  11. Office Business Applications (OBA)
  12. Functional Programming Tutorial for Visual Basic 9.0
  13. Complete Listing of ParseWordML - VB
  14. Conclusion - VB
  15. Filtering Out the Groups that we Don't Want - VB
  16. Retrieving the Two Code Groups - VB
  17. The Final Results - VB
  18. Refactoring using a Pure Function - VB
  19. Retrieving the Default Style Name from the Styles Part - VB
  20. Retrieving the Text of the Paragraphs - VB
  21. Retrieving the Paragraphs - VB
  22. Using the Open XML SDK - VB
  23. The Source Open XML Document - VB
  24. Printing the Parts of an Open XML Document - VB
  25. Programming in a Functional Style - VB
  26. Parsing XML from an Open XML Document - VB
  27. Aggregation - VB
  28. Pure Functions - VB
  29. Grouping - VB
  30. Implementing Iterators - VB
  31. Deferred Execution - VB
  32. Lazy Evaluation (and in contrast, Eager Evaluation) - VB
  33. Using Nominal Types for Tuples - VB
  34. Object and Collection Initializers - VB
  35. Projection
  36. Local Variable Type Inference
  37. Extension Methods
  38. Quick Intro to Query Expressions
  39. Lambda Expressions - VB
  40. An Example Presented in Both Coding Styles
  41. Contrast of FP to Traditional Object-Oriented Programming
  42. What this Tutorial Covers
  43. The Main Scenario for Functional Programming
  44. Introduction to the FP Tutorial for Visual Basic
  45. FP-Tutorial-VB
  46. Inner Join of Two Excel Tables
  47. Publication of ISO/IEC 29500 (Office Open XML)
  48. Detailed Description of PowerTools for Open XML cmdlets
  49. The SkipLast Extension Method
  50. Running SharePoint on Hyper-V
  51. Debugging LINQ Queries
  52. Remove Rsid Attributes and Elements before Comparing Open XML Documents
  53. Inserting / Deleting / Moving Paragraphs in Open XML Wordprocessing Documents
  54. Demo Files for the Open XML SDK Session at PDC
  55. Anders Hejlsberg Introduces C# 4.0 at PDC 2008
  56. How to Use altChunk for Document Assembly
  57. Great Hardware for SharePoint Development
  58. Comparing LINQ to XML and XPath
  59. Eric White's Blog Map
  60. Building an Office Business Application (OBA) that shows Integration of Office Client with SharePoint
  61. Fastest Start for LINQ to SQL
  62. SpreadsheetGear Announces Support for Open XML
  63. Open XML Adoption Numbers, and more from Zeyad Rajabi on Open XML SDK v2
  64. Build a Document Assembly Solution using Open XML SDK V2 in 5 Minutes
  65. Using LINQ to XML Events and Annotations to Track if an XML Tree has Changed
  66. Visual Studio Industry Partner Program
  67. SharePoint vs. File Servers
  68. SharePoint Development Tools
  69. Zeyad Rajabi Talks about the Open XML SDK V2
  70. Formatting LINQ Code
  71. Anders Hejlsberg Talks about C#, Mentions Dynamic Language Features for C# 4.0
  72. SharePoint Links
  73. Modifications to web.config for Debugging SharePoint Components
  74. LINQ to TEXT and LINQ to CSV
  75. Transforming Open XML Documents using XSLT
  76. Transforming Open XML Documents to Flat OPC Format
  77. Transforming Flat OPC Format to Open XML Documents
  78. The Flat OPC Format
  79. PowerTools for Open XML Installer and Award Winning PowerTools Scripts
  80. PDC 2008 – USB Hard Drive with All the Bits
  81. Introduction to SharePoint Development
  82. Are You Using PowerTools for Open XML?
  83. Bulk Convert DOC to DOCX
  84. How to Create a List of All Parts in an Open XML Document
  85. Congratulations to a Couple of Cool People
  86. PDC2008
  87. Open XML SDK V2 at PDC 2008
  88. Use INFER.EXE to Create XML Schemas
  89. Closures
  90. OpenXmlCodeTester: Validating Code in Open XML Documents
  91. New Spreadsheet cmdlets for PowerTools for Open XML
  92. Announcing the First CTP of Open XML SDK V2
  93. Using LINQ to XML to Retrieve Content Controls in Word 2007
  94. Using Microsoft Office Clients with Office Live Small Business (which is Based on SharePoint)
  95. Chunking a Collection into Groups of Three
  96. Use a Lambda Expression for an Event Handler
  97. Find Duplicates using LINQ
  98. Object Dumper: An Invaluable Tool for Writing Code in the Functional Programming Style
  99. SharePoint Integration with Dynamics CRM
  100. Disaster Recovery Planning for SharePoint
  101. Running an Executable and Collecting the Output
  102. Using PowerTools for Open XML in a Workflow
  103. Interesting Interview of Oliver Bell: Developer Interest Fueling Open XML
  104. SharePoint: Content Management vs. Collaboration
  105. Version 1.2 of Open XML Diff Released
  106. Using PowerTools for Open XML from C#
  107. Are Developers Using LINQ? (Part 2)
  108. Are Developers Using LINQ?
  109. Removing Comments and Personal Information, and Accepting Revisions in an Open XML Document Stored in SharePoint
  110. Diving Into SharePoint Development
  111. Where is XmlLite.h?
  112. A New Version of OpenXmlDiff (with a Graphical User Interface)
  113. Use PowerShell to Secure and Sign Open XML Documents
  114. Writing Robust LINQ to XML Code that Performs Well
  115. Using the Open XML SDK and LINQ to XML to Remove Comments from an Open XML Wordprocessing Document
  116. Using the Open XML SDK and LINQ to XML to Remove Personal Information from an Open XML Wordprocessing Document
  117. Using the Open XML SDK and LINQ to XML to Accept Revisions in an Open XML Wordprocessing Document
  118. Applying Consistent Styles to Documents
  119. How to Create Hierarchy from Flat Data using LINQ
  120. PowerShell, System.IO.Packaging, and Open XML
  121. Open XML SDK and LINQ to XML
  122. PowerTools for Open XML: Binary Install Available
  123. Using Annotations to Transform LINQ to XML Trees in an XSLT Style (Improved Approach)
  124. PowerTools Script that Generates a Table in an Open XML Document
  125. ARGH! Update to Update to OpenXmlDiff.Exe
  126. Update to OpenXmlDiff.Exe
  127. OpenXmlDiff.Exe: A Utility to Find the Differences Between Two Open XML Documents
  128. Automated Processing of Open XML Documents using PowerShell
  129. PowerTools How-To Documentation
  130. PowerTools for Open XML Technical Overview
  131. PowerTools Screen Casts
  132. PowerTools temp download page
  133. Video080607
  134. PowerTools
  135. Thoughts on Technical Writing for a Large Audience
  136. Microsoft Announces Support for More Document Format Standards, including ODF
  137. SharePoint at the Intersection
  138. Using Power Tools for Video Studio to Modify Open XML Documents
  139. New Version of Functional Programming Tutorial
  140. Retrieving the Two Code Groups
  141. Retrieving the Default Style Name from the Styles Part
  142. Coding Style
  143. Using the Open XML SDK
  144. Printing the Parts of an Open XML Document
  145. The Source Open XML Document
  146. Parsing XML from an Open XML Document
  147. Grouping
  148. Deferred Execution
  149. Using Nominal Types for Tuples
  150. Projection
  151. An Example Presented in Both Coding Styles
  152. Contrast of FP to Traditional Object-Oriented Programming
  153. The Main Scenario for Functional Programming
  154. The GroupAdjacent Extension Method
  155. New Version of the Open XML SDK is Available for Download
  156. Standards Norway Responds to Allegations
  157. Czech Republic Votes Yes on DIS 29500
  158. Technical Improvements in the Open XML SDK
  159. Spreadsheet KPart Simulation
  160. Spreadsheet Simulation Demonstrating an Embedded KPart on Linux
  161. An Analysis of the ODF Alliance's "Top 10 Worst Dispositions"
  162. The Legacy Hashing Algorithm in Open XML
  163. ThinkFree: A Cool Implementation of Open XML
  164. An Approach to Reading Specifications Quickly
  165. Hashing of Passwords in the Open XML File Format
  166. Why I Took This Job
  167. How to Extract Comments from Open XML Documents

2007 28

  1. What is the Difference Between the System.IO.Packaging and DocumentFormat.OpenXml.Packaging Namespaces?
  2. Using LINQ to XML to process Open XML: The SpreadsheetML Class
  3. Example that uses the OpenXmlDocument, WordprocessingML, and SpreadsheetML Classes (Dec 19, 2007)
  4. The OpenXmlDocument, WordprocessingML, and SpreadsheetML Classes (Dec 19, 2007)
  5. The WordprocessingML Class: A refinement of the approach of using LINQ to XML to access Open XML
  6. The WordprocessingML Class
  7. OpenXML Content Types as an XML Document
  8. OpenXML Content Types in an XML Document
  9. New Job as a Technical Evangelist for Open XML
  10. Using LINQ to XML with OpenXML Documents
  11. Writing LINQ to XML Queries using the OpenXmlDocument Class
  12. Using the OpenXmlDocument Class
  13. The OpenXmlDocument Class
  14. Packages and Parts
  15. Performance of LINQ to XML
  16. Performance of LINQ to XML
  17. Statically Compiled Queries
  18. Preatomization of XName Objects
  19. Atomized XName and XNamespace Objects
  20. Performance of Chained Queries
  21. LINQ to XML RTM docs are available online
  22. Upcoming changes in LINQ to XML
  23. More thoughts on LINQ to XML transformations that use annotations
  24. How to: Use Annotations to Transform LINQ to XML Trees in an XSLT Style
  25. Streaming From Text Files to XML
  26. LINQ to XML Beta1 Docs (now Beta2)
  27. Generating an XPath expression to find a LINQ to XML Node
  28. LINQ to XML Beta1 Docs are On-Line

2006 41

  1. Update to the Functional Programming Tutorial
  2. Procedural Analogs
  3. The FP Switch Pattern (used to implement the World's Smallest RPN Processor)
  4. The Source Word Document
  5. A Tutorial on Functional Programming using C# 3.0
  6. Translating Query Expressions to Dot Notation
  7. Query Composition using Functional Programming Techniques in C# 3.0
  8. Object and Collection Initializers
  9. Lazy Evaluation (and in contrast, Eager Evaluation)
  10. The Yield Contextual Keyword
  11. Overview of a Functional Transform
  12. Retrieving the Two Code/Comment Groups
  13. Separating Out the Code and Comments
  14. Conclusion
  15. Complete Listing of ParseWordML
  16. The Final Results
  17. Filtering Out the Groups that we Don’t Want
  18. Retrieving the Text of the Paragraphs
  19. Refactoring using a Pure Function
  20. Retrieving the Paragraphs
  21. Parsing WordML
  22. Pure Functions
  23. Programming in a Functional Style
  24. Aggregation
  25. Local Variable Type Inference
  26. Extension Methods
  27. Lambda Expressions
  28. Quick Intro to Query Expressions
  29. What this Tutorial Covers
  30. Introduction to the FP Tutorial
  31. Notes on Implementing the Visitor Pattern using Extension Methods
  32. More Notes on LINQ to Text Files
  33. LINQ to Text Files
  34. New programmer type: Mortenstein
  35. Additional Notes on Parsing WordML with XLinq
  36. Parsing WordML using XLinq
  37. Who are Mort, Elvis, and Einstein?
  38. Learning XLinq
  39. C# 3.0, LINQ, and XLinq Nomenclature
  40. LINQ and XLinq Patterns
  41. Introduction