Why I love XmlSpy with XSD Schema Editor.

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/why_i_love_xmlspy_with_xsd_schema_editor.htm]

Before coming to Ameripay's  Software Engineering department, I used to do consulting. Because with consulting, everything (such as what software you have licenses for) is project-driven, my software was often on the cheap. Clients and managers were very hesitant to pay for licenses for "frivolous" software, especially with the previous IT recession. Therefore certain things, like editing Xml Schemas, I often did the harder, manual way. For simple schemas this works, but it just becomes draining (You can learn the basics of Xml Schema at the online W3Schools).

Now I have XmlSpy installed, and it's great if even just for the schema editor. I've heard many good things about this popular tool, but never got the chance to check it out myself. The help section even has a step-by-step tutorial. It looks like Altova even offers a free XmlSPy Home Edition to get you started.

Yet another tool I wish I had had before.

Batch code generation with CodeSmith Console

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/batch_code_generation_with_codesmith_console.htm]

I'm always keeping my eyes open for practical tools that save time and mental sanity. One of the most mentally-draining tasks is repetitious modifying of simple code. For example, many simple CRUD (Create-Read-Update-Delete) stored procedures, and their accompanying DAL and Business Objects are redundant. Ideally we could just auto-generate this given the inputs. Auto code generation is a great time saver, which frees us from boring tasks to focus on interesting ones.

CodeSmith is a great code generator. It has both a free and purchase version, it has a large support community, is time tested (been out for several years now), and has great functionality. It's based around writing templates with ASP syntax, which is much more friendly then using XSL or writing your own C# app to assemble the target code. Therefore part of a CodeSmith template may look like:

private void <%= SampleStringProperty %>() {     // <%= GetSomething() %>     // Do something }

There are plenty of tutorials about auto-generating your data access layer. But one thing I really like about CodeSmith is its batch processing. These are features I'd like in batch processing:

• Ability to call the tool from a command line, passing in an Xml config file
• Extend step 1 to generate many objects from a single Xml file, as opposed to calling the exe each time.
• Ability to merge your changes into an existing, non-generated document.
• Ability to auto-generate a document, but leave certain sections open to customization

The first two help with batch processing, such that you could generate an entire layer at once. The last two help with versioning and customization. You need to both made custom modifications to templates, and then not have those overwritten upon re-running the tool.

CodeSmith offers both several help guides, and samples, to assist with these. Check:

• CodeSmith Console Tutorial in the CodeSmith Studio's Help section
• Samples at: "CodeSmith\v3.0\SampleProjects\ConsoleSamples\GenerateCode.bat"

If all you have is a hammer, everything looks like a nail. With a good code-generation tool, you start viewing all those redundant tasks very differently.

AJAX - Asynchronous JavaScript and XML

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/ajax__asynchronous_javascript_and_xml.htm]

Until recently, I assumed that web applications were based on a strict client-server / request-response model. This has several limitations, such as a thin client (your web browser) not being able to do any *real* business logic. For example, say you need to validate against a back-end data source such as ensuring a username-password combo is valid or checking if a city exist within a state. As this is really outside the scope of JavaScript, it would require a hit to the backend, and then re-posting the page.

But what if you could just do a "postback" for the desired field only, leaving the rest of the page unchanged? And what if you could have the server automatically update the client without the client initiating the event?

A technology, Asynchronous JavaScript and XML (AJAX) looks like it can do just that. Quoting from Adaptive Path's Jesse James Garrett:

[Quote]

Ajax isn't a technology. It's really several technologies, each flourishing in its own right, coming together in powerful new ways. Ajax incorporates:

• standards-based presentation using XHTML and CSS;
• dynamic display and interaction using the Document Object Model;
• data interchange and manipulation using XML and XSLT;
• asynchronous data retrieval using XMLHttpRequest;
• and JavaScript binding everything together.
   

[End Quote]

Check out these sites for more detail:

• http://ajax.schwarz-interactive.de/csharpsample/default.aspx - download relevant source code
• http://www.ajaxmatters.com/ - other Ajax links.

This looks like it has a ton of potential, and I'm looking forward to checking it out and doing a future blog post on a sample.

Enterprise Library Tips for Strong Names and Versions

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/enterprise_library_tips_for_strong_names_and_versions.htm]

Previously I offered some tips for configuring Enterprise Library. Today I'll discuss another problematic area - adding strong names.

First, this builds on concepts about Strong Names and PublicKeyTokens.  You may need to add a strong name to the EntLib blocks if you include it in a project that already uses strong names (because this requires that all assemblies being referenced also have strong names).

To add a strong name, you'll need to create a key and reference it in the AssemblyInfo.cs file.

Strong Names and Versioning Tips

0 - You will need to add the key to the source code. Microsoft gives us the source code partially so that we can do things like this.

1 - Put properties (like strong-naming) in the GlobalAssemblyInfo.cs. This requires you to remove (or comment out) the key from the other 38 AssemblyInfo files, however it lets you change it in one place.

2 - Note that there are two places that DLLs are stored.

• C:\Program Files\Microsoft Enterprise Library\bin
• C:\Program Files\Microsoft Enterprise Library\src\\bin

Opening the EntLib solution and compiling creates copies in the \src dir. You still need to copy these to the \bin
Make sure to run the "Copy Assemblies to Bin Directory" script included in the EntLib start menu. If you're not putting DLLs in the GAC,  EntLib's config tool pulls DLLs from the \bin dir. So you'll notice strong-name nightmares if you don't do this. It will set the assembly name (like PublicKeyToken) from those DLLs, not merely the ones used in your project. For example, check the version of the DLLs loaded by the config tool, and make sure that they include the strong name.

Enterprise Library Tips for Configuration

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/enterprise_library_tips_for_configuration.htm]

Enterprise Library is Microsoft's next generation of Application Blocks. It's a free, integrated suite of common architectural components that your project probably needs. It has several good perks:

• Includes all source code
• An auto-config tool to handle the Xml config files.
• 38 projects of well written code - i.e. a good example to learn from
• Full documentation
• A huge community supporting it.

You can download it here. Be sure to check the official blogs:

• Tom Hollander
• Scott Densmore

When I first was playing around with it, I had trouble with creating strong names and config files.

Configuration Tips

1. A single application can have multiple physical config files:

• CachingQuickStart.exe.config (app)
• cachingConfiguration.config (other block)
• dataconfiguration.config (other block)

Furthermore, you'll need to make sure that the correct file is copied to the app's bin. Merely rebuilding or using EntLib's config tool doesn't copy all configs.

2 - For the data access block config, you'll need to set both the connection string as well as the individual params. Config looks like:

3 - For the Caching Block's Data Provider:

• "PartitionName" does not correspond to actual database partitions, but rather a value in the Caching.CachData.PartitionName column. This means that you don't need to create a DB partition for the DB cache to work.
• Make sure that you run the script to create the Caching DB ('Caching').
• Make sure that user has access to the 'Caching' database, and can insert into the CacheData table. Merely running the create script doesn't provide access to custom users.

4 - For the Caching Block's Isolated Storage, this uses System.IO.IsolatedStorage. You do not provide a physical file path name. Partition Name is a folder name like "MyApp".

I'll discuss Strong Names in my next post.

Strong Names and PublicKeyTokens

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/strong_names_and_publickeytokens.htm]



Every now and then I see config files containing lines like:

<add assembly="System.Data,  Version=1.0.2411.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
</assemblies>

When I first came to .Net I tried to avoid this, but it actually serves a useful purpose: specifying your assemblies in the config ensures that your app is using the correct version of an assembly. Many developers I've known don't want to deal with details like that, so I'm going to blog about some things that I've found to make it easier.
Where does this info come from?
This is the assembly's FullName. You could view it with the following code:

public string GetFullName(string strAssemblyPath) {
    Assembly a = Assembly.LoadFrom(strAssemblyPath));
    return a.FullName;
}

It has the following parts:

• Assembly Name
• Version
• Culture
• PublicKeyToken (generated from a strong-name)

This link on MSDN provides more info about Assembly names.
How can I tell the version and PublicKeyToken of an assembly?
You can tell both via the Assembly.FullName property as mentioned above. But you can also use other tools.

• Assembly - right click on the assembly in Windows Explorer, and look at the "Version" tab.
• 
  PublicKeyToken  - use the Strong Name tool (sn.exe), run "sn -T C:\Temp\Common.dll" with the BIG 'T' (not little 't', which gives the token for the inline file instead).

My app doesn't need to worry about this. How can I simplify my life?
If you remove a section from the config file, then it won't filter on that. For example, if you don't care about the strong name, then you can simply remove it and use this instead:

<add assembly="System.Data,  Version=1.0.2411.0, Culture=neutral/></assemblies>

However, this could get you in trouble if multiple assemblies with different strong names are used later on.
Next...
I'll discuss some practical application of these concepts in a future post.

.Net Tools besides NUnit, NAnt, and NDoc

[This was originally posted at http://timstall.dotnetdevelopersjournal.com/net_tools_besides_nunit_nant_and_ndoc.htm]

There are a lot of other great and free tools out there besides just NUnit, NAnt, and NDoc. I'm always keeping my eyes out for freeware tools because they can really simplify one's life. Two things I do to help organize this: I have a special folder in IE dedicated to just tools, and each new tool gets its own subfolder. This provides a place if I ever come upon other articles or links for that tool. If I dump every tool-related download, FAQ, and article, then the folder gets unmanageable. Once you get 20+ tools, this is a big deal. I also have a corresponding folder structure on my hard drive where I can save the installers. I don't download them directly to the ProgramFiles folder because it gets flooded.

Here are some tools that aren't as popular as NUnit, but I've still found useful.

Free online tools (provided as a web-page):

• C# Code formatter for the web:    http://www.manoli.net/csharpformat/
• W3 validate your Html: http://validator.w3.org/
• Validate your Xml Schema: http://apps.gotdotnet.com/xmltools/xsdvalidator/Default.aspx

Free Downloads:

• devMetrics - get code metrics. This integrates directly into Visual Studio. But as of this writing, it has a bug that hinders the command line build with devenv.com. http://www.anticipatingminds.com/Content/Products/devMetrics/devMetrics.aspx
• ProcessExplorer - see which process is locking that file: http://www.sysinternals.com/Utilities/ProcessExplorer.html
• SharpReader blog aggregator: http://www.sharpreader.net/
• Locked File Wizard - allows you to copy directories despite certain files getting locked by other processes: http://www.noeld.com/programs.asp?cat=misc#lcounter

I'm sure this list will continue to grow.