Exemplo n.º 1
0
        private TraceLoggingEventTypes(
            EventTags tags,
            string defaultName,
            TraceLoggingTypeInfo[] typeInfos)
        {
            if (defaultName is null)
            {
                throw new ArgumentNullException(nameof(defaultName));
            }

            this.typeInfos = typeInfos;
            this.name      = defaultName;
            this.tags      = tags;
            this.level     = Statics.DefaultLevel;

            var collector = new TraceLoggingMetadataCollector();

            foreach (TraceLoggingTypeInfo typeInfo in typeInfos)
            {
                this.level     = Statics.Combine((int)typeInfo.Level, this.level);
                this.opcode    = Statics.Combine((int)typeInfo.Opcode, this.opcode);
                this.keywords |= typeInfo.Keywords;
                typeInfo.WriteMetadata(collector, null, EventFieldFormat.Default);
            }

            this.typeMetadata = collector.GetMetadata();
            this.scratchSize  = collector.ScratchSize;
            this.dataCount    = collector.DataCount;
            this.pinCount     = collector.PinCount;
        }
Exemplo n.º 2
0
        internal TraceLoggingEventTypes(string name, EventTags tags, ParameterInfo[] paramInfos)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }
            this.typeInfos = this.MakeArray(paramInfos);
            this.name      = name;
            this.tags      = tags;
            this.level     = (byte)5;
            TraceLoggingMetadataCollector collector = new TraceLoggingMetadataCollector();

            for (int index = 0; index < this.typeInfos.Length; ++index)
            {
                TraceLoggingTypeInfo traceLoggingTypeInfo = this.typeInfos[index];
                this.level    = Statics.Combine((int)traceLoggingTypeInfo.Level, this.level);
                this.opcode   = Statics.Combine((int)traceLoggingTypeInfo.Opcode, this.opcode);
                this.keywords = this.keywords | traceLoggingTypeInfo.Keywords;
                string name1 = paramInfos[index].Name;
                if (Statics.ShouldOverrideFieldName(name1))
                {
                    name1 = traceLoggingTypeInfo.Name;
                }
                traceLoggingTypeInfo.WriteMetadata(collector, name1, EventFieldFormat.Default);
            }
            this.typeMetadata = collector.GetMetadata();
            this.scratchSize  = collector.ScratchSize;
            this.dataCount    = collector.DataCount;
            this.pinCount     = collector.PinCount;
        }
Exemplo n.º 3
0
        public TypeAnalysis(Type dataType, EventDataAttribute eventAttrib, List <Type> recursionCheck)
        {
            IEnumerable <PropertyInfo> properties           = Statics.GetProperties(dataType);
            List <PropertyAnalysis>    propertyAnalysisList = new List <PropertyAnalysis>();

            foreach (PropertyInfo propInfo in properties)
            {
                if (!Statics.HasCustomAttribute(propInfo, typeof(EventIgnoreAttribute)) && propInfo.CanRead && propInfo.GetIndexParameters().Length == 0)
                {
                    MethodInfo getMethod = Statics.GetGetMethod(propInfo);
                    if (!(getMethod == (MethodInfo)null) && !getMethod.IsStatic && getMethod.IsPublic)
                    {
                        TraceLoggingTypeInfo typeInfoInstance = Statics.GetTypeInfoInstance(propInfo.PropertyType, recursionCheck);
                        EventFieldAttribute  customAttribute  = Statics.GetCustomAttribute <EventFieldAttribute>(propInfo);
                        string name = customAttribute == null || customAttribute.Name == null ? (Statics.ShouldOverrideFieldName(propInfo.Name) ? typeInfoInstance.Name : propInfo.Name) : customAttribute.Name;
                        propertyAnalysisList.Add(new PropertyAnalysis(name, getMethod, typeInfoInstance, customAttribute));
                    }
                }
            }
            this.properties = propertyAnalysisList.ToArray();
            foreach (PropertyAnalysis property in this.properties)
            {
                TraceLoggingTypeInfo traceLoggingTypeInfo = property.typeInfo;
                this.level    = (EventLevel)Statics.Combine((int)traceLoggingTypeInfo.Level, (int)this.level);
                this.opcode   = (EventOpcode)Statics.Combine((int)traceLoggingTypeInfo.Opcode, (int)this.opcode);
                this.keywords = this.keywords | traceLoggingTypeInfo.Keywords;
                this.tags     = this.tags | traceLoggingTypeInfo.Tags;
            }
            if (eventAttrib != null)
            {
                this.level    = (EventLevel)Statics.Combine((int)eventAttrib.Level, (int)this.level);
                this.opcode   = (EventOpcode)Statics.Combine((int)eventAttrib.Opcode, (int)this.opcode);
                this.keywords = this.keywords | eventAttrib.Keywords;
                this.tags     = this.tags | eventAttrib.Tags;
                this.name     = eventAttrib.Name;
            }
            if (this.name != null)
            {
                return;
            }
            this.name = dataType.Name;
        }
Exemplo n.º 4
0
        internal TraceLoggingEventTypes(
            string name,
            EventTags tags,
            System.Reflection.ParameterInfo[] paramInfos)
        {
            if (name is null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            this.typeInfos = MakeArray(paramInfos);
#if FEATURE_PERFTRACING
            this.paramNames = MakeParamNameArray(paramInfos);
#endif
            this.name  = name;
            this.tags  = tags;
            this.level = Statics.DefaultLevel;

            var collector = new TraceLoggingMetadataCollector();
            for (int i = 0; i < typeInfos.Length; ++i)
            {
                TraceLoggingTypeInfo typeInfo = typeInfos[i];
                this.level     = Statics.Combine((int)typeInfo.Level, this.level);
                this.opcode    = Statics.Combine((int)typeInfo.Opcode, this.opcode);
                this.keywords |= typeInfo.Keywords;
                string?paramName = paramInfos[i].Name;
                if (Statics.ShouldOverrideFieldName(paramName !))
                {
                    paramName = typeInfo.Name;
                }
                typeInfo.WriteMetadata(collector, paramName, EventFieldFormat.Default);
            }

            this.typeMetadata = collector.GetMetadata();
            this.scratchSize  = collector.ScratchSize;
            this.dataCount    = collector.DataCount;
            this.pinCount     = collector.PinCount;
        }
Exemplo n.º 5
0
        public TypeAnalysis(
            Type dataType,
            EventDataAttribute?eventAttrib,
            List <Type> recursionCheck)
        {
            var propertyList = new List <PropertyAnalysis>();

            foreach (PropertyInfo propertyInfo in dataType.GetProperties())
            {
                if (Statics.HasCustomAttribute(propertyInfo, typeof(EventIgnoreAttribute)))
                {
                    continue;
                }

                if (!propertyInfo.CanRead ||
                    propertyInfo.GetIndexParameters().Length != 0)
                {
                    continue;
                }

                MethodInfo?getterInfo = propertyInfo.GetGetMethod();
                if (getterInfo == null)
                {
                    continue;
                }

                if (getterInfo.IsStatic || !getterInfo.IsPublic)
                {
                    continue;
                }

                Type propertyType     = propertyInfo.PropertyType;
                var  propertyTypeInfo = TraceLoggingTypeInfo.GetInstance(propertyType, recursionCheck);
                EventFieldAttribute?fieldAttribute = Statics.GetCustomAttribute <EventFieldAttribute>(propertyInfo);

                string propertyName =
                    fieldAttribute != null && fieldAttribute.Name != null
                    ? fieldAttribute.Name
                    : Statics.ShouldOverrideFieldName(propertyInfo.Name)
                    ? propertyTypeInfo.Name
                    : propertyInfo.Name;
                propertyList.Add(new PropertyAnalysis(
                                     propertyName,
                                     propertyInfo,
                                     propertyTypeInfo,
                                     fieldAttribute));
            }

            this.properties = propertyList.ToArray();

            foreach (PropertyAnalysis property in this.properties)
            {
                TraceLoggingTypeInfo typeInfo = property.typeInfo;
                this.level     = (EventLevel)Statics.Combine((int)typeInfo.Level, (int)this.level);
                this.opcode    = (EventOpcode)Statics.Combine((int)typeInfo.Opcode, (int)this.opcode);
                this.keywords |= typeInfo.Keywords;
                this.tags     |= typeInfo.Tags;
            }

            if (eventAttrib != null)
            {
                this.level     = (EventLevel)Statics.Combine((int)eventAttrib.Level, (int)this.level);
                this.opcode    = (EventOpcode)Statics.Combine((int)eventAttrib.Opcode, (int)this.opcode);
                this.keywords |= eventAttrib.Keywords;
                this.tags     |= eventAttrib.Tags;
                this.name      = eventAttrib.Name;
            }

            this.name ??= dataType.Name;
        }