dir D:\Inetpub\Wwwroot\target\ -recurse -exclude *.*  | Get-Acl | % { @{Path=$_.Path; Access=$_.Access}} |% {$a = $_.Access
$b = @($a | ?{ $_.IsInherited -ne $true -and $_.IdentityReference -and ($_.IdentityReference -contains "NT AUTHORITY\Network Service" -or $_.IdentityReference -contains "MACHINE\IUSR_MACHINE") }|%{ $_.IdentityReference, $_.FileSystemRights})
if ($b.count -gt 0) {$_.Path, $b}
} >> D:\temp\FolderPermissionsWeb.txt

dir D:\Inetpub\Wwwroot\target\ -recurse -exclude *.*

The pipe takes the results and performs another command, in this case Get-Acl. Get-Acl returns a list of all access control levels for the items. So at this point we’ve already got all access permission for all the folders in the search. My first proof of concept included only these two commands and outputed the results straight to the command prompt. It was enough to get the job done since it showed me all access for everyone on those folders!

The rest of the statements are all about pruning the results down to only the information I want.

$b = @($a | ?{ $_.IsInherited -ne $true -and $_.IdentityReference -and ($_.IdentityReference -contains "NT AUTHORITY\Network Service" -or $_.IdentityReference -contains "MACHINE\IUSR_MACHINE") }|%{ $_.IdentityReference, $_.FileSystemRights})

This section achieves that. The end of the first line declares $a as a list of all ACL it could find. I then declared a variable called $b that will contain all the results from $a that match my conditions. I don’t want to see any access that has been inherited, and I only want to see right assigned for Network Service or the machine’s IUSER account (IUSER account name varies per machine).

if ($b.count -gt 0) {$_.Path, $b}
} >> D:\temp\FolderPermissionsWeb.txt

Finally, I check to see if there are any matches, and then append them to my file. The code here is sort of rough, which I will chalk up to being a novice at Powershell. I’d hope to make it shorter and format the output a little more, which I’ll work on.

private static List<Node> FilterList(List<Node> list, Utilities.TypeRequired type)
{
	List<Node> returnList = new List<Node>();

	// Go through each node of the full list and run the FilterNode recursive method
	foreach (Node item in list)
		returnList.AddRange(FilterNode(item, type));

	return returnList;
}

private static List<Node> FilterNode(Node item, Utilities.TypeRequired type)
{
	// Prep return list
	List<Node> list = new List<Node>();

	// call this same method on each of the children of this node, store in list
	foreach (var child in item.Children)
		list.AddRange(FilterNode(child, type));

	if (item.TypeId == (int)type)
	{
		// if the node is of the correct type, set it's current children to the
		// results from above and return the item within a list
		item.Children.Clear();
		item.Children.AddRange(list);
		return new List<Node>() { item };
	}
	else
		// if not, just return the children without the parent
		return list;
}

The FilterList() method accepts a list of nodes, this is considered to be the first level of children under the root node (in this case there is no root node). It also takes an object that I’ve called TypeRequired, really it can be any kind of data you’d like to use to evaluate the differences between one node and another. The method self-references on the children of the current node and so works through the whole tree.

The real trick here is that in cases where a parent node is not a match to the desired type, the children are promoted to it’s place in the hierarchy before the parent is removed. This way qualifying children stay in the list organized in the proper fashion.

// Load the physical file into a byte array

byte[] byteArray = new byte[file.Size];
System.IO.Stream stream = file.GetFile();
stream.Read(byteArray, 0, file.Size);
stream.Close();

// Push the byte array to the user as a download
context.Response.BinaryWrite(byteArray);
context.Response.ContentType = file.MimeType;
context.Response.AddHeader("content-disposition", "attachment;filename=" + context.Server.UrlEncode(file.FileName));

<asp:RequiredFieldValidator ID="valFirstNameReq" runat="server" ControlToValidate="txbFirstName" SetFocusOnError="true" ErrorMessage="Please enter your first name." Display="Dynamic" ValidationGroup="cgstpForm" />

There it is. The property Display=”Dynamic” on a validation control switches it to this method. I found the naming of this to be non intuitive, since display set to dynamic makes sense now that i know it, but i never would have thought it had to do with this.

The first thing I did was create my own control that inherits from CheckboxList. The table-based output of the standard checkbox list is harder to style, and in general I like to used unordered lists wherever possible, so I followed this simple method for overloading the Render method and making my own output as an <ul> and each selection as a <li>. The example Chris Pollock gives is in VB, below is my loose adaptation in C#.

protected override void Render(System.Web.UI.HtmlTextWriter writer)
{
string inputFormatString = "<input id=\"{0}\" name=\"{1}\" type=\"checkbox\" value=\"{2}\" {3} {4} />";
string labelFormatString = "{1}";
if (!string.IsNullOrEmpty(this.CssClass))
writer.WriteLine("<ul class=\"" + this.CssClass + "\">");
else
writer.WriteLine("<ul>");
for (int i = 0; i < Items.Count; i++)
{
string postbackScript = "";
if(this.AutoPostBack)
{
postbackScript = String.Format("onclick=\"javascript:setTimeout('__doPostBack(\'{0}\',\'\')', 0)\"", this.UniqueID + "$" + i.ToString());
}
string itemChecked = "";
if(Items[i].Selected)
{
itemChecked = "checked=\"checked\"";
}
writer.WriteLine("<li>");
writer.WriteLine(string.Format(inputFormatString, this.ClientID + "_" + i.ToString(), this.UniqueID + "$" + i.ToString(), Items[i].Value, itemChecked, postbackScript));
writer.WriteLine(string.Format(labelFormatString, this.ClientID + "_" + i.ToString(), Items[i].Text));
writer.WriteLine("</li>");
}
writer.WriteLine("</ul>");
}

It’s a nice start, but it doesn’t solve my problem of adding headings to the list. I could go pretty far into making this CheckBoxList control really custom so that it accepts a heirarchical data source, but i decided that would be good for another time. I simply decided to create an event on the CheckBoxList that would be called before each item renders.

public delegate void ItemPreRenderHandler(System.Collections.IEnumerable data, int index, ListItem item, System.Web.UI.HtmlTextWriter writer);
public event ItemPreRenderHandler ItemPreRender;
public void OnItemPreRender(System.Collections.IEnumerable data, int index, ListItem item, System.Web.UI.HtmlTextWriter writer)
{
if (ItemPreRender != null)
{
ItemPreRender(data, index, item, writer);
}
}


And call OnItemPreRender in the Render method as the first command in the for loop for each item.

OnItemPreRender(((System.Collections.IEnumerable)this.DataSource), i ,Items[i], writer);

With this, on the page using the control, I hooked a method up to the Event that checked to see if the ‘Category’ was different than the last item, and if so output an <li> with a heading. Very old school, but rather simple and flexible.

Create a Pager control

Create a UserControl for your pager (mine is called Pagination.ascx). On the Page that will contain the pagination, register the Pagination UserControl and drop two of them on there.

Handling CurrentPage and PageSize values on the pager

The pagers will need two numbers to function; the current page of results, and records per page. The super duper easy way to save and load this state is to read the values from GET variables and store them as Parameters. You can go ahead and do this on the pagers themselves and you are done! When the value is changed via a dropdownlist for the PageSize or clicking to navigate to a new page, just Response.Redirect back to the same page with your values in GET (ie ?currentpage=1&pagesize=15).  In fact if you have to get this done right away just go do that. It’s also worth noting that this makes it possible for users to bookmark searches (the below method does not).

The Event Driven Way: Handling the values on the containing element

As an alternative, lets say that you don’t wanna use GET variables and want to keep the info in a central location. When you first load the page, initialize the two variables and stuff the values into a serializable struct and save/load the control state of the page. Now the values are in one place and reliable.

Pass the values down to the child elements

Go ahead and write some code into the Pagination.ascx control to insert the values from the parent. To do this, you will need to create public Properties on the Pagination.ascx control in the codebehind file. Make a property for PageSize and CurrentPage as int. In the codebehind for your containing page, within the OnLoad method set these properties with your values like so…

cstTopPagination.PageSize = this.PageSize;
cstTopPagination.CurrentPage = this.CurrentPage;
cstBottomPagination.PageSize = this.PageSize;
cstBottomPagination.CurrentPage = this.CurrentPage;

So just before the pagers render, they will have the proper values and will be able to display as needed!

What to do when the pager changes

Here is where events come in. Even if you are pretty new to .NET you’ve likely utilized some events on Microsoft controls such as the DataGrid’s OnItemDataBound event or DropDownList’s OnSelectIndexChanged. We’re gonna make some of our own! Place the following lines into the codebehind for your Pagination UserControl…

public delegate void PageSizeChangedHandler(int PageSize);
public delegate void CurrentPageChangedHandler(int CurrentPage);
public event PageSizeChangedHandler PageSizeChanged;
public event CurrentPageChangedHandler CurrentPageChanged;

You can read more about how the above works, but in short the event serves as a method that you will call to signal ‘Hey, I’m changing the page size’.  Any controls that link to this event will be notified, this is called Event Bubbling. The delegate is a contract with the controls consuming the event that tells them how they must create their methods to comply with the event. Think of it as a kind of interface.

Here is an example from Pagination.ascx.cs of how I call the event when a user clicks on a LinkButton with the CommandName of “Navigate” and a CommandArgument of a page number.

protected void CommandFilter(object sender, CommandEventArgs e)
{
switch (e.CommandName)
{
case "Navigate":
OnCurrentPageChanged(int.Parse(e.CommandArgument.ToString()));
break;
default:
break;
}

}

Any controls that link into the Event CurrentPageChanged will be alerted with the value int.Parse(e.CommandArgument.ToString()). You’ll notice also that I call OnCurrentPageChanged not CurrentPageChanged. .NET creates this handle for you for your event.

On your containing page, you’ve probably got something similar to the following where your pagination control is on the page…

<rbl:Pagination ID="cstBottomPagination" runat="server" />

Modify it like so…

<rbl:Pagination ID="cstBottomPagination" runat="server" OnPageSizeChanged="PageSizeChanged" OnCurrentPageChanged="CurrentPageChanged" />

See how the events are accessible on the control? Now go to your codebehind for the page and add a method for PageSizeChanged…

protected void PageSizeChanged(int size)
{
this.PageSize = size;
this.CurrentPage = 1;
}

There you go. This officially completes the cycle; Value is loaded in the containing page, passed down to child, if it changes it is bubbled back, and the value is saved on the containing page at the end. This method also works if you have a UserControl within a UserControl and you’d like to bubble the event up.

There’s lots of practical and creative uses for events. This implementation is simple but it was fairly easy to learn and has potential for very powerful and smart controls. It cuts down on ‘black magic’ in your child controls where information is obtained circumstantialy or through unpredicatble traversal. Events are clean and readable once you understand them, and I like them alot.