Open Source .NET Development [Electronic resources] نسخه متنی

Other Development Tools for .NET

These tools really did not fit anywhere else, but they are essential enough to create a sort of catch-all group. Some of these tools are written in .NET; some are not. Some of these tools are Open Source, and some are not. But all are useful for developing .NET applications.

BugZilla

Occasionally when developing software, you may perhaps run across a bug. All joking aside, we all know that there are so many bugs, feature requests, and third-party bugs in our software that there has to be a system for keeping track of bugs. BugZilla (http://www.bugzilla.org) is the tracking system that the Open Source developers use, most notably the Mozilla team responsible for Netscape 6.x. BugZilla will also send emails to the team members responsible for the bug fixes. BugZilla can also integrate with CVS so that when checking the fixes into CVS, BugZilla will automatically set the bug to be resolved and send an email to the testing team. BugZilla saves its information to a MySQL database and has a convenient Web browser interface.

Merge and Diff Utilities

A good merge and diff utility is an absolute must in software development. Winmerge (http://winmerge.sourceforge.net) is a good graphical merge and diff utility that can be plugged into most SCM applications for easier differentiation through the versions in SCM. Normal merge and diff utilities usually do not work well with XML. This is because of XML Canocialization, which means that XML files can be structurally different but syntactically identical. For this reason, Microsoft (http://www.gotdotnet.com/team/xmltools/) and IBM (http://www.alphaworks.ibm.com/tech/xmldiffmerge) have both created a tool that can accurately compare XML files.

Decompilers and Disassembler

A disassembler is also very useful in low-level development and in creating System class libraries. The .NET framework, Rotor (SSCLI), and Portable.NET all ship with a disassembler.

Anakrino

Anakrino was the first available .NET decompiler. Available at http://www.saurik.com/net/exemplar/, Jay Freemans' project turned into a widely used tool. Why do you need a decompiler? Well, primarily to look at Runtime Managed code in IL, C#, or VB.Net, to debug low-level problems, and to interpret the code's implementation. I have also found a decompiler greatly helpful when using embedded resources to find the correct path to the resource.

Reflector

Lutz Roeder's Reflector (http://www.aisto.com/roeder/dotnet/) started out its life as an object browser. Reflector was then expanded into a full-fledged decompiler, and a good one at that (see Figure 3-20).

Reflector's most impressive feature is that it is almost entirely written in .NET code (unlike Anakrino). Users quickly added to Reflector's usefulness by adding it to the right-click context menu (http://www.managedcomponents.com/Weblog/permalink.aspx/0c16e449-ad8b-4f3f-b52b-49c64fb3e3ab) and writing a Visual Studio.NET plug-in for it (http://www.codeproject.com/csharp/ReflectorAddin.asp). The most impressive addins to Reflector are File disassembler (http://www.denisbauer.com) and IL Graph (http://blog.dotnetwiki.orglarchive/0001/01/01/287.dspx.

Obfuscator

After seeing how easily .NET assemblies are decompiled, you may want to consider using an obfuscator. For a more in-depth exploration of how decompilers and obfuscators work, see my book:

WebService Security in the .NET Platform

by Apress

Of course obfuscating Open Source would be an exercise in futility. However, if you are using an Open Source product in your proprietary application, or if you are interested in the internal workings of an obfuscator, there is an Open Source obfuscator called QNDObfuscator (http://www.desaware.com/downloadsqndl2).

Web Service Utilities

.NET Web services are powerful, fairly easy to develop, and somewhat simple to debug on a local machine. Visual Studio.NET does a great job of abstracting you from the ugly facts about Web services. Be careful when developing Web services because they require a different mindset. In DCOM or Remoting, you can use singleton design patterns, where one instance of a service object exists and knows all about the client. Setting attributes on the server object and having the server object maintain the state of the client is pretty common. This is a horrible design for Web services. Web services are mostly stateless (although you can keep sessions) and very costly to do round trips with. Also because XML Serialization is costly and because the structure of the message or data passed is essential, most Web service experts suggest starting with the design of the XML passed over the wire and working back though the layers of Web services to the Object Model. There really are not many tools available today that do this; however, there are numerous articles on how to get this accomplished.

When debugging and hacking a Web service, I have found the following tools to be priceless. Web service Studio is a general application to consume Web services, and it provides a quick way to test your Web methods. For this and other Microsoft Web service tools, visit the gotdotnet Web site at http://www.gotdotnet.com/team/tools/Web_svc/default.aspx. ProxyTrace, TcpTrace, PcapTrace, YATT, and WSDL Tools (http://www.pocketsoap.com) are all useful in looking at the various layers that go across the wire (i.e., WSDL, SOAP, TCP, etc). Ethereal (http://www.ethereal.com) removes all doubt about who or what is to blame when there is a network problem. This Open Source project is top-notch when it comes to a network sniffer.

Web Service Enhancements allow for security and other Web service standards to be added to a .NET Web service. With the addition of these and some upcoming Web service standards, Web services will be a more stable and more secure inter-platform system.

Newtelligence has released some Open Source Web Service Extensions (http://www.newtelligence.net/wsextensions/index.aspx) to show how easily the asmx Web service architecture can be extended and customized.

Regular Expressions

Regular expressions (regex) are a powerful and wonderful thing. Sometimes. Figuring out a language's regex idiosyncrasies can be a nightmare, but you cannot search or parse text any better than regex. Whether it is for searching the registry or creating a Regular Expression Validator for ASP.NET, the Regular Expressions Workbench (http://www.gotdotnet.com/Community/UserSamples/Details.aspx?SampleGuid=c712f2df-b026-4d58-8961-4ee2729d7322) or RegexDesigner.NET (http://www.sellsbrothers.com/tools/) will save you time.

CLRSpy

CLRSpy (http://www.gotdotnet.com/Community/UserSamples/Details.aspx?SampleGuid=C7B955C7-231A-406C-9FA5-AD09EF3BB37F) is a great tool to help understand the inner workings of the .NET runtime, especially when you are working with Platform Invoke (P/Invoke) or Com Interop. Allocation Profiler (http://www.gotdotnet.com/Community/UserSamples/Details.aspx?SampleGuid=36a3e666-6877-4c26-b62d-bfd7cb3154ac) is very useful in learning how Garbage Collection works. And Dependency Walker (http://www.gotdotnet.com/Community/UserSamples/Details.aspx?SampleGuid=d5e6ae32-0ed3-41d7-b731-8bdf34c13833) helps to track down missing dependencies.

Vil

Vil is a very interesting tool that graphically tells you about your coding tendencies. You can download it from http://www.1bot.com. This command-line tool analyzes .NET assemblies, provides metrics, and allows for queries regarding the Object Oriented design. This tool can point out code that needs to be refactored and help you better execute the coding of your architectural design. Vil can tell you how many try/catch blocks you use, class/struct/enumeration counts, local variable counts, events params, and much more!