Veggerby : IBlog » Reference Sheet http://blog.veggerby.dk Low decoupling, highly incoherent Fri, 28 May 2010 19:47:45 +0000 en hourly 1 http://wordpress.org/?v=3.0 Must have tools for .NET developers http://blog.veggerby.dk/2008/09/12/must-have-tools-for-net-developers/ http://blog.veggerby.dk/2008/09/12/must-have-tools-for-net-developers/#comments Fri, 12 Sep 2008 15:17:44 +0000 nosey http://blog.veggerby.dk/2008/09/12/must-have-tools-for-net-developers/ Like so many others have done before me I would like to present my take on a compiled list of favorite tools for developing using .NET.

Here goes:

Reflector

The most useful tool ever to reverse engineer assemblies – yes, it is a gray-zone regarding IP, but nonetheless very, very use full. Kudos to Lutz Roeder for this ultimate tool, and thank you very much for your effort in this. Lutz announced some days ago that he would end his work on Reflector. Red Gate (known for their useful tool SQL Compare – as mentioned later on ;) ) has taken over and "(…) will continue to maintain a free version for the benefit of the community". Do they implicitly say that there will be a commercial version!? I hope not – that would for sure have some effect on the Reflector community.

Red Gate SQL Compare

I really, really hate to include a commercial product in my toolbox, but being there are no free alternatives to a much required tool, I will include the best one I know of (or rather the only one I have used, but it is extremely useful and good so why bother with the others!?). Please drop a comment if you know of free and/or good/better alternatives. Price tag on the basic SQL Compare is $395.

LINQPad

Query Analyzer for LINQ. Very nice tool to help build, execute and debug queries, wether it be LINQ for SQL, LINQ for Objects or LINQ for XML.

StyleCop

StyleCop is a Visual Studio plug-in that performs code analysis directly on source code with the intent on enforcing a common coding standard for layout, readability, documentation and maintainability. SDK documentation for creating custom rules is available. StyleCop was originally created by one devoted (and might I add brilliant) Microsoft employee (Jason Allor) in his spare time. The tool has been used internally in Microsoft for years, but was first made available to the general public earlier this year. Follow Jason’s/the StyleCop blog here.

FxCop

FxCop is a tool to analyze managed assemblies for possible security issues and possible design and performance improvements that can be implemented.

VisualSVN

Sorry, but yet another commercial product. If you are using the most excellent version control system Subversion (if not then consider it!), there is a most excellent plug-in for Visual Studio. Comes with a free server version as well, which simplifies setup of Subversion on a Windows box. A free alternative – however I did not find it nearly as good as Visual SVN – is AnkhSVN. Neither unfortunately though are MSSCCI (Microsoft Source Code Control Interface) which means that they do not plug-in to the native source control module in Visual Studio. Price tag for Visual SVN is $49. For more information about Subversion you can read the SVN Book online.

For ASP.NET Developers

Must haves:

Firefox with Firebug and Web Developer Toolbar

Firefox speaks for itself, and so should Firebug, but a brief introduction: Firebug allows you to inspect and modify HTML, CSS and DOM. Debugging JavaScript and explicitly capture JavaScript XmlHttpRequest calls for debugging AJAX. The Web Developer Toolbar provides some additional functionality to what Firebug adds, but to some extent is a complimentary plugin.

Internet Explorer with Developer Toolbar

It is inevitable that as a web developer you need to assure cross-browser compatibility. Therefor a similar tool exists for Internet Explorer 6 and 7, however it not nearly as cool, so for general debugging, etc. Firebug is the choice, but for IE specific, the Internet Explorer Developer Toolbar does come handy.

Fiddler

Another tool that can help in debugging web applications/services is Fiddler. Fiddler acts as a HTTP proxy, logging all HTTP traffic from the local computer to other computers. This however means that out-of-the-box HTTP debugging when using Cassini (i.e. the development web "server" in Visual Studio) is not possible. It has to be tweaked.

For WPF / Silverlight Developers

Kaxaml

Kaxaml is a lightweight XAML editor with the split design / output view similar to the Visual Studio IDE. Kaxaml is a complimentary tool to Expression Blend, however Blend provides much more functionality, hence "lightweight".

Mole

Mole is a reverse engineering tool, similar to Reflector. However Mole disassembles the XAML of a WPF/Silverlight application and provides a tree view of the XAML structure. Nice for "how did they do that", but again gray zone concerning IP.

"Dark Horses"

Since I have not had any real experience with these I will put them on a "dark horse" list, just for reference, since they might prove themselves valuable given the time/opportunity to use them.

Framework Design Studio

Quoting the FDS site:

Framework Design Studio is a set of tools for reusable library designers. The package contains a GUI tool for viewing, reviewing, and comparing versions of managed APIs. It also contains a command line tool for generating API diff reports. Simple user guide explaining the basics of the tool is included in the setup.

]]> http://blog.veggerby.dk/2008/09/12/must-have-tools-for-net-developers/feed/ 0 Using Type.IsAssignableFrom() to check inheritance http://blog.veggerby.dk/2008/07/13/using-typeisassignablefrom-to-check-inheritance/ http://blog.veggerby.dk/2008/07/13/using-typeisassignablefrom-to-check-inheritance/#comments Sun, 13 Jul 2008 22:07:32 +0000 nosey http://blog.veggerby.dk/2008/07/13/using-typeisassignablefrom-to-check-inheritance/ Having been in the situation needing to check if a given instance of an object either implements an interface or a class in the form of a given Type object (i.e. "if A is B" wont do) I decided to write a little "note to self" post which others might find useful.

This is basically just a "wrapper" around Scott Hanselman’s post from a long time ago Does a Type Implement an Interface?

For a "class type" you can use the Type.IsSubclassOf() method and for an interface you can use something in the line of:

if (typeof(MyClass).GetInterface("MyNamespace.IMyInterface") != null)
{
    // MyClass implements IMyInterface
}

However the string literal looks bad also neither solution provides a simple check for "is this type implementing/a subclass of this interface/class".

The gist of Scott’s post is that using Type.IsAssignableFrom() can solve your problem concerning interfaces, but the same logic applies for classes. So:

if (typeof(IMyInterface).IsAssignableFrom(typeof(MyClass)))
{
    // MyClass implements IMyInterface
}

if (typeof(MyClass).IsAssignableFrom(typeof(MySubClass)))
{
    // MySubClass is a subclass of MyClass
}

if (typeof(IMyExtendedInterface).IsAssignableFrom(typeof(IMyInterface)))
{
    // IMyExtendedInterface extends IMyInterface
}

Actually this is exactly what the MSDN page for Type.IsAssignableFrom() states:

true if c and the current Type represent the same type, or if the current Type is in the inheritance hierarchy of c, or if the current Type is an interface that c implements, or if c is a generic type parameter and the current Type represents one of the constraints of c

First in "layman" terms it means:

TypeA a;
TypeB b;
if (typeof(TypeA).IsAssignableFrom(typeof(TypeB)))
{
    a = b; // this will work
}

But what does the underlined text then mean in the context of this check? The samples on this on the MSDN page are totally nonsense (e.g. text states "List<int> assignable from List<Type>" but in fact List<int> and int[] are compared).

The point in that statement is that A<T> is assignable from A<S> if T is assignable from S.

So it is a little more inclusive (which is no surprise) than just checking inheritance, but as long as the "master" class/interface is known explicitly (which is most often the case, since a scenario for this is checking if a type specified in config is in the correct inheritance tree) the check will be safe.

]]> http://blog.veggerby.dk/2008/07/13/using-typeisassignablefrom-to-check-inheritance/feed/ 0 Custom Sorting using Compare method(s) http://blog.veggerby.dk/2007/04/26/custom-sorting-using-compare-methods/ http://blog.veggerby.dk/2007/04/26/custom-sorting-using-compare-methods/#comments Thu, 26 Apr 2007 13:09:21 +0000 nosey http://blog.veggerby.dk/2007/04/26/custom-sorting-using-compare-methods/ Are you (just like me) one of these people who just can’t remember wether A > B should yield 1 or -1 in a compare method. I know there must be some (higher) form of logic behind it that makes it easily deductible when you just think about it.

Anyway as small reference sheet:

Compare(A,B) or A.CompareTo(B)

This should yield:

“Compare statement” Yields Resulting order
A > B 1 B, A
A = B 0 non-deterministic
A < B -1 A, B
]]> http://blog.veggerby.dk/2007/04/26/custom-sorting-using-compare-methods/feed/ 0 Formatting strings http://blog.veggerby.dk/2007/04/15/formatting-strings/ http://blog.veggerby.dk/2007/04/15/formatting-strings/#comments Sun, 15 Apr 2007 10:27:00 +0000 nosey http://blog.veggerby.dk/2007/04/15/formatting-strings/ After having clicked myself through the MSDN pages of string.Format() one too many times I will, part for my own reference and part for other not wanting to waste valuable synapses memorizing this, compile a list of the common strings when using string.Format().

NB! all results depend more or less on which culture is used, I am for the sake of the majority showing examples in en-us.

Format Name Type Sample value Sample format Sample result
C or c Currency any numerical 12345.6
12345.6
-123.567		 {0:C}
{0:C3}
{0:C2}		 $12,345.60
$12,345.600
($123.57)
D or d Decimal integer values 12
12
-12		 {0:D}
{0:D4}
{0:D4}		 12
0012
-0012
D or d   enumeration DayOfWeek.Monday
WD.Fri | WD.Mon		 {0:D} 5,
17
d Short date pattern DateTime 21:00:00 2007-02-20 {0:d} 2/20/2007
D Long date pattern DateTime 21:00:00 2007-02-20 {0:D} Tuesday, February 20, 2007
E or e Scientific any numerical 123.5
123.5
123.5		 {0:E}
{0:E4}
{0:e4}		 1.235000E+002
1.2350E+002
1.2350e+002
F or f Fixed-point any numerical 123.5
123.5
-123.5		 {0:F}
{0:F3}
{0:F2}		 123.50
123.500
-123.50
F or f   enumeration DayOfWeek.Monday
WD.Fri | WD.Mon		 {0:F} Monday
Mon, Fri
f Full date/time pattern (short time) DateTime 21:00:00 2007-02-20 {0:f} Tuesday, February 20, 2007 9:00 PM
F Full date/time pattern (long time) DateTime 21:00:00 2007-02-20 {0:F} Tuesday, February 20, 2007 9:00:00 PM
G or g General floating point 123456.7
123.5
123.5
123.5
123.5
123.5
-123.50		 {0:G}
{0:G2}
{0:g2}
{0:G3}
{0:G4}
{0:G5}
{0:G2}		 123456.7
1.2E+02
1.2e+02
124
123.5
123.5
-1.2E+02
G or g General integer value 123 (default precision based on type) {0:G}
{0:G1}
{0:g2}
{0:G3}
{0:G4}		 123
1E+02
1.2e+02
123
123
G or g   enumeration DayOfWeek.Monday
WD.Fri | WD.Mon		 {0:G} Monday
Mon, Fri
g General date/time pattern (short time) DateTime 21:00:00 2007-02-20 {0:g} 2/20/2007 9:00 PM
G General date/time pattern (long time) DateTime 21:00:00 2007-02-20 {0:G} 2/20/2007 9:00:00 PM
M or m Month day pattern DateTime 21:00:00 2007-02-20 {0:M} February 20
N or n Number any numerical 123456.7
12345.6
12345.6
12345.6
-123.45		 {0:N}
{0:N0}
{0:N1}
{0:N2}
{0:N1}		 123,456.70
12,346
12,345.6
12,345.60
-123.5
o Round-trip date/time pattern DateTime 21:00:00 2007-02-20 {0:o} 2007-02-20T21:00:00.0000000
P or p Percent any numerical 0.123
0.1234
1.234		 {0:P}
{0:P1}
{0:P2}		 12.30%
12.3%
123.40%
R or r Round-trip single or double 123456789.012 {0:R} 123456789.012
R or r RFC1123 pattern DateTime 21:00:00 2007-02-20 {0:R} Tue, 20 Feb 2007 21:00:00 GMT
s Sortable date/time pattern; conforms to ISO 8601 DateTime 21:00:00 2007-02-20 {0:s} 2007-02-20T21:00:00
t Short time pattern DateTime 21:00:00 2007-02-20 {0:t} 9:00 PM
T Long time pattern DateTime 21:00:00 2007-02-20 {0:T} 9:00:00 PM
u Universal sortable date/time pattern DateTime 21:00:00 2007-02-20 {0:u} 2007-02-20 21:00:00Z
U Universal sortable date/time pattern DateTime 21:00:00 2007-02-20 {0:U} Tuesday, February 20, 2007 8:00:00 PM
Y or y Year month pattern DateTime 21:00:00 2007-02-20 {0:D} February, 2007
X or x Hexadecimal integer value 23712
23712
23712
23712		 {0:X}
{0:X2}
{0:X6}
{0:x}		 5CA0
5CA0
005CA0
5ca0
X or x   enumeration DayOfWeek.Monday
WD.Fri | WD.Mon		 {0:X} 00000005
00000011

Note: When scientific notation comes into play, the case of the format specifier is significant. To have the output with E (capital e), i.e. 1.02E+02 you must you capital format specifier, i.e. {0:E2}. Note that General provides the same result as doing (byte|int|double|...).ToString()

The Round-trip specifier is a bit special. It only allows single or double values and is used to guarantee that a number can be converted back into the same numerical value from it's string representation. It is quite similar to General, and actually tries the General method first and then parses it back into a double or single. If it is not the same result, it extends the default General precision (15 for double and 7 for single) to 17 and 9 respectively. A presicion specifier is ignored for Round-trip.

For the enumeration with FlagsAttribute I have used a custom WD (WeekDay) enumeration like the following:

PLAIN TEXT
C#:
  1. [Flags]
  2. public enum WD
  3. {
  4. Mon = 0x1,
  5. Tue = 0x2,
  6. Wed = 0x4,
  7. Thu = 0x8,
  8. Fri = 0x10,
  9. Sat = 0x20,
  10. Sun = 0x40
  11. }

One thing that I often want is to have a number with unknown number of decimals, fx. 1234.567 displayed with thousand separators but without trailing 0 (zeros), i.e. as 1,234.567 not 1,234.58 or 1,234.5670. To accomplish this one can do this (almost perfectly) with custom formatting. If you specify the format string "#,#0.#" (read on this is not the complete truth!!!) it will display all numbers before the decimal separator (specified by "." in the format string) will be thousand separated ("#,#"). The 0 (zero) ensures that 0.12345 is displayed as "0.12345" and not ".12345". The # after the decimal symbol specifies that a decimal should appear (note! a decimal), so "#,#0.#" will display 123456.789 as 123,456.8 (using en-us culture). This is the "almost perfect" part: you'll have to specify the maximum number of decimals to use, so if you use the format string "#,#0.######" you can have a maximum of 6 decimals, but trailing/non-significant zero's are left out.

You can read more about Custom Formatting, the most interesting part is probably the custom date formatting.

]]> http://blog.veggerby.dk/2007/04/15/formatting-strings/feed/ 0