public TypeConverterManager(Type targetType, string converterTypeName, UnityTypeResolver typeResolver)
 {
     this.targetType = targetType;
     if (!string.IsNullOrEmpty(converterTypeName))
     {
         Type converterType = typeResolver.ResolveType(converterTypeName);
         descriptionProvider = TypeDescriptor.AddAttributes(targetType,
                                                            new Attribute[] { new TypeConverterAttribute(converterType) });
     }
 }
Esempio n. 2
0
 private static TypeConverter GetTypeConverter(
     Type typeToCreate,
     string typeConverterName,
     UnityTypeResolver typeResolver)
 {
     if (!string.IsNullOrEmpty(typeConverterName))
     {
         // return the type converter override
         Type converterType = typeResolver.ResolveType(typeConverterName);
         return((TypeConverter)Activator.CreateInstance(converterType));
     }
     else
     {
         // return the default type converter
         return(TypeDescriptor.GetConverter(typeToCreate));
     }
 }
        public static InjectionParameterValue CreateParameterValue(
            string typeName,
            string genericParameterName,
            InjectionParameterValueElement valueElement,
            UnityTypeResolver typeResolver)
        {
            string genericParameter;
            bool   isGenericParameterArray;

            ExtractGenericParameter(genericParameterName, out genericParameter, out isGenericParameterArray);

            if (!string.IsNullOrEmpty(genericParameter))
            {
                if (!isGenericParameterArray)
                {
                    if (valueElement == null)
                    {
                        return(new GenericParameter(genericParameter));
                    }
                    else
                    {
                        DependencyValueElement dependencyElement = valueElement as DependencyValueElement;
                        if (dependencyElement != null)
                        {
                            if (!string.IsNullOrEmpty(dependencyElement.Name))
                            {
                                return(new GenericParameter(genericParameter, dependencyElement.Name));
                            }
                            else
                            {
                                return(new GenericParameter(genericParameter));
                            }
                        }
                        else
                        {
                            // should not happen - checked during config deserialization
                            throw new InvalidOperationException(Resources.InvalidConfiguration);
                        }
                    }
                }
                else
                {
                    if (valueElement == null)
                    {
                        return(new GenericResolvedArrayParameter(genericParameter));
                    }
                    else
                    {
                        ArrayValueElement arrayElement = valueElement as ArrayValueElement;
                        if (arrayElement != null)
                        {
                            return(arrayElement.CreateParameterValue(genericParameter));
                        }
                        else
                        {
                            // should not happen - checked during config deserialization
                            throw new InvalidOperationException(Resources.InvalidConfiguration);
                        }
                    }
                }
            }
            else
            {
                if (valueElement == null)
                {
                    valueElement = new DependencyValueElement();
                }
                valueElement.TypeResolver = typeResolver;
                return(valueElement.CreateParameterValue(typeResolver.ResolveType(typeName)));
            }
        }