David_Bennett : DotNet

DataBind and Multiviews

David_Bennett — Fri, 22 Dec 2006 23:20:00 GMT

If you are using a multiview in asp to display a bunch of different pieces of information, for example if you are displaying a bunch of logs that are selectable inside your multiview (using the tabbed control I posted here recently), you need to be careful about how you display the data. The way that GridView's work is if you set a DataSourceID on them they bind automatically when the page is loaded. This is probably not the behavior you want, since that means all of you views will bind and load when the page is loaded which can slow things down a lot if you have a bunch of views in your multiview. The way to get around this is to only call DataBind() on the sepcific view that is current being displayed. This requires you to change the DataBind() call ont he multiview so it doesn't call base.DataBind() (since this will call DataBindChildren()). Make the DataBind() on the Multiview only call the DataBind of the currently selected view. In the DataBind code for your user control or whatever you have inside the view, you then set the datasourceid on the gridview. This means you still get all the bonuses of using a DataSouceID without it loading all the data in all the views of your multivirew when first loading it.

I put a bunch of traps on the DataBInd and DataBIndChildren on the various calls and found that it is not easy to intercept the automatic databinding done by the GridView when it first loads. It is not really easily possible to make a delayed data bind grid view (although this is another possibility). You could do this by intercepting the call to the DataSourceID call and keeping track of it yourself and only setting it on the base when a DataBind() is called. With some experimentation I found that this proved to have more problems than just overriding DataBind() on the various user controls. Since doing the override also made me think about other things that might need to be delay bound.

The following code is a snippet for the MultiView showing how to override it to only DataBind the specifically active view. The DataBind() call ends up heirachically going down the control tree, so anything lower than it will have DataBind() called on it when the DataBind is called on the view itself.

    /// <summary>
    /// This multiview will only databind the active view, not any other views.
    /// </summary>
    [ToolboxData("<{0}:MultiViewActiveDataBind runat=server></{0}:MultiViewActiveDataBind>")]
    public class MultiViewActiveDataBind : MultiView
    {
        protected override void DataBindChildren()
        {
            // Only data bind the currently active view.
            if (this.ActiveViewIndex != -1)
            {
                this.Views[this.ActiveViewIndex].DataBind();
            }
        }
    }

GDF Xml file format

David_Bennett — Sat, 18 Nov 2006 04:25:00 GMT

The GDF file is an xml file associated with games in vista. The file gives information about the various ratings associated with the game along with the name of the game. The XML file format is fairly simple and is as follows:

<GameDefinitionFile>
    <GameDefinition>
        <Version>
            <VersionNumber versionNumber="x.y.y.y" />
        </Version>
    <Name>name of game</Name>
    <GameExecutables>
        <GameExecutable path="xyz.exe" />
        ...
    </GameExecutables>
    <Ratings>
        <Rating ratingId='<rating guid>' ratingSystemID='<rating system guid>'>
            <Descriptor descriptorID='<descriptor guid>' />
        </Rating>
        ...
        </Ratings>
    </GameDefintion>
    ...
</GameDefinitionFile>

Here is a simple C# class to read in and parse a GDF file. It assumes you are given an xml file as an input.

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Data.SqlClient;
using WpcData;

namespace WpcGames
{
    class GDFFile
    {
        List<GameDefinition> _games;

        public GDFFile(XmlDocument doc)
        {
            _games = new List<GameDefinition>();
            // Lets go through this and do some happy parsing.
            foreach (XmlNode node in doc.ChildNodes)
            {
                if (node.Name == "GameDefinitionFile")
                {
                    ParseGDF(node);
                }
            }
        }

        internal List<GameDefinition> Games
        {
            get { return _games; }
        }

        private void ParseGDF(XmlNode list)
        {
            foreach (XmlNode node in list.ChildNodes)
            {
                if (node.Name == "GameDefinition")
                {
                    Guid gameId = new Guid(node.Attributes["gameID"].Value);
                    //Guid wmid = new Guid(node.Attributes["WMID"].Value);
                    Guid wmid = Guid.Empty;
                    GameDefinition def = new GameDefinition(gameId, wmid);

                    _games.Add(def);

                    ParseGameDefinition(def, node);
                }
            }
        }

        private void ParseGameDefinition(GameDefinition def, XmlNode node)
        {
            foreach (XmlNode child in node.ChildNodes)
            {
                if (child.Name == "Version")
                {
                    foreach (XmlNode inner in child.ChildNodes)
                    {
                        if (inner.Name == "VersionNumber")
                        {
                            def.Version = inner.Attributes["versionNumber"].Value;
                        }
                    }
                }
                else if (child.Name == "Name")
                {
                    def.Name = child.InnerText;
                }
                else if (child.Name == "Ratings")
                {
                    ParseRatings(def, child);
                }
            }
        }

        private void ParseRatings(GameDefinition def, XmlNode node)
        {
            foreach (XmlNode child in node.ChildNodes)
            {
                if (child.Name == "Rating")
                {
                    Guid RatingID = new Guid(child.Attributes["ratingID"].Value);
                    //Guid SystemID = new Guid(child.Attributes["ratingSystemID"]);
                    def.Ratings.Add(RatingID);
                    ParseDescriptors(def, child);
                }
            }
        }

        private void ParseDescriptors(GameDefinition def, XmlNode node)
        {
            foreach (XmlNode child in node.ChildNodes)
            {
                if (child.Name == "Descriptor")
                {
                    Guid DescriptorID = new Guid(child.Attributes["descriptorID"].Value);
                    def.Descriptors.Add(DescriptorID);
                }
            }
        }
    }
}

How to turn on debug exceptions with WCF

David_Bennett — Mon, 13 Nov 2006 08:54:00 GMT

It is possible to see exceptions passed back in the messages sent to the service. This makes it a lot easier to debug multi-peer applications. The way to do this is to add into the web.config file the section. You can see in the following config section that the behavior <serviceDebug includeExceptionDetailInFaults="true" /> is defined, this sets up the system to include exception details in the return faults. If you do this set this up, make sure you remove it when you deploy your code into the wild. Finding exception info can be used to find ways to exploit your server based on stack traces.

    <system.serviceModel>
        <services>
            <service name="OneCareStatus.LogUploadService" behaviorConfiguration="UploadServiceBehavior">
                <endpoint address="" contract="OneCareStatus.ILogUploadService" binding="wsHttpBinding" bindingConfiguration="myHttpBinding"/>
            </service>
            <service name="OneCareStatus.FamilySafetyService" behaviorConfiguration="UploadServiceBehavior">
                <endpoint address="" contract="WpcSettings.IWpcSettingsService" binding="wsHttpBinding" bindingConfiguration="myHttpBinding"/>
            </service>
        </services>
        <bindings>
            <wsHttpBinding>
        <binding name="myHttpBinding">
         <security mode="None" />
         <reliableSession enabled="true"/>
        </binding>
            </wsHttpBinding>
        </bindings>
        <behaviors>
            <serviceBehaviors>
                <behavior name="UploadServiceBehavior">
                    <serviceMetadata httpGetEnabled="true" />
                    <serviceDebug includeExceptionDetailInFaults="true" />
                </behavior>
            </serviceBehaviors>
        </behaviors>
    </system.serviceModel>

Tabbed menu system for asp.net

David_Bennett — Mon, 13 Nov 2006 08:14:00 GMT

This is a piece of code to deal with tabbed browing, it uses a CompositeControl to deal with creating the tabs and the views. The tabs are created using a simple table setup with the different td elements using different css classes to change the way each of the elements looks.

The class is easily customisable, using a template for both the selected tab and the unselected tabs. The ViewNamed is setup with the name and the description, the name is the name to use for the tab and the description is used to fill in the tooltip for the button.

The following is the code for TabbedPanel.

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.ComponentModel;
using System.Collections.Generic;

namespace WebControls
{
    /// <summary>
    /// Creates a tabbed panel, using a multiview and a table for the menu
    /// at the top. The menu control was not flexible enough to support the
    /// items I wanted supported.
    /// </summary>
    [DefaultProperty("Views")]
    [ToolboxData("<{0}:TabbedMultiview runat=server></{0}:TabbedMultiview>")]
    [ParseChildren(true)]
    public class TabbedPanel : CompositeControl
    {
        private MultiView _multiview;
        private List<ViewNamed> _views;
        private ITemplate _template;
        private ITemplate _selectedTemplate;
        private bool _isLoaded;

        public TabbedPanel() : base()
        {
            _views = new List<ViewNamed>();
            _multiview = new MultiView();
            _multiview.Load += new EventHandler(_multiview_Load);
        }

        private void _multiview_Load(object sender, EventArgs e)
        {
            _isLoaded = true;
            RefreshTableCell(_views[_multiview.ActiveViewIndex]);
        }

        #region DefaultTabMenu
        /// <summary>
        /// Internal class which is the default menu.
        /// </summary>
        public class DefaultTabMenu : ITemplate
        {
            #region ITemplate Members
            public void InstantiateIn(Control owner)
            {
                Literal space = new Literal();
                LinkButton tab = new LinkButton();
                tab.DataBinding += new EventHandler(tab_DataBinding);
                owner.Controls.Add(tab);
            }

            void tab_DataBinding(object sender, EventArgs e)
            {
                LinkButton but = (LinkButton)sender;
                TabMenuContainer cont = (TabMenuContainer)but.NamingContainer;
                but.Text = cont.Name + " ";
                but.CommandName = "Tab";
                but.CommandArgument = cont.ViewId;
                but.ToolTip = cont.Description;
            }
            #endregion

        }
        #endregion

        /// <summary>
        /// The views associated with the panel. These are all ViewNamed
        /// elements.
        /// </summary>
        [Bindable(false)]
        [Category("Data")]
        [Localizable(true)]
        public List<ViewNamed> Views
        {
            get { return _views; }
        }

        /// <summary>
        /// The Css class to use on the <td></td> for the selected menu item.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [Localizable(true)]
        [DefaultValue("")]
        public string SelectedCssClass
        {
            get
            {
                String s = (String)ViewState["SelectedCssClass"];
                return ((s == null) ? String.Empty : s);
            }
            set
            {
                ViewState["SelectedCssClass"] = value;
            }
        }

        /// <summary>
        /// The css class to use on the main section.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [Localizable(true)]
        [DefaultValue("")]
        public string MainSectionCssClass
        {
            get
            {
                String s = (String)ViewState["MainSectionCssClass"];
                return ((s == null) ? String.Empty : s);
            }
            set
            {
                ViewState["MainSectionCssClass"] = value;
            }
        }

        /// <summary>
        /// The css class to use on the menu.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [Localizable(true)]
        [DefaultValue("")]
        public string MenuCssClass
        {
            get
            {
                String s = (String)ViewState["MenuCssClass"];
                return ((s == null) ? String.Empty : s);
            }
            set
            {
                ViewState["MenuCssClass"] = value;
            }
        }

        /// <summary>
        /// The css class to use on unselected items.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [Localizable(true)]
        [DefaultValue("")]
        public string UnselectedCssClass
        {
            get
            {
                String s = (String)ViewState["UnselectedCssClass"];
                return ((s == null) ? String.Empty : s);
            }
            set
            {
                ViewState["UnselectedCssClass"] = value;
            }
        }

        /// <summary>
        /// The active view index, mirrored from inside the multiview.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [Localizable(true)]
        [DefaultValue(0)]
        public int ActiveViewIndex
        {
            get
            {
                return _multiview.ActiveViewIndex;
            }
            set
            {
                int s = _multiview.ActiveViewIndex;
                _multiview.ActiveViewIndex = value;
                if (_isLoaded)
                {
                    if (s != -1)
                    {
                        RefreshTableCell(_views[s]);
                    }
                    RefreshTableCell(_views[value]);
                }
            }
        }

        /// <summary>
        /// The template to use for the tab.
        /// </summary>
        [
        Browsable(false),
        PersistenceMode(PersistenceMode.InnerProperty),
        DefaultValue(typeof(ITemplate), ""),
        Description("Control template"),
        TemplateContainer(typeof(TabMenuContainer))
        ]
        public virtual ITemplate TabTemplate
        {
            get
            {
                return _template;
            }
            set
            {
                _template = value;
            }
        }

        /// <summary>
        /// The template to use for the selected item.
        /// </summary>
        [
        Browsable(false),
        PersistenceMode(PersistenceMode.InnerProperty),
        DefaultValue(typeof(ITemplate), ""),
        Description("Control template"),
        TemplateContainer(typeof(TabMenuContainer))
        ]
        public virtual ITemplate SelectedTabTemplate
        {
            get
            {
                return _selectedTemplate;
            }
            set
            {
                _selectedTemplate = value;
            }
        }

        private void RefreshTableCell(ViewNamed view)
        {
            view.TableCell.Controls.Clear();
            if (view == _multiview.GetActiveView() && _isLoaded)
            {
                view.TableCell.CssClass = SelectedCssClass;
            }
            else
            {
                view.TableCell.CssClass = UnselectedCssClass;
            }
            CreateTabMenu(view, view.TableCell, view.Counter);
        }

        /// <summary>
        /// Sets the current tab to the specified id.
        /// </summary>
        /// <param name="id"></param>
        public void SetCurrentTab(string id)
        {
            ViewNamed currentActiveView = (ViewNamed)_multiview.GetActiveView();
            foreach (ViewNamed view in _views)
            {
                if (view.ID == id)
                {
                    if (view != currentActiveView)
                    {
                        _multiview.SetActiveView(view);
                        RefreshTableCell(view);
                        view.DataBind();
                    }
                }
            }
            RefreshTableCell(currentActiveView);
        }

        private void CreateTabMenu(ViewNamed view, TableCell cell, int counter)
        {
            ITemplate temp;

            view.Counter = counter;

            if (ActiveViewIndex == counter && _isLoaded)
            {
                temp = _selectedTemplate;
            }
            else
            {
                temp = _template;
            }

            if (temp == null)
            {
                temp = new DefaultTabMenu();
            }

            TabMenuContainer cont = new TabMenuContainer();
            cont.ID = "cont" + counter;
            cont.Name = view.Name;
            cont.Description = view.Description;
            cont.ViewId = view.ID;

            temp.InstantiateIn(cont);
            cell.Controls.Add(cont);
            SetupOnCommand(cont);
            cont.DataBind();
        }

        private void SetupOnCommand(Control cont)
        {
            foreach (Control bing in cont.Controls)
            {
                if (bing is Button)
                {
                    Button but = (Button)bing;

                    but.Command += new CommandEventHandler(tab_Command);
                }
                if (bing is LinkButton)
                {
                    LinkButton but = (LinkButton)bing;

                    but.Command += new CommandEventHandler(tab_Command);
                }
                if (bing.Controls.Count > 0)
                {
                    SetupOnCommand(bing);
                }
            }
        }

        protected void tab_Command(object sender, CommandEventArgs e)
        {
            switch (e.CommandName)
            {
                case "Tab":
                    LinkButton but = (LinkButton)sender;
                    TabMenuContainer cont = (TabMenuContainer)but.NamingContainer;
                    TabbedPanel mult = (TabbedPanel)cont.NamingContainer;

                    mult.SetCurrentTab((string)e.CommandArgument);
                    break;
            }
        }

        /// <summary>
        /// Creates all the nessary child controls.
        /// </summary>
        protected override void CreateChildControls()
        {
            Controls.Clear();
            _multiview.ID = "multTabs";

            Table table = new Table();
            table.CellPadding = 0;
            table.CellSpacing = 0;
            table.BorderWidth = 0;
            table.CssClass = MenuCssClass;
            TableRow row = new TableRow();
            table.Rows.Add(row);
            int counter = 0;
            foreach (ViewNamed view in _views)
            {
                TableCell cell = new TableCell();

                _multiview.Views.Add(view);
                view.TableCell = cell;
                cell.CssClass = UnselectedCssClass;
                CreateTabMenu(view, cell, counter);
                row.Cells.Add(cell);
                counter++;
            }
            Controls.Add(table);
            if (MainSectionCssClass != String.Empty)
            {
                Panel pan = new Panel();
                pan.CssClass = this.MainSectionCssClass;
                pan.Controls.Add(_multiview);
                Controls.Add(pan);
            }
            else
            {
                Controls.Add(_multiview);
            }
            base.CreateChildControls();
        }

        /// <summary>
        /// Deal with databinding.
        /// </summary>
        public override void DataBind()
        {
            CreateChildControls();
            ChildControlsCreated = true;
            base.DataBind();
        }

        protected override void OnDataBinding(EventArgs e)
        {
            EnsureChildControls();
            base.OnDataBinding(e);
        }
    }
}

The following is the code for the ViewNamed.

using System;
using System.Collections.Generic;
using System.Text;
using System.Web.UI.WebControls;
using System.ComponentModel;
using System.Web.UI;

namespace WebControls
{
    /// <summary>
    /// View with a text name on it, so we can pull the details out for the tabed browsing stuff.
    /// </summary>
    [DefaultProperty("Name")]
    [ToolboxData("<{0}:NamedView runat=server></{0}:NamedView>")]
    public class ViewNamed : View
    {
        private TableCell _cell;
        private int _counter;

        /// <summary>
        /// Name to display on the tab.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string Name
        {
            get
            {
                String s = (String)ViewState["Name"];
                return ((s == null) ? String.Empty : s);
            }

            set
            {
                ViewState["Name"] = value;
            }
        }

        /// <summary>
        /// Tool tip to use on the tab.
        /// </summary>
        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string Description
        {
            get
            {
                String s = (String)ViewState["Description"];
                return ((s == null) ? String.Empty : s);
            }

            set
            {
                ViewState["Description"] = value;
            }
        }

        internal TableCell TableCell
        {
            get { return _cell; }
            set { _cell = value; }
        }

        internal int Counter
        {
            get { return _counter; }
            set { _counter = value; }
        }
    }
}

The TabMenuControl class.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace WebControls
{
    [DefaultProperty("Text")]
    [ToolboxItem(false)]
    public class TabMenuContainer : WebControl, INamingContainer
    {
        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string Name
        {
            get
            {
                String s = (String)ViewState["Name"];
                return ((s == null) ? String.Empty : s);
            }

            set
            {
                ViewState["Name"] = value;
            }
        }

        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string Description
        {
            get
            {
                String s = (String)ViewState["Description"];
                return ((s == null) ? String.Empty : s);
            }

            set
            {
                ViewState["Description"] = value;
            }
        }

        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue("")]
        [Localizable(true)]
        public string ViewId
        {
            get
            {
                String s = (String)ViewState["ViewId"];
                return ((s == null) ? String.Empty : s);
            }

            set
            {
                ViewState["ViewId"] = value;
            }
        }

        [Bindable(true)]
        [Category("Appearance")]
        [DefaultValue(false)]
        [Localizable(true)]
        public bool Selected
        {
            get
            {
                object ob = ViewState["Selected"];
                if (ob == null)
                {
                    return false;
                }
                return (bool)ob;
            }
            set
            {
                ViewState["Selected"] = value;
            }
        }

        protected override void OnDataBinding(EventArgs e)
        {
            EnsureChildControls();
            base.OnDataBinding(e);
        }
    }
}

ROW_NUMBER() and asp.net

David_Bennett — Sat, 11 Nov 2006 22:25:00 GMT

I was looking around at ways to optimise asp.net over the last few days and ran across this article about using ROW_NUMBER(), which is quite good. There were a few aspects of it missing that I had to do a little more work to look up. I tracked down some things on msdn that pointed out that ObjectDataSource has a SelectMethodCount attribute that is used to do paging when only getting partial data. If this attribute is specified and the grid view is doing paging then the object datasource select method will be called with two extra parameters, being startRowIndex and maximumRows. Using these two parameters you can pass down into the actual sql statement to do the data limiting returns.

These are documented on msdn, I just didn't see the documentation before. The ROW_NUMBER() method is a very obscure syntax inside of sql. It seems to do roughly what the LIMIT keyword does in mysql, although it is more flexible. The way it works is you use ROW_NUMBER() with the 'as' keyword in the select arguments, you can then use it in the WHERE parameters to restrict the return values. It seems that you also put the ORDER BY you want to use inside the ROW_NUMBER() argument syntax and this does the ordering for the returned dataset.

This looks like a very easy technique to constrain the return values to the datagrids and other paginated data views.

FileVersionInfo - getting the FileDescription in C#

David_Bennett — Tue, 31 Oct 2006 07:12:00 GMT

Getting the file description in C# requires using the VerQueryInfo calls to load in the data from the file. First you load in the culture information so you get the information in the right language and then you load the actual data into the buffer. To do this you need to call a couple of external unsafe method calls to the various methods defined in version.dll

Below is a small class that takes in a path and gets the file version information from it. This is useful when reading in the WPC logs to turn the application's run into an actual name for the application.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.InteropServices;

namespace OneCareService
{
    public class FileVersionInfo
    {
        [DllImport("version.dll")]
        private static extern bool GetFileVersionInfo(string sFileName,
             int handle, int size, byte[] infoBuffer);
        [DllImport("version.dll")]
        private static extern int GetFileVersionInfoSize(string sFileName,
             out int handle);

        // The third parameter - "out string pValue" - is automatically
        // marshaled from ANSI to Unicode:
        [DllImport("version.dll")]
        unsafe private static extern bool VerQueryValue(byte[] pBlock,
             string pSubBlock, out string pValue, out uint len);
        // This VerQueryValue overload is marked with 'unsafe' because
        // it uses a short*:
        [DllImport("version.dll")]
        unsafe private static extern bool VerQueryValue(byte[] pBlock,
             string pSubBlock, out short* pValue, out uint len);

        public static unsafe string GetFileVersionNameInfo(string path)
        {
            string name = null;
            int handle = 0;
            int size = GetFileVersionInfoSize(path, out handle);
            if (size != 0)
            {
                byte[] buffer = new byte[size];

                if (GetFileVersionInfo(path, handle, size, buffer))
                {
                    uint len = 0;
                    short* subBlock = null;
                    if (VerQueryValue(buffer, @"\VarFileInfo\Translation", out subBlock, out len) && len > 2)
                    {
                        string spv = @"\StringFileInfo\" + subBlock[0].ToString("X4") + subBlock[1].ToString("X4") + @"\FileDescription";
                        byte* pVersion = null;
                        string versionInfo;
                        if (VerQueryValue(buffer, spv, out versionInfo, out len))
                        {
                            name = versionInfo;
                        }
                    }
                }
            }
            if (name == null)
            {
                name = Path.GetFileNameWithoutExtension(path);
            }
            return name;
        }
    }
}

.net Binding for WPC Events

David_Bennett — Thu, 26 Oct 2006 23:40:00 GMT

The WPC event system logs a series of events to the WPC crimson channel. The channel contents is viewable inside the log viewer and it has a path of: Microsoft-Windows-ParentalControls/Operational. The events are logged with a variety of different parameters, mostly you can see what they are from inside the event viewer itself. Of the logs in the system, the ones that are logged by default are SettingChangeEvent (logged by the WPC system), Game Start Event (logged by the gameux system), Url Visit Event (logged by the WPC system), Media Playback Event (logged by Media Player), File Download Event (logged by IE), AppOverrideEvent (logged by the WPC system), WebOverrideEvent (logged by the WPC system) and AppBlockedEvent (safer events copied from the insecure application log).

The logs are mostly as you would expect, the web and app override events are generated by the over the shoulder allowing of specific web sites, when it pops up the elevation dialog box and allows you to allow or block the url/app on the spot. The other events in the wpc log are not currently logged by any existing application and will require logging from the apps themselves. This log format is not going to change in the future though, so logging these events will mean they will show up in the next versions of WPC as well.

The following code is a series of constants that allow you to reference the various parts of the crimson logs easily. The enum WPCEvents is used to look at the eventid of the crimson log to see which of the wpc events it is referring to. The other enums are used to index into the user array of events when querying the crimson logs, to get the correct values out.

The enum of WPC_MEDIA_TYPE and WPC_MEDIA_EXPLICIT_TYPE are used when looking at the values for the MEDIATYPE and the EXPLICIT fields in the the media playback event.

The enum of WPCFLAG_IM_FEATURE is used to determine which features the IMFEATUREEVENT refers to. The feature event is logged for several different types of log events and this mask determines which type they are. It is legal for this mask to contain multiple flags to mark that this event is for multiple event types.

The enum of WPCSettings is used to look at the SETTING name inside the SETTINGSCHANGEVENT to figure out which of the settings is being changed. This is a number to make the setting localizable correctly.

using System;
using System.Collections.Generic;
using System.Text;

namespace OneCareService
{
    /// <summary>
    /// The enums for the specific event ids.
    /// </summary>
    public enum WPCEvents
    {
        SettingChangeEvent = 1,
        GameStartEvent = 2,
        UrlVisitEvent = 3,
        EmailReceivedEvent = 4,
        EmailSentEvent = 5,
        MediaPlaybackEvent = 6,
        IMInvitationEvent = 7,
        IMJoinEvent = 8,
        IMLeaveEvent = 9,
        FileDownloadEvent = 10,
        IMFeatureEvent = 11,
        CustomEvent = 13,
        EmailContactEvent = 14,
        IMContactEvent = 15,
        AppBlockedEvent = 16,
        AppOverrideEvent = 17,
        WebOverrideEvent = 18
    }

    /// <summary>
    /// The indexes into the user settings for the setting chane event.
    /// </summary>
    public enum WPC_ARGS_SETTINGSCHANGEEVENT
    {
        CLASS = 0,
        SETTING,
        OWNER,
        OLDVAL,
        NEWVAL,
        REASON,
        OPTIONAL
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the AppBlockedEvent.
    /// </summary>
    public enum WPC_ARGS_SAFERAPPBLOCKED
    {
        TIMESTAMP = 0,
        USERID,
        PATH,
        RULEID
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailReceivedEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILRECEIEVEDEVENT
    {
        SENDER = 0,
        APPNAME,
        APPVERSION,
        SUBJECT,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        ATTACHCOUNT,
        ATTACHMENTNAME,
        RECEIVEDTIME,
        EMAILACCOUNT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailSentEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILSENTEVENT
    {
        SENDER = 0,
        APPNAME,
        APPVERSION,
        SUBJECT,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        ATTACHCOUNT,
        ATTACHMENTNAME,
        EMAILACCOUNT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the EmailContactEvent.
    /// </summary>
    public enum WPC_ARGS_EMAILCONTACTEVENT
    {
        APPNAME = 0,
        APPVERSION,
        OLDNAME,
        OLDID,
        NEWNAME,
        NEWID,
        REASON,
        EMAILACCOUNT
    }

    /// <summary>
    /// This is the values to use for the MEDIATYPE field in the
    /// WPC_ARGS_MEDIAPLAYBACKEVENT.
    /// </summary>
    public enum WPC_MEDIA_TYPE
    {
        OTHER = 0,
        DVD,
        RECORDED_TV,
        AUDIO_FILE,
        CD_AUDIO,
        VIDEO_FILE,
        PICTURE_FILE,
        MAX
    }

    /// <summary>
    /// This is the values to use for the EXPLICIT field in the
    /// WPC_ARGS_MEDIAPLAYBACKEVENT.
    /// </summary>
    public enum WPC_MEDIA_EXPLICIT_TYPE
    {
        FALSE = 0,
        TRUE,
        UNKNOWN
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the MediaPlaybackEvent.
    /// </summary>
    public enum WPC_ARGS_MEDIAPLAYBACKEVENT
    {
        APPNAME = 0,
        APPVERSION,
        MEDIATYPE,
        PATH,
        TITLE,
        PML,
        ALBUM,
        EXPLICIT,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the MediaDownloadEvent.
    /// </summary>
    public enum WPC_ARGS_MEDIADOWNLOADEVENT
    {
        APPNAME = 0,
        APPVERSION,
        MEDIATYPE,
        PATH,
        TITLE,
        PML,
        ALBUM,
        EXPLICIT,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMInvitationEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONINITEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        REQUESTINGIP,
        SENDER,
        REASON,
        RECIPCOUNT,
        RECIPIENT
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMJoinEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONJOINEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        JOININGIP,
        JOININGUSER,
        REASON,
        MEMBERCOUNT,
        MEMBER,
        SENDER
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMLeaveEvent.
    /// </summary>
    public enum WPC_ARGS_CONVERSATIONLEAVEEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        LEAVINGIP,
        LEAVINGUSER,
        REASON,
        MEMBERCOUNT,
        MEMBER,
        FLAGS
    }

    /// <summary>
    /// This is the flags to use in the MEDIA_TYPE setction of the WPC_ARGS_IMFEATUREEVENT
    /// when reading it out of the crimson logs.
    /// </summary>
    public enum WPCFLAG_IM_FEATURE : uint
    {
        NONE = 0x00,
        VIDEO = 0x01,
        AUDIO = 0x02,
        GAME = 0x04,
        SMS = 0x08,
        FILESWAP = 0x10,
        URLSWAP = 0x20,
        SENDING = 0x80000000, // Top bit means sending or receiving.
        ALL = 0xFFFFFFFF
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMFeatureEvent.
    /// </summary>
    public enum WPC_ARGS_IMFEATUREEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        CONVID,
        MEDIATYPE,
        REASON,
        RECIPCOUNT,
        RECIPIENT,
        SENDER,
        SENDERIP,
        DATA
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the IMContactEvent.
    /// </summary>
    public enum WPC_ARGS_IMCONTACTEVENT
    {
        APPNAME = 0,
        APPVERSION,
        ACCOUNTNAME,
        OLDNAME,
        OLDID,
        NEWNAME,
        NEWID,
        REASON
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the GameStartEvent.
    /// </summary>
    public enum WPC_ARGS_GAMESTARTEVENT
    {
        APPID = 0,
        INSTANCEID,
        APPVERSION,
        PATH,
        RATING,
        RATINGSYSTEM,
        REASON,
        DESCCOUNT,
        DESCRIPTOR,
        PID
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the FileDownloadEvent.
    /// </summary>
    public enum WPC_ARGS_FILEDOWNLOADEVENT
    {
        URL = 0,
        APPNAME,
        VERSION,
        BLOCKED,
        PATH,
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the UrlVisitEvent.
    /// </summary>
    public enum WPC_ARGS_URLVISITEVENT
    {
        URL = 0,
        APPNAME,
        VERSION,
        REASON,
        RATINGSYSTEMID,
        CATCOUNT,
        CATEGORY
    }

    /// <summary>
    /// The indexes into the user settings part of crimson for the CustomEvent.
    /// </summary>
    public enum WPC_ARGS_CUSTOMEVENT
    {
        PUBLISHER = 0,
        APPNAME,
        APPVERSION,
        EVENT,
        VALUE1,
        VALUE2,

Atlas, ContentPanel and controls

David_Bennett — Fri, 29 Sep 2006 00:09:00 GMT

I discovered, while trying to use atlas contentpanels in my app, that the bits inside the atlas content panels are not loaded along with the normal load process. This means if you have a PageLoad event in your custom control and you try and set something inside the ContentPanel it is not created yet. To work around this you need to do creative things with events.

With the paginated repeater I included the details on previously I added an extra function which goes through and finds a control that implement IDataSourceProxy in the parent list of the control. From this I can then get the datasourceid and do a FindControl on the page to find it. This is a bit messy, but it does work.

PaginatedRepeater in asp.net

David_Bennett — Sat, 16 Sep 2006 01:42:00 GMT

The Paginated repeater is an extension of the standard repeater to add in pagination capabilities. It is does it by wrapping the datasource with the PagedDataSource, which is a data source wrapper available in asp.net. I added in a NumberOfPagesToShow attribute, which determines how many of the numbers to show at the top of control to move through the pages before showing a .... The TableWidth attribute, which is used to put into the table which creates the pagination details at the top of the control. PageSize and PageIndex are both pretty much straightforward in what they do.

The PaginatedRepeater works by overloading the OnLoad function to find the datasource at that point in time and pass it on down to the main Repeater object. It also determines if the request is a post back and sets the page index to the correct value. The DataBind() call at the bottom of this function connects up and completes the data binding of the object, this is what connects the repeater to the actual data for rending.

The OnPreRender function is used to register a field which keeps track of the next page, this allows the javascript code to correctly move onto the next page when the next and previous buttons are clicked on the page. The OnPreRender function also registers the javascript to be used in the control.

The Render function does all the work, it wraps a table around the actual control which puts in the numbers, the current page number and works out which numbers to actually show. It switches on the PagerButtons enumerate type, that is used in other pager objects, to determine what type of pagination buttons to use and show. The NavigateUrl on the controls are setup with javascript to do the pagination. The code to this class is included below.

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Collections;

namespace CustomControls
{

    /// <summary>
    /// Summary description for PaginatedRepeater
    /// </summary>
    public class PaginatedRepeater : Repeater
    {
        private PagedDataSource _pagedDataSource = new PagedDataSource();
        private PagerButtons _pagerbuttons = PagerButtons.NumericFirstLast;
        private Unit _tableWidth = new Unit("100%");
        private int _numToShow = 10;
        private string _dataSourceId = "";

        public PaginatedRepeater()
        {
            _pagedDataSource.AllowPaging = true;
            DataSource = _pagedDataSource;
        }

        public override string DataSourceID
        {
            get
            {
                return _dataSourceId;
            }
            set
            {
                if (value == null)
                {
                    _dataSourceId = "";
                }
                else
                {
                    _dataSourceId = value;
                }
            }
        }

        /// <summary>
        /// The number of pages to show when putting up a pagination thingy.
        /// </summary>
        public int NumberOfPagesToShow
        {
            get { return _numToShow; }
            set { _numToShow = value; }
        }

        /// <summary>
        /// The width of the table.
        /// </summary>
        public Unit TableWidth
        {
            get { return _tableWidth; }
            set { _tableWidth = value; }
        }

        /// <summary>
        /// Which buttons to show where.
        /// </summary>
        public PagerButtons PagerButtons
        {
            get { return _pagerbuttons; }
            set { _pagerbuttons = value; }
        }

        /// <summary>
        /// The current page index.
        /// </summary>
        public int PageIndex
        {
            get
            {
                return _pagedDataSource.CurrentPageIndex;
            }
            set
            {
                _pagedDataSource.CurrentPageIndex = value;
            }
        }

        /// <summary>
        /// The current page size.
        /// </summary>
        public int PageSize
        {
            get
            {
                return _pagedDataSource.PageSize;
            }
            set
            {
                _pagedDataSource.PageSize = value;
            }
        }

        protected override void OnLoad(EventArgs e)
        {
            if (DataSourceID != "")
            {
                object frog = this.Page.FindControl(DataSourceID);
                DataSourceID = "";
                if (frog is ObjectDataSource)
                {
                    ObjectDataSource data = (ObjectDataSource)frog;

                    _pagedDataSource.DataSource = data.Select();
                }
            }
            if (Page.IsPostBack)
            {
                string str = Page.Request.Form["__NEXTPAGE"];
                int pos = 0;
                try
                {
                    pos = Int32.Parse(str);
                }
                catch (FormatException)
                {
                }

                _pagedDataSource.CurrentPageIndex = pos;
            }
            DataBind();
            base.OnLoad(e);
        }

        protected override void OnPreRender(EventArgs args)
        {
            _pagedDataSource.DataSource = _pagedDataSource.DataSource;
            if (Page != null)
            {
                //Add hidden fields used to store the next page the user wants to visit
                //Note that the __NEXTPAGE value could be a previous page or a next page
                Page.ClientScript.RegisterHiddenField("__NEXTPAGE", "");

                //Add javascript used for pagination
                if (!Page.ClientScript.IsClientScriptBlockRegistered("Paginate"))
                {
                    Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "Paginate",
                         "<script language=\"javascript\">\r\n" +
                         "\r\n" +
                         "</script>\r\n");
                }
            }

            base.OnPreRender(args);
        }

        protected override void Render(HtmlTextWriter writer)
        {
            Table table;
            TableRow row;
            TableCell cell;
            HyperLink link;
            Literal lit;

            table = new Table();
            table.Width = _tableWidth;
            table.CellPadding = 0;
            table.CellSpacing = 0;
            table.BorderWidth = 0;

            // Single row with all the stuff in it.
            row = new TableRow();
            row.CssClass = "Pager";
            table.Rows.Add(row);

            switch (_pagerbuttons)
            {
                case PagerButtons.NextPreviousFirstLast:
                case PagerButtons.NextPrevious:
                    if (_pagedDataSource.PageCount > 1)
                    {
                        if (_pagedDataSource.CurrentPageIndex > 1 && _pagerbuttons == PagerButtons.NextPreviousFirstLast)
                        {
                            // First.
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Right;
                            link.Text = "<<";
                            link.NavigateUrl = "javascript: __doPaginate(0);";
                            cell.Controls.Add(link);
                            row.Cells.Add(cell);
                        }
                        if (_pagedDataSource.CurrentPageIndex > 0)
                        {
                            // Now we have a previous.
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Right;
                            link.Text = "<";
                            link.NavigateUrl = "javascript: __doPaginate(" + (_pagedDataSource.CurrentPageIndex - 1) + ");";
                            cell.Controls.Add(link);
                            row.Cells.Add(cell);
                        }
                        if (_pagedDataSource.CurrentPageIndex < _pagedDataSource.PageCount - 1)
                        {
                            // Next
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Right;
                            link.Text = ">";
                            link.NavigateUrl = "javascript: __doPaginate(" + (_pagedDataSource.CurrentPageIndex + 1) + ");";
                            cell.Controls.Add(link);
                            row.Cells.Add(cell);
                        }
                        if (_pagedDataSource.CurrentPageIndex < _pagedDataSource.PageCount - 2 && _pagerbuttons == PagerButtons.NextPreviousFirstLast)
                        {
                            // First.
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Right;
                            link.Text = ">>";
                            link.NavigateUrl = "javascript: __doPaginate(" + (_pagedDataSource.PageCount - 1) + ");";
                            cell.Controls.Add(link);
                            row.Cells.Add(cell);
                        }
                    }
                    break;
                case PagerButtons.Numeric:
                case PagerButtons.NumericFirstLast:
                    if (_pagedDataSource.PageCount > 1)
                    {
                        int start = _pagedDataSource.CurrentPageIndex - (_numToShow / 2);
                        if (start < 0)
                        {
                            start = 0;
                        }
                        int max = start + _numToShow;
                        if (max > _pagedDataSource.PageCount)
                        {
                            start -= max - _pagedDataSource.PageCount;
                            if (start < 0)
                            {
                                start = 0;
                            }
                            max = _pagedDataSource.PageCount;
                        }
                        if (start > 0)
                        {
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Left;
                            link.Text = "<<";
                            link.NavigateUrl = "javascript: __doPaginate(0);";
                            cell.Controls.Add(link);
                            lit = new Literal();
                            lit.Text = " ";
                            cell.Controls.Add(lit);
                            row.Cells.Add(cell);
                        }
                        for (int i = start; i < max; i++)
                        {
                            cell = new TableCell();
                            if (i == this._pagedDataSource.CurrentPageIndex)
                            {
                                Label lab = new Label();

                                lab.Text = (i + 1).ToString();
                                cell.Controls.Add(lab);
                                lit = new Literal();
                                lit.Text = " ";
                                cell.Controls.Add(lit);
                            }
                            else
                            {
                                link = new HyperLink();
                                cell.HorizontalAlign = HorizontalAlign.Left;
                                link.Text = (i + 1).ToString();
                                link.NavigateUrl = "javascript: __doPaginate(" + i + ");";
                                cell.Controls.Add(link);
                                lit = new Literal();
                                lit.Text = " ";
                                cell.Controls.Add(lit);
                            }
                            row.Cells.Add(cell);
                        }
                        if (max < _pagedDataSource.PageCount)
                        {
                            cell = new TableCell();
                            link = new HyperLink();
                            cell.HorizontalAlign = HorizontalAlign.Left;
                            link.Text = ">>";
                            link.NavigateUrl = "javascript: __doPaginate(" + (_pagedDataSource.PageCount - 1) + ");";
                            cell.Controls.Add(link);
                            lit = new Literal();
                            lit.Text = " ";
                            cell.Controls.Add(lit);
                            row.Cells.Add(cell);
                        }
                    }
                    break;
            }

            cell = new TableCell();
            cell.HorizontalAlign = HorizontalAlign.Right;
            cell.Width = _tableWidth;
            cell.Text = "Page " + (_pagedDataSource.CurrentPageIndex + 1) + " of " + _pagedDataSource.PageCount;
            row.Cells.Add(cell);

            table.RenderControl(writer);

            // Put the pagination controls at the top or bottom.
            base.Render(writer);
        }
    }
}

Reading in Crimson Logs

David_Bennett — Sat, 25 Mar 2006 04:31:00 GMT

Crimson logs can be read in through c# by use of some bindings to the APIs. Crimson is a new logging protocol in Windows Vista.

I will start by including all the bindings to the actual apis, then talk about the specific classes than can wrap around them to get useful information out of Crimson.

This has all the crimson functions divided up into sections, when I go through each part of the session I will talk about what Crimson can support for the various types of logging.

///////////////////////////////////////////////////////////////////////////
///
/// <summary>
///     CrimsonEventLog: The structures and functions using P/Invoke for
///     accessing the CrimsonEventLog (Crimson).
/// </summary>
///
///////////////////////////////////////////////////////////////////////////
internal static class CrimsonEventLog
{
    //-----------------------------------------------------------------

    #region Cluster channels

    internal const string ClusterChannelRoot = "Microsoft-Windows-FailoverClustering";
    internal const string ClusterChannelAdmin = "Microsoft-Windows-FailoverClustering/Admin";
    internal const string ClusterChannelOperational = "Microsoft-Windows-FailoverClustering/Operational";

    #endregion

    //-----------------------------------------------------------------

    #region Utility routines

    [DllImport("wevtapi.dll", EntryPoint = "EvtClose",
                             CallingConvention = CallingConvention.Winapi,
                             SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EventClose(IntPtr handlePtr);

#if DEBUG_TEST
    [DllImport( "wevtapi.dll", EntryPoint = "EvtGetExtendedStatus",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true )]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EventGetExtendedStatus( int size,
                                                     StringBuilder buffer,
                                                 ref int charsWritten );
#endif

    #endregion

    //-----------------------------------------------------------------

    #region Session routines

    public enum EventLoginClass
    {
        EvtRpcLogin = 1
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct EventRPCLogin
    {
        // all str params are optional
        internal String server;
        internal String user;
        internal String domain;
        internal String password;
        internal Int32 flags; // currently must be 0.
    }

    [DllImport("wevtapi.dll", EntryPoint = "EvtOpenSession",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    public static extern IntPtr EventOpenSession(EventLoginClass loginClass,
                                             ref EventRPCLogin Login,
                                                 int timeout,
                                                 int flags);

    #endregion

    //-----------------------------------------------------------------

    #region Log Maintence routines
    [DllImport("wevtapi.dll", EntryPoint = "EvtClearLog",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    public static extern bool EventClearLog(EventSafeHandle sessionHandle,
                                             string path,
                                             string targetPath,
                                             int flags);

    public enum EventExportLogFlags
    {
        ChannelPath = 1,
        LogFilePath = 2
    };

    [DllImport("wevtapi.dll", EntryPoint = "EvtExportLog",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    public static extern bool EventExportLog(EventSafeHandle sessionHandle,
                                             string path,
                                             string query,
                                             string targetPath,
                                             [MarshalAs(UnmanagedType.I4)]EventExportLogFlags flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtArchiveExportedLog",
                     CallingConvention = CallingConvention.Winapi,
                     CharSet = CharSet.Auto,
                     SetLastError = true)]
    public static extern bool EventArchiveLog(EventSafeHandle sessionHandle,
                                             string path,
                                             int lcid,
                                             int flags);

    public enum EventLogOpenFlags
    {
        ChannelPath = 1,
        FilePath = 2
    };

    [DllImport("wevtapi.dll", EntryPoint = "EvtOpenLog",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern IntPtr EventOpenLog(EventSafeHandle sessionHandle,
                                             string path,
                                             [MarshalAs(UnmanagedType.I4)]EventLogOpenFlags flags);

    public enum EventLogPropertyId
    {
        CreationTime = 0,
        LastAccessTime = 1,
        LastWriteTime = 2,
        FileSize = 3,
        Attributes = 4,
        NumberOfLogRecords = 5,
        OldestRecordNumber = 6,
        Full = 7
    };

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetLogInfo",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern bool EventGetLogInfo(EventSafeHandle logHandle,
                                             [MarshalAs(UnmanagedType.I4)]EventLogPropertyId propId,
                                             int bufferSize,
                                             ref EventVariant propertyValueBuffer,
                                             ref int propertyValueBufferUsed);

    #endregion

    //-----------------------------------------------------------------

    #region Subscription routines

    public enum EventSubscribeFlags
    {
        EvtSubscribeToFutureEvents = 0x1,
        EvtSubscribeStartAtOldestRecord = 0x2,
        EvtSubscribeStartAfterBookmark = 0x3,
        EvtSubscribeInternal = 0x4
    }

    public enum EventSubscribeNotifyAction
    {
        EvtSubscribeActionError = 0x0,
        EvtSubscribeActionDeliver = 0x1
    }

    public enum EventEventPropertyId
    {
        EvtEventQueryIDs = 0x0,
        EvtEventPath = 0x1
    }

    public delegate Int32 EventSubscribeCallback([MarshalAs(UnmanagedType.I4)]EventSubscribeNotifyAction action,
                                                    IntPtr context,
                                                    IntPtr eventPtr);

    [DllImport("wevtapi.dll", EntryPoint = "EvtSubscribe",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    public static extern IntPtr EventSubscribe(EventSafeHandle sessionHandle,
                                                IntPtr signalEvent,
                                                String channelPath,
                                                String query,
                                                IntPtr bookMark,
                                                IntPtr context,
                                                [MarshalAs(UnmanagedType.I4)]EventSubscribeCallback eventCallback,
                                                int flags);

    #endregion

    //-----------------------------------------------------------------

    #region Query routines

    public enum EventQueryFlags
    {
        EvtQueryChannelPath = 0x1,
        EvtQueryFilePath = 0x2,
        EvtQueryForwardDirection = 0x100,
        EvtQueryReverseDirection = 0x200,
    }

    [DllImport("wevtapi.dll", EntryPoint = "EvtQuery", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern IntPtr EventQuery(
        EventSafeHandle sessionHandle,
        String path,
        String query,
        [MarshalAs(UnmanagedType.I4)]EventQueryFlags flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtNext", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool EventNext(
        EventSafeHandle resultSet,
        int eventsSize,
        IntPtr[] events,
        int timeout,
        int flags,
        ref int returned);

    #endregion

    //-----------------------------------------------------------------

    #region Channel enumeration routines

    [DllImport("wevtapi.dll", EntryPoint = "EvtOpenChannelEnum", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern IntPtr EventOpenChannelEnum(
        EventSafeHandle session,
        int flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtNextChannelPath", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool EventNextChannelPath(
        EventSafeHandle channelEnum,
        int channelPathBufferSize,
        StringBuilder channelPathBuffer,
        out int channelPathBufferUsed);

    #endregion

    //-----------------------------------------------------------------

    #region Channel config routines

    public enum ChannelConfigPropertyID
    {
        ChannelConfigEnabled = 0,
        ChannelConfigIsolation = 1,
        ChannelConfigType = 2,
        ChannelConfigIsClassicChannel = 3,
        ChannelConfigAccess = 4,
        ChannelLoggingConfigRetention = 5,
        ChannelLoggingConfigAutoBackup = 6,
        ChannelLoggingConfigMaxSize = 7,
        ChannelLoggingConfigLogFilePath = 8,
        ChannelPublishingConfigLevel = 9,
        ChannelPublishingConfigKeywords = 10,
        ChannelPublishingConfigControlGuid = 11,
        ChannelConfigPropertyIdEND
    };

    public enum ChannelType
    {
        Admin = 0,
        Operational = 1,
        Analytic = 2,
        Debug = 3,
        Unknown = 4
    };

    [DllImport("wevtapi.dll", EntryPoint = "EvtOpenChannelConfig", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern IntPtr EventOpenChannelConfig(
        EventSafeHandle session,
        string channelPath,
        int flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetChannelConfigProperty", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool EventGetChannelConfigProperty(
        EventSafeHandle channelConfig,
        [MarshalAs(UnmanagedType.I4)]ChannelConfigPropertyID propertyId,
        int flags,
        int propertyValueBufferSize,
        ref EventVariant propertyValueBuffer,
        out int propertyValueBufferUsed);

    [DllImport("wevtapi.dll", EntryPoint = "EvtSetChannelConfigProperty", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool EventSetChannelConfigProperty(
        EventSafeHandle channelConfig,
        [MarshalAs(UnmanagedType.I4)]ChannelConfigPropertyID propertyId,
        int flags,
        ref EventVariant propertyValueBuffer);

    [DllImport("wevtapi.dll", EntryPoint = "EvtSaveChannelConfig", CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto, SetLastError = true)]
    public static extern bool EventSaveChannelConfig(
        EventSafeHandle channelConfig,
        int Flags
        );
    #endregion

    //-----------------------------------------------------------------

    #region Rendering routines

    public enum EventRenderContextFlags
    {
        EvtRenderContextValues = 0x0, // Render specific properties
        EvtRenderContextSystem = 0x1,    // Render all system properties (System)
        EvtRenderContextUser = 0x2     // Render all user properties (User/EventData)
    }

    public enum EventRenderFlags
    {
        EvtRenderEventValues = 0x0,     // Variants
        EvtRenderEventXml = 0x1,         // System properties, ForwardingInfo, User/EventData
        EvtRenderBookmark = 0x2
    }

    [DllImport("wevtapi.dll", EntryPoint = "EvtCreateRenderContext",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    public static extern IntPtr EventCreateRenderContext(Int32 countOfValues,
                                                         String[] valuePaths,
                                                         Int32 flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtRender",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EventRender(IntPtr context,
                                         PushEventHandle eventHandle,
                                         int flags,
                                         int buffSize,
                                         byte[] buffer,
                                     ref int buffUsed,
                                     ref int propCount);

#if DEBUG_TEST

    [DllImport( "wevtapi.dll", EntryPoint = "EvtRender",
                             CallingConvention = CallingConvention.Winapi,
                             CharSet = CharSet.Auto,
                             SetLastError = true )]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EventRender( IntPtr context,
                                         PushEventHandle eventHandle,
                                         int flags,
                                         int buffSize,
                                         StringBuilder buffer,
                                     ref int buffUsed,
                                     ref int propCount );

#endif

    #endregion

    //-----------------------------------------------------------------

    #region Formatting routines

    public enum EventFormatMessageFlags
    {
        EvtFormatMessageEvent = 0x1,
        EvtFormatMessageLevel = 0x2,
        EvtFormatMessageTask = 0x3,
        EvtFormatMessageOpcode = 0x4,
        EvtFormatMessageKeyword = 0x5
    }

    [DllImport("wevtapi.dll", EntryPoint = "EvtFormatMessage",
                     CallingConvention = CallingConvention.Winapi,
                     CharSet = CharSet.Auto,
                     SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EventFormatMessage(EventSafeHandle publisherHandle,
                                                 PushEventHandle eventHandle,
                                                 int messageId,
                                                 int valueCount,
                                                 [In] byte[] valueBuffer,
                                                 int flags,
                                                 int buffSize,
                                                 StringBuilder buffer,
                                             ref int buffUsed);
#endregion

    //-----------------------------------------------------------------

    #region Publisher routines
    internal enum EventPublisherMetadataId
    {
        EvtPublisherMetadataPublisherGuid = 0,     // EvtVarTypeGuid
        EvtPublisherMetadataResourceFilePath,     // EvtVarTypeString
        EvtPublisherMetadataParameterFilePath,     // EvtVarTypeString
        EvtPublisherMetadataMessageFilePath,        // EvtVarTypeString
        EvtPublisherMetadataHelpLink,             // EvtVarTypeString
        EvtPublisherMetadataPublisherMessageID,     // EvtVarTypeUInt32

        EvtPublisherMetadataChannelReferences,     // EvtVarTypeEvtHandle, ObjectArray
        EvtPublisherMetadataChannelReferencePath, // EvtVarTypeString
        EvtPublisherMetadataChannelReferenceIndex, // EvtVarTypeUInt32
        EvtPublisherMetadataChannelReferenceID,     // EvtVarTypeUInt32
        EvtPublisherMetadataChannelReferenceFlags, // EvtVarTypeUInt32
        EvtPublisherMetadataChannelReferenceMessageID, // EvtVarTypeUInt32

        EvtPublisherMetadataLevels,                 // EvtVarTypeEvtHandle, ObjectArray
        EvtPublisherMetadataLevelName,             // EvtVarTypeString
        EvtPublisherMetadataLevelValue,             // EvtVarTypeUInt32
        EvtPublisherMetadataLevelMessageID,         // EvtVarTypeUInt32

        EvtPublisherMetadataTasks,                 // EvtVarTypeEvtHandle, ObjectArray
        EvtPublisherMetadataTaskName,             // EvtVarTypeString
        EvtPublisherMetadataTaskEventGuid,         // EvtVarTypeGuid
        EvtPublisherMetadataTaskValue,             // EvtVarTypeUInt32
        EvtPublisherMetadataTaskMessageID,         // EvtVarTypeUInt32

        EvtPublisherMetadataOpcodes,                // EvtVarTypeEvtHandle, ObjectArray
        EvtPublisherMetadataOpcodeName,             // EvtVarTypeString
        EvtPublisherMetadataOpcodeValue,            // EvtVarTypeUInt32
        EvtPublisherMetadataOpcodeMessageID,        // EvtVarTypeUInt32

        EvtPublisherMetadataKeywords,             // EvtVarTypeEvtHandle, ObjectArray
        EvtPublisherMetadataKeywordName,            // EvtVarTypeString
        EvtPublisherMetadataKeywordValue,         // EvtVarTypeUInt64
        EvtPublisherMetadataKeywordMessageID,     // EvtVarTypeUInt32
    };

    [DllImport("wevtapi.dll", EntryPoint = "EvtOpenPublisherMetadata",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern IntPtr EventOpenPublisherMetadata(EventSafeHandle sessionHandle,
                                                            string publisherId,
                                                            string logFilePath,
                                                            int locale,
                                                            int flags);

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetPublisherMetadataProperty",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern bool EventGetPublisherMetadataProperty(
        EventSafeHandle publisherHandle,
        [MarshalAs(UnmanagedType.I4)]EventPublisherMetadataId propId,
        int flags,
        int buffsize,
        ref EventVariant buffer,
        ref int buffUsed);

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetObjectArraySize",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern bool EventGetObjectArraySize(PushEventHandle arrayHandle,
                                                         ref int count);

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetObjectArrayProperty",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern bool EventGetObjectArrayProperty(
        PushEventHandle arrayHandle,
        [MarshalAs(UnmanagedType.I4)]EventPublisherMetadataId propId,
        int arrayIndex,
        int flags,
        int buffSize,
        ref EventVariant buffer,
        ref int buffUsed);

    [DllImport("wevtapi.dll", EntryPoint = "EvtGetObjectArrayProperty",
             CallingConvention = CallingConvention.Winapi,
             CharSet = CharSet.Auto,
             SetLastError = true)]
    public static extern bool EventGetObjectArrayProperty(
        PushEventHandle arrayHandle,
        [MarshalAs(UnmanagedType.I4)]EventPublisherMetadataId propId,
        int arrayIndex,
        int flags,
        int buffSize,
        ref EventVariantString buffer,
        ref int buffUsed);
    #endregion

    //-----------------------------------------------------------------

    #region Variant structures

    public enum EventVariantType
    {
        EvtVarTypeNull = 0,
        EvtVarTypeString = 1,
        EvtVarTypeAnsiString = 2,
        EvtVarTypeSByte = 3,
        EvtVarTypeByte = 4,
        EvtVarTypeInt16 = 5,
        EvtVarTypeUInt16 = 6,
        EvtVarTypeInt32 = 7,
        EvtVarTypeUInt32 = 8,
        EvtVarTypeInt64 = 9,
        EvtVarTypeUInt64 = 10,
        EvtVarTypeSingle = 11,
        EvtVarTypeDouble = 12,
        EvtVarTypeBoolean = 13,
        EvtVarTypeBinary = 14,
        EvtVarTypeGuid = 15,
        EvtVarTypeSizeT = 16,
        EvtVarTypeFileTime = 17,
        EvtVarTypeSysTime = 18,
        EvtVarTypeSid = 19,
        EvtVarTypeHexInt32 = 20,
        EvtVarTypeHexInt64 = 21,

        // These types used internally
        EvtVarTypeEvtHandle = 32,
        EvtVarTypeEvtXml = 35
    }

    public enum EventVariantTypeMask
    {
        EvtVarTypeMask = 0x7f,
        EvtVarTypeArray = 128
    }

    //Commenting some members to reduce the number
    // of fxcop errors
    [ComVisible(false)]
    [StructLayout(LayoutKind.Explicit)]
    unsafe public struct EventVariant
    {
        [FieldOffset(0)]
        public int BooleanVal;
        [FieldOffset(0)]
        public sbyte SByteVal;
        [FieldOffset(0)]
        public Int16 Int16Val;
        [FieldOffset(0)]
        public Int32 Int32Val;
        [FieldOffset(0)]
        public Int64 Int64Val;
        [FieldOffset(0)]
        public byte ByteVal;
        [FieldOffset(0)]
        public UInt16 UInt16Val;
        [FieldOffset(0)]
        public UInt32 UInt32Val;
        [FieldOffset(0)]
        public UInt64 UInt64Val;
        [FieldOffset(0)]
        public float SingleVal;
        [FieldOffset(0)]
        public double DoubleVal;
        [FieldOffset(0)]
        public UInt64 FileTimeVal;
        [FieldOffset(0)]
        public UInt64 SysTimeVal;
        [FieldOffset(0)]
        public IntPtr ByteArr;

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
        [FieldOffset(0)]
        public IntPtr StringVal;

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
        [FieldOffset(0)]
        public IntPtr SidVal;

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources")]
        [FieldOffset(0)]
        public IntPtr EvtHandleVal;

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields")]
        [FieldOffset(8)]
        public int ItemCount; // number of elements (not length) in bytes.
        [FieldOffset(12)]
        public int Type;
    }

    /// <summary>
    /// Use this structure to deal with variants that require strings.
    /// </summary>
    [ComVisible(false)]
    [StructLayout(LayoutKind.Explicit)]
    unsafe public struct EventVariantString
    {
        [FieldOffset(0)]
        public EventVariant var;
        [FieldOffset(16)]
        public fixed byte data[2000];
    }
    #endregion

    //-----------------------------------------------------------------
}

Problems installing .net framework 1.1

David_Bennett — Tue, 12 Jul 2005 22:01:00 GMT

I had a bunch of problems reinstalling .net framework 1.1, it kept coming with an internal error 2908 and failing to install. I spent a bunch of time cleaning the registry, only to find this didn't help. I finally tracked down this article, which said to rename mscoree.dll in the Windows\System32 directory. This worked like a charm, making the system correctly reinstall again. So if you have problems, do this.

Converting XML to RTF using .net

David_Bennett — Wed, 29 Jun 2005 23:00:00 GMT

It is quite easy to convert XML into RTF, well to turn it into fairly simple rtf output anyway. The RTF format is pretty straightforward and this makes it pretty easy to write into the RtfTextBox inside the .net system to display your xml in a nicely formatted way. With .net 2.0 it is possible to add a WebBrowser component instead and convert your xml into html.

One thing to be careful of, the transform will only deal with valid xml, so if you are doing a transform on a segment of the code, turn the whole thing into a new document with a XmlDefintion up the top of the file or it will fail to convert at all, while also not telling you what went wrong.

Here is an example of an xslt StyleSheet I used to converting an xml file into output:

<xsl:stylesheet
version="1.0"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:ToolManTools="urn:ToolManTools"
>
<xsl:output method="text"/>
<xsl:template match="FreeFormData">
<xsl:text>{\rtf1</xsl:text>
<xsl:text>{\info{\title Frog data}{\author David Bennett}}</xsl:text>
<xsl:text>\par\b Created: \b0\tab </xsl:text>
<xsl:value-of select="ToolManTools:GetDateFromTicks(./Created)"/>
<xsl:text>\par </xsl:text>

<xsl:for-each select="Data/Node">
<xsl:text>\b </xsl:text>
<xsl:value-of select="Key" />
<xsl:text>\b0\tab\tab </xsl:text>
<xsl:value-of select="Value" />
<xsl:text>\line </xsl:text>
</xsl:for-each>
<xsl:text>\par </xsl:text>
<xsl:text>}</xsl:text>
</xsl:template>
</xsl:stylesheet>

From this output it is possible to see that to start with you just write out a small rtf header with the {\rtf output. Then I write out some information about the file, giving it a header and an author. The \b turns on bold and \b0 turns it off. \i turns on italic and \i0 turns it off. The \tab command inserts a tab character, and causes the output to be lined up. The \line command puts in a line break at the specified location and \par does a paragraph output.

I also use an external object in this style sheet to convert the ticks stored in the xml file into a useful string output. The object gets passed in using the XsltArgumentList object and is mapped to a specific namespace with the xmlns argument in the xsl:stylesheet element. It is pretty easy to add in, all xml functions are assumed to take in a string and return a string.

XmlDocument doc = new XmlDocument();
XslTransform transform = new XslTransform();
XsltArgumentList args = new XsltArgumentList();
StringWriter str = new StringWriter();
transform.Load(dir + "\\" + this.incidentEvent.Name + ".xslt");
// Put this in, just in case it needs it...
doc.AppendChild(doc.CreateXmlDeclaration("1.0", null, null));
doc.AppendChild(this.incidentEvent.ToXml(doc));
args.AddExtensionObject("urn:ToolManTools", new ToolManTools());
transform.Transform(doc, args, str, null);
tmp = str.ToString();
DataTextBox.Rtf = tmp;

You can see that I add in the extension object there and that I use a StringrWriter to get the RTF before putting into the RtfTextBox for viewing.

Setting a ToolTip on a TreeView control

David_Bennett — Wed, 22 Jun 2005 03:21:00 GMT

A TreeView control in WinForms does not have a tooltip associated with and each node definately doesn't have a tooltip associated with it. The way to get around this is to use the MouseMoved event and trigger the tooltip creation with this.

The MouseHover event prooved to be somewhat problematic in terms of figureing out where the point is to get at. The useful method GetNodeAt is used on the tooltip to find the specific node I want to reference inside the treeview itself.

You need to keep track of the Active status of the tooltip, since it you set it as active multiple times it will wait for the 300 milliseconds again before displaying itself so it will never be displayed.

public class MainWindow : System.Windows.Forms.Form
{
    public MainWindow()
    {
        //
        // Required for Windows Form Designer support
        //
        InitializeComponent();
        // Initialize the tooltip
        toolTip1.InitialDelay = 300;
        toolTip1.ReshowDelay = 0;
    }
    private void TimeLineTreeView_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e)
    {
        TreeNode node = TimeLineTreeView.GetNodeAt(e.X, e.Y);
        if (node != null)
        {
            if (node.Tag != null && node.Tag is IIncidentEvent)
            {
                IIncidentEvent ev = (IIncidentEvent)node.Tag;
                if (!toolTip1.Active)
                {
                    toolTip1.SetToolTip(TimeLineTreeView, ev.ShortDescription);
                    toolTip1.Active = true;
                }
            }
            else
            {
                toolTip1.Active = false;
            }
        }
        else
        {
            toolTip1.Active = false;
        }
    }
}

.net Beta 1 and .net beta 2

David_Bennett — Tue, 07 Jun 2005 01:55:00 GMT

Here is a list of a few changes I ran across when changing my code from beta 1 to beta 2. The DockingPanel stuff has gone altogether, you completely remove these from your project altogether in most cases. This doesn't seem to have any detrimental effects on how the code works and runs.

The FtpRequests.UploadFile etc constants have now moved to be in WebRequestmethods.Ftp.UploadFile. There is no easy pointer I found in the docs to point to where this disappeared to.

AppDomain and ConfigurationFile's

David_Bennett — Fri, 08 Apr 2005 09:13:00 GMT

After a bit of messing around when trying to make my own app domain I discovered that if you set the ConfigurationFile up to a place that doesn't exist you will get an error saying that it cannot load the assembly. Which is a little confusing, since what it cannot actually load is the configuration file. So if you make up an AppDomain make sure the config file exists.

Here is some code for making a simple AppDomain with the same permissions as the current AppDomain, if you fail to include the Evidence when making your AppDomain or do something different with this you will end up with an AppDomain that cannot load anything or something similar.

            perm = new PermissionSet(level.GetNamedPermissionSet("FullTrust"));
            perm.AddPermission(new ReflectionPermission(PermissionState.Unrestricted));
            perm.AddPermission(new SecurityPermission(PermissionState.Unrestricted));