At work, we use Castle Windsor for Dependency Injection. In Castle Windsor, as with any dependency injection framework, you can configure components identified by an interface, that can be resolved at runtime using the dependency injection framework. Components can have dependencies, which can be yet other components and so on. In this way, you can have your dependency injection framework create a whole graph of objects for you.
One limitation we run into now and then, is with components, that depend on a file path to work. Typically, we need to know the full path of the file to load it. But hardcoding the full path in the configuration file is generally a bad idea, it will create problems when you move your web application between environments. Also, we cannot just pass the path as a virtual path to the component and then have the component call Server.MapPath to map the path - since that would mean changing the interface of the component just to accomodate the injection framework, which is not a good idea. And, what is worse, you would create a dependency on System.Web in a place where it probably isn't needed.
Now, one way to get around this would be to create a wrapper interface, IFilePath, which only should exist in order to be passed into the component and being able to convert the path. This also involves changing the component and generally feels like a bad idea.
Luckily, the Windsor IoC container offers a large variety of extension points - one being facilities. So I wrote a facility, that allows paths configured in Castle Windsor to be relative. The way this works is by registering an ISubDependencyResolver in the IKernel instance. When resolving a dependency, Windsor will ask the ISubDependencyResolver whether it can resolve the dependency using the CanResolve method. By examining the passed ComponentModel and in particular it's configuration node, I look for a custom attribute on the dependency, pathType. If found (and the dependency is of type string), then we can easily resolve the dependency by taking the relative path in the configuration tag and making it absolute.
This will allow you to have your Windsor configuration look like this (notice the one-line facility registration - this is what registers the custom facility in Windsor, and makes us able to register the path dependency as a virtual path):
1: <castle>
2: <facilities>
3: <facility id="pathResolver" type="dr.Castle.WebPathFacility.RelativePathSupportFacility, dr.Castle.WebPathFacility" />
4: </facilities>
5: <components>
6: <component id="dummy"
7: service="dr.Castle.WebPathFacility.Test.IDummy, dr.Castle.WebPathFacility.Test"
8: type="dr.Castle.WebPathFacility.Test.Dummy, dr.Castle.WebPathFacility.Test" >
9: <parameters>
10: <path pathType="Relative">App_Data/test.xml</path>
11: </parameters>
12: </component>
13: </components>
14: </castle>
The valid values for pathType are:
1: private enum PathType
2: {
3: /// <summary>
4: /// The path is absolute (we will do nothing to it).
5: /// </summary>
6: Absolute = 0,
7: /// <summary>
8: /// The path is a virtual path to a web application resource.
9: /// </summary>
10: Virtual,
11: /// <summary>
12: /// The path is relative to the current directory.
13: /// </summary>
14: Relative
15: }
The code for the facility it self is really simple, since it simply registers our dependency resolver to the Kernel. The advantage of using a facility, is that it can be declared in the config, and Windsor will automatically initialize for all containers you create:
1:
using Castle.MicroKernel.Facilities;
2:
3:
namespace dr.Castle.WebPathFacility
4: {
5: public class RelativePathSupportFacility : AbstractFacility
6: {
7: protected override void Init()
8: {
9: Kernel.Resolver.AddSubResolver(new PathParameterDependencyResolver());
10: }
11: }
12: }
Finally, the implementation of ISubDependencyResolver, that makes this possible:
1:
using System;
2:
using System.Collections.Generic;
3:
using System.IO;
4:
using System.Linq;
5:
using System.Web;
6:
using Castle.Core;
7:
using Castle.MicroKernel;
8:
9:
namespace dr.Castle.WebPathFacility
10: {
11: /// <summary>
12: /// Custom dependency resolver, that will inspect the parameters collection for the pathType attribute, and, if found, convert the dependency to
13: /// a absolute path based on the path type.
14: /// </summary>
15: class PathParameterDependencyResolver : ISubDependencyResolver
16: {
17: /// <summary>
18: /// Holds the supported conversion operations.
19: /// </summary>
20: private static readonly Dictionary<PathType,Func<string, string>> conversions = new Dictionary<PathType, Func<string, string>>
21: {
22: {PathType.Absolute, path => path},
23: {PathType.Relative, path => Path.Combine(Environment.CurrentDirectory,path) },
24: {PathType.Virtual, path => HttpContext.Current.Server.MapPath(path)}
25: };
26:
27: /// <summary>
28: /// Cache of the type path parameters.
29: /// </summary>
30: private readonly Dictionary<string,PathParameter> typePathParameters = new Dictionary<string, PathParameter>();
31:
32: /// <summary>
33: /// Resolves the specified dependency.
34: /// </summary>
35: /// <param name="context">Creation context</param>
36: /// <param name="contextHandlerResolver">Parent resolver</param>
37: /// <param name="model">Model of the component that is requesting the dependency</param>
38: /// <param name="dependency">The dependcy to satisfy</param>
39: /// <returns><c>true</c> if the dependency can be satsfied by this resolver, else <c>false</c>.</returns>
40: /// <returns>The resolved dependency</returns>
41: public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
42: {
43: PathParameter parameter = GetPathParameter(model, dependency);
44: if (parameter == null)
45: throw new ApplicationException(String.Format("Cannot resolve dependency {0}", dependency));
46: if (!conversions.ContainsKey(parameter.Type))
47: return parameter.Value; // Unknown conversion
48:
49: return conversions[parameter.Type](parameter.Value);
50: }
51: /// <summary>
52: /// Determines whether this sub dependency resolver can resolve the specified dependency.
53: /// </summary>
54: /// <param name="context">Creation context</param>
55: /// <param name="contextHandlerResolver">Parent resolver</param>
56: /// <param name="model">Model of the component that is requesting the dependency</param>
57: /// <param name="dependency">The dependcy to satisfy</param>
58: /// <returns><c>true</c> if the dependency can be satsfied by this resolver, else <c>false</c>.</returns>
59: public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
60: {
61: if ( dependency.DependencyType == DependencyType.Parameter && dependency.TargetType.Equals(typeof(string)) )
62: {
63: PathParameter parameter = GetPathParameter(model, dependency);
64: return parameter != null;
65: }
66: return false;
67: }
68:
69: /// <summary>
70: /// Finds the parameter by looking at the cache, then in the model configuration.
71: /// </summary>
72: /// <param name="model"></param>
73: /// <param name="dependency"></param>
74: /// <returns></returns>
75: private PathParameter GetPathParameter(ComponentModel model, DependencyModel dependency)
76: {
77: if (!typePathParameters.ContainsKey(model.Name))
78: typePathParameters.Add(model.Name, GetPathParameterInternal(model, dependency));
79:
80: return typePathParameters[model.Name];
81: }
82:
83: /// <summary>
84: /// Finds the parameter by looking at the model configuration.
85: /// </summary>
86: /// <param name="model"></param>
87: /// <param name="dependency"></param>
88: /// <returns></returns>
89: private PathParameter GetPathParameterInternal(ComponentModel model, DependencyModel dependency)
90: {
91: var parametersContainer = model.Configuration.Children.SingleOrDefault(n => n.Name == "parameters");
92: if ( parametersContainer != null )
93: {
94: var parameterNode = parametersContainer.Children.SingleOrDefault(n => n.Name == dependency.DependencyKey);
95: string pathType = parameterNode.Attributes["pathType"];
96: if (pathType != null)
97: {
98: PathType type;
99: if (!Enum.TryParse(pathType, true, out type))
100: throw new ApplicationException(
101: String.Format("Configuration error: Invalid pathType value '{0}'", pathType));
102:
103: return new PathParameter {Type = type, Value = parameterNode.Value};
104: }
105: }
106: return null;
107: }
108:
109: /// <summary>
110: /// Holds a path parameter
111: /// </summary>
112: private class PathParameter
113: {
114: /// <summary>
115: /// Value as entered in config
116: /// </summary>
117: public string Value { get; set; }
118: /// <summary>
119: /// Type of path.
120: /// </summary>
121: public PathType Type { get; set;}
122: }
123:
124: /// <summary>
125: /// Defines the types of paths supported by <see cref="PathParameterDependencyResolver" />
126: /// </summary>
127: private enum PathType
128: {
129: /// <summary>
130: /// The path is absolute (we will do nothing to it).
131: /// </summary>
132: Absolute = 0,
133: /// <summary>
134: /// The path is a virtual path to a web application resource.
135: /// </summary>
136: Virtual,
137: /// <summary>
138: /// The path is relative to the current directory.
139: /// </summary>
140: Relative
141: }
142: }
143: }
Now, I am finally able to use virtual paths in my configuration files, with a minimum of noise. Great. Please notice, that the "Relative" path type might not make sense for a real application (since it uses Environment.CurrentDirectory as base), but it can be really helpful in test configurations. The primary reason for creating this is pathType="virtual", which maps to Server.MapPath.
RSS 2.0