(How)
C^# You Are - 7 January 2007

1. How do you prevent the debugger from stepping into a block of code declaratively.?  Answer

   You can use the DebuggerStepThroughAttribute attribute to specify that a target (such as a class, method or accessor) will not be stepped into when single stepping through the debugger.  This attribute is generally applied to accessors and to methods that simply wrap other methods.  This attributes speeds up debugging by skipping unimportant code.  A client can still debug the target if they set a breakpoint or if an exception is thrown but by default the debugger will not step into the target.

   The DebuggerHiddenAttribute attribute can be used to prevent a user from stepping into code irrelevant of how it would get there (by breakpoint or exception).

2. How can you control what is displayed when hovering over an instance name in the VS debugger?  Answer

   Prior to v2 you would use the ToString method.  When hovering over an instance name in the VS debugger it will call the ToString method to get the text to display in the tooltip.  The problem with this approach is that many controls also use this same method when converting an arbitrary value to a string (such as in a list box).

   class Test
   {
       public int Id { get { return 1234; } } 
       public string Name { get { return "Michael"; } }
   
       public override string ToString ( )
       { return String.Format("{0} [{1}]", Name, Id); }
   }

   In v2 you should instead use the DebuggerDisplayAttribute attribute.  This attribute allows you to display useful information about the instance without requiring the user to drill down into the properties or fields.
   

   [DebuggerDisplay("{Name} [{Id}]")]
   class Test
   {
       public int Id { get { return 1234; } } 
       public string Name { get { return "Michael"; } }
   }

   The downside to this is that the debugger will use the ToString method if it is defined over the attribute. 

3. How can you hide a property from the debugger?  Answer

   The DebuggerBrowsableAttribute attribute allows you to specify how a property or field is displayed in the debugger.  Options include not displaying it at all, displaying it collapsed or hiding the property but displaying its children.  Note that this attribute is not supported in VB at this time.

4. How can you hide a class member from Intellisense?  Answer

   The EditorBrowsableAttribute attribute is used to specify how a member appears in the editor (Intellisense).  By default all public members will be displayed.  Protected members are displayed when inside the owning class or a derived class.  Internal members are displayed when within the same assembly.  The attribute can be used to hide a type or type member by specifying the EditorBrowsableState.Never.  This attribute is useful when hiding an implementation member that must be exposed for whatever reason.  It is also useful for hiding design-time only attributes that are set by the designer rather than in code.

5. How can you hide a property or field from the Property Window in Visual Studio?  Answer

   The BrowsableAttribute attribute is used to hide a property or field within the property window.  Technically it can be used on any target.  This attribute is generally applied to runtime-only properties such as a control's parent or the current number of items displayed in a list.

6. Given the following class definitions if you attempt to view an instance of MyRectangle in a property grid you will not be able to edit the values of the points.  What do you need to do to allow a user to edit the individual properties of the point objects in the grid?  Answer
   public class MyPoint
   { 
      private int x, y; 
   
      public int X { get { return x; } set { x = value; } } 
      public int Y { get { return y; } set { y = value; } }
   
      public override string ToString ( )
      { return String.Format("({0},{1})", x, y); }
   }
   
   public class MyRectangle
   {
      private MyPoint tl = new MyPoint();
      private MyPoint br = new MyPoint();
   
      public MyPoint TopLeft { get { return tl; } }
      public MyPoint BottomRight { get { return br; } }
   }

   You must specify the type converter to use for the property or class.  .NET comes with the ExpandableObjectConverter type converter that allows the expansion of child properties.  Therefore specify

   [TypeConverter(typeof(ExpandableObjectConverter))]

   on the MyPoint class.  Alternatively this attribute can be applied to each of the public properties of MyRectangle if it is not applied to the class directly.  Now a user can expand the point instances in the grid and edit the child properties.

7. After making the changes in the previous question notice that the MyPoint instance will display the incorrect (X,Y) value until you click on the point row.  How do you force the parent point instance to update itself whenever a child property changes?  Answer

   Use the NotifyParentPropertyAttribute attribute on the X and Y properties.  Whenever these properties are changed in the grid the parent object (MyPoint) will be notified so it to will update its display. 

   You could also use the RefreshPropertiesAttribute attribute but this would update the entire grid rather than just the parent property.

8. Suppose we wanted to create a custom editor (perhaps a graphical one) for editing instances of the MyRectangle class in the property grid.  How would we do that?  Answer

   Firstly we would have to create a new class that ultimately derives from UITypeEditor.  We would then have to implement the appropriate code to work with the property grid.  Once we have a custom editor defined we associate it with the MyRectangle instance using the EditorAttribute attribute.  This attribute requires the name of the editor type to create and its base type.  In all current cases the base type is always UITypeEditor.

   [Editor(typeof(MyRectangleEditor), typeof(UITypeEditor))]
   public class MyRectangle
   {
      ...
   }

   
   
9. How do you define the default tag prefix for an ASP.NET server control?  Answer

   The TagPrefixAttribute attribute can be used to provide a default tag prefix for your server controls.  By default the designer will create a generic prefix for your server control when it is initially adding a reference to the assembly containing your control.

10. How can you provide nice support for getting and setting properties representing URLs in an ASP.NET control ?  Answer

    The best method is to set the type of the property to Uri.  Thie enables the URL editor where the user can browse for an appropriate URL.  However in some situations you must use a string property (as does many of the built in controls).  In this case the UrlPropertyAttribute attribute can be used to make a string property look like a URL.  This attribute accepts a filter which allows you to filter the URLs displayed.

    public class MyControl : WebControl
    {
       [UrlProperty("*.jpg")]
       public string ImageUrl
       {
          get { ... }
          set { ... }
       }
    }