CreateManifestAndDescriptors()

static byte[] System.Diagnostics.Tracing.EventSource.CreateManifestAndDescriptors ( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type eventSourceType, string eventSourceDllName, EventSource source, EventManifestOptions flags = EventManifestOptions::None )

inlinestaticprivateinherited

Definition at line 2181 of file EventSource.cs.

    {
        ManifestBuilder manifestBuilder = null;
        bool flag = source == null || !source.SelfDescribingEvents;
        Exception ex = null;
        byte[] result = null;
        if (eventSourceType.IsAbstract && (flags & EventManifestOptions.Strict) == 0)
        {
            return null;
        }
        try
        {
            MethodInfo[] methods = eventSourceType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            int num = 1;
            EventMetadata[] eventData = null;
            Dictionary<string, string> eventsByName = null;
            if (source != null || (flags & EventManifestOptions.Strict) != 0)
            {
                eventData = new EventMetadata[methods.Length + 1];
                eventData[0].Name = "";
            }
            ResourceManager resources = null;
            EventSourceAttribute eventSourceAttribute = (EventSourceAttribute)GetCustomAttributeHelper(eventSourceType, typeof(EventSourceAttribute), flags);
            if (eventSourceAttribute != null && eventSourceAttribute.LocalizationResources != null)
            {
                resources = new ResourceManager(eventSourceAttribute.LocalizationResources, eventSourceType.Assembly);
            }
            manifestBuilder = ((source == null) ? new ManifestBuilder(GetName(eventSourceType, flags), GetGuid(eventSourceType), eventSourceDllName, resources, flags) : new ManifestBuilder(source.Name, source.Guid, eventSourceDllName, resources, flags));
            manifestBuilder.StartEvent("EventSourceMessage", new EventAttribute(0)
            {
                Level = EventLevel.LogAlways,
                Task = (EventTask)65534
            });
            manifestBuilder.AddEventParameter(typeof(string), "message");
            manifestBuilder.EndEvent();
            if ((flags & EventManifestOptions.Strict) != 0)
            {
                if (!(GetEventSourceBaseType(eventSourceType, (flags & EventManifestOptions.AllowEventSourceOverride) != 0, eventSourceType.Assembly.ReflectionOnly) != null))
                {
                    manifestBuilder.ManifestError(SR.EventSource_TypeMustDeriveFromEventSource);
                }
                if (!eventSourceType.IsAbstract && !eventSourceType.IsSealed)
                {
                    manifestBuilder.ManifestError(SR.EventSource_TypeMustBeSealedOrAbstract);
                }
            }
            string[] array = new string[3] { "Keywords", "Tasks", "Opcodes" };
            foreach (string text in array)
            {
                Type nestedType = eventSourceType.GetNestedType(text);
                if (!(nestedType != null))
                {
                    continue;
                }
                if (eventSourceType.IsAbstract)
                {
                    manifestBuilder.ManifestError(SR.Format(SR.EventSource_AbstractMustNotDeclareKTOC, nestedType.Name));
                    continue;
                }
                FieldInfo[] fields = nestedType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                foreach (FieldInfo staticField in fields)
                {
                    AddProviderEnumKind(manifestBuilder, staticField, text);
                }
            }
            manifestBuilder.AddKeyword("Session3", 17592186044416uL);
            manifestBuilder.AddKeyword("Session2", 35184372088832uL);
            manifestBuilder.AddKeyword("Session1", 70368744177664uL);
            manifestBuilder.AddKeyword("Session0", 140737488355328uL);
            if (eventSourceType != typeof(EventSource))
            {
                foreach (MethodInfo methodInfo in methods)
                {
                    ParameterInfo[] args = methodInfo.GetParameters();
                    EventAttribute eventAttribute = (EventAttribute)GetCustomAttributeHelper(methodInfo, typeof(EventAttribute), flags);
                    if (methodInfo.IsStatic)
                    {
                        continue;
                    }
                    if (eventSourceType.IsAbstract)
                    {
                        if (eventAttribute != null)
                        {
                            manifestBuilder.ManifestError(SR.Format(SR.EventSource_AbstractMustNotDeclareEventMethods, methodInfo.Name, eventAttribute.EventId));
                        }
                        continue;
                    }
                    if (eventAttribute == null)
                    {
                        if (methodInfo.ReturnType != typeof(void) || methodInfo.IsVirtual || IsCustomAttributeDefinedHelper(methodInfo, typeof(NonEventAttribute), flags))
                        {
                            continue;
                        }
                        EventAttribute eventAttribute2 = new EventAttribute(num);
                        eventAttribute = eventAttribute2;
                    }
                    else if (eventAttribute.EventId <= 0)
                    {
                        manifestBuilder.ManifestError(SR.Format(SR.EventSource_NeedPositiveId, methodInfo.Name), runtimeCritical: true);
                        continue;
                    }
                    if (methodInfo.Name.LastIndexOf('.') >= 0)
                    {
                        manifestBuilder.ManifestError(SR.Format(SR.EventSource_EventMustNotBeExplicitImplementation, methodInfo.Name, eventAttribute.EventId));
                    }
                    num++;
                    string name = methodInfo.Name;
                    if (eventAttribute.Opcode == EventOpcode.Info)
                    {
                        bool flag2 = eventAttribute.Task == EventTask.None;
                        if (flag2)
                        {
                            eventAttribute.Task = (EventTask)(65534 - eventAttribute.EventId);
                        }
                        if (!eventAttribute.IsOpcodeSet)
                        {
                            eventAttribute.Opcode = GetOpcodeWithDefault(EventOpcode.Info, name);
                        }
                        if (flag2)
                        {
                            if (eventAttribute.Opcode == EventOpcode.Start)
                            {
                                string text2 = name.Substring(0, name.Length - "Start".Length);
                                if (string.Compare(name, 0, text2, 0, text2.Length) == 0 && string.Compare(name, text2.Length, "Start", 0, Math.Max(name.Length - text2.Length, "Start".Length)) == 0)
                                {
                                    manifestBuilder.AddTask(text2, (int)eventAttribute.Task);
                                }
                            }
                            else if (eventAttribute.Opcode == EventOpcode.Stop)
                            {
                                int num2 = eventAttribute.EventId - 1;
                                if (eventData != null && num2 < eventData.Length)
                                {
                                    EventMetadata eventMetadata = eventData[num2];
                                    string text3 = name.Substring(0, name.Length - "Stop".Length);
                                    if (eventMetadata.Descriptor.Opcode == 1 && string.Compare(eventMetadata.Name, 0, text3, 0, text3.Length) == 0 && string.Compare(eventMetadata.Name, text3.Length, "Start", 0, Math.Max(eventMetadata.Name.Length - text3.Length, "Start".Length)) == 0)
                                    {
                                        eventAttribute.Task = (EventTask)eventMetadata.Descriptor.Task;
                                        flag2 = false;
                                    }
                                }
                                if (flag2 && (flags & EventManifestOptions.Strict) != 0)
                                {
                                    throw new ArgumentException(SR.EventSource_StopsFollowStarts);
                                }
                            }
                        }
                    }
                    bool hasRelatedActivityID = RemoveFirstArgIfRelatedActivityId(ref args);
                    if (source == null || !source.SelfDescribingEvents)
                    {
                        manifestBuilder.StartEvent(name, eventAttribute);
                        for (int l = 0; l < args.Length; l++)
                        {
                            manifestBuilder.AddEventParameter(args[l].ParameterType, args[l].Name);
                        }
                        manifestBuilder.EndEvent();
                    }
                    if (source == null && (flags & EventManifestOptions.Strict) == 0)
                    {
                        continue;
                    }
                    DebugCheckEvent(ref eventsByName, eventData, methodInfo, eventAttribute, manifestBuilder, flags);
                    if (eventAttribute.Channel != 0)
                    {
                        eventAttribute.Keywords |= (EventKeywords)manifestBuilder.GetChannelKeyword(eventAttribute.Channel, (ulong)eventAttribute.Keywords);
                    }
                    if (manifestBuilder.HasResources)
                    {
                        string key = "event_" + name;
                        string localizedMessage = manifestBuilder.GetLocalizedMessage(key, CultureInfo.CurrentUICulture, etwFormat: false);
                        if (localizedMessage != null)
                        {
                            eventAttribute.Message = localizedMessage;
                        }
                    }
                    AddEventDescriptor(ref eventData, name, eventAttribute, args, hasRelatedActivityID);
                }
            }
            NameInfo.ReserveEventIDsBelow(num);
            if (source != null)
            {
                TrimEventDescriptors(ref eventData);
                source.m_eventData = eventData;
                source.m_channelData = manifestBuilder.GetChannelData();
            }
            if (!eventSourceType.IsAbstract && (source == null || !source.SelfDescribingEvents))
            {
                flag = (flags & EventManifestOptions.OnlyIfNeededForRegistration) == 0 || manifestBuilder.GetChannelData().Length != 0;
                if (!flag && (flags & EventManifestOptions.Strict) == 0)
                {
                    return null;
                }
                result = manifestBuilder.CreateManifest();
            }
        }
        catch (Exception ex2)
        {
            if ((flags & EventManifestOptions.Strict) == 0)
            {
                throw;
            }
            ex = ex2;
        }
        if ((flags & EventManifestOptions.Strict) != 0 && ((manifestBuilder != null && manifestBuilder.Errors.Count > 0) || ex != null))
        {
            string text4 = string.Empty;
            if (manifestBuilder != null && manifestBuilder.Errors.Count > 0)
            {
                bool flag3 = true;
                foreach (string error in manifestBuilder.Errors)
                {
                    if (!flag3)
                    {
                        text4 += Environment.NewLine;
                    }
                    flag3 = false;
                    text4 += error;
                }
            }
            else
            {
                text4 = "Unexpected error: " + ex.Message;
            }
            throw new ArgumentException(text4, ex);
        }
        if (!flag)
        {
            return null;
        }
        return result;
    }

References System.Diagnostics.Tracing.EventSource.AddEventDescriptor(), System.Diagnostics.Tracing.EventSource.AddProviderEnumKind(), System.array, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Globalization.CultureInfo.CurrentUICulture, System.Diagnostics.Tracing.EventSource.DebugCheckEvent(), System.SR.EventSource_AbstractMustNotDeclareEventMethods, System.SR.EventSource_AbstractMustNotDeclareKTOC, System.SR.EventSource_EventMustNotBeExplicitImplementation, System.SR.EventSource_NeedPositiveId, System.SR.EventSource_StopsFollowStarts, System.SR.EventSource_TypeMustBeSealedOrAbstract, System.SR.EventSource_TypeMustDeriveFromEventSource, System.SR.Format(), System.Diagnostics.Tracing.EventSource.GetCustomAttributeHelper(), System.Diagnostics.Tracing.EventSource.GetEventSourceBaseType(), System.Diagnostics.Tracing.EventSource.GetGuid(), System.Diagnostics.Tracing.EventSource.GetName(), System.Diagnostics.Tracing.EventSource.GetOpcodeWithDefault(), System.Diagnostics.Tracing.EventSource.IsCustomAttributeDefinedHelper(), System.key, System.Math.Max(), System.Diagnostics.Tracing.EventSource.Name, System.Environment.NewLine, System.Diagnostics.Tracing.EventSource.RemoveFirstArgIfRelatedActivityId(), System.Diagnostics.Tracing.NameInfo.ReserveEventIDsBelow(), System.source, System.text, and System.Diagnostics.Tracing.EventSource.TrimEventDescriptors().

Referenced by System.Diagnostics.Tracing.EventSource.EnsureDescriptorsInitialized(), and System.Diagnostics.Tracing.EventSource.GenerateManifest().