Not that you should be putting debug builds into a production environment, but when you do how do you view the debug output? You can’t run using the VS debugger so what do you do?
Well, I found this tool today, and it's the answer to your (and my) prayers!
http://www.microsoft.com/technet/sysinternals/utilities/DebugView.mspx
Naturally, it's a Sysinternals product (OK - they're owned Microsoft now) - go get it!
GhostDoc is a free add-in for Visual Studio that automatically generates XML
documentation comments. Either by using existing documentation inherited
from base classes or implemented interfaces, or by deducing comments from
name and type of e.g. methods, properties or parameters.
MyType thing = null;
...
if ( thing == null)
{
// do something
}
public static bool IsNull(MyType thing)
{
object testThing = thing as object;
// uses the == operator from object, NOT MyType
return (testThing == null);
}
public static bool operator == (MyType thing1, MyType thing2)
{
// two nulls => equal
if (IsNull(thing1) && IsNull(thing2))
return true;
// one null => not equal
if (IsNull(thing1) || IsNull(thing2))
return false;
// do the REAL equality test here
...
}
http://joel.fjorden.se/static.php?page=CodeStyleEnforcerAnd go use it!
Wednesday saw another well-organised, interesting and informative VBUG event - this one a "SPECIAL NON-MEMBER EVENT" entitled "Flirting with AJAX with Gary Rowntree".
The location was once again QA Training in Stockport - a great little venue apart from the very hard seats!
Gary did a great intro to ATLAS - Microsoft's AJAX technology libraries - easing those who'd not played with it before through the concepts and basic techniques whilst fielding deep technical questions from others in the audience. Finishing the session off by writing a simple chat application from scratch was a definite crowd pleaser.
It was nice to be able to chat to other developers and guage their experiences with the technology, and I think that the informality of these events is a definite positive.
Kudos to Phil Winstanley (plip) for organising another event - the prize draw was a nice surprise, even if I did win the CodeZone hat. Still, my 20 month old, Daniel, thinks it's great!
Now when's the next one?
Footnote: This was written using Windows Live Writer running on Vista RC1. I'm such a beta-whore! :-)
using System;Next, let's define a "complex" class against a List
using System.Collections.Generic;
using System.Text;
namespace List_Find_Predicate_Test
{
class Program
{
static void Main(string[] args)
{
}
}
}
...You'll notice I've spiced things up with a custom enumeration used within the Criteria class. Next, let's add some code to the Main method to build us a list of criteria objects:
class Program
{
private enum Gender
{
Male,
Female
}
private class Criteria
{
public string Field;
public Type DataType;
public Criteria(string theField, Type theDataType)
{
this.Field = theField;
this.DataType = theDataType;
}
}
...
}
...
Simple enough so far. The complexity happens in providing a mechanism to let the List... ...
static void Main(string[] args)
{
List<Criteria> critList = new List<Criteria>();
critList.Add(new Criteria("Name", typeof(System.String)));
critList.Add(new Criteria("Age", typeof(System.Int16)));
critList.Add(new Criteria("Gender", typeof(Gender)));
Console.WriteLine("List has {0} entries...", critList.Count);
// TODO: Search the list
...
}
...OK - that was easy enough - just your common-or-garden-variety top-down programming so far. But now we get to the meat of the issue - the implementation of the FindCriteriaByName method - and this is where Predicates are used.
static void Main(string[] args)
{
...
// Search the list
Criteria crit = FindCriteriaByName(critList, "Name");
Console.WriteLine("Name criteria has type {0}", crit.DataType.Name);
// TODO: Search without having to use a helper method
...
}
// TODO: Implement FindCriteriaByName
...
You'll notice that the critical FilterByField method accepts a Criteria object as its parameter - when we call this class through a Predicate, this is the method that will be used to perform the filtering. So we can now finally implement the filter method:... private class CriteriaFieldFilter
class Program
{
...
{
private string criteriaField;
public CriteriaFieldFilter(string fieldName)
{
criteriaField = fieldName;
}
public bool FilterByField(Criteria crit)
{
return (crit.Field == criteriaField);
}
}
...
}
...
...So our filtermethod starts by instantiating an instance of our filter class tailored with the field name passed in the theName parameter. The Predicate is then created against a pointer to the FilterByField method of that instance, and in turn that Predicate is used with the List
class Program
{
...
// Implement FindCriteriaByName
private static Criteria FindCriteriaByName(List<Criteria> theList, string theName)
{
CriteriaFieldFilter searchFilter = new CriteriaFieldFilter(theName);
Predicate<Criteria> searchPredicate = new Predicate<Criteria>(searchFilter.FilterByField);
Criteria crit = theList.Find(searchPredicate);
return crit;
}
...
}
...
...Rather harder on the eye, but more compact. I'd imagine that something could be done with Anonymous classes/methods to simplify this further, but that's a topic of research for another time.
static void Main(string[] args)
{
...
// Search without having to use a helper method
crit = critList.Find(new Predicate<Criteria>((new CriteriaFieldFilter("Gender")).FilterByField));
Console.WriteLine("Gender criteria has type {0}", crit.DataType.Name);
...
}
...
I’ve heard a lot of arguments against DoNotCatchGeneralExceptionTypes, but they generally boil down to one or both of the following:Well worth reading and thinking about how you code your exception handling routines - I know for one I use catch (Exception e) w-a-y too much!
- “If I call an API which doesn’t document which exceptions it can throw, then I have no choice but to catch all possible exceptions!”
- “My application needs to be robust; it can’t crash just because of an exception that I forgot to handle!”
"forums.microsoft.com to the rescue once again!" shouted Little Cook.
"Have I inherited a disaster? I hate taking over someone's bad code. The projects always go on forever and you are forced to follow bad practices to try and string together fixes and features without it all crumbling down. There are some quick, not always 100% accurate, ways to know whether you've inherited a disaster"It's an excellent read, and a good aide-memoire because it brings such a quick way to check for best (or worst) practice.
public partial class DemoPage : System.Web.UI.PageBut what if you're abstracting things so that a library object has to be able to render itself as HTML?
{
protected void Page_Load(object sender, EventArgs e)
{
LabelControl.Text =
Server.HtmlEncode( LibraryClassInstance.Content );
}
// rest of the implementation goes here
}
namespace demoVoila - HTML (and URL) encoding and de-coding at your fingertips.
{
class LibraryClass
{
public string GetHtmlSafeContent()
{
return HttpContext.Current.Server.HtmlEncode(this.Content);
}
// remainder of the implementation goes here
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Design;
using System.Drawing.Design;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.Design;
namespace DemoControls
{
[DefaultProperty("Caption")]
[ToolboxData("<{0}:CoolButton runat=server>")]
public class CoolButton : ImageButton
{
[Bindable(true)]
[Category("Appearance")]
[DefaultValue("")]
[Localizable(true)]
[Editor("System.Web.UI.Design.ImageUrlEditor, System.Design,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",typeof(UITypeEditor))]
public string RolloverImageUrl
{
get
{
String s = (String)ViewState["RolloverImageUrl"];
return ((s == null) ? String.Empty : s);
}
set
{
ViewState["RolloverImageUrl"] = value;
}
}
// rest of the implementation goes here...
}
Today we released the source code for the built-in ASP.NET 2.0 Membership, Role Management, Site Navigation, Session State, Profile, Web Events, and Web Part Personalization providers
The 'Atlas' Control Toolkit is a collection of samples and components that makes it easier then ever to build and consume rich client-side “Atlas” controls and extenders. The toolkit provides both ready to go samples and a powerful SDK to simplify the creation and re-use of your own custom controls and extenders.As always, the best way to evaluate at a toolkit like this is to look at the samples provided, and the ATLAS toolkit doesn't disappoint, with 9 new controls and extenders that cover some of the most common AJAX features you'd need to make a site provide a rich and dynamic experience.
#if !NUNITNice when you find a simple solution to an apparently intractable problem!
using Microsoft.VisualStudio.TestTools.UnitTesting;
#else
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestInitialize = NUnit.Framework.SetUpAttribute;
using TestCleanup = NUnit.Framework.TearDownAttribute;
#endif
To build software that meets your security objectives, you must integrate security activities into your software development lifecycle. This handbook captures and summarises the key security engineering activities that should be an integral part of your software development processes.At over 170 pages, it's fairly heavyweight, but well worth a read, particularly in concert with Writing Secure Code (which you can, of course, get from Amazon).
In this article on MSDN, Pat Helland provides an interesting metaphor "for the evolution of information technology into the world of service-oriented architectures".
Explores the idea that information technology is evolving in a fashion similar to how American cities have evolved over the last two centuries. The opportunities and pressures of the technological revolution have driven our metropolises to adopt new frameworks, models, and patterns for commerce and communication. Recent developments in IT are analogous. What can we learn about the present and future directions of IT by studying the recent history of our urban centers.Well worth 10 minutes of your time to read.
"Sometimes it happens that a form is processing and you need to make sure that the users don't panic and run away before it finishes."Phil Winstanley pointed out in this blog entry that this kind of thing isn't necessarily applicable or suitable when a page is using AJAX for it's processing, and gives a number of reasons.
