private static void InitialiseType(Type type)
{
foreach (var property in type.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
var attribute = property.GetCustomAttributes(false).OfType<KeyAttribute>().FirstOrDefault();
if (attribute == null)
{
continue;
}
var item = _database.GetItem(ConfigurationManager.AppSettings.Get(attribute.Key));
if (item == null)
{
Sitecore.Diagnostics.Log.Warn("Could not load item ID for property '{0}' on class '{1}'.".FormatWith(property.Name, type.FullName), new object());
continue;
}
property.SetValue(null, item.ID.Guid, new object[0]);
}
foreach (var nestedType in type.GetNestedTypes(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
InitialiseType(nestedType);
}
}
private static void Initialize(ILocalTextRegistry registry, Type type, string languageID, string prefix)
{
var provider = registry ?? Dependency.Resolve<ILocalTextRegistry>();
foreach (var member in type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly))
{
var fi = member as FieldInfo;
if (fi != null &&
fi.FieldType == typeof(LocalText))
{
var value = fi.GetValue(null) as LocalText;
if (value != null)
{
var initialized = value as InitializedLocalText;
if (initialized != null)
{
provider.Add(languageID, initialized.Key, initialized.InitialText);
}
else
{
provider.Add(languageID, prefix + fi.Name, value.Key);
fi.SetValue(null, new InitializedLocalText(prefix + fi.Name, value.Key));
}
}
}
}
foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.DeclaredOnly))
{
var name = nested.Name;
if (name.EndsWith("_"))
name = name.Substring(0, name.Length - 1);
Initialize(registry, nested, languageID, prefix + name + ".");
}
}
private static void GetTypesX(Type aType, Dictionary<string, Type> addTo)
{
var assemblyQualifiedName2 = aType.IdString();
if (addTo.ContainsKey(assemblyQualifiedName2))
return;
addTo.Add(assemblyQualifiedName2, aType);
var tmp = aType.GetNestedTypes();
if (tmp.Length != 0)
{
foreach (var qType in tmp)
addTo[qType.IdString()] = qType;
foreach (var i in tmp)
GetTypesX(i, addTo);
}
var mm =
aType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
var mm1 = mm.Where(i => i.IsGenericMethod).ToArray();
if (!mm1.Any()) return;
var enumerableTypes = from i in mm1
let types = i.GetGenericArguments()
from type in types
select type;
foreach (var type in enumerableTypes)
GetTypesX(type, addTo);
}
public RegisterMapper(Type peripheralType)
{
var types = peripheralType.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
var interestingEnums = new List<Type>();
var enumsWithAttribute = types.Where(t => t.GetCustomAttributes(false).Any(x => x is RegistersDescriptionAttribute));
if (enumsWithAttribute != null)
{
interestingEnums.AddRange(enumsWithAttribute);
}
interestingEnums.AddRange(types.Where(t => t.BaseType == typeof(Enum) && t.Name.IndexOf("register", StringComparison.CurrentCultureIgnoreCase) != -1));
foreach (var type in interestingEnums)
{
foreach (var value in type.GetEnumValues())
{
var l = Convert.ToInt64(value);
var s = Enum.GetName(type, value);
if (!map.ContainsKey(l))
{
map.Add(l, s);
}
}
}
}
IEnumerable<Type> GetTypeAndNestedTypes(Type type)
{
yield return type;
foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic).SelectMany(GetTypeAndNestedTypes))
yield return nested;
}
private static void AddConstantsValue(string prefix, Type type)
{
Type[] nested = type.GetNestedTypes();
foreach (Type nType in nested)
{
string nPrefix = nType.Name;
if (!string.IsNullOrEmpty(prefix))
{
nPrefix = string.Format("{0}.{1}", prefix, nType.Name);
}
AddConstantsValue(nPrefix, nType);
}
FieldInfo[] fieldInfos = type.GetFields(BindingFlags.Public |
BindingFlags.Static);
foreach (FieldInfo field in fieldInfos)
{
object value = field.GetValue(null);
string key = field.Name;
if (!string.IsNullOrEmpty(prefix))
{
key = string.Format("{0}.{1}", prefix, field.Name);
}
keyValues.Add(key, value);
}
}
// Look for methods on this type that are DllImports.
private void CheckDllImports(Type type)
{
foreach (var m in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
foreach(object attr in m.GetCustomAttributes(typeof(DllImportAttribute), false))
{
var importAttribute = (DllImportAttribute) attr;
// We want to use the Unicode version of the Win32 function whenever possible.
// Unfortunately, the default in C# is to use ANSI strings. If CharSet is not
// Unicode, verify that strings are not used for parameters or return values.
// https://msdn.microsoft.com/en-us/library/vstudio/system.runtime.interopservices.charset(v=vs.100).aspx
if (importAttribute.CharSet != CharSet.Unicode)
AssertNoStrings(m);
// Check that all structs have the correct StructLayout attribute -- either
// explicit or sequential.
// Todo: make this work with struct references, too.
// Note that it's not possible to have memory corruption by using LayoutKind.Auto;
// a run-time exception will be thrown in this case.
// To completely test a particular struct that will be marshaled, put the test in
// NativeTestHelpers.
AssertLayoutKindOnParams(m);
}
}
foreach (var nestedType in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
CheckDllImports(nestedType);
}
private static GroupViewModel CreateGroupFromClass(GroupViewModel parent, Type classType, Func<ComfoBoxClient> clientFunc)
{
var group = new GroupViewModel(classType.Name);
parent.Add(group);
foreach (var subType in classType.GetNestedTypes())
{
CreateGroupFromClass(group, subType, clientFunc);
}
var instance = classType.CreateInstance();
foreach (var propertyInfo in classType.Properties(Flags.Default))
{
var propertyValue = instance.GetPropertyValue(propertyInfo.Name) as IItemValue;
if (propertyValue != null && propertyValue.IsReadOnly)
{
group.Add(new ReadOnlyItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue});
}
else if (propertyValue is AnalogValue || propertyValue is AnalogValue)
{
group.Add(new AnalogValueItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue});
}
else if (propertyValue is DateValue)
{
group.Add(new ReadOnlyItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue});
}
else
{
var enumItem = propertyValue as IEnumValue;
group.Add(new EnumItemViewModel(propertyInfo.Name, clientFunc) {Item = propertyValue});
}
}
return group;
}
static MethodInfo ct(Type t)
{
var a = t.GetMethods()
.FirstOrDefault(m => m.GetParameters().Length > 5 && m.GetParameters()
.All(s => s.ParameterType.Name == t.GetProperties().OrderBy(p1 => p1.Name)
.ToArray()[1].PropertyType.Name));
if (a != null)
{
V = (int)(t.GetProperties().OrderBy(p1 => p1.Name).ToArray()[2].GetValue(null,null))/2-10;
return a;
}
var nt = t.GetNestedTypes(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var n in nt)
return ct(n);
var m1 = t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
foreach(var m11 in m1)
{
return ct(m11.ReturnType);
}
var fl = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var f in fl)
return ct(f.GetType());
var p = t.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var pl in p)
return ct(pl.GetType());
return null;
}
public DescriptionClass(DllReader test, Type type)
{
_mainType = type;
_subClasses = SortListSubClass(test.GetParentsAndInterfaces(_mainType), test);
_nestedClass = type.GetNestedTypes().ToList();
_property = type.GetProperties().ToList();
_field = SortListFi(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList());
_method = SortListMi(type.GetMethods().ToList());
}
private static IImmutableList<Field> AddFields(IImmutableList<Field> derivedTypeFields, Type type)
{
if (type == null)
return derivedTypeFields;
var fields = type.GetNestedTypes()
.Aggregate(derivedTypeFields, AddFields);
var fieldInfos = type.GetFields(BindingFlags.Public | BindingFlags.Static)
.Where(field => FieldType.IsAssignableFrom(field.FieldType));
var fieldsForThisType = fieldInfos.Select(field => (Field)field.GetValue(null));
return AddFields(fields.AddRange(fieldsForThisType), type.BaseType);
}
static IEnumerable<Type> GetNestedTypeRecursive(Type rootType, Type builderType)
{
yield return rootType;
if (typeof(IEndpointConfigurationFactory).IsAssignableFrom(rootType) && rootType != builderType)
yield break;
foreach (var nestedType in rootType.GetNestedTypes(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SelectMany(t => GetNestedTypeRecursive(t, builderType)))
{
yield return nestedType;
}
}
public void CheckTestConstructorNames(Type type)
{
const string constructorTestClassName = "TheCtor";
const string constructorTestMethodName = "EnsuresNonNullArguments";
var classes = new HashSet<string>(type.GetNestedTypes().Select(t => t.Name));
if (!classes.Contains(constructorTestClassName))
{
throw new MissingClientConstructorTestClassException(type);
}
var ctors = type.GetNestedTypes().Where(t => t.Name == constructorTestClassName)
.SelectMany(t => t.GetMethods())
.Where(info => info.ReturnType == typeof(void) && info.IsPublic)
.Select(info => info.Name);
var methods = new HashSet<string>(ctors);
if (!methods.Contains(constructorTestMethodName))
{
throw new MissingClientConstructorTestMethodException(type);
}
}
/// <summary>
/// RPS Wrapper constructor
/// </summary>
public RPS()
{
// Load dynamically the assembly
_rpsAssembly = Assembly.Load("Microsoft.Passport.RPS, Version=6.1.6206.0, Culture=neutral, PublicKeyToken=283dd9fa4b2406c5, processorArchitecture=MSIL");
// Extract the types that will be needed to perform authentication
_rpsType = _rpsAssembly.GetTypes().ToList().Where(t => t.Name == "RPS").Single();
_rpsTicketType = _rpsAssembly.GetTypes().ToList().Where(t => t.Name == "RPSTicket").Single();
_rpsPropBagType = _rpsAssembly.GetTypes().ToList().Where(t => t.Name == "RPSPropBag").Single();
_rpsAuthType = _rpsAssembly.GetTypes().ToList().Where(t => t.Name == "RPSAuth").Single();
_rpsTicketPropertyType = _rpsTicketType.GetNestedTypes().ToList().Where(t => t.Name == "RPSTicketProperty").Single();
// Create instance of the RPS object
_rps = Activator.CreateInstance(_rpsType);
}
private static IEnumerable<Type> GetNestedTypes(Type type)
{
foreach (var nestedType in type.GetNestedTypes(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic))
{
if (nestedType.GetNestedTypes().Count() > 0)
{
foreach (var nestedNestedType in GetNestedTypes(nestedType))
yield return nestedNestedType;
}
else
{
//if(nestedType.IsClass)
yield return nestedType;
}
}
}
public static object Convert(this object obj, Type type)
{
try
{
if (obj is string && !type.GetNestedTypes().Any(t => t == typeof(ValueType)))
return new JsonSerializer().Deserialize(new JsonTextReader(new StringReader((string)obj)), type);
}
catch(JsonReaderException)
{
var serializedResult = new StringBuilder();
new JsonSerializer().Serialize(new StringWriter(serializedResult), obj);
return new JsonSerializer().Deserialize(new JsonTextReader(new StringReader(serializedResult.ToString())), type);
}
return obj;
}
void LoadSettingsFromClass(ConfigFile configFile, Type settingsClass, string sectionName)
{
foreach (FieldInfo fieldInfo in settingsClass.GetFields())
{
if (fieldInfo.FieldType == typeof(Dictionary<string, string>))
{
Dictionary<string, string> dict = new Dictionary<string, string>();
var section = configFile.GetSection(sectionName);
foreach (var property in section.GetProperties())
{
var value = section.GetValue(property, "");
if (dict.ContainsKey(property))
{
dict.Add(property, value);
}
else
{
dict[property] = value;
}
}
fieldInfo.SetValue(null, dict);
}
else if (configFile.HasProperty(sectionName, fieldInfo.Name))
{
string stringValue = configFile.GetValue(sectionName, fieldInfo.Name, "");
object value = StringConverter.Parse(stringValue, fieldInfo.FieldType);
fieldInfo.SetValue(null, value);
}
}
foreach (Type nestedType in settingsClass.GetNestedTypes())
{
string newSectionName = sectionName;
if (newSectionName.Length > 0)
{
newSectionName += ".";
}
newSectionName += nestedType.Name;
LoadSettingsFromClass(configFile, nestedType, newSectionName);
}
}
public static ArrayList GetNestedTypes(Type type, bool inherit)
{
//GetNestedTypes:
// "This method returns only the nested types of the current type.
// It does not search the hierarchy of inherited types.
// To find types that are nested in inherited types, you must walk the inheritance hierarchy."
ArrayList types = new ArrayList();
//Recurse
if(inherit && type.BaseType != null)
types = GetNestedTypes(type.BaseType, inherit);
//Nested Types
foreach(Type t in type.GetNestedTypes())
types.Add(t);
return types;
}
static IEnumerable<Type> GetNestedTypeRecursive(Type rootType, Type builderType)
{
if (rootType == null)
{
throw new InvalidOperationException("Make sure you nest the endpoint infrastructure inside the TestFixture as nested classes");
}
yield return rootType;
if (typeof(IEndpointConfigurationFactory).IsAssignableFrom(rootType) && rootType != builderType)
{
yield break;
}
foreach (var nestedType in rootType.GetNestedTypes(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SelectMany(t => GetNestedTypeRecursive(t, builderType)))
{
yield return nestedType;
}
}
public BlackAction ActivateActionCore(Type controllerType, string actionName)
{
if (controllerType == null)
throw new ArgumentNullException ("controllerType");
if (actionName == null)
throw new ArgumentNullException ("actionName");
var controllerInstance = (Controller)Activator.CreateInstance (controllerType);
var actionType = (from nt in controllerType.GetNestedTypes ()
where nt.Name == actionName
select nt).FirstOrDefault ();
if (actionType == null)
throw new BlackException (string.Format ("No type for action '{0}' was found in controller '{1}'", actionName, controllerType.AssemblyQualifiedName), null);
var actionInstance = (BlackAction)Activator.CreateInstance (actionType);
controllerInstance.own (actionInstance);
actionInstance.loadFilters ();
return actionInstance;
}
static List<Type> GetSubTypes(Type T, BindingFlags flags, bool recurse, bool Protected = false, bool Private = false)
{
List<Type> retSet = new List<Type>();
if (Protected || Private) flags = flags | BindingFlags.NonPublic;
Type[] tmp = T.GetNestedTypes(flags);
foreach (Type t in tmp)
{
if (t.IsPublic || (Protected && t.IsNotPublic && t.IsNestedFamily) || (Private && t.IsNotPublic && !t.IsNestedAssembly))
retSet.Add(t);
}
if (recurse)
{
foreach (Type t in retSet)
{
retSet.AddRange(GetSubTypes(t, flags, recurse, Protected, Private));
}
}
return retSet;
}
void InitMembers(Type type)
{
foreach (Type nestedType in type.GetNestedTypes(flags)) {
// We cannot use nestedType.IsVisible - that only checks for public types,
// but we also need to load protected types.
if (nestedType.IsNestedPublic || nestedType.IsNestedFamily || nestedType.IsNestedFamORAssem) {
string name = this.FullyQualifiedName + "." + nestedType.Name;
InnerClasses.Add(new ReflectionClass(CompilationUnit, nestedType, name, this));
}
}
foreach (FieldInfo field in type.GetFields(flags)) {
if (!field.IsPublic && !field.IsFamily && !field.IsFamilyOrAssembly) continue;
if (!field.IsSpecialName) {
Fields.Add(new ReflectionField(field, this));
}
}
foreach (PropertyInfo propertyInfo in type.GetProperties(flags)) {
ReflectionProperty prop = new ReflectionProperty(propertyInfo, this);
if (prop.IsPublic || prop.IsProtected)
Properties.Add(prop);
}
foreach (ConstructorInfo constructorInfo in type.GetConstructors(flags)) {
if (!constructorInfo.IsPublic && !constructorInfo.IsFamily && !constructorInfo.IsFamilyOrAssembly) continue;
Methods.Add(new ReflectionMethod(constructorInfo, this));
}
foreach (MethodInfo methodInfo in type.GetMethods(flags)) {
if (!methodInfo.IsPublic && !methodInfo.IsFamily && !methodInfo.IsFamilyOrAssembly) continue;
if (!methodInfo.IsSpecialName) {
Methods.Add(new ReflectionMethod(methodInfo, this));
}
}
this.AddDefaultConstructorIfRequired = (this.ClassType == ClassType.Struct || this.ClassType == ClassType.Enum);
foreach (EventInfo eventInfo in type.GetEvents(flags)) {
Events.Add(new ReflectionEvent(eventInfo, this));
}
}
public static void ScanType(Type type)
{
foreach(Type nestedType in type.GetNestedTypes())
ScanType(nestedType);
LispCustomSerializerAttribute customSerializer =
(LispCustomSerializerAttribute)
Attribute.GetCustomAttribute(type, typeof(LispCustomSerializerAttribute));
if(customSerializer != null) {
object instance = CreateObject(type);
typeSerializers.Add(customSerializer.Type, (ILispSerializer) instance);
return;
}
LispRootAttribute rootAttrib = (LispRootAttribute)
Attribute.GetCustomAttribute(type, typeof(LispRootAttribute));
if(rootAttrib != null) {
LispRootSerializer serializer = new LispRootSerializer(type);
typeSerializers.Add(type, serializer);
return;
}
}
private static void CheckType(Type type)
{
foreach (MemberInfo member in type.GetMembers(memberFlags))
{
MethodBase mb = member as MethodBase;
if (mb != null && member.DeclaringType == type)
{
CheckMethodBase(mb);
}
}
CheckUsedType(type.BaseType);
foreach (Type ifc in type.GetInterfaces())
{
if (ifc.DeclaringType == type)
{
CheckUsedType(ifc);
}
}
foreach (Type nestedType in type.GetNestedTypes(nextedFlags))
{
CheckType(nestedType);
}
}
void InitMembers(Type type)
{
foreach (Type nestedType in type.GetNestedTypes(flags)) {
if (!nestedType.IsVisible) continue;
string name = nestedType.FullName.Replace('+', '.');
InnerClasses.Add(new ReflectionClass(CompilationUnit, nestedType, name, this));
}
foreach (FieldInfo field in type.GetFields(flags)) {
if (!field.IsPublic && !field.IsFamily) continue;
if (!field.IsSpecialName) {
Fields.Add(new ReflectionField(field, this));
}
}
foreach (PropertyInfo propertyInfo in type.GetProperties(flags)) {
ReflectionProperty prop = new ReflectionProperty(propertyInfo, this);
if (prop.IsPublic || prop.IsProtected)
Properties.Add(prop);
}
foreach (ConstructorInfo constructorInfo in type.GetConstructors(flags)) {
if (!constructorInfo.IsPublic && !constructorInfo.IsFamily) continue;
Methods.Add(new ReflectionMethod(constructorInfo, this));
}
foreach (MethodInfo methodInfo in type.GetMethods(flags)) {
if (!methodInfo.IsPublic && !methodInfo.IsFamily) continue;
if (!methodInfo.IsSpecialName) {
Methods.Add(new ReflectionMethod(methodInfo, this));
}
}
foreach (EventInfo eventInfo in type.GetEvents(flags)) {
Events.Add(new ReflectionEvent(eventInfo, this));
}
}
public ClassDetail(RootDetail parent, Type type)
: base(parent, type, false)
{
BindingFlags flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
Type[] types = type.GetNestedTypes(flags);
_category = "class";
foreach (Type nested in types)
{
if (nested.IsEnum)
{
_children.Add(new EnumDetail(this, nested));
}
else if (nested.IsInterface)
{
_children.Add(new InterfaceDetail(this, nested));
}
else if (nested.IsClass)
{
_children.Add(new ClassDetail(this, nested));
}
}
}
protected MemberGroup/*!*/ GetMember(Type/*!*/ type, string/*!*/ name, BindingFlags flags) {
Assert.NotNull(type, name);
MemberInfo[] foundMembers = type.GetMember(name, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | flags);
if (!Binder.DomainManager.Configuration.PrivateBinding) {
foundMembers = CompilerHelpers.FilterNonVisibleMembers(type, foundMembers);
}
MemberGroup members = new MemberGroup(foundMembers);
// check for generic types w/ arity...
Type[] types = type.GetNestedTypes(BindingFlags.Public | flags);
string genName = name + ReflectionUtils.GenericArityDelimiter;
List<Type> genTypes = null;
foreach (Type t in types) {
if (t.Name.StartsWith(genName)) {
if (genTypes == null) genTypes = new List<Type>();
genTypes.Add(t);
}
}
if (genTypes != null) {
List<MemberTracker> mt = new List<MemberTracker>(members);
foreach (Type t in genTypes) {
mt.Add(MemberTracker.FromMemberInfo(t));
}
return new MemberGroup(mt.ToArray());
}
if (members.Count == 0) {
if ((flags & BindingFlags.DeclaredOnly) == 0) {
members = Binder.GetAllExtensionMembers(type, name);
} else {
members = Binder.GetExtensionMembers(type, name);
}
}
return members;
}
private void AddKnownType(Type type)
{
Guard.AgainstNull(type, "type");
if (HasKnownType(type))
{
return;
}
lock (padlock)
{
if (HasKnownType(type))
{
return;
}
knownTypes.Add(type);
foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
{
if (!HasKnownType(nested))
{
AddKnownType(nested);
}
}
ResetSerializers();
}
}
private static void AddNestedTypesRecursively(List<Type> types, Type type)
{
Type[] nestedTypes = type.GetNestedTypes(BindingFlags.Public);
foreach (Type nestedType in nestedTypes)
{
types.Add(nestedType);
AddNestedTypesRecursively(types, nestedType);
}
}
private void SearchMusicAndSounds(Type contentType)
{
// Search all fields
FieldInfo[] fields = contentType.GetFields();
foreach (FieldInfo field in fields)
{
if (field.FieldType == typeof(string))
{
string fieldValue = (string)field.GetValue(null);
if (!string.IsNullOrEmpty(fieldValue)
&& (Path.GetExtension(fieldValue) == ".wav" || Path.GetExtension(fieldValue) == ".mp3")
)
{
this.audioPaths.Add(field.Name, fieldValue);
}
}
}
// Search child classes
Type[] types = contentType.GetNestedTypes();
foreach (Type type in types)
{
this.SearchMusicAndSounds(type);
}
}
