FieldInfo

system\reflection\emit\fieldbuilder.cs (1)

22public sealed class FieldBuilder : FieldInfo, _FieldBuilder

system\reflection\emit\xxxontypebuilderinstantiation.cs (1)

197internal sealed class FieldOnTypeBuilderInstantiation : FieldInfo

system\reflection\fieldinfo.cs (1)

225internal abstract class RuntimeFieldInfo : FieldInfo, ISerializable

system\runtime\serialization\serializationfieldinfo.cs (1)

32internal sealed class SerializationFieldInfo : FieldInfo {

AuthoringOM\Compiler\TypeSystem\FieldInfo.cs (1)

15internal sealed class DesignTimeFieldInfo : FieldInfo

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (1)

873private class RTFieldInfoWrapper : FieldInfo

system\__filters.cs (1)

86FieldAttributes attr = ((FieldInfo) m).Attributes;

system\attribute.cs (2)

847FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 916FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

system\defaultbinder.cs (6)

442public override FieldInfo BindToField(BindingFlags bindingAttr,FieldInfo[] match, Object value,CultureInfo cultureInfo) 454FieldInfo[] candidates = (FieldInfo[]) match.Clone(); 989private static int FindMostSpecificField(FieldInfo cur1,FieldInfo cur2)

system\diagnostics\eventing\eventsource.cs (5)

3340foreach (FieldInfo staticField in nestedType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)) 3598private static void AddProviderEnumKind(ManifestBuilder manifest, FieldInfo staticField, string providerEnumKind) 6419FieldInfo[] staticFields = enumType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static); 6420foreach (FieldInfo staticField in staticFields) 6728FieldInfo[] fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);

system\object.cs (6)

26using FieldInfo = System.Reflection.FieldInfo; 135FieldInfo fldInfo = GetFieldInfo(typeName, fieldName); 170FieldInfo fldInfo = GetFieldInfo(typeName, fieldName); 178private FieldInfo GetFieldInfo(String typeName, String fieldName) 182Contract.Ensures(Contract.Result<FieldInfo>() != null); 206FieldInfo fldInfo = t.GetField(fieldName, BindingFlags.Public |

system\reflection\binder.cs (2)

34public abstract FieldInfo BindToField(BindingFlags bindingAttr,FieldInfo[] match,

system\reflection\cominterfaces.cs (5)

81FieldInfo GetField(String name, BindingFlags bindingAttr); 82FieldInfo[] GetFields(BindingFlags bindingAttr); 110FieldInfo GetField(String name); 111FieldInfo[] GetFields(); 472[TypeLibImportClassAttribute(typeof(System.Reflection.FieldInfo))]

system\reflection\customattribute.cs (6)

380FieldInfo[] fields = m_ctor.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); 614FieldInfo field = memberInfo as FieldInfo; 661return m_memberInfo is FieldInfo ? 662((FieldInfo)m_memberInfo).FieldType : 672public bool IsField { get { return MemberInfo is FieldInfo; } }

system\reflection\emit\customattributebuilder.cs (5)

41new FieldInfo[]{}, new Object[]{}); 50propertyValues, new FieldInfo[]{}, new Object[]{}); 56FieldInfo[] namedFields, Object[] fieldValues) 66FieldInfo[] namedFields, Object[] fieldValues) 105FieldInfo[] namedFields, Object[] fieldValues)

system\reflection\emit\dynamicilgenerator.cs (1)

195public override void Emit(OpCode opcode, FieldInfo field)

system\reflection\emit\enumbuilder.cs (2)

163public override FieldInfo GetField(String name, BindingFlags bindingAttr) 168public override FieldInfo[] GetFields(BindingFlags bindingAttr)

system\reflection\emit\generictypeparameterbuilder.cs (2)

130public override FieldInfo GetField(String name, BindingFlags bindingAttr) { throw new NotSupportedException(); } 132public override FieldInfo[] GetFields(BindingFlags bindingAttr) { throw new NotSupportedException(); }

system\reflection\emit\ilgenerator.cs (2)

838public virtual void Emit(OpCode opcode, FieldInfo field) 1222public virtual void EmitWriteLine(FieldInfo fld)

system\reflection\emit\modulebuilder.cs (6)

1022public override FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) 1076public override FieldInfo[] GetFields(BindingFlags bindingFlags) 1081public override FieldInfo GetField(String name, BindingFlags bindingAttr) 2107public FieldToken GetFieldToken(FieldInfo field) 2116private FieldToken GetFieldTokenNoLock(FieldInfo field) 2180FieldInfo fb = fOnTB.FieldInfo;

system\reflection\emit\symboltype.cs (2)

443public override FieldInfo GetField(String name, BindingFlags bindingAttr) 448public override FieldInfo[] GetFields(BindingFlags bindingAttr)

system\reflection\emit\typebuilder.cs (4)

151public static FieldInfo GetField(Type type, FieldInfo field) 1171public override FieldInfo GetField(String name, BindingFlags bindingAttr) 1180public override FieldInfo[] GetFields(BindingFlags bindingAttr)

system\reflection\emit\typebuilderinstantiation.cs (2)

177public override FieldInfo GetField(String name, BindingFlags bindingAttr) { throw new NotSupportedException(); } 178public override FieldInfo[] GetFields(BindingFlags bindingAttr) { throw new NotSupportedException(); }

system\reflection\emit\xxxontypebuilderinstantiation.cs (7)

200internal static FieldInfo GetField(FieldInfo Field, TypeBuilderInstantiation type) 202FieldInfo m = null; 217m = type.m_hashtable[Field] as FieldInfo; 229private FieldInfo m_field; 234internal FieldOnTypeBuilderInstantiation(FieldInfo field, TypeBuilderInstantiation type) 243internal FieldInfo FieldInfo { get { return m_field; } }

system\reflection\fieldinfo.cs (7)

38public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle) 43FieldInfo f = RuntimeType.GetFieldInfo(handle.GetRuntimeFieldInfo()); 55public static FieldInfo GetFieldFromHandle(RuntimeFieldHandle handle, RuntimeTypeHandle declaringType) 69public static bool operator ==(FieldInfo left, FieldInfo right) 82public static bool operator !=(FieldInfo left, FieldInfo right)

system\reflection\ireflect.cs (2)

46FieldInfo GetField( 50FieldInfo[] GetFields(

system\reflection\memberinfo.cs (3)

93FieldInfo field1, field2; 101else if ((field1 = left as FieldInfo) != null && (field2 = right as FieldInfo) != null)

system\reflection\memberinfoserializationholder.cs (2)

114FieldInfo[] fields = m_reflectedType.GetMember(m_memberName, MemberTypes.Field, bindingFlags) as FieldInfo[];

system\reflection\module.cs (11)

180public FieldInfo ResolveField(int metadataToken) 185public virtual FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) 387public FieldInfo[] GetFields() 392public virtual FieldInfo[] GetFields(BindingFlags bindingFlags) 404public FieldInfo GetField(String name) 409public virtual FieldInfo GetField(String name, BindingFlags bindingAttr) 744private FieldInfo ResolveLiteralField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) 776public override FieldInfo ResolveField(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) 1153public override FieldInfo[] GetFields(BindingFlags bindingFlags) 1156return new FieldInfo[0]; 1161public override FieldInfo GetField(String name, BindingFlags bindingAttr)

system\reflection\RuntimeReflectionExtensions.cs (2)

39public static IEnumerable<FieldInfo> GetRuntimeFields(this Type type) 60public static FieldInfo GetRuntimeField(this Type type, string name)

system\reflection\typedelegator.cs (2)

116public override FieldInfo GetField(String name, BindingFlags bindingAttr) 121public override FieldInfo[] GetFields(BindingFlags bindingAttr)

system\reflection\typeinfo.cs (2)

89public virtual FieldInfo GetDeclaredField(String name) 142public virtual IEnumerable<FieldInfo> DeclaredFields

system\rttype.cs (18)

355internal FieldInfo AddField(RuntimeFieldHandleInternal field) 374return (FieldInfo)(object)list[0]; 1923internal FieldInfo GetField(RuntimeFieldHandleInternal field) 2146internal unsafe static FieldInfo GetFieldInfo(IRuntimeFieldInfo fieldHandle) 2152internal unsafe static FieldInfo GetFieldInfo(RuntimeType reflectedType, IRuntimeFieldInfo field) 2177FieldInfo retVal = reflectedType.Cache.GetField(fieldHandle); 2992private ListBuilder<FieldInfo> GetFieldCandidates(String name, BindingFlags bindingAttr, bool allowPrefixLookup) 3002ListBuilder<FieldInfo> candidates = new ListBuilder<FieldInfo>(cache.Length); 3097public override FieldInfo[] GetFields(BindingFlags bindingAttr) 3124ListBuilder<FieldInfo> fields = GetFieldCandidates(null, bindingAttr, false); 3350public override FieldInfo GetField(String name, BindingFlags bindingAttr) 3360FieldInfo match = null; 3466ListBuilder<FieldInfo> fields = new ListBuilder<FieldInfo>(); 4685FieldInfo selFld = null; 4686FieldInfo[] flds = GetMember(name, MemberTypes.Field, bindingFlags) as FieldInfo[];

system\runtime\interopservices\ComTypes\iexpando.cs (1)

27FieldInfo AddField(String name);

system\runtime\interopservices\ComTypes\ireflect.cs (2)

36FieldInfo GetField( 40FieldInfo[] GetFields(

system\runtime\interopservices\expando\iexpando.cs (1)

28FieldInfo AddField(String name);

system\runtime\interopservices\marshal.cs (1)

285FieldInfo f = t.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

system\runtime\interopservices\tceadaptergen\eventproviderwriter.cs (5)

99FieldInfo DelegateField = SinkHelperClass.GetField( "m_" + SrcItfMethod.Name + "Delegate" ); 103FieldInfo CookieField = SinkHelperClass.GetField( "m_dwCookie" ); 242FieldInfo DelegateField = SinkHelperClass.GetField( "m_" + SrcItfMethod.Name + "Delegate" ); 246FieldInfo CookieField = SinkHelperClass.GetField( "m_dwCookie" ); 587FieldInfo CookieField = SinkHelperClass.GetField( "m_dwCookie" );

system\runtime\interopservices\ucomiexpando.cs (1)

29FieldInfo AddField(String name);

system\runtime\interopservices\ucomireflect.cs (2)

37FieldInfo GetField( 41FieldInfo[] GetFields(

system\runtime\remoting\remotingattributes.cs (2)

53private FieldInfo RI; // reflection structure on which this data structure is stored 847_xmlElementName = ((FieldInfo)ReflectInfo).Name;

system\runtime\remoting\soap.cs (1)

201foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly))

system\runtime\serialization\formatters\binary\binaryobjectinfo.cs (4)

403if (objMember is FieldInfo) 405objectType = ((FieldInfo)objMember).FieldType; 875if (objMember is FieldInfo) 877objectType = ((FieldInfo)objMember).FieldType;

system\runtime\serialization\formatters\sertrace.cs (1)

105public static void SerializationSetValue(FieldInfo fi, Object target, Object value)

system\runtime\serialization\formatterservices.cs (6)

54FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); 62FieldInfo[] properFields = new FieldInfo[countProper]; 86FieldInfo [] typeFields; 122foreach (FieldInfo field in typeFields) { 366members[i].Name, " with member type: ", ((FieldInfo)members[i]).FieldType);

system\runtime\serialization\objectmanager.cs (19)

352private bool DoValueTypeFixup(FieldInfo memberToFix, ObjectHolder holder, Object value) { 354FieldInfo[] fieldsTemp=new FieldInfo[4]; 355FieldInfo[] fields=null; 374FieldInfo[] temp = new FieldInfo[fieldsTemp.Length * 2]; 387FieldInfo parentField = currFixup.ParentField; 438fields = new FieldInfo[currentFieldIndex]; 440FieldInfo fieldInfo = fieldsTemp[(currentFieldIndex - 1 - i)]; 474void DumpValueTypeFixup(object obj, FieldInfo[] intermediateFields, FieldInfo memberToFix, object value){ 603if (!DoValueTypeFixup((FieldInfo)tempMember, holder, tempObjectHolder.ObjectValue)) { 731Contract.Assert(member == null || member is FieldInfo, "RegisterString - member is FieldInfo"); 734temp = new ObjectHolder(obj, objectID, info, null, idOfContainingObj, (FieldInfo)member, null); 791temp = new ObjectHolder(obj, objectID, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex); 807temp.UpdateData(obj, info, surrogate, idOfContainingObj, (FieldInfo)member, arrayIndex, this); 1172ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex) { 1206ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex) { 1333internal void UpdateData(Object obj, SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainer, FieldInfo field, int[] arrayIndex, ObjectManager manager) {

system\runtime\serialization\valuetypefixupinfo.cs (5)

31private FieldInfo m_parentField; 37public ValueTypeFixupInfo(long containerID, FieldInfo member, int[] parentIndex) { 60if (((((FieldInfo)member).FieldType).IsValueType) && containerID==0) { 66m_parentField = (FieldInfo)member; 76public FieldInfo ParentField {

system\runtimehandles.cs (1)

1799FieldInfo f =(RuntimeFieldInfo) info.GetValue("FieldObj", typeof(RuntimeFieldInfo));

system\type.cs (7)

569abstract public FieldInfo GetField(String name, BindingFlags bindingAttr); 572public FieldInfo GetField(String name) { 579public FieldInfo[] GetFields() { 582abstract public FieldInfo[] GetFields(BindingFlags bindingAttr); 796FieldInfo[] f = null; 1424FieldInfo[] flds = GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); 1474FieldInfo[] fields = GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

system\typedreference.cs (2)

14using FieldInfo = System.Reflection.FieldInfo; 29public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds) {

system\valuetype.cs (1)

46FieldInfo[] thisFields = thisType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

BuildTasks\Ms\Internal\MarkupCompiler\MarkupCompiler.cs (2)

1779if (desc.MemberInfo is FieldInfo || desc.MemberInfo is PropertyInfo) 1860FieldInfo fiEvent = miEvent.DeclaringType.GetField(eventName + EVENT, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

Framework\System\Windows\Markup\BamlRecords.cs (1)

2612FieldInfo enumField = ValueType.GetField(enumValue.Trim(), BindingFlags.Static | BindingFlags.Public | BindingFlags.IgnoreCase);

Framework\System\Windows\Markup\XamlTypeMapper.cs (2)

1095private bool IsAllowedField(FieldInfo fi) 2441isAllowed = IsAllowedField(mi as FieldInfo);

src\Framework\MS\Internal\Interop\InternalDispatchObject.cs (2)

84FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr) 88FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr)

src\Framework\MS\Internal\LayoutDump.cs (2)

907System.Reflection.FieldInfo field = paragraphResultType.GetField("_paraClient", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); 952System.Reflection.FieldInfo fieldOfParaClient = paragraphResultType.GetField("_paraClient",

src\Framework\MS\Internal\SystemDataHelper.cs (1)

75FieldInfo nullField = type.GetField("Null", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

src\Framework\System\Windows\Input\Command\CommandConverter.cs (1)

158FieldInfo fieldInfo = ownerType.GetField(localName, BindingFlags.Static | BindingFlags.Public);

src\Framework\System\Windows\Input\Command\CommandValueSerializer.cs (1)

54FieldInfo fieldInfo = ownerType.GetField(localName, BindingFlags.Static | BindingFlags.Public);

src\Framework\System\Windows\Markup\BamlRecords.cs (1)

2612FieldInfo enumField = ValueType.GetField(enumValue.Trim(), BindingFlags.Static | BindingFlags.Public | BindingFlags.IgnoreCase);

src\Framework\System\Windows\Standard\ErrorCodes.cs (2)

357foreach (FieldInfo publicStaticField in typeof(HRESULT).GetFields(BindingFlags.Static | BindingFlags.Public)) 372foreach (FieldInfo publicStaticField in typeof(Win32Error).GetFields(BindingFlags.Static | BindingFlags.Public))

src\Shared\MS\Internal\WindowsRuntime\ReflectionHelper.cs (1)

281FieldInfo fieldInfo;

compmod\system\componentmodel\AttributeCollection.cs (1)

331System.Reflection.FieldInfo field = reflect.GetField("Default", BindingFlags.Public | BindingFlags.Static | BindingFlags.GetField);

compmod\system\componentmodel\design\serialization\InstanceDescriptor.cs (5)

49if (member is FieldInfo) { 50FieldInfo fi = (FieldInfo)member; 146else if (member is FieldInfo) { 147return ((FieldInfo)member).GetValue(null);

compmod\system\componentmodel\EnumConverter.cs (3)

192FieldInfo info = type.GetField(enumName); 256FieldInfo[] fields = reflectType.GetFields(BindingFlags.Public | BindingFlags.Static); 264foreach (FieldInfo field in fields) {

misc\SecurityUtils.cs (1)

199internal static object FieldInfoGetValue(FieldInfo field, object target) {

net\System\Net\_AutoWebProxyScriptHelper.cs (3)

208FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr) { 212FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) { 214return new FieldInfo[0];

regex\system\text\regularexpressions\RegexCompiler.cs (25)

System\Activities\Expressions\ExpressionServices.cs (8)

370if (member.Member is FieldInfo) 372FieldInfo field = member.Member as FieldInfo; 517if (member.Member is FieldInfo) 519FieldInfo field = member.Member as FieldInfo; 1057else if (memberExpressionBody.Member is FieldInfo) 1148if (memberExpressionBody.Member is FieldInfo)

System\Activities\Expressions\FieldReference.cs (4)

14FieldInfo fieldInfo; 81FieldInfo fieldInfo; 85public FieldLocation(FieldInfo fieldInfo, object owner) 129internal FieldInfo SerializedFieldInfo

System\Activities\Expressions\FieldValue.cs (1)

46FieldInfo fieldInfo = null;

System\Activities\Expressions\ValueTypeFieldReference.cs (4)

14FieldInfo fieldInfo; 78FieldInfo fieldInfo; 82public FieldLocation(FieldInfo fieldInfo, Location<TOperand> ownerLocation) 104internal FieldInfo SerializedFieldInfo

System\Activities\ExpressionUtilities.cs (9)

96FieldInfo fieldInfo = (FieldInfo)memberExpression.Member; 336FieldInfo fieldInfo; 346this.fieldInfo = (FieldInfo)memberExpression.Member; 384FieldInfo fieldInfo; 390public FieldLocation(FieldInfo fieldInfo, object owner, Location parent) 430internal FieldInfo SerializedFieldInfo 1610FieldInfo fieldInfo = memberInfo as FieldInfo;

System\Activities\Statements\MethodResolver.cs (2)

424public override FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo culture)

System\ServiceModel\Activities\Presentation\TypeToTreeConverter.cs (2)

35else if (value is FieldInfo) 37type = ((FieldInfo)value).FieldType;

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (2)

1081public override FieldInfo GetField(string name, BindingFlags bindingAttr) { return _baseReflectionType.GetField(name, bindingAttr); } 1082public override FieldInfo[] GetFields(BindingFlags bindingAttr) { return _baseReflectionType.GetFields(bindingAttr); }

Microsoft\Scripting\Ast\Expression.cs (2)

403FieldInfo field = (FieldInfo)member.Member;

Microsoft\Scripting\Ast\MemberAssignment.cs (2)

96FieldInfo fi = member as FieldInfo;

Microsoft\Scripting\Ast\MemberExpression.cs (10)

62FieldInfo fi = (FieldInfo)member; 105private readonly FieldInfo _field; 107public FieldExpression(Expression expression, FieldInfo member) 148public static MemberExpression Field(Expression expression, FieldInfo field) { 173FieldInfo fi = expression.Type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy); 196FieldInfo fi = type.GetField(fieldName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy); 335FieldInfo fi = expression.Type.GetField(propertyOrFieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy); 357FieldInfo fi = member as FieldInfo;

Microsoft\Scripting\Ast\MemberMemberBinding.cs (2)

130FieldInfo fi = member as FieldInfo;

Microsoft\Scripting\Ast\NewExpression.cs (2)

301FieldInfo field = member as FieldInfo;

Microsoft\Scripting\Compiler\CompilerScope.Storage.cs (2)

101private readonly FieldInfo _boxValueField; 147private readonly FieldInfo _boxValueField;

Microsoft\Scripting\Compiler\ILGen.cs (3)

264internal static void EmitFieldAddress(this ILGenerator il, FieldInfo fi) { 274internal static void EmitFieldGet(this ILGenerator il, FieldInfo fi) { 284internal static void EmitFieldSet(this ILGenerator il, FieldInfo fi) {

Microsoft\Scripting\Compiler\LambdaCompiler.Address.cs (2)

131FieldInfo field = (FieldInfo)member;

Microsoft\Scripting\Compiler\LambdaCompiler.Expressions.cs (7)

671_ilg.EmitFieldSet((FieldInfo)member); 702FieldInfo fi = (FieldInfo)member; 799FieldInfo fi = binding.Member as FieldInfo; 911FieldInfo fi = member as FieldInfo;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (2)

1081public override FieldInfo GetField(string name, BindingFlags bindingAttr) { return _baseReflectionType.GetField(name, bindingAttr); } 1082public override FieldInfo[] GetFields(BindingFlags bindingAttr) { return _baseReflectionType.GetFields(bindingAttr); }

fx\src\data\Microsoft\SqlServer\Server\SmiContextFactory.cs (5)

49System.Reflection.FieldInfo instanceField = GetStaticField(smiLinkType, "Instance"); 58System.Reflection.FieldInfo buildVersionField = GetStaticField(smiLinkType, "BuildVersion"); 124private object GetValue(System.Reflection.FieldInfo fieldInfo) { 130private System.Reflection.FieldInfo GetStaticField(Type aType, string fieldName) { 131System.Reflection.FieldInfo result = aType.GetField(fieldName, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.GetField);

fx\src\data\System\Data\Common\DbProviderFactories.cs (3)

fx\src\data\System\Data\Common\GreenMethods.cs (1)

32private static FieldInfo SystemDataSqlClientSqlProviderServices_Instance_FieldInfo;

fx\src\data\System\Data\Common\SQLTypes\SqlUDTStorage.cs (1)

50System.Reflection.FieldInfo fieldInfo = type.GetField("Null", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);

fx\src\data\System\Data\Sql\sqlnorm.cs (34)

System\Data\Common\Internal\Materialization\CoordinatorScratchpad.cs (2)

472var fieldInfo = assignment.Member as FieldInfo;

System\Data\Objects\ELinq\Funcletizer.cs (1)

733memberValue = ((FieldInfo)me.Member).GetValue(instance);

System\Data\Objects\ELinq\TypeSystem.cs (2)

114FieldInfo field = (FieldInfo)member;

System\Data\Objects\Internal\EntityProxyFactory.cs (4)

463FieldInfo interceptorField = proxyType.GetField(LazyLoadImplementor.GetInterceptorFieldName(member.Name), BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.NonPublic); 486private static void AssignInterceptionDelegate(Delegate interceptorDelegate, FieldInfo interceptorField) 497var resetFKSetterFlagField = proxyType.GetField(ResetFKSetterFlagFieldName, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.NonPublic); 541var compareByteArraysField = proxyType.GetField(CompareByteArraysFieldName, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.NonPublic);

System\Data\Objects\Internal\EntityProxyTypeInfo.cs (1)

76FieldInfo entityWrapperField = proxyType.GetField(EntityWrapperFieldName, BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);

System\Data\Objects\Internal\PocoPropertyAccessorStrategy.cs (1)

125FieldInfo field = entityType.GetField(propertyName);

System\Data\EntityModel\Emitters\Utils.cs (3)

110else if(member is FieldInfo) 112return ShouldReserveName((FieldInfo)member); 168private static bool ShouldReserveName(FieldInfo member)

ChangeDirector.cs (2)

412FieldInfo fi = mi as FieldInfo;

DataContext.cs (2)

417FieldInfo[] fields = schema.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance); 418foreach (FieldInfo fi in fields) {

DataServices.cs (3)

220Expression memberExpression = (metaMember.Member is FieldInfo) 221? Expression.Field(serverItem, (FieldInfo)metaMember.Member) 264: Expression.Field(e, (FieldInfo)member.Member);

Mapping\Accessors.cs (3)

22internal static MetaAccessor Create(Type objectType, FieldInfo fi) { 67FieldInfo fi; 69internal Accessor(FieldInfo fi, DGet<T, V> dget, DRSet<T, V> drset) {

Mapping\AttributedMetaModel.cs (6)

131FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); 132foreach (FieldInfo fi in fields) { 602FieldInfo[] fis = TypeSystem.GetAllFields(this.type, flags).ToArray(); 605FieldInfo fi = fis[i]; 1263FieldInfo fi = mi as FieldInfo;

Mapping\MappedMetaModel.cs (9)

95FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); 96foreach (FieldInfo fi in fields) { 650FieldInfo[] fis = TypeSystem.GetAllFields(this.type, flags).ToArray(); 652foreach (FieldInfo fi in fis) { 1168FieldInfo fi = mi as FieldInfo; 1667foreach (FieldInfo fi in this.type.GetFields(flags)) { 1817FieldInfo fi = mi as FieldInfo;

parent\parent\misc\SecurityUtils.cs (1)

199internal static object FieldInfoGetValue(FieldInfo field, object target) {

SqlClient\Common\InheritanceRules.cs (2)

29FieldInfo fi = mi as FieldInfo;

SqlClient\Common\TypeSystem.cs (6)

73FieldInfo fi = mi as FieldInfo; 81internal static IEnumerable<FieldInfo> GetAllFields(Type type, BindingFlags flags) { 82Dictionary<MetaPosition, FieldInfo> seen = new Dictionary<MetaPosition, FieldInfo>(); 85foreach (FieldInfo fi in currentType.GetFields(flags)) {

SqlClient\Query\SqlBinder.cs (2)

923FieldInfo f = (FieldInfo)m.Member;

SqlClient\Query\Translator.cs (4)

172Expression memberExpression = (metaMember.Member is FieldInfo) 173? Expression.Field(parameterAsDeclaring, (FieldInfo)metaMember.Member) 487FieldInfo fi = mi as FieldInfo;

SqlClient\Reader\ObjectReaderCompiler.cs (16)

99FieldInfo readerField; 100FieldInfo bufferReaderField; 102FieldInfo ordinalsField; 103FieldInfo globalsField; 104FieldInfo argsField; 880FieldInfo fi = m.Member as FieldInfo; 1144FieldInfo fi = member as FieldInfo; 1184if (m is FieldInfo || (m is PropertyInfo && ((PropertyInfo)m).CanWrite)) { 1246if (m is FieldInfo || (m is PropertyInfo && ((PropertyInfo)m).CanWrite)) { 2163FieldInfo fi = varType.GetField("Value", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); 2191FieldInfo fi = mi as FieldInfo; 2204FieldInfo fi = mi as FieldInfo;

System\Data\Services\Client\ALinq\ExpressionWriter.cs (1)

259if (m.Member is FieldInfo)

System\Data\Services\Client\ALinq\ProjectionAnalyzer.cs (2)

514FieldInfo fieldInfo = member as FieldInfo;

System\Data\EntityModel\Emitters\Utils.cs (3)

96else if (member is FieldInfo) 98return ShouldReserveName((FieldInfo)member); 154private static bool ShouldReserveName(FieldInfo member)

System\Xml\Xsl\IlGen\GenerateHelper.cs (2)

46public FieldInfo SeqEmpty; 1508public void Emit(OpCode opcode, FieldInfo fldInfo) {

System\Xml\Xsl\IlGen\XmlILModule.cs (2)

253public FieldInfo DefineInitializedData(string name, byte[] data) { 261public FieldInfo DefineField(string fieldName, Type type) {

System\Xml\Xsl\XmlIlGenerator.cs (1)

336FieldInfo fldInitData, fldData, fldTypes;

Instrumentation\Instrumentation.cs (1)

428 FieldInfo fieldInfo = null ;

Instrumentation\SchemaMapping.cs (6)

209 if(!(field is FieldInfo || field is PropertyInfo)) 215 if(field is FieldInfo) 217 FieldInfo fi = field as FieldInfo; 247 if(field is FieldInfo) 248 t2 = (field as FieldInfo).FieldType;

Instrumentation\SchemaRegistration.cs (1)

343 references.Add(typeof(System.Reflection.FieldInfo));

metadata\wsdlwriter.cs (11)

307FieldInfo[] fields = rsType.GetInstanceFields(); 332FieldInfo[] fields = rsType.GetInstanceFields(); 1436internal FieldInfo[] GetInstanceFields(){ 1639FieldInfo field = _fields[i]; 2512static private FieldInfo[] GetInstanceFields(Type type){ 2521FieldInfo[] fields = type.GetFields(bFlags); 2542FieldInfo[] ifields = new FieldInfo[actualLength]; 2565private FieldInfo[] _fields; 2572private static FieldInfo[] emptyFieldSet = new FieldInfo[0];

System\Runtime\Serialization\ClassDataContract.cs (6)

539if (this.Members[i].MemberInfo is FieldInfo) 625if (this.Members[i].MemberInfo is FieldInfo) 930FieldInfo field = member as FieldInfo; 975FieldInfo field = member as FieldInfo;

System\Runtime\Serialization\CodeGenerator.cs (4)

741FieldInfo fieldInfo = (FieldInfo)memberInfo; 785FieldInfo fieldInfo = (FieldInfo)memberInfo;

System\Runtime\Serialization\DataContract.cs (4)

2385static internal bool FieldRequiresMemberAccess(FieldInfo field) 2413else if (member is FieldInfo) 2415FieldInfo field = (FieldInfo)member;

System\Runtime\Serialization\DataMember.cs (6)

220FieldInfo field = MemberInfo as FieldInfo; 272FieldInfo field = memberInfo as FieldInfo; 293FieldInfo field = memberInfo as FieldInfo;

System\Runtime\Serialization\EnumDataContract.cs (2)

272FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public); 279FieldInfo field = fields[i];

System\Runtime\Serialization\XmlFormatGeneratorStatics.cs (4)

896static FieldInfo contractNamespacesField; 897internal static FieldInfo ContractNamespacesField 909static FieldInfo memberNamesField; 910internal static FieldInfo MemberNamesField

System\ServiceModel\Description\OperationGenerator.cs (2)

1006FieldInfo field = member as FieldInfo;

System\ServiceModel\Description\TypeLoader.cs (1)

1313memberType = ((FieldInfo)memberInfo).FieldType;

System\ServiceModel\Description\XmlSerializerOperationBehavior.cs (1)

555part.Type = (member.MemberType == MemberTypes.Property) ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType;

System\ServiceModel\Dispatcher\OperationFormatter.cs (2)

597return ((FieldInfo)members[index]).GetValue(instance); 610((FieldInfo)members[index]).SetValue(instance, value);

System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (4)

296FieldInfo field = member as FieldInfo; 354FieldInfo field = member as FieldInfo;

Compilation\ClientBuildManagerTypeDescriptionProviderBridge.cs (2)

57FieldInfo runtimeFieldInfo = type.GetField(name, bindingAttr); 62FieldInfo reflectionFieldInfo = reflectionType.GetField(name, bindingAttr);

Compilation\CodeDOMUtility.cs (1)

103if (desc.MemberInfo is FieldInfo) {

Compilation\DelayLoadType.cs (2)

104public override FieldInfo GetField(string name, BindingFlags bindingAttr) { 108public override FieldInfo[] GetFields(BindingFlags bindingAttr) {

parent\parent\parent\Misc\SecurityUtils.cs (1)

199internal static object FieldInfoGetValue(FieldInfo field, object target) {

UI\ControlBuilder.cs (9)

827Debug.Assert(memberInfo is FieldInfo); 828entry.Type = ((FieldInfo)memberInfo).FieldType; 915Debug.Assert(memberInfo is FieldInfo); 916memberType = ((FieldInfo)memberInfo).FieldType; 1019Debug.Assert(memberInfo is FieldInfo); 1020memberType = ((FieldInfo)memberInfo).FieldType; 1182Debug.Assert(memberInfo is FieldInfo); 1183memberType = ((FieldInfo)memberInfo).FieldType; 2524FieldInfo fieldInfo = TargetFrameworkUtil.GetField(templateControl.GetType(), control.ID,

UI\PropertyMapper.cs (1)

41FieldInfo fieldInfo = null;

UI\TargetFrameworkUtil.cs (7)

21private ConcurrentDictionary<Tuple<string, int>, FieldInfo> _fields; 35internal ConcurrentDictionary<Tuple<string, int>, FieldInfo> Fields { 38_fields = new ConcurrentDictionary<Tuple<string, int>, FieldInfo>(); 224internal static FieldInfo GetField(Type type, string name, BindingFlags bindingAttr) { 229FieldInfo result = null; 241private static FieldInfo GetFieldInfo(Type type, string name, BindingFlags bindingAttr) { 252FieldInfo fieldInfo = targetFrameworkType.GetField(name, bindingAttr);

UI\Util.cs (1)

562FieldInfo fieldInfo = classType.GetField(fieldName,

Util\FastPropertyAccessor.cs (5)

63PropertyInfo propInfo, FieldInfo fieldInfo) { 255private static void GetPropertyInfo(Type type, string propertyName, out PropertyInfo propInfo, out FieldInfo fieldInfo, out Type declaringType) { 322FieldInfo fieldInfo = null; 384FieldInfo fieldInfo = null; 424FieldInfo fieldInfo = null;

Util\ReflectionUtil.cs (2)

32FieldInfo[] allFields = targetType.GetFields(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public); 33foreach (FieldInfo fieldInfo in allFields) {

Script\Serialization\JavaScriptSerializer.cs (2)

249FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance); 250foreach (FieldInfo fieldInfo in fields) {

Script\Serialization\ObjectConverter.cs (1)

81FieldInfo fieldInfo = serverType.GetField(memberName,

UI\WebControls\ContextDataSourceView.cs (1)

128return ((FieldInfo)mi).FieldType;

UI\WebControls\Dynamic.cs (9)

321FieldInfo[] fields = GenerateProperties(tb, properties); 335FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties) { 336FieldInfo[] fields = new FieldBuilder[properties.Length]; 363void GenerateEquals(TypeBuilder tb, FieldInfo[] fields) { 379foreach (FieldInfo field in fields) { 398void GenerateGetHashCode(TypeBuilder tb, FieldInfo[] fields) { 405foreach (FieldInfo field in fields) { 1210Expression.Field(instance, (FieldInfo)member); 1586if (memberInfos.Length != 0) return ((FieldInfo)memberInfos[0]).GetValue(null);

UI\WebControls\LinqDataSourceView.cs (4)

376FieldInfo field = tableMemberInfo as FieldInfo; 705FieldInfo field = member as FieldInfo;

System\Web\Services\Protocols\PatternMatcher.cs (9)

72if (memberInfo is FieldInfo) 73((FieldInfo)memberInfo).SetValue(target, matchType == null ? MatchString(text) : MatchClass(text)); 81Type fieldType = memberInfo is FieldInfo ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType; 115Type fieldType = memberInfo is FieldInfo ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType; 173if (memberInfo is FieldInfo) { 174FieldInfo fieldInfo = (FieldInfo)memberInfo;

System\Web\Services\Protocols\Scalars.cs (8)

295if (memberInfo is FieldInfo ) { 296((FieldInfo)memberInfo).SetValue(target, value); 304if (memberInfo is FieldInfo) { 305return ((FieldInfo)memberInfo).GetValue(target); 313if (memberInfo is FieldInfo) 314return ((FieldInfo)memberInfo).IsStatic; 320if (memberInfo is FieldInfo) 327if (memberInfo is FieldInfo)

System\Web\Services\Protocols\SoapReflector.cs (1)

454soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType;

misc\SecurityUtils.cs (1)

199internal static object FieldInfoGetValue(FieldInfo field, object target) {

winforms\Managed\System\WinForms\AccessibleObject.cs (4)

2514FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr) { 2520FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) { 3287FieldInfo IReflect.GetField(string name, BindingFlags bindingAttr) { 3291FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) {

winforms\Managed\System\WinForms\AxHost.cs (9)

4008FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) { 4012FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) { 4013return new FieldInfo[0]; 5294FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) { 5298FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) { 5299return new FieldInfo[0]; 6373FieldInfo IReflect.GetField(String name, BindingFlags bindingAttr) { 6377FieldInfo[] IReflect.GetFields(BindingFlags bindingAttr) { 6378return new FieldInfo[0];

winforms\Managed\System\WinForms\ComponentModel\COM2Interop\COM2IManagedPerPropertyBrowsingHandler.cs (1)

132FieldInfo fi = t.GetField(fieldName);

winforms\Managed\System\WinForms\FeatureSupport.cs (2)

53FieldInfo fi = c.GetField(featureConstName); 88FieldInfo fi = c.GetField(featureConstName);

winforms\Managed\System\WinForms\HtmlToClrEventProxy.cs (2)

72System.Reflection.FieldInfo IReflect.GetField(string name, System.Reflection.BindingFlags bindingAttr) { 75System.Reflection.FieldInfo[] IReflect.GetFields(System.Reflection.BindingFlags bindingAttr) {

CorrelationValidator.cs (2)

780FieldInfo[] publicFields = correlationParameterType.GetFields(); 781foreach (FieldInfo fieldInfo in publicFields)

LocalService\CorrelationResolver.cs (1)

195type = ((FieldInfo)mInfo).FieldType;

LocalService\DataExchangeServiceBinder.cs (2)

76public override FieldInfo BindToField(BindingFlags bindingAttr, 77FieldInfo[] match,

Rules\Design\Dialogs\IntellisenseTextBox.cs (3)

371else if (item is FieldInfo) 373FieldInfo fi = (FieldInfo)item;

Rules\Executor.cs (2)

48private FieldInfo fieldInfo; 50public RuleFieldResult(object targetObject, FieldInfo fieldInfo)

Rules\Expressions.cs (2)

944FieldInfo fi = targetType.GetField(fieldRefExpr.FieldName, bindingFlags); 1002FieldInfo fi = fieldExprInfo.FieldInfo;

Rules\Parser\Parser.cs (5)

311if (member.DeclaringType == thisType || IsNonPrivate((FieldInfo)member, thisType)) 486FieldInfo fieldInfo, Type thisType) 822if (mi.DeclaringType == thisType || ParserContext.IsNonPrivate((FieldInfo)mi, thisType)) 1621FieldInfo fieldInfo = member as FieldInfo;

Rules\RuleAction.cs (1)

138FieldInfo field = currentType.GetField(parts[i], bindingFlags);

Rules\RuleAttributes.cs (1)

140FieldInfo field = currentType.GetField(parts[i], bindingFlags);

Rules\RuleValidation.cs (6)

105private FieldInfo fieldInfo; 107internal RuleFieldExpressionInfo(FieldInfo fi) 113internal FieldInfo FieldInfo 1015internal static bool IsPrivate(FieldInfo fieldInfo) 1029internal static bool IsInternal(FieldInfo fieldInfo) 2285CodeExpression targetExpression, Type targetType, FieldInfo accessorMethod, string memberName, CodeExpression parentExpr)

AuthoringOM\Bind.cs (14)

101memberType = (eventArgs.MemberInfo as FieldInfo).FieldType; 102targetObject = (eventArgs.MemberInfo as FieldInfo).GetValue(targetObject); 209obj = (eventArgs.MemberInfo as FieldInfo).GetValue(parentObj); 235if (memberInfo is FieldInfo) 237(memberInfo as FieldInfo).SetValue(parentObj, value); 276if (memberInfo is FieldInfo) 277memberType = ((FieldInfo)memberInfo).FieldType; 709if (memberInfo is FieldInfo || memberInfo is PropertyInfo || memberInfo is EventInfo) 795if (memberInfo is FieldInfo || memberInfo is PropertyInfo || memberInfo is EventInfo) 852else if (memberInfo is FieldInfo) 1049value = (eventArgs.MemberInfo as FieldInfo).GetValue(value); 1239FieldInfo fieldInfo = memberInfo as FieldInfo; 1526newPropertyType = (newMemberInfo as FieldInfo).FieldType;

AuthoringOM\Compiler\TypeSystem\DesignTimeType.cs (18)

28private FieldInfo[] fields = null; 391public override FieldInfo GetField(string name, BindingFlags bindingAttr) 393return GetMemberHelper<FieldInfo>(bindingAttr, new MemberSignature(name, null, null), ref this.fields); 396public override FieldInfo[] GetFields(BindingFlags bindingAttr) 398return GetMembersHelper<FieldInfo>(bindingAttr, ref this.fields, true); 436members.AddRange(GetMembersHelper<FieldInfo>(bindingAttr, new MemberSignature(name, null, null), ref this.fields)); 722else if (memberInfo is FieldInfo) 724isPublic = (memberInfo as FieldInfo).IsPublic; 725isStatic = (memberInfo as FieldInfo).IsStatic; 786if ((memberInfo is FieldInfo && (memberInfo as FieldInfo).IsPrivate) || (memberInfo is MethodBase && (memberInfo as MethodBase).IsPrivate) || (memberInfo is Type && (memberInfo as Type).IsNestedPrivate)) 813else if (type == typeof(FieldInfo)) 867if ((memberInfo is FieldInfo && (memberInfo as FieldInfo).IsPrivate) || (memberInfo is MethodBase && (memberInfo as MethodBase).IsPrivate) || (memberInfo is Type && (memberInfo as Type).IsNestedPrivate)) 906else if (typeof(FieldInfo).IsAssignableFrom(type)) 1046else if ((type == typeof(FieldInfo)) && (this.fields == null)) 1047this.fields = GetCodeDomMembers<FieldInfo>().ToArray(); 1186else if ((memberInfoType == typeof(FieldInfo)) && (member is CodeMemberField))

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (14)

326public override FieldInfo GetField(string name, BindingFlags bindingAttr) 328FieldInfo field = this.runtimeType.GetField(name, bindingAttr); 333public override FieldInfo[] GetFields(BindingFlags bindingAttr) 335List<FieldInfo> fieldInfos = new List<FieldInfo>(); 336foreach (FieldInfo fieldInfo in this.runtimeType.GetFields(bindingAttr)) 466else if (memberInfo is FieldInfo) 467returnMemberInfo = EnsureFieldWrapped(memberInfo as FieldInfo); 493private FieldInfo EnsureFieldWrapped(FieldInfo realInfo) 495FieldInfo wrapperInfo = (FieldInfo)this.memberMapping[realInfo]; 876private FieldInfo fieldInfo = null; 877public RTFieldInfoWrapper(RTTypeWrapper rtTypeWrapper, FieldInfo fieldInfo)

AuthoringOM\Compiler\TypeSystem\TypeProvider.cs (1)

796FieldInfo[] flds = enumType.GetFields();

AuthoringOM\Compiler\Validation\BindValidator.cs (16)

118FieldInfo fieldInfo = resolvedType.GetField(dsName, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy); 172Type memberType = (memberInfo is FieldInfo ? (memberInfo as FieldInfo).FieldType : (memberInfo as PropertyInfo).PropertyType); 197else if (memberInfo is FieldInfo) 199FieldInfo pathFieldInfo = memberInfo as FieldInfo; 369Type memberType = (memberInfo is FieldInfo ? (memberInfo as FieldInfo).FieldType : (memberInfo as PropertyInfo).PropertyType); 394else if (memberInfo is FieldInfo) 396FieldInfo pathFieldInfo = memberInfo as FieldInfo; 673if (memberInfo is FieldInfo) 853if (memberInfo is FieldInfo) 854memberType = ((FieldInfo)(memberInfo)).FieldType; 891if (memberInfo is FieldInfo) 892memberType = ((FieldInfo)(memberInfo)).FieldType;

AuthoringOM\DependencyProperty.cs (1)

178FieldInfo fieldInfo = null;

AuthoringOM\Design\CustomActivityDesigner.cs (1)

444FieldInfo fieldInfo = customActivityType.GetField(member.Name + fieldSuffix, BindingFlags.Public | BindingFlags.Static);

AuthoringOM\Design\Dialogs\ActivityBindForm.cs (4)

650foreach (FieldInfo field in typeToGetPropertiesOn.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy))//BindingFlags.Static is needed for the const fields 844else if (this.pathInfo.MemberInfo is FieldInfo) 846FieldInfo fieldInfo = this.pathInfo.MemberInfo as FieldInfo;

AuthoringOM\Design\IdentifierCreationService.cs (4)

88if (member is FieldInfo) 89memberType = ((FieldInfo)member).FieldType; 153if (member is FieldInfo) 154memberType = ((FieldInfo)member).FieldType;

AuthoringOM\Design\PropertyDescriptors.cs (7)

491else if (memberInfo is FieldInfo) 493FieldInfo fieldInfo = memberInfo as FieldInfo; 554if (matchingMember is FieldInfo) 556isPrivate = ((FieldInfo)matchingMember).IsPrivate; 557memberType = ((FieldInfo)matchingMember).FieldType; 593matchingMember is FieldInfo &&

AuthoringOM\Serializer\DependencyObjectCodeDomSerializer.cs (1)

105FieldInfo fieldInfo = dependencyProperty.OwnerType.GetField(dependencyPropertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);

AuthoringOM\Serializer\FormatterServicesNoSerializableCheck.cs (5)

60FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); 70FieldInfo[] properFields = new FieldInfo[countProper]; 102FieldInfo[] typeFields; 144foreach (FieldInfo field in typeFields)

AuthoringOM\Serializer\WorkflowMarkupSerializer.cs (1)

2080FieldInfo fieldInfo = ownerType.GetField(propertyName + "Property", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

Tracking\PropertyHelper.cs (2)

173FieldInfo[] fields = t.GetFields(BindingFlags.Public | 179foreach (FieldInfo f in fields)

System\Workflow\Activities\ContractType.cs (9)

24private FieldInfo[] fields = null; 284public override FieldInfo GetField(string name, BindingFlags bindingAttr) 286return GetMemberHelper<FieldInfo>(bindingAttr, new MemberSignature(name, null, null), ref this.fields); 289public override FieldInfo[] GetFields(BindingFlags bindingAttr) 291return GetMembersHelper<FieldInfo>(bindingAttr, ref this.fields, true); 350members.AddRange(GetMembersHelper<FieldInfo>(bindingAttr, new MemberSignature(name, null, null), ref this.fields)); 550else if (memberInfo is FieldInfo) 552isPublic = (memberInfo as FieldInfo).IsPublic; 553isStatic = (memberInfo as FieldInfo).IsStatic;

System\Workflow\Activities\ServiceOperationHelpers.cs (1)

314FieldInfo argumentNamesField = typeof(AttributeInfo).GetField("argumentNames", bindingFlags);

System\Workflow\Activities\TypedOperationInfo.cs (1)

246FieldInfo argumentNamesField = typeof(AttributeInfo).GetField("argumentNames", bindingFlags);

System\Xml\Serialization\CodeGenerator.cs (6)

731FieldInfo fieldInfo = (FieldInfo)memberInfo; 763FieldInfo fieldInfo = (FieldInfo)memberInfo; 798FieldInfo fieldInfo = (FieldInfo)memberInfo;

System\Xml\Serialization\Models.cs (12)

152if (memberInfo is FieldInfo) 153model = GetFieldModel((FieldInfo)memberInfo); 177FieldModel GetFieldModel(FieldInfo fieldInfo) { 252FieldInfo specifiedField = memberInfo.DeclaringType.GetField(memberInfo.Name + "Specified"); 276else if (memberInfo is FieldInfo) { 277readOnly = ((FieldInfo)memberInfo).IsInitOnly; 321FieldInfo fieldInfo; 324internal ConstantModel(FieldInfo fieldInfo, long value) { 337internal FieldInfo FieldInfo { 351FieldInfo[] fields = Type.GetFields(); 353FieldInfo field = fields[i]; 364ConstantModel GetConstantModel(FieldInfo fieldInfo) {

System\Xml\Serialization\SourceInfo.cs (2)

155Type memberType = (MemberInfo is FieldInfo) ? 156((FieldInfo)MemberInfo).FieldType : ((PropertyInfo)MemberInfo).PropertyType;

System\Xml\Serialization\Types.cs (1)

1070foreach (FieldInfo info in currentInfo.DeclaredFields)

System\Xml\Serialization\XmlSerializationILGen.cs (1)

571Type memType = (memInfo.MemberType == MemberTypes.Field) ? ((FieldInfo)memInfo).FieldType : ((PropertyInfo)memInfo).PropertyType;

System\Xml\Serialization\XmlSerializationReaderILGen.cs (1)

2811ilg.ConvertValue(stackType, memInfo.MemberType == MemberTypes.Field ? ((FieldInfo)memInfo).FieldType : ((PropertyInfo)memInfo).PropertyType);

System\Xml\Serialization\XmlSerializationWriter.cs (2)

3421typeof(FieldInfo).FullName, typeof(PropertyInfo).FullName, 3450FieldInfo[] enumFields = type.GetFields();

System\Xml\Serialization\XmlSerializationWriterILGen.cs (1)

2314FieldInfo DBNull_Value = typeof(DBNull).GetField("Value", CodeGenerator.StaticBindingFlags);

System\Xml\Xslt\XslCompiledTransform.cs (2)

271FieldInfo fldData = compiledStylesheet.GetField(XmlQueryStaticData.DataFieldName, BindingFlags.Static | BindingFlags.NonPublic); 272FieldInfo fldTypes = compiledStylesheet.GetField(XmlQueryStaticData.TypesFieldName, BindingFlags.Static | BindingFlags.NonPublic);

MS\Internal\Automation\ProxyManager.cs (1)

83FieldInfo fi = t.GetField("ClientSideProviderDescriptionTable", BindingFlags.Static | BindingFlags.Public);

Base\MS\Internal\ComponentModel\AttachedPropertyMethodSelector.cs (2)

121public override FieldInfo BindToField(BindingFlags bindingAttr, FieldInfo[] match, object value, CultureInfo culture)

Base\MS\Internal\Interop\ErrorCodes.cs (2)

306foreach (FieldInfo publicStaticField in typeof(HRESULT).GetFields(BindingFlags.Static | BindingFlags.Public)) 321foreach (FieldInfo publicStaticField in typeof(Win32Error).GetFields(BindingFlags.Static | BindingFlags.Public))