Hello.

In this follow-up post, I've decided to use Mercurial for my project's version control. While feedback leaned towards Subversion (SVN), I prefer Mercurial due to its distributed nature, Codeplex support, available .Net tools, and superior branching capabilities. I'm open to further discussion and any compelling arguments for reconsidering SVN.

I'm curious to hear from .Net developers, both those working with Windows and Mono, about their preferred source control service between Subversion (SVN) and Mercurial (HG). I'd love to know which one you find most effective and has the least impact on your daily workflow. While I know other SCMs exist, I'm specifically interested in opinions on these two.

I'm giving a talk on DSL Tools and T4 templates at the Liverpool Users of .Net User group on April 17th. The talk will cover an overview of DSLs, what Microsoft DSL Tools are (and aren't), how they can be used, and a walkthrough of creating a DSL Tool. The event is at AIMES and details can be found on Upcoming.yahoo.com. I'll share the slides afterward. Let me know if you have any good examples of tools built with the DSL Toolkit!

The Liverpool .Net User Group is officially formed! Join fellow .Net enthusiasts in the Liverpool area for discussions on all things .Net. Visit our website at http://www.usersof.net/ or join our Google group at http://groups.google.co.uk/group/liverpoolusersofdotnet to connect with other members and stay updated on upcoming meetings. The next meeting is scheduled for April 17th, 2008 - http://upcoming.yahoo.com/event/454169/. We encourage everyone interested in .Net to join us!

I've released a new, open-source Microformat parser for .NET, available on Codeplex! This stream-based parser uses a flexible XML configuration to define how microformats like hCard and rel-tag are extracted from HTML/XML, allowing for easy adaptation to spec changes. The provided C# code example demonstrates the simplicity of using the framework to read and process microformat data. Feedback and contributions are welcome!

Arrived at DevWeek 2007 last night. Looking forward to the keynote by Jeff Prosise on ASP.NET AJAX and then attending architect track sessions on securing ASP.NET 2.0 apps and practical patterns in .NET. Hoping to post summaries if internet access allows.

In a previous post, I discussed the scarcity of ReSharper plugins and sample code. I'm happy to announce that JetBrains has launched a new resource page dedicated to ReSharper Plugin Development. This page provides guides and sample code to help you create your own plugins. You'll need ReSharper 2.5 or later, which is a free upgrade for existing users.

I'm really enjoying working with WSE 3.0, especially its policy mechanism. It allows for Aspect Oriented Programming (AOP) through SoapFilters, enabling me to add functionality like security, auditing, and exception handling via configuration rather than hardcoding it into my web service. This keeps my service code clean and maintainable. I demonstrated this with a simple example of an OrderService, comparing the cleaner policy-based approach to a more complex, hardcoded alternative. The policy configuration significantly simplifies adding and managing cross-cutting concerns.

I'm searching for plugins created using JetBrains OpenAPI for ReSharper 2.0+, but they're proving difficult to find. The only one I've encountered is mentioned in a blog post, and it doesn't seem to have been officially released. I have some plugin ideas of my own, but the available documentation and examples aren't very helpful.

I had a problem getting TypeConverters to work with generic lists in XNA and WinForms. The designer wouldn't generate the code I wanted for properties. I needed a simple way to serialize objects, so I tried a minimalist approach. Overriding CanConvertTo and ConvertTo methods in my TypeConverter was enough for the designer to serialize the objects correctly, generating much cleaner and simpler code.

I came across ARogan's F14 XNA game which features 3 levels of parallax scrolling. I'm thinking it would be a great opportunity to demonstrate the capabilities of my XNA Parallax Engine. Ideally, someone ports the game to use my engine, but if not, I'll do it myself since the F14 game's source code is available. This will be a good test of my engine's flexibility and I'm eager to see how easy the porting process is and how well it performs. I'll keep you updated on my progress.

In this post, I describe a solution to a problem I encountered while working with XNA Beta1 and Vector2 structs. Because Vector2 didn't have an associated TypeConverter, the designer lacked support. Applying a TypeConverter to the property worked in the designer, but Visual Studio 2005 ignored it during serialization, resorting to resource files, which was messy. My workaround involves dynamically adding a TypeConverter to the Vector2 type itself using TypeDescriptor.AddAttributes, which is invoked during the class's construction. By registering the Vector2Converter with the Vector2 type early on, both the designer and code serialization work harmoniously.

I've just pushed an update to my XNA Parallax Engine project, which now includes its first demo. This initial demo showcases a basic single scrolling background—simple, yet functional, requiring minimal code for setup. I'm currently refining the layer collection initialization process. The updated source code is available on Codeplex for those interested in exploring it further.

I've started a project on Codeplex and I'm very impressed with how easy Team Foundation Server is to use compared to Rational ClearCase and ClearQuest. It integrates seamlessly with VS2005. I'm still getting used to it, but running into some integration issues between VS C# Express (required for XNA) and Team Foundation Server. I'm currently using VS2005 Team Edition, VS Express, and the command line (tf) in my workflow.

I've started an open-source parallax scrolling component project on CodePlex to help game developers create repeating scrolling backgrounds for their XNA games. It's still in early stages, but currently includes a 2D camera, layer oscillators, scrolling, and clipping functionality. Check out the XNAParalax Component project on CodePlex and provide feedback!

I was developing a component in XNA and needed a way to edit Vector2 properties directly within the Game Designer. Since Vector2 is a struct and doesn't inherently support this, I created a custom TypeConverter. The provided code allows you to modify Vector2 values in the designer using comma notation (e.g., 50, 100). Feel free to adapt it for other types like Vector3.

I finally figured out why my Windows Live Writer plugins weren't working! It turns out that new classes added via the Solution Explorer default to "internal" access. Making the class "public" fixed the issue and now the plugins work perfectly.

I previously doubted the possibility of C# on Xbox 360 and a hobbyist homebrew version. I was wrong! Microsoft announced the release of Visual Studio 2005 Express for Xbox 360 content creation on August 30, 2006. The $99/year dev kit allows non-commercial game development and sharing among hobbyists (no network support yet). I'm excited to get an Xbox 360, Xbox Live account, and the developer account! Check out these resources: XNA Team Blog, Microsoft XNA homepage, XNA FAQ, Game Studio, News Report, another Blog Post.

I bought iforgive.eu and iforgiv.eu domains hoping to create something cool, but my initial ideas (a flower shop, a public forgiveness platform, and an open email apology site) were flawed due to practicality and potential abuse. Then I thought about a social charity platform ("If Or Give") or a Q&A site, but those didn't pan out either. So now, I'm thinking of just using it to host my .Net 2.0 experiments. Any suggestions? Let me know in the comments!

This post agrees with Kirk Allen Evans's argument that .NET 3.0 should be named something closer to 2.5 due to its reliance on the 2.0 framework and compilers. The additive nature of the release doesn't warrant a full version number increment.

Microsoft has renamed WinFX to .NET Framework 3.0. This new version will include the existing .NET Framework 2.0 components (ASP.NET, WinForms, ADO.NET, additional base class libraries, and the CLR) along with new technologies like WPF, WCF, WF, and WCS. However, there's no mention of C# 3.0 being included, and the author finds this renaming confusing and unnecessary.

This post responds to Mike Champion's comment on my previous XLinq blog post. I clarify the XML file used (Wikipedia XML Abstract) and explain why I chose an XMLReader for its speed, especially when combined with custom data structures for a cyclic graph representation. XLinq's syntax and lambda expressions felt less intuitive for my task of converting XML into SQL statements. The project involves relating "title" elements with "sublink" entities, resulting in a complex graph structure not easily handled by XLinq without excessive data duplication and memory consumption. While XStreamingElement offers some improvement by avoiding redundant data scans, I desire deferred data loading for processing only necessary slices of the XML. This approach could handle selects, wheres, and counts efficiently in a single pass, and even joins with clever indexing. Defining a schema during XML iteration seems redundant when XLinq expressions already specify data requirements. Pre-loading entire XML documents into memory feels inefficient when only a small portion is used. I propose deferring data loading until needed, despite potential issues with repeated XDocument inspections. Ideally, XLinq should scale without forcing users to revert to less efficient methods due to data size limitations. I inquire about potential hard limits and scaling formulas related to XML document size in XLinq.

I've reinstalled the latest WPF and WCF beta versions and I'm planning to write some blog posts about it very soon. I'm ready to dive back into WPF and share new insights.

I recently commented on an old blog post about C# 3.0, expressing initial agreement with a sentiment against functional programming in the industry. However, upon reflection, I realized C# 3.0 isn't purely functional but rather integrates some academic concepts into a practical context for industry use. While still learning C# 3.0, functional programming, and LINQ, I've found my tests using these features to be clearer and more presentable. Although there's a learning curve, especially with the generic delegate syntax and translating between "SQL" and object syntax, I'm embracing the ongoing learning process.

My friend, Paul Pierce, has started a new blog! He plans to cover various topics, including .Net. He's already got a helpful post up about using NMock 2. I encourage you to check it out, it is very good - possibly even better than mine. Visit his blog here: http://www.paulpierce.co.uk

I've been busy with side projects lately, so the blog has been quiet. One project should be released this week. Another is a .Net 2.0/ASP.Net 2.0 hosted site for examples from this blog (and to help me learn .Net). It's behind schedule, but will eventually host controls, tutorials, etc. More info soon on the first project. And, btw, the FIELDSET tag is awesome!

In this first part of my series on C# Trackback implementation, I delve into the Trackback Ping functionality, providing a comprehensive code explanation. While I remain unconvinced about the overall effectiveness of Trackbacks, exploring the implementation in C# has been an interesting coding exercise.

This is the second part of my series on implementing trackback functionality using C#. I've provided the complete source code, which is free for anyone to use and adapt. This post dives deeper into the intricacies of trackbacks and how to use them within your C# applications. Click the "read more" link for the full article and source code. If you find it useful, consider giving it a digg!

Microsoft is bringing a subset of the .NET Framework, including C# and VB.NET support, to the Mac platform via WPF/E. This goes beyond the JavaScript engine also included with WPF/E, allowing for richer and more complex applications.

A quick explanation of associative arrays in C# .NET, clarifying that they are simply hash tables. A basic code example demonstrates adding and retrieving a key-value pair.

I've just posted the C# source code for serializing and deserializing OPML files using a simple object model. The code demonstrates basic serialization and deserialization, creating an OPML structure with a head, body, and outline elements. While the object model is functional, it's not perfect and could be refined. The example code shows how to create an OPML object, populate it with sample data, serialize it to XML, and then deserialize it back into an object, useful for anyone working with OPML in C#.

Someone searched for "directory explorer c#" and landed on my site, likely not finding what they needed. This post clarifies how to use C# for directory exploration. It covers using .NET's System.IO namespace, specifically the File and Directory classes, for tasks like checking file existence (File.Exists) and getting a list of subdirectories (Directory.GetDirectories). This information will hopefully be helpful to future visitors with similar searches.

I'm working on a .NET object model for OPML 2.0 to easily serialize and deserialize OPML files. Serialization is working well and creates correctly formatted files thanks to constraints based on the OPML spec. Deserialization is proving tricky as the XML Deserializer isn't enforcing those same constraints, allowing incorrectly structured OPML files to be loaded. I'll share the code and continue working on it.

I've noticed a lot of searches related to C# and Xbox 360 development. While it's unclear what the future holds, some recent posts suggest that using the CLR on the Xbox 360 may be possible someday. Whether this will open up homebrew development remains uncertain, especially considering potential licensing restrictions. Though it's unlikely, we can still hold onto a glimmer of hope!

This post explains AJAX (Asynchronous JavaScript and XML) and its use in .NET. AJAX allows web pages to update small sections without reloading the entire page, improving user experience. Traditional ASP.NET (1.x) struggles with this as it's designed to reload entire pages. However, .NET's flexible request pipeline allows plugins/HTTPHandlers to manage AJAX requests, enabling developers to execute specific methods within a page. The post lists several .NET AJAX frameworks, including AjaxPro, Arshad.NET, and AjaxAspects, and points readers to ajaxpatterns.org for more options.

I'm exploring the eBay API using ASP.NET and SOAP. It's proving a bit cumbersome due to its monolithic structure. Ideally, each API call would have its own WSDL and SOAP interface for easier management. Currently, I'm stuck on generating a User Token for authentication, having tried my developer account, regular eBay account, and a new account without success. Any advice on obtaining a User Token would be greatly appreciated!

This post addresses a common search query: how to find file extensions using regular expressions in C#. I provide several regex examples for this purpose, including variations for finding extensions only at the end of a string and for specifically finding three-letter extensions.

I've found some useful resources for C# developers working with Internet Explorer. Rich Crane's code provides a framework for .NET interaction with IE, handling the COM interop for you. While the framework looks promising, it seems to have limited browser event support. For more comprehensive IE integration, including toolbars and shell extensions, check out Sky Software's EZShellExtensions.Net and Shell MegaPack.Net. These support .NET versions 1.0 through 2.0.

I had trouble getting the GetWatcher method of the Feed Management API to work. Thanks to Matt Dotson's code on GotDotNet, I resolved the issue. The problem was a casting error; I was casting to FeedsWatcherClass instead of the IFeedEvents_Event interface. The corrected code now successfully attaches the watcher to the feed and handles FeedItemCountChanged and FeedDownloadCompleted events.

A quick link to Heath Stewart's blog post on MSDN.

I'm puzzled why Microsoft's new Feed Manager API is COM-based instead of a managed API. Given their push for managed code in Vista and .NET's excellent XML handling, a managed API for RSS (which is XML-based) seems logical. It's frustrating to need interop to use this new feature.

This post addresses the Google search query "c# convert date from uk to usa." It provides a C# code snippet using CultureInfo and DateTime to convert a date string formatted according to UK conventions into a US date format. The code takes the date string from a textbox, parses it using the UK culture settings (en-GB), and then formats the resulting DateTime object according to US culture settings (en-US) before outputting it to another textbox.

In a previous post, I discussed using the .NET Framework on the Xbox 360. It turns out you can create Media Center applications, install them on your media server, and then control them via the Xbox 360 UI. The processing happens on the Media Center PC. More details are available in an MSDN article.

This post addresses the numerous Google searches related to ".NET framework" and "Xbox 360." Despite the search traffic, I currently have no information on this topic. It seems unlikely that .NET Framework would be available on the Xbox 360 due to the console's different chip architecture and the recent introduction of x86 64-bit support in .NET 2.0. However, I remain open to the possibility.

This post addresses the search query "c# instanceof" by clarifying that C# uses "is" and "as" keywords instead of "instanceof" for type checking and casting. The "is" keyword checks an object's type, while "as" performs a safe cast, returning null if the cast fails, unlike an explicit cast which throws an exception.

I've updated my AJAX Tagger to Version 2! This release adds a simple but useful feature: you can now manually add your own tags in the tag list panel. This is really helpful when the Yahoo Developer Term Extraction API isn't sufficient for tagging, like when you need specific tags such as "C#" and ".Net".

I've been experimenting with the Bluetooth library for .NET I mentioned earlier, but I'm having trouble getting it to work. I wanted to connect my phone to my computer and transfer images, but it's not working as expected. The library itself seems fine, it's likely my understanding of Bluetooth communication that's lacking. On the plus side, detecting devices with the library is very easy!

This post discusses the best placement for enum declarations in C#. While some argue that defining enums outside the class avoids extra typing, I believe that placing them inside the class improves code clarity, reduces ambiguity, and makes it easier to handle similarly named enums from different classes. IntelliSense helps with the extra typing. The original article argues against this, prioritizing less typing, but I find that less important than clarity and proper scoping.

I've posted another update to my ICMP ping tutorial series on MSDN Blogs. This installment focuses on crucial aspects like calculating checksums and serializing packets into byte arrays for transmission. While we haven't started sending data over the wire, understanding these concepts is vital for the next steps. Check out the post for more detail.

Part two of my C# Ping tutorial is now available! This installment dives into the structure of Ping packets and their place in the communication stack. It explores the fundamentals of how ping works, from sending echo packets to receiving echo responses and using response time to determine network connectivity.

I'm back to blogging and starting a series on socket programming! First up: building a simple Ping client using System.Net.Sockets. I'll walk you through it, and as a starting point, you can check out the ICMP RFC. Stay tuned for more!

James Manning left a comment on my blog post about compression, pointing to a Microsoft article about built-in decompression support in .NET 2.0 for SOAP replies. While I appreciate the comment, Yahoo APIs don't use SOAP, so it won't be helpful in that context. However, this information could be useful for working with Amazon APIs, which do have a SOAP interface.

In a follow-up to my previous post about the scarcity of Bluetooth libraries for desktop PCs, Mark Arteaga brought 32feet.net to my attention. This site offers a managed Bluetooth library which I plan to investigate further. Initial impressions from the sample code suggest it's straightforward to use, with device discovery appearing as simple as calling a function and communication happening via streams.

I just watched an exciting Channel 9 video about the future of C# 3.0, featuring Anders Hejlsberg. It highlighted some game-changing features, including extending classes with new methods without derivation and the introduction of Lambda functions. One particularly cool feature is the addition of LINQ (Language Integrated Query), which extends IEnumerable objects with SQL-style operators. I'm still exploring how I can use this in my own projects, but it looks incredibly promising!

I'm really interested in ATLAS (AJAX), but I need to prioritize my time. I can't afford to get sidetracked by this project right now, especially since it's not .Net-based and my current work focuses on .Net.

I've previously mentioned the .NET Image Filter Library, and I highly recommend it to anyone interested in learning about programmatic image manipulation. The library is well-documented in an easy-to-follow CodeProject article by Andrew Krillov. You can find it here: Image Processing Lab and Motion Detection. I even created a fisheye filter for this API, which you can find here: Fisheye Example

This post, part 8 of a series about my first AJAX application, discusses my return to Perl programming after a year of focusing on C# and .Net. I needed to solve cross-domain scripting issues when calling a web service directly from the webpage. My solution involved proxying the request through a Perl script on my server, which also hid my developer tokens. I found Perl's libraries easy to use and effective for this task. Future plans include more Perl scripting to aggregate data from different blogs and web services, leveraging the proxy to combine multiple calls and enhance functionality. I also learned a valuable lesson about using "content()" methods for POST operations instead of the query string.

I explored the idea of C# 3.0 XML Generics based on Matt War's blog post. I'm questioning the practicality of defining a generic from an XML Schema within the code itself, as it seems redundant compared to simply creating a class. However, the concept becomes more intriguing if the generic type could be derived from a streamed XML schema, offering dynamic type creation possibilities.

This short, humorous post suggests the seriousness of the topic of C# Generics 3.0 despite its light-hearted tone. It hints at a deeper dive into the topic, perhaps planned for the future, while acknowledging its complexity and importance.

I'm exploring the concept of generics in C# 3.0, particularly how they might relate to XML types. I'm having trouble grasping the connection described in MattWar's blog, which suggests generics and XML are fundamentally linked. While I understand how generics allow parameterized specialization of classes (like a list of ints, longs, or custom objects), the example of XML generics like "Foo<int x="...">" confuses me. Is it parameterization, an attribute, element constraint, or class conversion? I don't see the advantage over generating classes from XSDs. I'm curious about how XML generics might be tied to schemas for constraining parameter values and eager to learn more about this potentially paradigm-shifting concept.

I've been experimenting with the Microsoft Avalon CTP (Community Technology Preview) Framework and wanted to share a simple XAML menu example. This example demonstrates how to create a custom style for menu items to make them look like GelButtons. Initially, I tried using a ControlTemplate but later realized a HeaderTemplate within the style was the correct approach. The XAML code provided creates a menu with styled menu items, showcasing how to customize the appearance and behavior of menu items in Avalon.

During the development of a custom IHttpModule, it's important to be aware of the timing of context access. Avoid accessing HttpContext properties directly within the Init method, as the context isn't fully initialized yet. Instead, handle events like BeginRequest. Within those event handlers, the HttpContext object provided will be fully populated, allowing access to properties such as HttpMethod, QueryString, and Form.

In this second part of my series on image processing, I'm exploring the Tiger Imaging Library for C#, a cool resource with complete source code and various image manipulation filters. I'm considering expanding its capabilities by creating new filters like the fish eye effect described by Jason Waltman. I'm also planning further research and experimentation with Tiger Imaging.

Visual Studio 2005 Beta 2 is now available for download to MSDN Universal subscribers. I'm excited about this release and will be posting examples soon. Check out the product page and the uninstallation instructions for previous versions if you plan to upgrade.

I finally took my own advice and watched the MSDN videos, specifically "Designing .NET Class Libraries: Member Types." I was impressed with the discussion on .NET class library design principles, especially regarding method overloading and cohesion. I highly recommend checking it out and plan to incorporate these best practices into my own coding.

I've been exploring Amazon's SOAP API and Yahoo's REST API and I'm quite impressed with both. I'm thinking about ways to make these two APIs interact and will share my ideas in a future post. I've also been working on using REST in .Net 1.1, which is a little tricky but possible, thanks to Martin G. Brown's work. The process involves using an XSD of the response, running it through XSD.exe to generate a Dataset object, and then processing the results. It's a similar concept to WSDL, but without the automatic stub generation. I'll post some Yahoo API code examples soon. I plan to look into Google's API as well, even though it's in beta with usage restrictions.

I'm excited about the new MSDN .NET Framework Developer Center on designing class libraries! It looks like a promising series based on internal Microsoft training, with a focus on API design best practices. Brad Abrams is presenting, and the content is being released weekly. Check out the introductory article!

A quick test post to check if everything's working. Planning to share learnings about C#, C# 2.0, and .NET Framework soon.