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);
}
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);
}
}
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 });
}
}
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"));
}
public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
}
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);
}
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);
}
public override Object GetValue(object obj)
{
// We don't need to get into instance probing
throw new NotImplementedException(TypeSystemSR.GetString("Error_RuntimeNotSupported"));
}