public NamedType TypeOf(TypeName name)
        {
            if (!types.ContainsKey(name))
            {
                if (name.Name == typeof(IEnumerable<>).QualifiedName())
                {
                    var itemType = TypeOf(name.GenericArguments.Single());
                    if (itemType == null)
                        return null;
                    types.Add(name, NamedType.Enumerable(itemType));
                }
                else if (name.Name == typeof(Vector<>).QualifiedName())
                {
                    var itemType = TypeOf(name.GenericArguments.Single());
                    if (itemType == null)
                        return null;
                    types.Add(name, NamedType.Vector(itemType));
                }
                else if (name.Name == typeof(Nullable<>).QualifiedName())
                {
                    var itemType = TypeOf(name.GenericArguments.Single());
                    if (itemType == null)
                        return null;
                    types.Add(name, NamedType.Nullable(itemType));
                }
                else
                {
                    return null;
                }
            }

            return types[name];
        }

        public void ProgressGatherStat(TypeName typeName)
        {
            if(_gatherSkillCollection[typeName] > 300)
                return;

            _gatherSkillCollection[typeName]++;
        }

        public void Add(Class @class)
        {
            var typeName = new TypeName(@class.Name.Identifier);

            types[typeName] = new NamedType(@class);
            classes[typeName] = @class;
        }

        /// <summary>
        /// instantiate a new Jewel
        /// </summary>
        /// <param name="contentManager">game content manager object</param>
        /// <param name="spriteName">file name of sprite</param>
        /// <param name="position">vector position of Jewel</param>
        public Jewel(
            ContentManager contentManager,
            TypeName type,
            Vector2 position
            )
        {
            _contentManager = contentManager;
            _type = type;
            _position = position;

            // load the jewel image
            if (type == TypeName.Green)
            {
                _sprite = _contentManager.Load<Texture2D>("green_jewel");
            }

            _active = true;

            _spriteWidth = _sprite.Width;
            _spriteHeight = _sprite.Height;

            // set the initial center and bounding rectangle for the player
            _center = new Vector2(position.X + (_spriteWidth / 2), position.Y + (_spriteHeight / 2));
            _boundingRectangle = new Rectangle((int)position.X, (int)position.Y, _spriteWidth, _spriteHeight);
        }

        public IList<IComponentDescriptor> FindByServiceTypeName(TypeName serviceTypeName)
        {
            if (serviceTypeName == null)
                throw new ArgumentNullException("serviceTypeName");

            return FindByServiceTypeNameImpl(serviceTypeName);
        }

 public Coin(TypeName name, string description, int value, int countInGameInventory )
 {
     _name = name;
     _description = description;
     _valueInDollars = value;
     _countInGameInventory = countInGameInventory;
 }

 public TypeDef ResolveType(TypeName name)
 {
     var typeDef = default(TypeDef);
     if (!nameToTypeDefCache.TryGetValue(name, out typeDef))
         return null;
     return typeDef;
 }

        public IServiceDescriptor GetByServiceTypeName(TypeName serviceTypeName)
        {
            if (serviceTypeName == null)
                throw new ArgumentNullException("serviceTypeName");

            return GetByServiceTypeNameImpl(serviceTypeName);
        }

 /// <summary>
 /// Creates a component registration.
 /// </summary>
 /// <param name="plugin">The plugin to which the component will belong.</param>
 /// <param name="service">The service implemented by the component.</param>
 /// <param name="componentId">The component id.</param>
 /// <param name="componentTypeName">The component type name, or null to use the default component type specified by the service.</param>
 /// <exception cref="ArgumentNullException">Thrown if <paramref name="plugin"/>, <paramref name="service"/>,
 /// <paramref name="componentId"/> is null.</exception>
 public ComponentRegistration(IPluginDescriptor plugin, IServiceDescriptor service, string componentId, TypeName componentTypeName)
 {
     Plugin = plugin;
     Service = service;
     ComponentId = componentId;
     ComponentTypeName = componentTypeName;
 }

        public IList<IComponentDescriptor> FindComponentsByServiceTypeName(TypeName serviceTypeName)
        {
            ServiceDescriptor service = GetServiceByServiceTypeName(serviceTypeName);
            if (service == null)
                return EmptyArray<IComponentDescriptor>.Instance;

            return FindComponentsByServiceId(service.ServiceId);
        }

 public ServiceDescriptor(Registry registry, ServiceRegistration serviceRegistration)
 {
     this.registry = registry;
     pluginDescriptor = (PluginDescriptor) serviceRegistration.Plugin;
     serviceId = serviceRegistration.ServiceId;
     serviceTypeName = serviceRegistration.ServiceTypeName;
     defaultComponentTypeName = serviceRegistration.DefaultComponentTypeName;
     traitsHandlerFactory = serviceRegistration.TraitsHandlerFactory;
 }

        private void RegisterComponentForServices(Type type, IPluginDescriptor plugin)
        {
            var componentId = type.FullName;

            var interfaceTypes = GetDirectInterfaces(type);
            var typeName = new TypeName(type).ConvertToPartialAssemblyName();

            RegisterFirstInterface(interfaceTypes, plugin, componentId, typeName);
            RegisterEventHandlers(interfaceTypes, plugin, componentId, typeName);
        }

        public void HasValueEqualitySemantics()
        {
            var type = new TypeName("B", new TypeName("A"));
            type.ShouldEqual(type);
            type.ShouldEqual(new TypeName("B", new TypeName("A")));
            type.ShouldNotEqual(new TypeName("B"));

            type.GetHashCode().ShouldEqual(new TypeName("B", new TypeName("A")).GetHashCode());
            type.GetHashCode().ShouldNotEqual(new TypeName("B").GetHashCode());
        }

 public ComponentDescriptor(Registry registry, ComponentRegistration componentRegistration)
 {
     this.registry = registry;
     pluginDescriptor = (PluginDescriptor) componentRegistration.Plugin;
     serviceDescriptor = (ServiceDescriptor) componentRegistration.Service;
     componentId = componentRegistration.ComponentId;
     componentTypeName = componentRegistration.ComponentTypeName ?? serviceDescriptor.DefaultComponentTypeName;
     componentProperties = componentRegistration.ComponentProperties.Copy().AsReadOnly();
     traitsProperties = componentRegistration.TraitsProperties.Copy().AsReadOnly();
     componentHandlerFactory = componentRegistration.ComponentHandlerFactory;
 }

        public Binding[] MembersOf(NamedType type)
        {
            var typeName = new TypeName(type.Name);

            if (!classes.ContainsKey(typeName))
                return new Binding[] { };

            var @class = classes[typeName];

            var result = @class.Methods.Select(m => (Binding)new MethodBinding(m.Name.Identifier, DeclaredType(m))).ToArray();
            //TODO: Cache these results instead of recalculating each time.
            return result;
        }

 public PluginDescriptor(Registry registry, PluginRegistration pluginRegistration, IList<IPluginDescriptor> completePluginDependenciesCopy)
 {
     this.registry = registry;
     pluginId = pluginRegistration.PluginId;
     pluginTypeName = pluginRegistration.PluginTypeName;
     baseDirectory = pluginRegistration.BaseDirectory;
     pluginProperties = pluginRegistration.PluginProperties.Copy().AsReadOnly();
     traitsProperties = pluginRegistration.TraitsProperties.Copy().AsReadOnly();
     pluginHandlerFactory = pluginRegistration.PluginHandlerFactory;
     assemblyBindings = new ReadOnlyCollection<AssemblyBinding>(GenericCollectionUtils.ToArray(pluginRegistration.AssemblyBindings));
     pluginDependencies = new ReadOnlyCollection<IPluginDescriptor>(completePluginDependenciesCopy);
     probingPaths = new ReadOnlyCollection<string>(GenericCollectionUtils.ToArray(pluginRegistration.ProbingPaths));
     enableCondition = pluginRegistration.EnableCondition;
     recommendedInstallationPath = pluginRegistration.RecommendedInstallationPath;
     filePaths = new ReadOnlyCollection<string>(GenericCollectionUtils.ToArray(pluginRegistration.FilePaths));
 }

        public void Scan()
        {
            var plugin = registry.Plugins[PluginId];

            var assembly = Assembly.GetExecutingAssembly();

            foreach (var type in assembly.GetTypes())
            {
                if (type.IsInterface || type.IsAbstract)
                    continue;

                var typeName = new TypeName(type).ConvertToPartialAssemblyName();

                RegisterComponentForServices(assembly, type, typeName, plugin);
            }
        }

		private TypeName BuildName(string name, TypeName[] genericTypes)
		{
			var typeStartsHere = name.LastIndexOf('.');
			string typeName;
			string @namespace = null;

			if (typeStartsHere > -1 && typeStartsHere < (name.Length - 1))
			{
				typeName = name.Substring(typeStartsHere + 1);
				@namespace = name.Substring(0, typeStartsHere);
			}
			else
			{
				typeName = name;
			}
			return new TypeName(@namespace, typeName, genericTypes);
		}

        private void RegisterFirstInterface(IEnumerable<Type> interfaceTypes, IPluginDescriptor plugin, 
            string componentId, TypeName typeName)
        {
            foreach (var interfaceType in interfaceTypes)
            {
                if (IsOpenGenericType(interfaceType))
                    return;

                if (ComponentIsAlreadyRegisteredForService(interfaceType, typeName))
                    return;

                var serviceDescriptor = GetServiceDescriptor(interfaceType, plugin);
                RegisterComponent(componentId, typeName, plugin, serviceDescriptor);
                
                return;
            }
        }

        public void TypeNameClone()
        {
            TypeName tn = new TypeName()
            {
                Namespace = "SurveyEngine.DataTypeConverters",
                Name = "CalendarQuestionConstraintType",
                Assembly = "SurveyEngine.DataTypeConverters",
                Version = new Version("2.3.5.2"),
                Culture = "neutral",
                PublicKeyToken = "79cd5921ea88a364"
            };

            TypeName clone = tn.Clone();
            Assert.IsFalse(object.ReferenceEquals(tn, clone));
            Assert.AreEqual(tn.Assembly, clone.Assembly);
            Assert.AreEqual(tn.Culture, clone.Culture);
            Assert.AreEqual(tn.Name, clone.Name);
            Assert.AreEqual(tn.Namespace, clone.Namespace);
            Assert.AreEqual(tn.PublicKeyToken, clone.PublicKeyToken);
            Assert.AreEqual(tn.Version, clone.Version);
        }