DotNetKicks.com : Stories kicked by JamesEggers

Development Achievements

Fri, 26 Mar 2010 18:40:09 GMT

A look into possibly using an Achievement system as a way to increase motivation and recognition of developers.

Making Part Declarations Easier with InheritedExports

Wed, 27 Jan 2010 02:27:30 GMT

A look at the lesser documented feature of the Managed Extensibility Framework - the InheritedExport attribute.

A Configurable Type Catalog for MEF

Wed, 13 Jan 2010 03:29:45 GMT

A post that looks at what extending the TypeCatalog that comes with the Managed Extensibility Framework to provide provider-model like functionality.

Random Acts of Coding: Using MEF and Custom Configuration Sections

Wed, 23 Dec 2009 12:52:39 GMT

In this post, we'll look at how to utilize a custom configuration section defined in an assembly used as a MEF part and not located in the same directory as the executable. Using this method, it will allow even greater power to your application and freedom to the parts consumed by such.

Managing Composition Through Lazy Loading Parts

Tue, 01 Dec 2009 12:43:28 GMT

So far in this post series, we've been looking at various aspects of working with MEF in the context of a single level of composition. One interesting thing about MEF is that its composition is recursive based on the assemblies and types identified in the catalogs within the container. What this means is that if one of our parts also has imports defined for parts of its own, the composition container will continue loading parts for the initial type as well as all parts loaded until no more parts are found or all imports are fulfilled. This is a really nice feature since it will ensure everything is ready for you once compose the initial type; however, this eager loading can greatly cause a performance issue if the parts are not constructed properly. In this post on our ongoing series about MEF, we'll look into the concept of parts of parts and how to apply lazy loading principles towards them.

Looking Around at Circular References in MEF

Wed, 25 Nov 2009 13:56:24 GMT

In the last post of this series, we created a new example code base used to display help text for various "commands". This was a simple code base that extended previous examples by using external assemblies and different catalogs to identify all of the parts that can be imported and mapped. This example covers a lot of scenarios when applied beyond the means of console-based text output since each imported "command" could literally be a functional piece of code by itself. However, what happens when the imports require something from our main application? When one object has a dependency with another object of another type; only for the dependent have a dependency towards the initial type; this is called a circular dependency. In this post, we're going to look at the condition of a circular dependency and see how MEF encounters such issues.

Random Acts of Coding: Playing Nice with Other Assemblies using MEF Ca

Mon, 23 Nov 2009 13:15:55 GMT

Looking over the previous three posts, we have been working within a single assembly for managing our extensibility parts. While this works well if we want to use MEF more as an IoC container, it really limits the extensibility of our application. In the single assembly model that we've been using, every update would require a new build of the application. To overcome this limitation, we'll create a new example project that builds on what we've covered and branch it out into multiple assemblies.

LINQing to MEF Imports

Thu, 19 Nov 2009 12:54:53 GMT

At the end of the last post, we looked at how we can explicitly manage our imports and exports using a combination of text-based labels and type declarations. In addition, we began to look at the ImportMany() attribute for importing more than one value in our extensible application. Along with the ImportMany(), we looked at looping through the simple example to display the property of each imported type. This approach isn't bad if the number of imported types are small; however, looping really wouldn't work well if your application loaded a very large amount of applications. In a way, it's a great problem to have if your application has a large community based plug-in repository (i.e. Wordpress or Firefox). There may come a time when we may need to find a specific plug-in without looping through everything. In order to determine this, there's a couple different ways to handling this. In this post, we're going to explore a non-MEF way of handling it using LINQ. In a future post, we'll look at how we can expand upon this using some of the constructs that MEF provides.

Pass Number 1: ActiveRecordEngine for ASP.NET « Rob Conery

Fri, 20 Nov 2009 12:00:00 GMT

Rob is looking for feedback

Random Acts of Coding: A Deeper Look at MEF's Imports and Exports

Mon, 16 Nov 2009 12:53:08 GMT

In the last article, I provided a very brief introduction to MEF and showed a very simple console application. In this section, we'll be looking at the issues associated with that sample and diving into the various aspects of declaring your Imports and Exports to overcome those issues. The code and samples in this post will still be within a single assembly. Because of this, I'll may use the word Dependencies and Parts interchangeably.

Random Acts of Coding: An Introduction to MEF

Fri, 13 Nov 2009 02:53:34 GMT

Have you ever attempted to write an extensible application? You know the kind. The applications where your boss wants to be able to add stuff to it without rewriting the entire application and with minimum costs. Or the type of application you want to release out to the community and provide a way for them to add their own customizations to it. We have all seen these types of applications; however, if you have ever attempted to write such, it is usually a pain to developer the core application or a pain to develop the extensions or plug-ins. Thankfully the Managed Extensibility Framework (MEF) is available to those of us that have extensibility needs inside of the application.

Architect's perspective on Silverlight 3

Tue, 10 Nov 2009 00:00:00 GMT

Many .NET developers are becoming more and more interested in the Rich Internet Application development space, and in particular Silverlight. In this session we will step back from a detailed implementation technology and take a higher level look at Silverlight from the architect's perspective. We will discuss the types of applications where Silverlight makes sense and some scenarios where Silverlight may not be the appropriate technology. We will also delve into some of the architectural decisions that the architect must consider when writing applications for this platform and where some of the tradeoffs may lie.

Reviewing UppercuT - A Build Framework Based On NAnt

Fri, 30 Oct 2009 11:06:26 GMT

A review/opinion of UppercuT, a Build Framework based on NAnt developed by Rob Reynolds.

Is Learning Through a UI Worth It?

Mon, 26 Oct 2009 01:19:18 GMT

When learning some form or back-end component, is it worth while to spend time applying the product to a UI?

Simple 6 steps to use stored procedure in LINQ

Tue, 15 Sep 2009 08:45:00 GMT

This is an extremely small article which describes how to flourish LINQ objects using stored procedure. What provoked me to write this article is the 'ExecuteMethodCall' function which helps to execute stored procedures in LINQ. As this is a protected function it changes the way you architect the DAL using

Deep Fried Bytes Episode 36: What Happens In The Speaker's Lounge

Wed, 09 Sep 2009 15:28:34 GMT

In this episode Keith sits down with a bunch of speakers at the DevLink 2009 conference held in Nashville, TN. It isn't every day one gets to hear what other speakers talk about and that's why we titled the show the way we did. Listen in to learn how much time speakers devote to the community, why they do it, why some are getting tired and why the developer community can be so rude at times.

My Barriers to Learning TDD

Wed, 02 Sep 2009 11:45:42 GMT

As a follow up to my previous post declaring that I finally "get" TDD to some extent, I figured I'd reflect on the barriers that I have had up to this point which made it difficult for me to learn how to unit test in some effective manner as well as truly understanding the benefits of TDD practices. Now, I am by no means claiming to be an expert in unit testing, mocking, or TDD. I didn't open the refrigerator, drink some of the TDD-flavored Kool-Aid, and threw on a subsequent Mortarboard to illustrate that I've somehow graduated into this new, higher level of software development. I'm still learning from others as well as my own errors experiences just like everyone else. The purpose of this is to reveal to others some of the issues that I had and hopefully provide some insight on how to overcome such.

Finally Understanding the Merits of TDD

Thu, 27 Aug 2009 08:00:07 GMT

I'm not a TDD person...or at least I wasn't until last week. Up until then, I had read the blogs and looked at the examples to try to understand TDD and unit testing (with mocking) in general. Almost all of the examples I was shown demonstrated very basic scenarios that, in most cases, were too trivial to show value. I would ask people who would speak about unit testing in general how you'd do a specific scenario and would get mix responses ranging from "just try it" to "you should be using this tool and it'll just write the tests for you".

ParseWiki.js - A JavaScript Wiki Parsing Engine

Sun, 23 Aug 2009 22:37:17 GMT

An introduction to the start of a client-side wiki-parsing engine that uses regular expressiosn.

How to run JsTestDriver with Visual Studio

Mon, 10 Aug 2009 17:43:31 GMT

JsTestDriver is a tool which allows to run unit tests for JavaScript in command line. This article provides a way how to integrate JsTestDriver into Visual Studio.

Lessons From My First Attempt At Bringing Agile Into A Non-Agile shop.

Mon, 10 Aug 2009 12:58:42 GMT

Real world account of trying to bring Agile methodology into a traditional MS developer shop.

Writing a Custom NAnt Tas (Part 4)

Fri, 31 Jul 2009 13:53:27 GMT

In the final segment in my series about creating a custom NAnt task, we dive into how to create a custom task used to execute an external application.

Exploring NDjango: Setting up NDjango for usage

Thu, 30 Jul 2009 12:30:00 GMT

Taking a look at the NDjango view engine. We will cover installing NDjango, integrating it with an existing asp.mvc project, and some basic syntax features.

Writing a Custom NAnt Task (Part 3)

Wed, 29 Jul 2009 22:04:29 GMT

In this, the third of a four post series on create a custom NAnt task, we dive into how to create a custom collection of child elements in order to provide more flexibility to your task.

Mike Moore, Rob Conery and James Avery on Domain Driven Design

Thu, 30 Jul 2009 00:30:08 GMT

In this episode, Mike Moore talks with Rob Conery and James Avery about Domain Driven Design. This episode of the Alt.NET podcast is brought to you by The Lounge Advertising Network. Reach .NET developers on the sites and blogs that they trust and respect, by advertising with The Lounge Advertising Network.