learnerps dotNET

Dependency Injection IoC

2012-01-19T14:46:00.000Z

"Dependancy Injection" is a more specific name for and term used "Inversion of Control".

It's all about letting client developers of your code add there own implementations. To do this your code needs to be very loosly coupled (i.e. none of the usual newing up of concrete classes, the code must be written using Interfaces for example) and configurable (e.g. the client developer drops their implementation dll into a location and adds content to a XML configuration file to tell your host app what class to load and instantiate from the dll).

This is a good intro to "Dependancy Injection" http://www.martinfowler.com/articles/injection.html

These are intros to Microsofts "Dependancy Injection" framework, Unity.

https://www106.livemeeting.com/cc/wwe_us/view?cn=guest&id=1032382093&pw=23D44136 with sourcecode at http://unity.codeplex.com/wikipage?title=Webcast%20demos&referringTitle=Home

http://visualstudiomagazine.com/articles/2011/01/27/the-factory-pattern-in-net-part-3.aspx

XML file for Visual Studio HelpViewer 1.0

2011-05-11T10:25:00.004Z

The following XML file is used in combination with the XSLT file posted in an earlier post. These 2 files transoform into HMTL that views correctly in Visual Studio 2010 HelpViewer 1.0.

xml version="1.0" encoding="iso-8859-1"?>
xml-stylesheet type="text/xsl" href="../xslt/gravity.xslt"?>
<TopoixHelpDocument>
  <Meta>
    <title>Buttontitle>
    <metaTitle>ButtonmetaTitle>
    <metaID>TopoixApiHelp3-7F3D2D9D-000016metaID>
    <metaParent>TopoixApiHelp3-7F3D2D9D-0000C2metaParent>
    <metaKeyword1>ButtonmetaKeyword1>
    <metaKeyword2>Avaeon.Topoix.Gravity.ButtonmetaKeyword2>
    <metaF1>Avaeon.Topoix.Gravity.ButtonmetaF1>
  Meta>
  <HelpBody>
    <majorTitle>ButtonmajorTitle>
    <title>Buttontitle>
    <feedbackLink>ButtonfeedbackLink>
    <summary>
      <summaryText>
        A control to represent a clickable button.
      summaryText>
    
    summary>
    <syntax>
      <codeSnippet>control Button buttonNamecodeSnippet>
 
      <properties>
        
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00010BlinkUrl>
          <linkUrlName>TextlinkUrlName>
          <linkUrlDescription>The text that appears on the client as the name of the button.linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-0000B6linkUrl>
          <linkUrlName>IsVisiblelinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086">GravityExpression a> returning a boolean value indicating whether or not the button
            should be visible.
          linkUrlDescription>
        property>
        
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00005ElinkUrl>
          <linkUrlName>EnabledlinkUrlName>
          <linkUrlDescription>Evalutes to true or false and determines is the button is clickable or not.linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00005FlinkUrl>
          <linkUrlName>EnableOnFormCompletelinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086">GravityExpressiona> returning a boolean indicating to the client that this button
            should be enabled when all the required controls on its form have a value.
          linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-0000ADlinkUrl>
          <linkUrlName>ImageUrllinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086">GravityExpressiona> returning the string to use as an icon for the button.
          linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000117linkUrl>
          <linkUrlName>ToolTiplinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086">GravityExpressiona> returning the string to use as a tooltip for the button.
          linkUrlDescription>
        property>
 
 
        
        <property>
          <hierachy>public;inherited;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000040linkUrl>
          <linkUrlName>AlwaysPostlinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086" xmlns="http://www.w3.org/1999/xhtml">GravityExpressiona> that returns true if the control should always post its
            value when it loses the focus, even if it has not changed.
          linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;inherited;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-0000DAlinkUrl>
          <linkUrlName>PromptlinkUrlName>
          <linkUrlDescription>The prompt that will be displayed when focus is set on the  control.linkUrlDescription>
        property>
        
        <property>
          <hierachy>public;inherited;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00001ElinkUrl>
          <linkUrlName>ClassNamelinkUrlName>
          <linkUrlDescription>
            <p>The ClassName property can be applied to any control.p>
            <p>It takes a string and adds that string to the html element of the control as one of the class names of that controlp>
            <p>e.g.p>
            <p>property ClassName:=hello;p>
            <p>would result in class="hello" in the HTMLp>
            <p>any existing classes in HTML are unaffected, i.e the class is added e.g. class="existing hello"p>
          linkUrlDescription>
        property>
 
        <property>
          <hierachy>public;inherited;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-0000CDlinkUrl>
          <linkUrlName>NextControllinkUrlName>
          <linkUrlDescription>
            A <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000086">GravityExpressiona> returning the control that the focus will move to when the
            current control is tabbed off.
          linkUrlDescription>
        property>
 
      properties>
 
      
 
      
      
      <events>
        <event>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00001FlinkUrl>
          <linkUrlName>ClicklinkUrlName>
          <linkUrlDescription>The <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000090">GravityStatementa> executed when a click event is fired.linkUrlDescription>
        event>
 
        <event>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-00006ClinkUrl>
          <linkUrlName>FocuslinkUrlName>
          <linkUrlDescription>
            The <a href="ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000090">GravityStatementa> executed when a control is focused.
          linkUrlDescription>
        event>
 
        
      events>
 
      
      <settings>
         <setting>
          <hierachy>public;declared;hierachy>
          <linkUrl>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-0000F5linkUrl>
          <linkUrlName>DoNotPostlinkUrlName>
          <linkUrlDescription>Flag to determine if value is posted to server after being set.linkUrlDescription>
        setting>
      settings>
 
        
      
      
      <parameters>
        <parameter>
          <name>valuename>
          <typeLink>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-EntitiestypeLink>
          <typeLinkNameSpace>EntityCollectiontypeLinkNameSpace>
          <typeName>typeName>
          <typeText>The Entity to add.typeText>
        parameter>
      parameters>
      
      <remarks>
        <text>
          <p>A Button is defined with the control keyword.p>
          <p>
            To reference this Button from the HTML. Add the following code in the HTML where you want to show the Button. You can only reference a Button from a HTML page that has been assigned to the URL property of the containing form.
                  input  type="button" id="BtnHelloWorld" class="button"
             
          p>
        
        text>
      remarks>
 
      <example>
        <link>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000016link>
        <linkText>ButtonlinkText>
        <codeSnippetFull>
          <span class="kwrd">
            controlspan> Button BtnHelloWorld
           {
            <span class="kwrd">eventspan> Click
            {
             UI.ShowMessage(<span class="str">"Hello World"span>);  
            }
            <span class="kwrd">propertyspan> Text := <span class="str">"Say Hello"span>;
            <span class="kwrd">propertyspan> ToolTip := <span class="str">"Say Hello!"span>;
              <span class="kwrd">propertyspan> NextControl := <span class="kwrd">nullspan>;
           }
 
        codeSnippetFull>
      example>
    syntax>
    <seeAlsos>
      <seeAlso>
        <link>ms-xhelp:///?Id=TopoixApiHelp3-7F3D2D9D-000071link>
        <text>Formtext>
      seeAlso>
      
    seeAlsos>
 
  HelpBody>
TopoixHelpDocument>

XSL XSLT file for Visual Studio HelpViewer 1.0

2011-05-11T10:18:00.002Z

This XSL/XSLT file is based on a Visual Studio Help file found in "C:\ProgramData\Microsoft\HelpLibrary\content\Microsoft\store\Development_Frameworks_21823146_VS_100_en-us_9.msha"
I've stripped out the content and replaced with <xsl:if gt;
etc.
The values for this content are taken from XML files which have the corresponding XML element hierachy, e.g

 <xsl:value-of select="TopoixHelpDocument/Meta/title"/>

xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/">
    <html xmlns="http://www.w3.org/1999/xhtml">
      <head>
        
        <meta name="Microsoft.Help.ContentType" content="Reference" >meta>
        <meta name="Microsoft.Help.Locale" content="en-us" >meta>
        <meta name="Microsoft.Help.TopicLocale" content="en-us" >meta>
        <meta name="Microsoft.Help.Category" content="TopoixApiHelp3" >meta>
        <meta name="SelfBranded" content="false" >meta>
        <link href="stylesheets/CSharp.css" type="text/css" rel="Stylesheet" />
 
        
        <title>
          <xsl:value-of select="TopoixHelpDocument/Meta/title"/>
        title>
        <xsl:variable name="metaTitleVar">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaTitle"/>
        xsl:variable>
        <meta name="Title" content="{$metaTitleVar}" >meta>
 
        <xsl:variable name="metaIDVar">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaID"/>
        xsl:variable>
        <meta name="Microsoft.Help.Id" content="{$metaIDVar}">meta>
 
        <xsl:variable name="metaParentVar">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaParent"/>
        xsl:variable>
        <meta name="Microsoft.Help.TocParent" content="{$metaParentVar}">meta>
 
        <xsl:variable name="metaKeyword1Var">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaKeyword1"/>
        xsl:variable>
        <meta name="Microsoft.Help.Keywords" content="{$metaKeyword1Var}" >meta>
 
        <xsl:variable name="metaKeyword2Var">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaKeyword2"/>
        xsl:variable>
        <meta name="Microsoft.Help.Keywords" content="{$metaKeyword1Var}" >meta>
 
        <xsl:variable name="metaF1Var">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaF1"/>
        xsl:variable>
        <meta name="Microsoft.Help.F1" content="{$metaF1Var}" >meta>
 
        <xsl:variable name="metaTocOrderVar">
          <xsl:value-of select="TopoixHelpDocument/Meta/metaTocOrder"/>
        xsl:variable>
        <meta name="Microsoft.Help.TocOrder" content="{$metaTocOrderVar}" >meta>
        
      head>
      <body class="primary-mtps-offline-document">
        <div class="topic">
          <div class="majorTitle">
            <xsl:value-of select="TopoixHelpDocument/HelpBody/majorTitle"/>
          div>
          <div class="title">
            <xsl:value-of select="TopoixHelpDocument/HelpBody/title"/>
          div>
 
          <xsl:variable name="feedbackLinkVar">
            <xsl:value-of select="TopoixHelpDocument/HelpBody/feedbackLink"/>
          xsl:variable>
          <div class="OH_feedbacklink">
            <a href="mailto:support@avaeon.com?subject=Documentation Feedback:{$feedbackLinkVar}">Send commentsa>
          div>
 
          <div id="mainSection">
            <div id="mainBody">
              <p>
                
              p>
              
               <div>
                <div class="summary">
                  <p>
                    <xsl:copy-of select="TopoixHelpDocument/HelpBody/summary/summaryText"/>
                  p>
 
 
                div>
              div>
              <p>
                
              p>
              
              
              
              <xsl:if test="TopoixHelpDocument/HelpBody/syntax">
                <CollapsibleArea runat="server" Expanded="1" Title="Syntax" xmlns="http://msdn2.microsoft.com/mtps">
 
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/codeSnippet">
                    <a id="syntaxToggle" xmlns="http://www.w3.org/1999/xhtml">
                      
                    a>
                    <CodeSnippet runat="server" Language="Gravity" DisplayLanguage="Gravity" ContainsMarkup="false" EnableCopyCode="false">
                      <xsl:copy-of select="TopoixHelpDocument/HelpBody/syntax/codeSnippet"/>
                    CodeSnippet>
                  xsl:if>
 
                  
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/properties">
                    <CollapsibleArea runat="server" Expanded="1" Title="Properties" xmlns="http://msdn2.microsoft.com/mtps">
                      <a id="propertyTableToggle" xmlns="http://www.w3.org/1999/xhtml">
                        
                      a>
                      <table id="memberList1" class="members" xmlns="http://www.w3.org/1999/xhtml">
                        <tr>
                          <th class="iconColumn">
                             
                          th>
                          <th class="nameColumn">Nameth>
                          <th class="descriptionColumn">Descriptionth>
                        tr>
                        <xsl:for-each select="TopoixHelpDocument/HelpBody/syntax/properties/property">
                          <xsl:variable name="hierachyVar">
                            <xsl:value-of select="hierachy"/>
                          xsl:variable>
                          
                          
                          <xsl:variable name="hierachyImageVar">
                            <xsl:if test="$hierachyVar='public;declared;'">
                              <xsl:value-of select="'images/IC74937'"/>
                            xsl:if>
                            <xsl:if test="$hierachyVar='public;inherited;'">
                              <xsl:value-of select="'images/IC100399'"/>
                            xsl:if>
                          xsl:variable>
                          <xsl:variable name="hierachyImageAltVar">
                            <xsl:if test="$hierachyVar='public;declared;'">
                              <xsl:value-of select="'Public Property'"/>
                            xsl:if>
                            <xsl:if test="$hierachyVar='public;inherited;'">
                              <xsl:value-of select="'Public Inherited Property'"/>
                            xsl:if>
                          xsl:variable>
                          
                          <tr data="{$hierachyVar}">
                            <td>
                                   <img class="mtps-img-src" alt="{$hierachyImageAltVar}" src="{$hierachyImageVar}" />
                            td>
                            <td>
                              <xsl:variable name="linkUrlVar">
                                <xsl:value-of select="linkUrl"/>
                              xsl:variable>
                              <a class="mtps-internal-link" href="{$linkUrlVar}">
                                <xsl:value-of select="linkUrlName"/>
                              a>
                            td>
                            <td>
                              <span>
                                <xsl:copy-of select="linkUrlDescription"/>
                              span>
                            td>
                          tr>
                           xsl:for-each>
                        
                      table>
                      <a href="#mainBody" xmlns="http://www.w3.org/1999/xhtml">Topa>
                    CollapsibleArea>
                    
                  xsl:if>
 
                  
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/settings">
                    <CollapsibleArea runat="server" Expanded="1" Title="Settings" xmlns="http://msdn2.microsoft.com/mtps">
                      <a id="propertyTableToggle" xmlns="http://www.w3.org/1999/xhtml">
                        
                      a>
                      <table id="memberList1" class="members" xmlns="http://www.w3.org/1999/xhtml">
                        <tr>
                          <th class="iconColumn">
                             
                          th>
                          <th class="nameColumn">Nameth>
                          <th class="descriptionColumn">Descriptionth>
                        tr>
                        <xsl:for-each select="TopoixHelpDocument/HelpBody/syntax/settings/setting">
                          <xsl:variable name="hierachyVar">
                            <xsl:value-of select="hierachy"/>
                          xsl:variable>
 
 
                          <xsl:variable name="hierachyImageVar">
                            <xsl:if test="$hierachyVar='public;declared;'">
                              <xsl:value-of select="'images/IC74937'"/>
                            xsl:if>
                            <xsl:if test="$hierachyVar='public;inherited;'">
                              <xsl:value-of select="'images/IC100399'"/>
                            xsl:if>
                          xsl:variable>
                          <xsl:variable name="hierachyImageAltVar">
                            <xsl:if test="$hierachyVar='public;declared;'">
                              <xsl:value-of select="'Public Setting'"/>
                            xsl:if>
                            <xsl:if test="$hierachyVar='public;inherited;'">
                              <xsl:value-of select="'Public Inherited Setting'"/>
                            xsl:if>
                          xsl:variable>
 
                          <tr data="{$hierachyVar}">
                            <td>
                              <img class="mtps-img-src" alt="{$hierachyImageAltVar}" src="{$hierachyImageVar}" />
                            td>
                            <td>
                              <xsl:variable name="linkUrlVar">
                                <xsl:value-of select="linkUrl"/>
                              xsl:variable>
                              <a class="mtps-internal-link" href="{$linkUrlVar}">
                                <xsl:value-of select="linkUrlName"/>
                              a>
                            td>
                            <td>
                              <span>
                                <xsl:copy-of select="linkUrlDescription"/>
                              span>
                            td>
                          tr>
                        xsl:for-each>
                        
 
                      table>
                      <a href="#mainBody" xmlns="http://www.w3.org/1999/xhtml">Topa>
                    CollapsibleArea>
                    
                  xsl:if>
                  
                  
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/events">
                    <CollapsibleArea runat="server" Expanded="1" Title="Events" xmlns="http://msdn2.microsoft.com/mtps">
                      <a id="eventTableToggle" xmlns="http://www.w3.org/1999/xhtml">
                        
                      a>
                      <table id="memberList3" class="members" xmlns="http://www.w3.org/1999/xhtml">
                        <tr>
                          <th class="iconColumn">
                             
                          th>
                          <th class="nameColumn">Nameth>
                          <th class="descriptionColumn">Descriptionth>
                        tr>
                        
                        
                        <xsl:for-each select="TopoixHelpDocument/HelpBody/syntax/events/event">
                          <xsl:variable name="hierachyVar">
                            <xsl:value-of select="hierachy"/>
                          xsl:variable>
 
                          <tr data="{$hierachyVar}">
                            <td>
                              
                              <img class="mtps-img-src" alt="Public event" src="images/IC90369" />
                            td>
                            <td>
                              <xsl:variable name="linkUrlVar">
                                <xsl:value-of select="linkUrl"/>
                              xsl:variable>
                              <a class="mtps-internal-link" href="{$linkUrlVar}">
                                <xsl:value-of select="linkUrlName"/>
                              a>
                            td>
                            <td>
                              <span>
                                <xsl:copy-of select="linkUrlDescription"/>
                              span>
                            td>
                          tr>
                          
                        xsl:for-each>
                      table>
                      <a href="#mainBody" xmlns="http://www.w3.org/1999/xhtml">Topa>
                    CollapsibleArea>
                    
                  xsl:if>
 
                  
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/parameters">
                    <div id="parameters" xmlns="http://www.w3.org/1999/xhtml">
                      <h4 class="subHeading">Parametersh4>
                      <xsl:for-each select="TopoixHelpDocument/HelpBody/syntax/parameters/parameter">
                        <dl>
                          <dt>
                            <span class="parameter">
                              <xsl:value-of select="name"/>
                            span>
                          dt>
                          <dd>
                            Type:
                            <xsl:variable name="typeLinkVar">
                              <xsl:value-of select="typeLink"/>
                            xsl:variable>
                            <a class="mtps-internal-link" href="{$typeLinkVar}" >
                              <xsl:value-of select="typeLinkNameSpace"/>
                              <LanguageSpecificText runat="server" devLangcs="." devLangvb="." devLangcpp="::" devLangnu="." xmlns="http://msdn2.microsoft.com/mtps">.LanguageSpecificText>
                              <xsl:value-of select="typeName"/>
                            a>
                            <br/>
                            <span>
                              <xsl:value-of select="typeText"/>
                              <br />
                            span>
                          dd>
                        dl>
                      xsl:for-each>
                      
                    div>
                  xsl:if>
 
                  
                  <xsl:if test="TopoixHelpDocument/HelpBody/syntax/return">
                    <div id="returns" xmlns="http://www.w3.org/1999/xhtml">
                      <h4 class="subHeading">Return Valueh4>Type:
                      <xsl:variable name="returnTypeLinkVar">
                        <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/typeLink"/>
                      xsl:variable>
                      <a class="mtps-internal-link" href="{$returnTypeLinkVar}" >
                        <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/typeNameSpace"/>
                        <LanguageSpecificText runat="server" devLangcs="." devLangvb="." devLangcpp="::" devLangnu="." xmlns="http://msdn2.microsoft.com/mtps">.LanguageSpecificText>
                        <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/typeName"/>
                      a>
                      <br/>
                      <span>
                        <span>
                          <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/typeDescription"/>
                          <span class="parameter">
                            <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/typeVar"/>
                          span>.
                        span>
                        <br/>
                        <div class="caption">
                          
                        div>
                        <div class="tableSection">
                          <table>
                            <tr>
                              <th>
                                <p>Return Value p>
                              th>
                              <th>
                                <p>Description p>
                              th>
                            tr>
                            <tr>
                              <td>
                                <p>
                                  <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/value"/>
                                p>
                              td>
                              <td>
                                <p>
                                  <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/description"/>
                                  <span class="parameter">
                                    <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/return/name"/>
                                  span>.
                                p>
                              td>
                            tr>
                          table>
                        div>
                      span>
                    div>
                  xsl:if>
 
                  <br xmlns="http://www.w3.org/1999/xhtml"/>
                CollapsibleArea>
 
 
 
 
                <xsl:if test="TopoixHelpDocument/HelpBody/syntax/exceptions">
                  <CollapsibleArea runat="server" Expanded="1" Title="Exceptions" xmlns="http://msdn2.microsoft.com/mtps">
                    <a id="ddueExceptionsToggle" xmlns="http://www.w3.org/1999/xhtml">
                      
                    a>
                    <div class="tableSection" xmlns="http://www.w3.org/1999/xhtml">
                      <table>
                        <tr>
                          <th class="exceptionNameColumn">Exceptionth>
                          <th class="exceptionConditionColumn">Conditionth>
                          <th class="exceptionConditionColumn">Descriptionth>
                        tr>
                        <xsl:for-each select="TopoixHelpDocument/HelpBody/syntax/exceptions/exception">
                          <tr>
                            <td>
                              <span>
                                <xsl:variable name="typeLinkVar">
                                  <xsl:value-of select="typeLink"/>
                                xsl:variable>
                                <a class="mtps-internal-link" href="{$typeLinkVar}" >
                                  <xsl:value-of select="name"/>
                                a>
 
                              span>
                            td>
                            <td>
                              <p>
                                <span class="parameter">
                                  <xsl:value-of select="parameter/value"/>
                                span> <xsl:value-of select="parameter/text"/>
                                <span>
                                  <xsl:variable name="typeLinkVar">
                                    <xsl:value-of select="parameter/typeLink"/>
                                  xsl:variable>
                                  <a class="mtps-internal-link" href="{$typeLinkVar}" >
                                    
                                    <xsl:value-of select="parameter/typeName"/>
                                  a>
                                span>
                              p>
                            td>
                            <td>
                              <p>
                                <xsl:value-of select="description"/>
                              p>
                            td>
                          tr>
                        xsl:for-each>
                      table>
                    div>
                  CollapsibleArea>
                xsl:if>
 
                
                <xsl:if test="TopoixHelpDocument/HelpBody/syntax/remarks">
                  <CollapsibleArea runat="server" Expanded="1" Title="Remarks" xmlns="http://msdn2.microsoft.com/mtps">
                    <a id="remarksToggle" xmlns="http://www.w3.org/1999/xhtml">
                      
                    a>
                    <p xmlns="http://www.w3.org/1999/xhtml">
 
                      <xsl:copy-of select="TopoixHelpDocument/HelpBody/syntax/remarks/text"/>
                    p>
                  CollapsibleArea>
                xsl:if>
 
                
                <xsl:if test="TopoixHelpDocument/HelpBody/syntax/example">
                  <CollapsibleArea runat="server" Expanded="1" Title="Examples" xmlns="http://msdn2.microsoft.com/mtps">
                    <a id="exampleToggle" xmlns="http://www.w3.org/1999/xhtml">
                      
                    a>
                    <p xmlns="http://www.w3.org/1999/xhtml">
                      The following code example demonstrates the
                      <span>
                        <xsl:variable name="exampleLinkVar">
                          <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/example/link"/>
                        xsl:variable>
                        <a class="mtps-internal-link" href="{$exampleLinkVar}" >
                          <xsl:value-of select="TopoixHelpDocument/HelpBody/syntax/example/linkText"/>
                        a>
                      span> method.
                    p>
                    <div id="snippetGroup" xmlns="http://www.w3.org/1999/xhtml">
                      <CodeSnippet EnableCopyCode="true" runat="server" Language="Gravity" ContainsMarkup="false" DisplayLanguage="Gravity" xmlns="http://msdn2.microsoft.com/mtps">
                        <xsl:copy-of select="TopoixHelpDocument/HelpBody/syntax/example/codeSnippetFull"/>
                      CodeSnippet>
                    div>
                  CollapsibleArea>
                xsl:if>
              
              xsl:if>
                
 
              <xsl:if test="TopoixHelpDocument/HelpBody/seeAlsos">
                <CollapsibleArea runat="server" Expanded="1" Title="See Also" xmlns="http://msdn2.microsoft.com/mtps">
                  <a id="seeAlsoToggle" xmlns="http://www.w3.org/1999/xhtml">
                    
                  a>
                  <h4 class="subHeading" xmlns="http://www.w3.org/1999/xhtml">Referenceh4>
 
                  <xsl:for-each select="TopoixHelpDocument/HelpBody/seeAlsos/seeAlso">
                    <div class="seeAlsoStyle" xmlns="http://www.w3.org/1999/xhtml">
                      <span>
                        <xsl:variable name="seeAlsoLinkVar">
                          <xsl:value-of select="link"/>
                        xsl:variable>
                        <a class="mtps-internal-link" href="{$seeAlsoLinkVar}" >
                          <xsl:value-of select="text"/>
                        a>
                      span>
                    div>
                  xsl:for-each>
                CollapsibleArea>
              xsl:if>
 
            div>
          div>
        div>
      body>
    html>
 
 
 
 
  xsl:template>
xsl:stylesheet>

XML to HTML

2011-05-11T09:42:00.007Z

To convert XML to HTML you need an XSL (XSLT) file and some application to transform the XML to HTML using this XSL file. Usually this work is done by the browser, by including a link to the XSL file in the XML file, when you open the file in a browser it runs the transform on the XML using the XSL file you've pointed to.

But I wanted to run this as a seperate step from a batch file so that I can create my .html files on disk but maintain their content using XML.

Here's how I've done it:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Xsl;
using System.IO;
 
 
namespace Tool.XMLToHTML
{
    class Program
    {
        /// <summary>
        /// "Help\Help3\_HelpSource\gravity.xslt" "Help\Help3\_HelpSource"
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            
            try
            {
                Console.WriteLine("\n");
                Console.WriteLine("\tTransform xslt + xml to html.");
                Console.WriteLine("\n");
                
                
                if (args.Length != 2)
                    throw new ArgumentException("2 args required, .xslt file and the .xml file or directory");
                if (!args[0].ToString().Contains(".xslt"))
                    throw new ArgumentException(".xslt file expected as first arg");
                string xmlSourceLocation = Path.GetDirectoryName(args[1] + Path.DirectorySeparatorChar);
                if (!args[1].ToString().Contains(".xml"))
                {
                    if (!Directory.Exists(Path.GetDirectoryName(args[1] + Path.DirectorySeparatorChar)))
                         throw new ArgumentException(string.Format("Directory {0} does not exist.", Path.GetDirectoryName(args[1]+Path.DirectorySeparatorChar)));
                    else
                       if(Directory.GetFiles(args[1], "*.xml").Length ==0)
                           throw new ArgumentException(string.Format("Directory {0} does not contain .xml files.", args[1]));
                }
 
                Console.WriteLine("\n");
                Console.WriteLine("\tTakes the fullpath to the .xslt");
                Console.WriteLine("\tand the full path to the .xml or the directory containing the .xml.");
                Console.WriteLine("\tTransforms to .html files, in an output directory below the xml source location 'htmlOutput' i.e. {0}", Path.Combine(Path.GetDirectoryName(args[1]), "htmlOutput"));
                Console.WriteLine("\n");
 
                
 
 
                // Load the style sheet. 
                XslCompiledTransform xslt = new XslCompiledTransform();
                xslt.Load(args[0]);
 
                string rootPath = Path.GetDirectoryName(args[1] + Path.DirectorySeparatorChar);
                string htmlOutputPath = Path.Combine(rootPath, "htmlOutput");
                Directory.CreateDirectory(htmlOutputPath);
 
                if (Directory.Exists(xmlSourceLocation))
                {
                    string[] fileNames = Directory.GetFiles(xmlSourceLocation, "*.xml");
 
                    foreach (string xmlFileName in fileNames)
                        xslt.Transform(xmlFileName, Path.Combine(htmlOutputPath, Path.GetFileNameWithoutExtension(xmlFileName) + ".html"));
                }
                else//single file
                    xslt.Transform(args[1], Path.Combine(htmlOutputPath, Path.GetFileNameWithoutExtension(args[1]) + ".html"));
                
                Console.WriteLine("\tSuccess. HTML output can be found at {0}\n", htmlOutputPath);
            }
            catch (Exception e)
            {
                Console.WriteLine("\n");
                Console.WriteLine("\tFailure. Transform to HMTL failed.");
                Console.WriteLine("\t" + e.Message);
                Console.WriteLine("\n");
            }
            
 
        }
    }
}

Visual Studio 2010 HelpViewer 1.0 Custom Help Creation

2011-05-11T08:53:00.010Z

Recently I've been working with our legacy HTML help files, trying to add them the the new Visual Studio 2010 HelpViewer. This is not a simple task.

We wanted the styling of our html to be the same as .NET help files
We would also like there to be little or no maintenance required to keep them up to date with the latest Visual Studio Help Styles etc.
We have a custom development language so the code snippets require their own color coding and the Language should be "Gravity" and not C# or VB.
The content itself should be easily maintained.
Our own applications logos and copyright should appear instead of Visual Studios.

The requirements above proved to be not a simple to implement as you might think. Below I'll mention the snags I came across and describe how I overcame them.

1. Styling:

The styling information was not simple to find, there are documents on http://www.helpware.net/mshelp3/intro.htm which explain some of the content of the help files, this is useful but where do you start to get a custom page up and running which looks like a .NET help file? The solution I found is by looking in the Help Store "C:\ProgramData\Microsoft\HelpLibrary\content\Microsoft\store". In here you'll find the help mshi files etc.
The .msha files are actually Zip files which have been renamed, these contain .html help files.

The trick is to find the correct .msha file unzip it and look through the HTML file for the content you require. I found the Int32.CompareTo help file and the Windows.Form help file of great use. These help files contain the bare HTML with CSS links before the HTML has been rendered, it's useless to start looking at the rendered HTML with "view source" from the browser, it's too large.

A Web Form class help file I found of great use was in the "Development_Frameworks_21823146_VS_100_en-us_9.msha" file. I renamed this to .zip and extracted it's contents (this can also be done with an application called FAR, it can read the contents of the .msha file and will give you the option to unzip the contents). I extracted the contents to "C:\Users\me\Documents\Development_Frameworks_21823146_VS_100_en-us_9" and in here searched the .html files for the content I wanted. The file with title <title>MenuStrip Class (System.Windows.Forms)</title>

was the file I chose. I've made a copy of this and used it as my template for most things.

3 & 5. Color coding and logos, Branding.
There are issues here, it looks like you cannot mix and match, what I mean is you either go with the complete look and feel of Visual Studio's help including the logos and copyright or else you loose it all and provide your own styling. This is all controlled by one simple metadata tag provided in each html help file

<meta name="SelfBranded" content="false" >meta>

Changing this to "true" results in you losing all the styles and logos etc that msdn gives you, you must then provide your own styles, this solution is not really feasable as the styling and layout of the msdn help is complex and also I'd imagine it's better to keep with the sytles provided by msdn and if they update them then they get pulled in hopefully without and work.
If you do change this setting to "true" applying styles for the color coding snippets is simple with adding html spans to the keywords etc, giving the Span a style class and adding the correct style to a linked stylesheet.
e.g.

  <span class="kwrd">
            controlspan> Button BtnHelloWorld
           {
            <span class="kwrd">eventspan> Click
            {
             UI.ShowMessage(<span class="str">"Hello World"span>);  
            }
            <span class="kwrd">propertyspan> Text := <span class="str">"Say Hello"span>;
            <span class="kwrd">propertyspan> ToolTip := <span class="str">"Say Hello!"span>;
              <span class="kwrd">propertyspan> NextControl := <span class="kwrd">nullspan>;
           }

the class "kwrd" has a style like so

.kwrd
{
 color: #0000ff;
}

4. Easily maintained.

I've used XSL and XML to store my help content. The idea behind this is the XSL stores the HMTL, the .NET help files are chunky with alot of styling, so I have one large XSL file "gravity.xslt" which all the XML files reference.

The XML files are simple the text content and some links. This keeps the content files size to a minimum, they contain the title name, the description, the Help Meta information (keywords, id, parent, TocOrder) etc. When new content is required all that needs to be added is a new XML file, copy the content from another and change the text.

I've made the XSL file have as many <xsl:if> statements as possible

In order for XML to become (X)HTML it needs to be transformed using some application (usually a browser) and the XSL file. I wanted to do this in one go from command line so I've written a small application which takes the XSL file and a directory containing the XML files, this outputs a HTML file for each XML file. It's these HTML file's that I later add to my Zip and remame to a .msha file, my help file.

Here's a sample of one of my XML files.

Here's my one and only XSL/XSLT file.

Here's the code for my application that tranforms the XML files to (X)HTML using the XSL/XSLT file.

TFSbuild custom parameters and Testing

2011-01-28T12:02:00.012Z

To test your Team Build Project locally with TFSBuild use the Visual Studio 2010 command prompt.

here's a sample

C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC>TFSBuild start /collectio

n:http://MYSERVER:8080 /builddefinition:"MYTFS/TestBuild" /droplocation:"\\

SOMECOMPUTER\SOMEDIRECTORY"

http://msdn.microsoft.com/en-us/library/ms181742.aspx

However firstly I recommend testing the syntax of your project with MsBuild

e.g.

C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC>msbuild C:\SOMEDIR\TeamBui

ldTypes\MsBuildSamples\TFSBuild.proj

http://msdn.microsoft.com/en-us/library/ms181723(VS.90).aspx

In order to tell msbuild to run a particular target within use something like

C:\MsBuildSamples>msbuild TfsBuild.proj /t:DesktopRebuild

this will run the Target "DesktopRebuild".

Passing Parameters/Arguments

To use parameters passed in through TFSbuild it's simple, just pass in your argument with the /property switch on the command line or do it through the Visual Studio Team Build UI.

this can first be tested with MSBuild

e.g.

C:\TeamBuildTypes\MsBuildSamples>msbuild TfsBuild.proj /t:DesktopRebuild

/property:MyArgument=2

inside in your TfsBuild.proj tjos argument can used anywhere with the syntax $(MyArgument)

And further test with TFSBuild from the command line

C:\Topoix\TeamBuildTypes\MsBuildSamples>TFSBuild start /collection:http://offaly

:8080 /builddefinition:"Topoix-scrum/TestBuild" /droplocation:"\\dunnacarraige\b

uildDrops" /msbuildarguments:"/p:MyArgument=2"

These same msbuildarguments can be passed in through the Visual Studio Queue Build dialog in the "MSBuild command line arguments" panel with

/p:MyArgument=2

Build with .NET 4.0 in Team Foundation Server

2011-01-27T13:10:00.004Z

In order to force your Team Build to use the .NET assemblies and tools you'll need to make the following change.

Change the value in the

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies\tfsbuildservice.exe.config

From

add key="MSBuildPath" value=""

add key="MSBuildPath" value="C:\WINDOWS\Microsoft.NET\Framework\v4.0.30319"

TFS service must be restarted afterwards "Visual Studio Team Foundation Build"

http://blogs.infosupport.com/blogs/martijnb/archive/2010/05/04/building-visual-studio-2010-solutions-using-team-build-2008.aspx

Dependency Injection

2010-11-01T10:52:00.005Z

Loose coupling i.e. making your code modules less tightly bound to each other.

Dependency Injection helps this process, allowing clients of your code to get the application using their own code without them having to know very much at all as to how the application works internally.

The article linked in the title of this post has a very brief outline of some how it can work but basically I'm interested in using Interfaces and registering my own classes with the host application with the minimum possible code work.

There are lots of third party frameworks which provide implementations.

The method is usually the same, create and instance of the third party class and then call a method on it which tells the framework to run a particular concrete class that you have provided when a particular interface or type is used, it's a form of mapping allowing client classes to be used at runtime.

http://www.martinfowler.com/articles/injection.html

ISerializable - Serializing objects

2010-08-11T11:44:00.008Z

Serializing is a mechanism to create a text/binary version of your objects state, this can be saved or sent somewhere and then deserialized back into the instance again.

i.e. The member variables of your Type get written somewhere with their values of the instance of your Type.

e.g.

Here's the class who's instance I want to recreate somewhere else or at a later time.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SimpleClass

{

public class Class1

{

public int _myMemberVar;

///

/// required for serialization

///

public Class1()

{

_myMemberVar = 0;

}

public Class1(int value)

{

_myMemberVar = value;

}

Here's a class which Serializes the instance of the class above with the XMLSerializer. The version below writes the XML version of the instance to the Console, you could replace the

using (Stream str = Console.OpenStandardOutput())

with a FileStream of some sort to write the XML to file.

This results in

www.w3.org/2001/XMLSchema">

<_mymembervar>10

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Xml.Serialization;

namespace CallMySimpleClass

{

class Program

{

static void Main(string[] args)

{

SimpleClass.Class1 c = new SimpleClass.Class1(10);

string result = Serialize(c);

Console.WriteLine(result);

}

static string Serialize(object o)

{

string result = null;

using (Stream str = Console.OpenStandardOutput())

{

XmlSerializer x = new XmlSerializer(typeof(SimpleClass.Class1));

x.Serialize(str, o);

}

return result;

}

So that's how the default Serialization works but what if you want to customize how Serialize works.To do this you can either make members Serializable and NonSerialiazed by putting the [Serializable] and [NonSerialized] attributes on your Types and members (Note: these only work when using the Formatters .net gives you BinaryFormatter and SoapFormatter).Or you can take over the process completely buy making the Type you want to serialize implement ISerializable.

ISerializable:

Testing COM components

2010-07-13T13:58:00.004Z

Here's some code you can use to try to load your Type through COM.

You can use the GetPEKind method to get the platform that the assembly was compiled for.

(Recently ran into a problem where I couldn't be sure the assembly I'd registered was registered correctly, my query was particular to win64, there are some changes in the registry entries for 64bit windows when running 32 bit applications.)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Reflection;

namespace ComTest

{

class MyGetTypeFromCLSIDSample

{

public static void Main()

{

try

{

Guid myGuid1 = new Guid("3A21CE6B-8571-4955-9780-BAE1EE3215C0");//my Types GUID, regasm was ran on this assembly.

// Get the type associated with the CLSID

// and specify whether to throw an exception if an error occurs

// while loading the type.

//if this shows The type of the GUID is System.__ComObject.

//The current module is mscorlib.dll.

//assembly kind ILOnly, PE32Plus , platform AMD64

//then your assembly isn't registered.

Type myType1 = Type.GetTypeFromCLSID(myGuid1, true);

Console.WriteLine("The GUID associated with myType1 is {0}.", myType1.GUID);

Console.WriteLine("The type of the GUID is {0}.", myType1.ToString());

// Show the current module.

Module m = myType1.Module;

Console.WriteLine("The current module is {0}.", m.Name);

PortableExecutableKinds peKind;

ImageFileMachine machine;

m.GetPEKind(out peKind, out machine);

Console.WriteLine("assembly kind {0} , platform {1}", peKind.ToString(), machine);//assembly kind ILOnly , platform I386

Console.ReadLine();

}

catch

{

Console.WriteLine();

}

http://msdn.microsoft.com/en-us/library/1e1wse3a.aspx

Visual Studio build configuration with x64 "Any CPU"

2010-07-09T10:58:00.005Z

In Visual Studio you may have noticed, and ignored, the pulldowns in your toolbar which usually contain "Release" "Any Cpu".

The "Any CPU" part in particular is of interest especially if you plan on running your apps on Windows 64.

These configurations are contained in each project and solution i.e. if you open the projects in a text editor you'll see sections in the XML which contain the settings. These settings are also accessible through the Visual Studio UI via the pulldowns mentioned earlier.

The significance of the "Any CPU" is it's telling the compiler to compile the code into assemblies into code which can run on either 32 or 64 bit machines. If your assemblies are used by an application written in 64bit (and of course the app runs on a 64bit machine) then your assemblies will be used in the 64bit context, the same stands for 32bit (of course 32bit apps can also run on 32 or 43 bit machines).

64bit machines have an additional registry section "HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node", this section contains registry entries for applications build with "Any CPU" or x86 (32bit). The normal registry section "HKEY_LOCAL_MACHINE\SOFTWARE" is used for pure 64bit apps but if the 64bit OS comes across 32bit apps then it uses the "HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node" to get registry settings.

Note to that your installer may target this "HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node" section if your assemblies and installer are configured to "Any CPU" or "x86". It may not be what you expect.

Registry.

There are some cavaets around the Registry entries used on 64bit machines. If your application uses registry entries in any way then you'll need to be aware.

When you compile your assemblies with "Any CPU" and your assembly is used by an application written for 64bit then the registry entries used will be slightly different.

(thanks to Miral on the msdn forums)

.NET app compiled for "x86":
- Always 32-bit
- On 32-bit platforms, accesses 32-bit registry
- On 64-bit platforms, accesses 32-bit registry (inside Wow6432Node)
  - 64-bit registry inaccessible (without doing something weird)
.NET app compiled for "x64":
- Always 64 bit
- On 32-bit platforms, won't run
- On 64-bit platforms, accesses 64-bit registry (not inside Wow6432Node)
  - If you want to get to the 32-bit registry, you need to do something weird
.NET app compiled for "AnyCpu"
- Either 32 or 64 bit depending on platform
- On 32-bit platforms, accesses 32-bit registry
- On 64-bit platforms, accesses 64-bit registry (not inside Wow6432Node)
  - If you want to get to the 32-bit registry, you need to do something weird

Roles in ASP.NET

2010-07-07T13:50:00.002Z

Roles are part of the Authorization in ASPNET i.e. a mechanism to tell if the user has or has not access to resources.

Roles are a mechanism to group users into sets of permissions.

Roles can reuse already existing groups from windows. Roles can also be linked into a SQL database.

Roles are configured on the aspnet websites web.config.

http://msdn.microsoft.com/en-us/library/ff647401.aspx

XMLSerializer and .NET CLR (sgen.exe)

2010-07-07T11:55:00.004Z

You might have spotted on your .NET projects in Visual Studio a radiobutton to turn on/off serialization "Generate serialization assembly" in your project's property's Build tab , so what's that all about?

Serialization is a mechanism for recreating .NET objects from text. There's another post in this blog on the topic. So why is this option on your project? in brief it's there as a performance improvement for .NET CLR.

.NET serializes the assemblies when loading, if you tick the "Generate serialization assembly" listbox your creating a second assembly to accompany the original, the second assembly , with extension .xmlserialize.dll , will be loaded by the CLR at load load if it exists, this improves performance at load time because now the CLR does not have to serialize the original assembly at load time instead if can just load the already existing second assembly.

The second assembly is generated with Visual Studio with a tool called sgen.exe.

http://blogs.msdn.com/b/billwert/archive/2008/02/23/use-of-sgen-exe-to-avoid-common-xmlserializer-performance-pitfalls.aspx

Interop Assemblies

2010-06-03T09:54:00.004Z

What the hell are these Interop Assemblies, Primary Interop Assemblies (PIAs)?

You'll see these assemblies from time to time pulled in as references in you projects, but I never really cared why they were called Interop and what it meant, I'll explain.

Interop is short for interoperability meaning how to get .NET to talk to COM.

Primary Interop Assembly (PIA):

A PIA is an interop assembly that is signed by the originator to mark it as the one and only assembly to use to get the Type information. It's used to avoid conflicting Types. The assembly is signed in a particular way using the tlbimp.exe and then used by the client to resolve Types.

http://msdn.microsoft.com/en-us/library/aa302338.aspx

What have they got to do with COM?

So implementations and Types available through COM is not accessible itself through .NET itself in the usual manner i.e. you cannot new up objects etc because you do not know the Type names. To get over this the COM Types are wrapped into an Interop Assembly. Interop is short for interoperability meaning how to get .NET to talk to COM.

So using some mechanism we want to extract all the Type information on the COM Types into a nice assembly which we can then pass around as references to let clients know what Types are available from COM. One tool we can uses is tlbimp.exe. This tool is ran against the COM Type and results in an assembly with all the Type information of those COM Types found, it does not contain the implementations, they still exist in COM.

The usefulness of this is you can add a reference to this Interop assembly to you .NET project in Visual Studio and then us the Types like ordinary .NET types allowing you to new up objects etc without having to worry about the COM mechanism which runs in the background.

What is TLB and a .tlb file?

http://msdn.microsoft.com/en-us/library/xwzy44e4.aspx

tlb stands for Type Library. A .tlb file is a file that contains the COM Type information. The COM Type information does not have to be in a .tlb file, it can also be in an assembly or other file types such as .ocx or .olb.

A tlb file can be generated using the tlbimp.exe http://msdn.microsoft.com/en-us/library/tt0cf3sx.aspx

What does the "Embed Interop Type" property do in Visual Studio?

http://msdn.microsoft.com/en-us/library/fwawt96c.aspx

In .NET 4, Visual Studio 2010, you have the ability to include references to Interop Assemblies with the property "Embed Interop Type" (you'll see then in the assemblies properties window after you add the reference). This is known as "design-time-only interop assemblies". This embeds the interop type information into the current executable/assembly, the benefit is you do not have to redeploy the interop assemblies with your application afterwards. This is handy as when using installers etc you usually have to copy the interop assemblies to the clients machine, this new mechanism removes that requirement.

Again see http://msdn.microsoft.com/en-us/library/xwzy44e4.aspx

IIS 5.0 - setting the maximum requests

2009-10-22T11:44:00.001Z

cscript adsutil.vbs set w3svc/MaxConnections 40

Transactions and .NETs TransactionScope, what and why?

2009-09-15T16:07:00.007Z

Transactions are used to add the Rollback functionality to calls, Rollback meaning the if an exception or something is thrown your call will not be executed (Commited is the term used for this).

Another benefit of using Transactions is that you can group calls together, if somethign happens to one call then all of calls in that group can also be rolled back. This type of feature is particularly useful when taking user input and saving to DB, you may not want anything to get written to the DB is some error occurs on the client.

.NET provides us with the System.Transaction assembly, it's not completly straight forward to use but it does hide alot of the underlying complexities.

A couple of things I've learned about using System.Transactions or more specifically the System.Transactions.TransactionScope class:

The safest way to use it is with the using clause.
Always call Commit() before the end of the using.
The optional TransactionScopeOptions enum parameter in the constructor defaults to TransactionScopeOption.Required meaning this new Transaction will join an existing one, the existing one is one that has already been created and is know as the "Ambiant Transaction".

TransactionOptions options = new TransactionOptions();

options.IsolationLevel = IsolationLevel.ReadCommitted;

options.Timeout = TimeSpan.FromMinutes(1);

using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))

{

//do something

scope.Complete();

}

The different States of the Transaction

If the Transaction is not Completed it will rollback in code this means if you do not explicitly call TransactionScope.Complete() on the Transaction it will rollback.

So if you detect something wrong has happened in your code then do not call Complete() on it. You must dispose of the Transaction too, if you have your instance wrapped in a Using statement then this is done for you, else you can explicitly call it with the Dispose() method.

If Commit() has not been called before Dispose() then the Transaction goes into a state of Aborted. This indicates something has gone wrong inside the Transaction as Dispose() was called without a Complete().

You may not call Complete() after this, else you'll get a TransactionAbortedException.

So the rule is always either explicitly call Dispose() or let the Using block take care of it and if your code has not thrown an error then call Complete() before Dispose() is called else the functionality inside the Transaction will be rolled back.

What can be put inside a TransactionScope for commital/rollback?

You can put any code you like inside the using of the TransactionScope but only this object that support Transactions will be Rolledback or committed. Objects that support Transactions are usually objects that inherit from System.Transaction e.g.

System.Data.Common.DbConnection.

The official wording from MS indicates that the object must be be able to support transaction promotion i.e. in .NET 2.0 there is something known as the the Lightweight Transaction Manager (LTM) which runs the transactions, it only manages objects that support transaction promotion, I think this actually means the objects implement a set of interfaces or inherit form System.Transaction.Transaction.

from msdn:

"Developers get access to this capability through new classes and interfaces within the System.Transactions namespace. For example, to explicitly start a transaction, an application can instantiate a new TransactionScope. If the application code for that transaction runs inside a single app domain, and if it involves at most a single durable resource, and if that resource supports transaction promotion, then the LTM can coordinate the transaction. For a transaction that involves application code that runs in multiple app domains (including multi-process and multi-machine scenarios), or for any transaction that involves more than one durable resource, even when all application code resides in a single app domain, or when a single transactional resource is involved but the resource does not support transaction promotion, the distributed (OleTx) transaction manager will be used. The application code itself need not concern itself with these optimizations—they just work."

What manages the Transactions?

The Lightweight Transaction Manager (LTM) manages the transactions.

http://delicious.com/learnerplates/transactions

Loading Assemblies, Assembly.Load, Assembly.LoadFrom, Assembly.LoadFile, appDomain.Load

2009-09-03T12:02:00.004Z

I always find this topic a great source of confusion each time I get back to it.

I've just across various Exceptions being thrown in my application, FileNotFoundException and AccessViolationException.

The first caused because the application cannot location a Type that one of my assemblies references and lives in another assembly.

The second is caused by that same file being found but it's locked by another process i.e. something else is reading or has read and not released the assembly.

Both of the above were caused by messy code which used a simple Assembly.LoadFile(...). Looks to me like you should never use this method, I'll explain more below.

There are many ways to create an Assembly instance.

Assembly.Load(assemblyName);

Assembly.LoadFile(assemblyName);

Assembly.LoadFrom(assemblyName);

or even

AppDomain.Load(assemblyName);

There are some subtelties however, some consequences which may later cause issues e.g. the assembly you've loaded is locked.

Assembly.LoadFile is the simplest but most crude solution, it simple reads an assembly, the assembly should be standalone, no references to Types other than the .NET. The file may have issues later too as it maybe locked until the application is shut down.

Assembly.LoadFrom is a bit more intelligent, it uses the current AppDomains settings, if there's an issue with references then the current AppDomain will try to find the Types using the it's settings.

The most complete solution but not the easiest to debug is the use of the AppDomain.Load. This in my experience is tricky until you get used to what all the properties on the AppDomain mean.

What you do is setup a new AppDomain, until you unload that AppDomain everthing that happens in the meantime is in the context of your new AppDomain's settings.

This will help you resolve references to your assembly in code, you can configure where the AppDomain should look when the Load fails to locate an Type.

Installer CustomAction, Debugging the CustomAction, InstallState

2009-08-27T08:41:00.004Z

Custom Action

The Custom Action is added to the Setup Project, select the Project node and hit the Custom Action button. This allows you add an Action to a particular phase in the Installation. But first you must create the Custom Action.

To Add a Custom Action you must first have a Custom Action created, this is usually in the form of a Installer Class, this should be created in a seperate project, the Installer Class is actually one of the File Templates in the C# Projects. So it's File->New Project and select Visual C# Projects. Then add a Class Library, this will prompt you for the Class Library Types , select "Installer Class".

Walkthrough - Creating Custom Action (msdn).

Also here's a more comprehensive document on Setup/Installer implementations, it delves into the Registry etc
Getting Started with Setup Projects (SimpleTalk).

Visual Studio Setup Projects and Custom Actions (Simple Talk).

Create your Installer Class and then add it as a Custom Action to the Setup Project.

What happens now is that you can access the Installers data using what are called Installer Properties. How this is done is a bit messy, after you've added your Installer Class as a Custom Action to the Setup Project you must specify arguments to be passed to the Installer Class at runtime, apparantly this is the only way to references installer data after the installation has completed.

Here's an example of how to pass the name of the installation directory to the Custom Action assembly:

This is done in your Setup Project's Custom Action Tab.

Set the property of the Custom Action you have just added to

        /InstallLoc="[TARGETDIR]\"

NOTE: the extra \" at the end is required to return a directory.

This tells the Custom Action dll that it can access the TARGETDIR (which is the installation location) with the InstallLoc arg, here's how it's done in the Custom Action class:

            this.Context.Parameters["InstallLoc"];

see CustomEventInstaller.Installer

private void AfterInstallEventHandler(object sender, InstallEventArgs e)
{
//Copy the assemblies to the location _installationLoc
//From the command line (passed in by the Setup)
//_installationLoc is also used in the generated .targets file
//InstallLoc="[TARGETDIR]""
_installationLoc = this.Context.Parameters["InstallLoc"];


For multiple Custom Action parameters use a single space between each parameter.



/appsetting1=[EDITA1] /appsetting2=[EDITA2] /installLoc="[TARGETDIR]\"

accessible in your Custom Action code with

_installLoc = Context.Parameters["installLoc"];
_appsetting1 = Context.Parameters["appsetting1"];//first edit
_appsetting2 = Context.Parameters["appsetting2"];//second edit

For Common Properties used in installer applications and other like TARGETDIR see
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/property_reference.asp

http://msdn2.microsoft.com/en-us/library/9cdb5eda.aspx

Debugging the CustomAction

Debugging the CustomAction can be tricky.

To attach the Visual Studio Debugger to the installation process, msiexec.exe is nigh on impossible. The best solution is to add a

Debugger.Break();

or a

System.Windows.Forms.MessageBox.Show(............);

The Debugger.Break() will force the runtime to prompt the installer to attach a Debugger this is your opportunity. Attach to a Visual Studio session that has the CustomAction project source code open and debug as normal once attached.

You may however find that the Debugger.Break() or other code you've just added to your CustomAction does not get picked up even though you've rebuilt, this has caught me out a few times, usually when I'm trying to debug the UnInstall. The usual reason is that the code the installer is using as the CustomAction is not the one you've just built. To resolve this drop the newly built assembly into the Target installation location, e.g. if your CustomAction is built to a dll named MyCustomAction.dll and you've just installed to C:\Program Files\MyCompany\MyApp then drop the newly built dll and it's pdb into here and then try to uninstall. The uninstall picks up the CustomAction from the target location (this is also why you see you CustomAction's assembly in the target installation directory after install).

InstallState, stateSaver and savedState IDictionary

In your CustomAction code you'll see an IDictionary being passed around the Install and UnInstall overrides. This IDictionary is a HashTable. Because the Install and UnInstall are 2 completely different instances the UnInstall knows nothing of member variables set in the Install, instead it relies on an IDictionary, this IDictionary uses a text file to store it's data, thsi is how the Install and the UnInstall can comunicate i.e. the actual have no communication but the Install writes to a file and later the Uninstall reads from that same file. The IDictionary contains paths to the components that the CustomAction has installed (these also get written to a file in the Target installation location which has an extension ".InstallState").

At install time the IDictionary, "stateSaver", records the component names and their paths that were installed, this gets serialized in the file ".InstallState". At UnInstall time, this .InstallState file is deserialized into the IDictionary, "stateSaved", which the Uninstall override uses.

public override void Uninstall(IDictionary savedState)

{

base.Uninstall(savedState);

}

With the call to baseUninstall(stateSaved) it can uninstall all that was installed.

In the Install override you're free to add content yourself, the key can be any string really, remember the key must be unique, the value however should be a path to a file or the full path to a registry entry. The base.Uninstall(savedState) goes through each of these entries and attempts to remove them. The IDictionary can also be used to store values you'd like to explicitly uninstall yourself, remember you cannot depend on member variables you must have some persitant storage to store variables and that is this IDictionary.

Here's an example of a registry entry which was created by the CustomAction on Install and so must be deleted by the CustomAction on UnInstall

public override void Install(IDictionary stateSaver)

{

RegistryKey expressionEvaluatorPackageVersionKey = expressionEvaluatorInProcKey.CreateSubKey(packageVersion);

add the entry to the IDictionary with unique name for the Key and full registry path for the Value

stateSaver.Add("expressionEvaluatorPackageVersionKey" + guidString + packageVersion, expressionEvaluatorInProcKey.OpenSubKey(packageVersion).ToString());

}

At UnInstall pull the entry from the IDictionary and Explictly uninstall

It's unusual to have to explicitly do this, this should be done by the call to base.Uninstall(savedState).

public override void Uninstall(IDictionary savedState)

{

RegistryKey hKeyClassesRootCLSID = Registry.ClassesRoot.OpenSubKey("CLSID", true) as RegistryKey;

foreach (object key in savedState.Keys)

{

if (key.ToString().Contains("expressionEvaluatorPackageVersionKey"))

{

if (savedState[key] != null)

{

int index = savedState[key].ToString().IndexOf(@"\");

string keyStringWithoutHKEY_CLASSES_ROOT = savedState[key].ToString().Substring(index + 1);

RegistryKey expressionEvaluatorPackageVersionKey = Registry.ClassesRoot.OpenSubKey(keyStringWithoutHKEY_CLASSES_ROOT, true) as RegistryKey;

if(Registry.ClassesRoot.OpenSubKey(keyStringWithoutHKEY_CLASSES_ROOT, true) != null) Registry.ClassesRoot.DeleteSubKeyTree(keyStringWithoutHKEY_CLASSES_ROOT);

}

TransactionScope, Transactions in .NET, A very basic level introduction

2009-08-10T10:00:00.003Z

Transactions are used to prevent your application from getting into an unknown state.

Transactions work on services which register with the Transaction service such as Database calls.

It's useful where you cannot be sure that the resource (DB) will remain available while some data is changing and if the resource for some reason is made unavailable during a call then what happens to the data, well the Transaction should Rollback your Data so the app remains in the state it was before the data was sent.

Transactions in .NET are implemented with System.Transaction.TransactionScope class. In the background this uses COM+.

Wrap your DB call in a new TransactionScope instance, when the functionality is finished call TransactionScope.Complete(), then TransactionScope.Dispose(). If the execution makes it to these calls then your changes will be applied, if not your changes will be Rolled-back by the Transaction and you app will remain the same as before the call started.

MSDN Video

http://www.microsoft.com/downloads/details.aspx?familyid=08fa2cd1-0c1f-436e-9b19-632ae246a464&displaylang=en