// note : originally input deltaTime when iterating. Faster, but issues is that deltaTime might differ when -creating -the invocations and when executing them. Now fetches the current deltaTime when creating new flows, then use a cached deltaTime when iterating. public static void LinkDeltaTimeProperties(System.Reflection.PropertyInfo deltaTimeProperty, System.Reflection.PropertyInfo unscaledDeltaTimeProperty) { var del = deltaTimeProperty.GetGetMethod().CreateDelegate(typeof(Func <float>)); _getDeltaTime = (Func <float>)del; del = deltaTimeProperty.GetGetMethod().CreateDelegate(typeof(Func <float>)); _getUnscaledDeltaTime = (Func <float>)del; }
public IMethod GetGetMethod() { System.Reflection.MethodInfo getter = _property.GetGetMethod(true); if (null != getter) { return(_typeSystemServices.Map(getter)); } return(null); }
private void parentUserCtrl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e) { texOneProp = null; texTwoProp = null; if (e.OldValue != null) { if (weatherCtrlProp != null) { object weatherCtrl = weatherCtrlProp.Invoke(e.OldValue, null); if (weatherCtrl is INotifyPropertyChanged) { ((INotifyPropertyChanged)weatherCtrl).PropertyChanged -= TestTextureChanged; } } weatherCtrlProp = null; } if (e.NewValue != null) { object weatherCtrl = null; System.Reflection.PropertyInfo weatherTestProp = e.NewValue.GetType().GetProperty("WeatherTest"); if (weatherTestProp != null) { weatherCtrlProp = weatherTestProp.GetGetMethod(); weatherCtrl = weatherCtrlProp.Invoke(e.NewValue, null); if (weatherCtrl is INotifyPropertyChanged) { System.Reflection.PropertyInfo p = null; p = weatherCtrl.GetType().GetProperty("TextureOne"); if (p != null) { texOneProp = p.GetGetMethod(); } p = weatherCtrl.GetType().GetProperty("TextureTwo"); if (p != null) { texTwoProp = p.GetGetMethod(); } ((INotifyPropertyChanged)weatherCtrl).PropertyChanged += TestTextureChanged; } } TestTextureChanged(weatherCtrl, new PropertyChangedEventArgs("TextureOne")); TestTextureChanged(weatherCtrl, new PropertyChangedEventArgs("TextureTwo")); } if (texOneProp == null) { testImgCtrl.Source = null; Debug.WriteLine("Cannot bind to WeatherTest.TextureOne property"); } if (texTwoProp == null) { testImgEffect.Input2 = null; Debug.WriteLine("Cannot bind to WeatherTest.TextureTwo property"); } }
public static string AggregateWhere <T>(List <T> Array, string IfMethod, string ValueMethod, char?split) #endif { Type type = typeof(T); System.Reflection.PropertyInfo propertyValue = type.GetProperty(ValueMethod); System.Reflection.PropertyInfo propertyIf = type.GetProperty(IfMethod); System.Reflection.MethodInfo methodValue = propertyValue.GetGetMethod(); System.Reflection.MethodInfo methodIf = propertyIf.GetGetMethod(); string stmp = string.Empty; foreach (T item in Array) { GetValue <string> getValue = (GetValue <string>)Delegate.CreateDelegate(typeof(GetValue <string>), item, methodValue); GetValue <bool> getBoolean = (GetValue <bool>)Delegate.CreateDelegate(typeof(GetValue <bool>), item, methodIf); if (getBoolean()) { if (split.HasValue && stmp.Length > 0) { stmp += split.Value; } stmp += getValue(); } } return(stmp); }
public JsPropertyDefinition(string name, System.Reflection.PropertyInfo propInfo) : base(name, JsMemberKind.Property) { this.propInfo = propInfo; #if NET20 var getter = propInfo.GetGetMethod(true); if (getter != null) { this.GetterMethod = new JsPropertyGetDefinition(name, getter); } var setter = propInfo.GetSetMethod(true); if (setter != null) { this.SetterMethod = new JsPropertySetDefinition(name, setter); } #else var getter = propInfo.GetMethod; if (getter != null) { this.GetterMethod = new JsPropertyGetDefinition(name, getter); } var setter = propInfo.SetMethod; if (setter != null) { this.SetterMethod = new JsPropertySetDefinition(name, setter); } #endif }
private DictionaryInfo(TypeInfo typeInfo, System.Reflection.PropertyInfo info, TypeInfo keyType, TypeInfo valueType) : base(typeInfo, info, keyType, valueType) { this.info = info; this.callTryGetValue = new Lazy <TryGetValueDelegate>(() => { System.Reflection.MethodInfo tryGetMethod = typeInfo.Type.GetMethod("TryGetValue"); if (tryGetMethod == null) { return(null); } ParameterExpression targetParam = Expression.Parameter(typeof(object), null); ParameterExpression keyParam = Expression.Parameter(typeof(object), null); ParameterExpression outValueParam = Expression.Parameter(typeof(object).MakeByRefType(), null); Expression castTarget = ReflectionUtility.Convert(targetParam, typeInfo); Expression castKey = ReflectionUtility.Convert(keyParam, keyType); Expression callTryGet = Expression.Call(castTarget, tryGetMethod, castKey, outValueParam); return(ReflectionUtility.CompileLambda <TryGetValueDelegate>(callTryGet, targetParam, keyParam, outValueParam)); }); this.callGet = new Lazy <Func <object, object, object> >(() => { System.Reflection.MethodInfo getMethod = info.GetGetMethod(nonPublic: false); if (getMethod == null) { return(null); } ParameterExpression targetParam = Expression.Parameter(typeof(object), null); ParameterExpression keyParam = Expression.Parameter(typeof(object), null); Expression castTarget = ReflectionUtility.Convert(targetParam, typeInfo); Expression castKey = ReflectionUtility.Convert(keyParam, keyType); Expression callGet = Expression.Call(castTarget, getMethod, castKey); return(ReflectionUtility.CompileLambda <Func <object, object, object> >(callGet, targetParam, keyParam)); }); this.callSet = new Lazy <Action <object, object, object> >(() => { System.Reflection.MethodInfo setMethod = info.GetSetMethod(nonPublic: false); if (setMethod == null) { return(null); } ParameterExpression targetParam = Expression.Parameter(typeof(object), null); ParameterExpression keyParam = Expression.Parameter(typeof(object), null); ParameterExpression valueParam = Expression.Parameter(typeof(object), null); Expression castTarget = ReflectionUtility.Convert(targetParam, typeInfo); Expression castKey = ReflectionUtility.Convert(keyParam, keyType); Expression castValue = ReflectionUtility.Convert(valueParam, valueType); Expression callSet = Expression.Call(castTarget, setMethod, castKey, castValue); return(ReflectionUtility.CompileLambda <Action <object, object, object> >(callSet, targetParam, keyParam, valueParam)); }); }
/// <summary> /// Initializes the internal structures from values specified in the .config files /// </summary> /// <param name="providerName">Unique name used to refer to this instance of SqlServerStorageProvider</param> /// <param name="attrs">Parameters stored in the .config files</param> public override void Initialize(string providerName, NameValueCollection attrs) { this._name = providerName; //Get parameters from attrs _connectionString = attrs["ConnectionString"]; _tableName = safeName(attrs["TableName"]); _dataColumnName = safeName(attrs["DataColumnName"]); _partialFlagColumnName = safeName(attrs["PartialFlagColumnName"]); _fileNameColumnName = safeName(attrs["FileNameColumnName"]); _MIMETypeColumnName = safeName(attrs["MIMETypeColumnName"]); _createProcedure = attrs["CreateProcedure"]; _openProcedure = attrs["OpenProcedure"]; _writeProcedure = attrs["WriteProcedure"]; _readProcedure = attrs["ReadProcedure"]; _cleanupProcedure = attrs["CleanupProcedure"]; _renameProcedure = attrs["RenameProcedure"]; _storeHashProcedure = attrs["StoreHashProcedure"]; _deleteProcedure = attrs["DeleteProcedure"]; _hashAlgorithm = attrs["HashAlgorithm"]; _hashColumnName = safeName(attrs["HashColumnName"]); //In .net v2.0 there is a nice ConfigurationManager and centralized ConnectionStrings. Use it if "ConnectionName" is specified if (System.Environment.Version.Major >= 2 && attrs["ConnectionName"] != null && attrs["ConnectionName"].Length > 0) { _connectionName = attrs["ConnectionName"]; // Use reflection to do: // _connectionString = System.Configuration.ConfigurationManager.ConnectionStrings[_connectionName].ConnectionString; // so we don't need a special 2.0 version of the assembly. string configAssembly = "System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL"; Type configManager = Type.GetType("System.Configuration.ConfigurationManager, " + configAssembly, true); System.Reflection.PropertyInfo connStringsPropInfo = configManager.GetProperty("ConnectionStrings"); object connStringSettingCollection = connStringsPropInfo.GetGetMethod().Invoke(null, null); System.Reflection.BindingFlags instanceGetPropBindingFlags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty | System.Reflection.BindingFlags.Public; object connStringSettings = Type.GetType("System.Configuration.ConnectionStringSettingsCollection, " + configAssembly) .InvokeMember("", instanceGetPropBindingFlags, null, connStringSettingCollection, new object[] { _connectionName }); _connectionString = (string)Type.GetType("System.Configuration.ConnectionStringSettings, " + configAssembly) .InvokeMember("ConnectionString", instanceGetPropBindingFlags, null, connStringSettings, null); } //Make sure we have at least a connenction string, a table name and a dataColumnName. The rest is optional string error = string.Empty; if (_connectionString == null) { error = "No ConnectionString specified"; } if (_createProcedure == null && (_tableName == null || _dataColumnName == null)) { error += (error.Length > 0 ? "; " : string.Empty) + "Either CreatorProcedure or TableName/DataColumnName mut be specified"; } if (error.Length > 0) { throw new System.Xml.XmlException("Missing attribute: " + error); } }
public void System_PropertyInfo_is_wrapped_by_Routine_PropertyInfo() { Assert.AreEqual(propertyInfo.Name, testing.Name); Assert.AreEqual(propertyInfo.GetGetMethod()?.Name, testing.GetGetMethod().Name); Assert.AreEqual(propertyInfo.GetSetMethod()?.Name, testing.GetSetMethod().Name); Assert.AreSame(propertyInfo.DeclaringType, testing.DeclaringType.GetActualType()); Assert.AreSame(propertyInfo.ReflectedType, testing.ReflectedType.GetActualType()); Assert.AreSame(propertyInfo.PropertyType, testing.PropertyType.GetActualType()); }
System.Reflection.MethodInfo GetAccessor() { System.Reflection.MethodInfo mi = _property.GetGetMethod(true); if (null != mi) { return(mi); } return(_property.GetSetMethod(true) ); }
private static System.Xml.XmlNode MakePropertyNode(System.Reflection.PropertyInfo memberInfo, System.Xml.XmlDocument ownerdoc) { System.Xml.XmlNode nodeMember; nodeMember = Utility.xmlHelpers.NewElement(ownerdoc, "Property", memberInfo.Name); nodeMember.Attributes.Append(Utility.xmlHelpers.NewAttribute(ownerdoc, "Type", memberInfo.PropertyType.ToString())); nodeMember.Attributes.Append(Utility.xmlHelpers.NewBoolAttribute(ownerdoc, "CanRead", memberInfo.CanRead)); nodeMember.Attributes.Append(Utility.xmlHelpers.NewBoolAttribute(ownerdoc, "CanWrite", memberInfo.CanWrite)); MakeParameterNodes(nodeMember, memberInfo.GetIndexParameters()); if (memberInfo.GetGetMethod() != null) { nodeMember.AppendChild(MakeMethodNode(memberInfo.GetGetMethod(), ownerdoc, false)); } if (memberInfo.GetSetMethod() != null) { nodeMember.AppendChild(MakeMethodNode(memberInfo.GetSetMethod(), ownerdoc, false)); } return(nodeMember); }
public override bool Process(PropertyInfo property, IMethodRemover methodRemover, IFacetHolder holder) { if ((property.PropertyType.IsPrimitive || TypeUtils.IsEnum(property.PropertyType)) && property.GetCustomAttribute<OptionallyAttribute>() != null) { Log.Warn("Ignoring Optionally annotation on primitive or un-readable parameter on " + property.ReflectedType + "." + property.Name); return false; } if (property.GetGetMethod() != null && !property.PropertyType.IsPrimitive) { return Process(property, holder); } return false; }
/// <summary> /// Recupera o valor de um membro de uma classe (Normalmente Propriedade) atraves da função membro.GetValue() /// </summary> /// <param name="objeto">Instancia do Objeto</param> /// <param name="membro">Instancia do membro do objeto</param> /// <returns></returns> private object getMemberValue(object objeto, System.Reflection.PropertyInfo membro) { if (membro.GetGetMethod().IsStatic) { return(membro.GetValue(null, null)); } else { return(membro.GetValue(objeto, null)); } }
/// <summary> /// Initializes a new OSpace instance of the property class /// </summary> /// <param name="name">name of the property</param> /// <param name="typeUsage">TypeUsage object containing the property type and its facets</param> /// <param name="propertyInfo">for the property</param> internal NavigationProperty(string name, TypeUsage typeUsage, System.Reflection.PropertyInfo propertyInfo) : this(name, typeUsage) { System.Diagnostics.Debug.Assert(name == propertyInfo.Name, "different PropertyName?"); if (null != propertyInfo) { System.Reflection.MethodInfo method; method = propertyInfo.GetGetMethod(); PropertyGetterHandle = ((null != method) ? method.MethodHandle : default(System.RuntimeMethodHandle)); } }
//System.Reflection.PropertyInfo prop; /// <summary> /// ManagedProperty インスタンスを PropertyInfo から作成します。 /// </summary> /// <param name="prop">PropertyInfo</param> public ManagedProperty(System.Reflection.PropertyInfo prop) { //this.prop=prop; System.Type type = prop.ReflectedType; if (prop.CanRead) { this[":propget:"] = new ManagedMethod(type, prop.GetGetMethod()); } if (prop.CanWrite) { this[":propput:"] = new ManagedMethod(type, prop.GetSetMethod()); } }
private static string GetGacDir() { System.Reflection.PropertyInfo gac = typeof(System.Environment).GetProperty("GacPath", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic); if (gac == null) { WriteLine("ERROR: Mono runtime not detected, please use " + "the mono runtime for gacutil.exe"); Environment.Exit(1); } System.Reflection.MethodInfo get_gac = gac.GetGetMethod(true); return((string)get_gac.Invoke(null, null)); }
/// <summary> /// Initializes a new OSpace instance of the property class /// </summary> /// <param name="name">name of the property</param> /// <param name="typeUsage">TypeUsage object containing the property type and its facets</param> /// <param name="propertyInfo">for the property</param> /// <param name="entityDeclaringType">The declaring type of the entity containing the property</param> internal EdmProperty(string name, TypeUsage typeUsage, System.Reflection.PropertyInfo propertyInfo, RuntimeTypeHandle entityDeclaringType) : this(name, typeUsage) { System.Diagnostics.Debug.Assert(name == propertyInfo.Name, "different PropertyName"); if (null != propertyInfo) { System.Reflection.MethodInfo method; method = propertyInfo.GetGetMethod(true); // return public or non-public getter PropertyGetterHandle = ((null != method) ? method.MethodHandle : default(System.RuntimeMethodHandle)); method = propertyInfo.GetSetMethod(true); // return public or non-public getter PropertySetterHandle = ((null != method) ? method.MethodHandle : default(System.RuntimeMethodHandle)); EntityDeclaringType = entityDeclaringType; } }
/// <summary> /// Metodo abstrato que salva o valor proprieamente dito no objeto da classe atraves da função membro.GetValue() /// </summary> /// <param name="objeto">Instancia do Objeto</param> /// <param name="membro">Instancia do membro do objeto</param> /// <param name="valor">Valor</param> private void setMemberValue(object objeto, System.Reflection.PropertyInfo membro, object valor) { try { if (membro.GetGetMethod().IsStatic) { membro.SetValue(null, valor, null); } else { membro.SetValue(objeto, valor, null); } } catch (System.Exception ex) { throw new System.Exception("setMemberValue() - Erro :" + ex.Message); } }
public static object GetPropertyValue(this object instance, string PropertyName) { if (PropertyName == null) { return(null); } Type type = instance.GetType(); System.Reflection.PropertyInfo property = type.GetProperty(PropertyName); if (property == null) { return(null); } System.Reflection.MethodInfo method = property.GetGetMethod(); if (method == null) { return(null); } return(method.Invoke(instance, null)); }
public static bool IsDesignMode(Control control) { while (control != null) { System.Reflection.PropertyInfo siteProperty = control.GetType().GetProperty("Site"); if (siteProperty != null) { System.ComponentModel.ISite site = siteProperty.GetGetMethod().Invoke(control, new object[0]) as System.ComponentModel.ISite; if (site != null && site.DesignMode) { return(true); } } control = control.Parent; } return(false); }
// Ctor for imported properties public PropertyExpEntry( ISemanticResolver s, System.Reflection.PropertyInfo info ) { m_info = info; m_strName = m_info.Name; // Class that we're defined in? System.Type tClrClass = info.DeclaringType; m_tClassDefined = s.ResolveCLRTypeToBlueType(tClrClass); // Symbol type this.m_type = s.ResolveCLRTypeToBlueType(info.PropertyType); // Spoof accessors if (info.CanRead) // Has Get { System.Reflection.MethodInfo mGet = info.GetGetMethod(); m_symbolGet = new MethodExpEntry(s, mGet); } if (info.CanWrite) // Has Set { System.Reflection.MethodInfo mSet = info.GetSetMethod(); m_symbolSet = new MethodExpEntry(s, mSet); } // Get modifiers System.Reflection.MethodInfo [] m = info.GetAccessors(); m_mods = new Modifiers(m[0]); /* * m_mods = new Modifiers(); * if (m[0].IsStatic) m_mods.SetStatic(); * if (m[0].IsAbstract) m_mods.SetAbstract(); * if (m[0].IsVirtual) m_mods.SetVirtual(); */ }
// based partially on : http://stackoverflow.com/questions/1253725/convert-ienumerable-to-datatable internal static System.Func <T, object> GetGetter <T>(System.Reflection.PropertyInfo property) { // get the get method for the property var method = property.GetGetMethod(true); // get the generic get-method generator (ReflectionUtility.GetSetterHelper<TTarget, TValue>) var genericHelper = typeof(ReflectionUtility).GetMethod( "GetGetterHelper", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic); // reflection call to the generic get-method generator to generate the type arguments var constructedHelper = genericHelper.MakeGenericMethod( method.DeclaringType, method.ReturnType); // now call it. The null argument is because it's a static method. object ret = constructedHelper.Invoke(null, new object[] { method }); // cast the result to the action delegate and return it return((System.Func <T, object>)ret); }
public static string Aggregate <TItem>(IList <TItem> array, string ValueMethod, char?split) #endif #endif { System.Reflection.PropertyInfo propertyValue = null; System.Reflection.MethodInfo methodValue = null; Type type = typeof(TItem); if (ValueMethod != null) { propertyValue = type.GetProperty(ValueMethod); } if (propertyValue != null) { methodValue = propertyValue.GetGetMethod(); } string Result = string.Empty; foreach (TItem item in array) { if (split.HasValue && Result.Length > 0) { Result += split.Value; } if (methodValue != null) { GetValue <string> getValue = (GetValue <string>)Delegate.CreateDelegate(typeof(GetValue <string>), item, methodValue); Result += getValue(); } else { Result += item.ToString(); } } return(Result); }
internal CILPropertyImpl( CILReflectionContextImpl ctx, Int32 anID, System.Reflection.PropertyInfo pInfo) : base(ctx, anID, CILElementKind.Property, () => new CustomAttributeDataEventArgs(ctx, pInfo)) { ArgumentValidator.ValidateNotNull("Property", pInfo); if (pInfo.DeclaringType #if WINDOWS_PHONE_APP .GetTypeInfo() #endif .IsGenericType&& !pInfo.DeclaringType #if WINDOWS_PHONE_APP .GetTypeInfo() #endif .IsGenericTypeDefinition) { throw new ArgumentException("This constructor may be used only on properties declared in genericless types or generic type definitions."); } InitFields( ref this.name, ref this.propertyAttributes, ref this.setMethod, ref this.getMethod, ref this.declaringType, ref this.constValue, ref this.customModifiers, new SettableValueForClasses <String>(pInfo.Name), new SettableValueForEnums <PropertyAttributes>((PropertyAttributes)pInfo.Attributes), () => ctx.Cache.GetOrAdd(pInfo.GetSetMethod(true)), () => ctx.Cache.GetOrAdd(pInfo.GetGetMethod(true)), () => (CILType)ctx.Cache.GetOrAdd(pInfo.DeclaringType), new SettableLazy <Object>(() => ctx.LaunchConstantValueLoadEvent(new ConstantValueLoadArgs(pInfo))), ctx.LaunchEventAndCreateCustomModifiers(new CustomModifierEventLoadArgs(pInfo)), true ); }
static public System.Drawing.Bitmap GetIcon(string eventtypestr, string seltext = null) // get ICON associated with the event type. { Type jtype = TypeOfJournalEntry(eventtypestr); if (jtype == null) { return(EDDiscovery.Properties.Resources.genericevent); } System.Reflection.MethodInfo m = jtype.GetMethod("IconSelect"); // first we see if the class defines this function.. if (m != null) { return((System.Drawing.Bitmap)m.Invoke(null, new Object [] { seltext })); // if so, pass it the string and let it pick the icon } else { System.Reflection.PropertyInfo p = jtype.GetProperty("Icon"); // else use the Icon property, or if its not defined, its a generic event System.Reflection.MethodInfo getter = p?.GetGetMethod(); return((getter != null) ? ((System.Drawing.Bitmap)getter.Invoke(null, null)) : EDDiscovery.Properties.Resources.genericevent); } }
public static List <T> Where <T>(List <T> Array, string IfMethod) #endif { Type type = typeof(T); System.Reflection.PropertyInfo propertyIf = type.GetProperty(IfMethod); System.Reflection.MethodInfo methodIf = propertyIf.GetGetMethod(); string stmp = string.Empty; List <T> ret = new List <T>(); foreach (T item in Array) { GetValue <bool> getBoolean = (GetValue <bool>)Delegate.CreateDelegate(typeof(GetValue <bool>), item, methodIf); if (getBoolean()) { ret.Add(item); } } return(ret); }
public bool GetValuesIndicated(Object o) // For all in the Values list, fill in data given from fields in O { Type jtype = o.GetType(); foreach (string k in values.Keys.ToList()) { System.Reflection.PropertyInfo pi = jtype.GetProperty(k); if (pi != null) { System.Reflection.MethodInfo getter = pi.GetGetMethod(); AddDataOfType(getter.Invoke(o, null), pi.PropertyType, k, 0); } else { System.Reflection.FieldInfo fi = jtype.GetField(k); if (fi != null) { AddDataOfType(fi.GetValue(o), fi.FieldType, k, 0); } } } return(true); }
public override bool Process(PropertyInfo property, IMethodRemover methodRemover, IFacetHolder holder) { if (property.GetGetMethod() != null && TypeUtils.IsString(property.PropertyType)) { return Process(property, holder); } return false; }
public RMCommandParser(string commandLine, object classForAutoAttributes) { m_commandLine = commandLine; Type type = classForAutoAttributes.GetType(); System.Reflection.MemberInfo[] members = type.GetMembers(); for (int i = 0; i < members.Length; i++) { object[] attributes = members[i].GetCustomAttributes(false); if (attributes.Length > 0) { SwitchRecord rec = null; foreach (Attribute attribute in attributes) { if (attribute is CommandLineSwitchAttribute) { CommandLineSwitchAttribute switchAttrib = (CommandLineSwitchAttribute)attribute; // Get the property information. We're only handling // properties at the moment! if (members[i] is System.Reflection.PropertyInfo) { System.Reflection.PropertyInfo pi = (System.Reflection.PropertyInfo)members[i]; rec = new SwitchRecord(switchAttrib.Name, switchAttrib.Description, pi.PropertyType); // Map in the Get/Set methods. rec.SetMethod = pi.GetSetMethod(); rec.GetMethod = pi.GetGetMethod(); rec.PropertyOwner = classForAutoAttributes; // Can only handle a single switch for each property // (otherwise the parsing of aliases gets silly...) break; } } } // See if any aliases are required. We can only do this after // a switch has been registered and the framework doesn't make // any guarantees about the order of attributes, so we have to // walk the collection a second time. if (rec != null) { foreach (Attribute attribute in attributes) { if (attribute is CommandLineAliasAttribute) { CommandLineAliasAttribute aliasAttrib = (CommandLineAliasAttribute)attribute; rec.AddAlias(aliasAttrib.Alias); } } } // Assuming we have a switch record (that may or may not have // aliases), add it to the collection of switches. if (rec != null) { if (m_switches == null) { m_switches = new System.Collections.ArrayList(); } m_switches.Add(rec); } } } }
public T _Mod_GetGenericPropertyValue <T>(string name, Object[] index) { System.Reflection.PropertyInfo prop = this.GetType().GetProperty(name); return((T)prop.GetValue(prop.GetGetMethod().IsStatic ? null : this, index)); }
//THIS DOESNT WORK - REMOVED FROM THE CHECK FUNCTION FOR NOW bool ProcessStructVariableTypes(object input, int inputType) { if (inputType == 0) { System.Reflection.PropertyInfo p = input as System.Reflection.PropertyInfo; Debug.Log("name: " + p.Name + " attributes: " + p.Attributes + " declaring type: " + p.DeclaringType + " accessors: " + p.GetAccessors() + " attributes: " + p.GetCustomAttributes(true) + " getmethod: " + p.GetGetMethod() + " setmethod: " + p.GetSetMethod() + " type: " + p.GetType() + " membertype: " + p.MemberType + " module: " + p.Module + " proptype: " + p.PropertyType + " reftype: " + p.ReflectedType); CompleteVariableSetup(16); return(false); } return(false); }
public override bool Process(PropertyInfo property, IMethodRemover methodRemover, IFacetHolder holder) { if (property.GetGetMethod() != null) { return Process(property, holder); } return false; }
public object InvokeGet(object target) { return(_property.GetGetMethod().Invoke(target, null)); }
private static System.Func <object, object> FindMember(Type type, string name) { if (type == null) { throw new ArgumentNullException("type"); } if (name == null) { throw new ArgumentNullException("name"); } lock (_memberAccessors) { Dictionary <string, System.Func <object, object> > members; System.Func <object, object> accessor = null; if (_memberAccessors.TryGetValue(type, out members)) { if (members.TryGetValue(name, out accessor)) { return(accessor); } } else { members = new Dictionary <string, System.Func <object, object> >(); _memberAccessors[type] = members; } // must look up using reflection string methodSuffix = char.ToUpperInvariant(name[0]) + name.Substring(1); bool checkOriginalName = !string.Equals(methodSuffix, name); MethodInfo method = null; if (method == null) { PropertyInfo p = type.GetProperty(methodSuffix); if (p == null && checkOriginalName) { p = type.GetProperty(name); } if (p != null) { method = p.GetGetMethod(); } } if (method == null) { method = type.GetMethod("Get" + methodSuffix, Type.EmptyTypes); if (method == null && checkOriginalName) { method = type.GetMethod("Get" + name, Type.EmptyTypes); } } if (method == null) { method = type.GetMethod("get_" + methodSuffix, Type.EmptyTypes); if (method == null && checkOriginalName) { method = type.GetMethod("get_" + name, Type.EmptyTypes); } } if (method == null) { method = type.GetMethod(name, Type.EmptyTypes); } if (method != null) { accessor = BuildAccessor(method); } else { // try for an indexer method = type.GetMethod("get_Item", new Type[] { typeof(string) }); if (method == null) { var property = type.GetProperties().FirstOrDefault(IsIndexer); if (property != null) { method = property.GetGetMethod(); } } if (method != null) { accessor = BuildAccessor(method, name); } else { // try for a visible field FieldInfo field = type.GetField(name); // also check .NET naming convention for fields if (field == null) { field = type.GetField("_" + name); } if (field != null) { accessor = BuildAccessor(field); } } } members[name] = accessor; return(accessor); } }