Esempio n. 1
0
        public void AddCodeCompileUnit(CodeCompileUnit codeCompileUnit)
        {
            if (codeCompileUnit == null)
            {
                throw new ArgumentNullException("codeCompileUnit");
            }

            if (this.compileUnitLoaders.ContainsKey(codeCompileUnit) || (this.addedCompileUnits != null && this.addedCompileUnits.Contains(codeCompileUnit)))
            {
                throw new ArgumentException(TypeSystemSR.GetString("Error_DuplicateCodeCompileUnit"), "codeCompileUnit");
            }

            // lets put these changes into our cache
            if (this.addedCompileUnits == null)
            {
                this.addedCompileUnits = new List <CodeCompileUnit>();
            }
            this.addedCompileUnits.Add(codeCompileUnit);
            if (this.needRefreshCompileUnits != null && this.needRefreshCompileUnits.ContainsKey(codeCompileUnit))
            {
                this.needRefreshCompileUnits.Remove(codeCompileUnit);
            }

            if (this.TypesChanged != null)
            {
                FireEventsNoThrow(this.TypesChanged, new object[] { this, EventArgs.Empty });
            }
        }
 private static TypeSystemSR GetLoader()
 {
     if (loader == null)
     {
         loader = new TypeSystemSR();
     }
     return(loader);
 }
 private static TypeSystemSR GetLoader()
 {
     if (loader == null)
     {
         loader = new TypeSystemSR();
     }
     return loader;
 }
        internal static string GetString(CultureInfo culture, string name)
        {
            TypeSystemSR loader = GetLoader();

            if (loader == null)
            {
                return(null);
            }
            return(loader.resources.GetString(name, culture));
        }
        internal static string GetString(CultureInfo culture, string name, params object[] args)
        {
            TypeSystemSR loader = GetLoader();

            if (loader == null)
            {
                return(null);
            }
            string format = loader.resources.GetString(name, culture);

            if ((args != null) && (args.Length > 0))
            {
                return(string.Format(CultureInfo.CurrentCulture, format, args));
            }
            return(format);
        }
Esempio n. 6
0
        internal static string GetString(CultureInfo culture, string name, params object[] args)
        {
            TypeSystemSR sys = GetLoader();

            if (sys == null)
            {
                return(null);
            }

            string res = sys.resources.GetString(name, culture);

            if (args != null && args.Length > 0)
            {
                return(String.Format(CultureInfo.CurrentCulture, res, args));
            }
            else
            {
                return(res);
            }
        }
Esempio n. 7
0
 public void RefreshCodeCompileUnit(CodeCompileUnit codeCompileUnit, EventHandler refresher)
 {
     if (codeCompileUnit == null)
     {
         throw new ArgumentNullException("codeCompileUnit");
     }
     if ((!this.compileUnitLoaders.Contains(codeCompileUnit) && (this.addedCompileUnits != null)) && !this.addedCompileUnits.Contains(codeCompileUnit))
     {
         throw new ArgumentException(TypeSystemSR.GetString("Error_NoCodeCompileUnit"), "codeCompileUnit");
     }
     if (this.needRefreshCompileUnits == null)
     {
         this.needRefreshCompileUnits = new Dictionary <CodeCompileUnit, EventHandler>();
     }
     this.needRefreshCompileUnits[codeCompileUnit] = refresher;
     if (this.TypesChanged != null)
     {
         FireEventsNoThrow(this.TypesChanged, new object[] { this, EventArgs.Empty });
     }
 }
Esempio n. 8
0
        public static string[] GetEnumNames(Type enumType)
        {
            if (enumType == null)
            {
                throw new ArgumentNullException("enumType");
            }
            if (!IsSubclassOf(enumType, typeof(Enum)))
            {
                throw new ArgumentException(TypeSystemSR.GetString("Error_TypeIsNotEnum"));
            }
            FieldInfo[]   fields = enumType.GetFields();
            List <string> list   = new List <string>();

            for (int i = 0; i < fields.Length; i++)
            {
                list.Add(fields[i].Name);
            }
            list.Sort();
            return(list.ToArray());
        }
 public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
 {
     throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
 }
 public override object GetValue(object obj)
 {
     throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
 }
Esempio n. 11
0
 public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
 {
     throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
 }
Esempio n. 12
0
        public Type GetType(string name, bool throwOnError)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            EnsureCurrentTypes();

            bool   hasTypeLoadErrors = false;
            Type   returnType        = null;
            string typeName          = string.Empty;

            string[] parameters       = null;
            string   elementDecorator = string.Empty;

            if (ParseHelpers.ParseTypeName(name, ParseHelpers.ParseTypeNameLanguage.NetFramework, out typeName, out parameters, out elementDecorator))
            {
                if ((parameters != null) && (parameters.Length > 0))
                {
                    //Generic type
                    Type templateType = GetType(typeName, throwOnError);
                    if ((templateType == null) || (!templateType.IsGenericTypeDefinition))
                    {
                        return(null);
                    }
                    Type[] templateParamTypes = new Type[parameters.Length];
                    for (int index = 0; index < parameters.Length; index++)
                    {
                        Type templateParameter = GetType(parameters[index], throwOnError);
                        if (templateParameter == null)
                        {
                            return(null);
                        }
                        templateParamTypes[index] = templateParameter;
                    }
                    return(templateType.MakeGenericType(templateParamTypes));
                }
                else if (elementDecorator != string.Empty)
                {
                    //type with element (Array, ByRef, Pointer)
                    Type elementType = this.GetType(typeName);
                    if (elementType != null)
                    {
                        // first we verify the name is formated well (AssemblyQualifiedName for generic
                        // parameters + no spaces in array brackets)
                        System.Text.StringBuilder nameBuilder = new System.Text.StringBuilder(elementType.FullName);
                        for (int loop = 0; loop < elementDecorator.Length; loop++)
                        {
                            if (elementDecorator[loop] != ' ')
                            {
                                nameBuilder.Append(elementDecorator[loop]);
                            }
                        }

                        name = nameBuilder.ToString();

                        // let tha assembly of the element type a chance to find a type (will fail only
                        // if element contains parameter from external assembly
                        if (elementType.Assembly != null)
                        {
                            returnType = elementType.Assembly.GetType(name, false);
                        }

                        if (returnType == null)
                        {
                            // now we can fetch or create the type
                            if (this.hashOfDTTypes.Contains(name))
                            {
                                returnType = this.hashOfDTTypes[name] as Type;
                            }
                            else
                            {
                                returnType = new DesignTimeType(null, name, this);
                                this.hashOfDTTypes.Add(name, returnType);
                            }
                            return(returnType);
                        }
                    }
                }
                else
                {
                    // regular type, get the type name
                    string assemblyName = string.Empty;
                    int    indexOfComma = name.IndexOf(',');
                    if (indexOfComma != -1)
                    {
                        typeName     = name.Substring(0, indexOfComma);
                        assemblyName = name.Substring(indexOfComma + 1).Trim();
                    }
                    typeName = typeName.Trim();
                    if (typeName.Length > 0)
                    {
                        returnType = this.designTimeTypes[typeName] as Type;
                        if (returnType == null)
                        {
                            foreach (DictionaryEntry dictionaryEntry in this.rawAssemblyLoaders)
                            {
                                AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader;
                                if ((assemblyName.Length == 0) || (ParseHelpers.AssemblyNameEquals(assemblyLoader.AssemblyName, assemblyName)))
                                {
                                    try
                                    {
                                        returnType = assemblyLoader.GetType(typeName);
                                    }
                                    catch (Exception e)
                                    {
                                        if (!this.typeLoadErrors.Contains(dictionaryEntry.Key))
                                        {
                                            this.typeLoadErrors[dictionaryEntry.Key] = e;
                                            hasTypeLoadErrors = true;
                                        }
                                        // bubble up exceptions only when appropiate
                                        if (throwOnError)
                                        {
                                            throw e;
                                        }
                                    }
                                    if (returnType != null)
                                    {
                                        break;
                                    }
                                }
                            }
                        }

                        if (returnType == null)
                        {
                            foreach (DictionaryEntry dictionaryEntry in this.assemblyLoaders)
                            {
                                AssemblyLoader assemblyLoader = dictionaryEntry.Value as AssemblyLoader;
                                if ((assemblyName.Length == 0) || (ParseHelpers.AssemblyNameEquals(assemblyLoader.AssemblyName, assemblyName)))
                                {
                                    try
                                    {
                                        returnType = assemblyLoader.GetType(typeName);
                                    }
                                    catch (Exception e)
                                    {
                                        if (!this.typeLoadErrors.Contains(dictionaryEntry.Key))
                                        {
                                            this.typeLoadErrors[dictionaryEntry.Key] = e;
                                            hasTypeLoadErrors = true;
                                        }
                                        // bubble up exceptions only when appropiate
                                        if (throwOnError)
                                        {
                                            throw e;
                                        }
                                    }
                                    if (returnType != null)
                                    {
                                        break;
                                    }
                                }
                            }
                        }

                        if (hasTypeLoadErrors)
                        {
                            if (this.TypeLoadErrorsChanged != null)
                            {
                                FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
                            }
                        }

                        if (returnType == null && this.localAssembly != null && assemblyName == this.localAssembly.FullName)
                        {
                            returnType = this.localAssembly.GetType(typeName);
                        }
                    }
                }
            }

            if (returnType == null)
            {
                if (throwOnError)
                {
                    throw new Exception(TypeSystemSR.GetString(CultureInfo.CurrentCulture, "Error_TypeResolution", name));
                }
                else
                {
                    return(null);
                }
            }

            // replace the System.Type with RTTypeWrapper for generic types.
            // WinOE



            if (this.designTimeTypes != null && this.designTimeTypes.Count > 0 && returnType.Assembly != null && returnType.IsGenericTypeDefinition)
            {
                if (this.hashOfRTTypes.Contains(returnType))
                {
                    returnType = (Type)this.hashOfRTTypes[returnType];
                }
                else
                {
                    Type returnType2 = new RTTypeWrapper(this, returnType);
                    this.hashOfRTTypes.Add(returnType, returnType2);
                    returnType = returnType2;
                }
            }
            return(returnType);
        }
Esempio n. 13
0
        public Type GetType(string name, bool throwOnError)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            this.EnsureCurrentTypes();
            bool   flag     = false;
            Type   type     = null;
            string typeName = string.Empty;

            string[] parameters       = null;
            string   elemantDecorator = string.Empty;

            if (ParseHelpers.ParseTypeName(name, ParseHelpers.ParseTypeNameLanguage.NetFramework, out typeName, out parameters, out elemantDecorator))
            {
                if ((parameters != null) && (parameters.Length > 0))
                {
                    Type type2 = this.GetType(typeName, throwOnError);
                    if ((type2 == null) || !type2.IsGenericTypeDefinition)
                    {
                        return(null);
                    }
                    Type[] typeArguments = new Type[parameters.Length];
                    for (int i = 0; i < parameters.Length; i++)
                    {
                        Type type3 = this.GetType(parameters[i], throwOnError);
                        if (type3 == null)
                        {
                            return(null);
                        }
                        typeArguments[i] = type3;
                    }
                    return(type2.MakeGenericType(typeArguments));
                }
                if (elemantDecorator != string.Empty)
                {
                    Type type4 = this.GetType(typeName);
                    if (type4 != null)
                    {
                        StringBuilder builder = new StringBuilder(type4.FullName);
                        for (int j = 0; j < elemantDecorator.Length; j++)
                        {
                            if (elemantDecorator[j] != ' ')
                            {
                                builder.Append(elemantDecorator[j]);
                            }
                        }
                        name = builder.ToString();
                        if (type4.Assembly != null)
                        {
                            type = type4.Assembly.GetType(name, false);
                        }
                        if (type == null)
                        {
                            if (this.hashOfDTTypes.Contains(name))
                            {
                                return(this.hashOfDTTypes[name] as Type);
                            }
                            type = new DesignTimeType(null, name, this);
                            this.hashOfDTTypes.Add(name, type);
                            return(type);
                        }
                    }
                }
                else
                {
                    string thatName = string.Empty;
                    int    index    = name.IndexOf(',');
                    if (index != -1)
                    {
                        typeName = name.Substring(0, index);
                        thatName = name.Substring(index + 1).Trim();
                    }
                    typeName = typeName.Trim();
                    if (typeName.Length > 0)
                    {
                        type = this.designTimeTypes[typeName] as Type;
                        if (type == null)
                        {
                            foreach (DictionaryEntry entry in this.rawAssemblyLoaders)
                            {
                                AssemblyLoader loader = entry.Value as AssemblyLoader;
                                if ((thatName.Length == 0) || ParseHelpers.AssemblyNameEquals(loader.AssemblyName, thatName))
                                {
                                    try
                                    {
                                        type = loader.GetType(typeName);
                                    }
                                    catch (Exception exception)
                                    {
                                        if (!this.typeLoadErrors.Contains(entry.Key))
                                        {
                                            this.typeLoadErrors[entry.Key] = exception;
                                            flag = true;
                                        }
                                        if (throwOnError)
                                        {
                                            throw exception;
                                        }
                                    }
                                    if (type != null)
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                        if (type == null)
                        {
                            foreach (DictionaryEntry entry2 in this.assemblyLoaders)
                            {
                                AssemblyLoader loader2 = entry2.Value as AssemblyLoader;
                                if ((thatName.Length == 0) || ParseHelpers.AssemblyNameEquals(loader2.AssemblyName, thatName))
                                {
                                    try
                                    {
                                        type = loader2.GetType(typeName);
                                    }
                                    catch (Exception exception2)
                                    {
                                        if (!this.typeLoadErrors.Contains(entry2.Key))
                                        {
                                            this.typeLoadErrors[entry2.Key] = exception2;
                                            flag = true;
                                        }
                                        if (throwOnError)
                                        {
                                            throw exception2;
                                        }
                                    }
                                    if (type != null)
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                        if (flag && (this.TypeLoadErrorsChanged != null))
                        {
                            FireEventsNoThrow(this.TypeLoadErrorsChanged, new object[] { this, EventArgs.Empty });
                        }
                        if (((type == null) && (this.localAssembly != null)) && (thatName == this.localAssembly.FullName))
                        {
                            type = this.localAssembly.GetType(typeName);
                        }
                    }
                }
            }
            if (type == null)
            {
                if (throwOnError)
                {
                    throw new Exception(TypeSystemSR.GetString(CultureInfo.CurrentCulture, "Error_TypeResolution", new object[] { name }));
                }
                return(null);
            }
            if (((this.designTimeTypes == null) || (this.designTimeTypes.Count <= 0)) || ((type.Assembly == null) || !type.IsGenericTypeDefinition))
            {
                return(type);
            }
            if (this.hashOfRTTypes.Contains(type))
            {
                return((Type)this.hashOfRTTypes[type]);
            }
            Type type5 = new RTTypeWrapper(this, type);

            this.hashOfRTTypes.Add(type, type5);
            return(type5);
        }
Esempio n. 14
0
 public override Object GetValue(object obj)
 {
     // We don't need to get into instance probing
     throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
 }