//******************************************************************************************************//  LogStackFrame.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  10/24/2016 - Steven E. Chisholm//       Generated original version of source code. //       ////****************************************************************************************************** using System;using System.Data;using System.Diagnostics;using System.IO;using System.Security;using System.Text;using GSF.IO;using GSF.Reflection; namespace GSF.Diagnostics{    /// <summary>    /// Provides information about the specific stack frame.    /// </summary>    public class LogStackFrame        : IEquatable<LogStackFrame>    {        /// <summary>        /// The name of the method's type.        /// </summary>        /// <remarks>        /// Example: System.Collections.Generic.List`1+Enumerable        /// </remarks>        public readonly string ClassName;        /// <summary>        /// The name of the method        /// </summary>        /// <remarks>        /// Example: MethodName&lt;TKey,TValue&gt;(String key, String value)        /// </remarks>        public readonly string MethodName;         /// <summary>        /// The file name if debug symbols were compiled with the assembly        /// </summary>        public readonly string FileName;         /// <summary>        /// Gets the offset position in the IL Code.        /// </summary>        public readonly int NativeOffset;         /// <summary>        /// The line number of the data.        /// </summary>        public readonly int LineNumber;         /// <summary>        /// The column number of the execution point.        /// </summary>        public readonly int ColumnNumber;         /// <summary>        /// Creates a <see cref="LogStackFrame"/> from a <see cref="StackFrame"/>        /// </summary>        /// <param name="frame"></param>        public LogStackFrame(StackFrame frame)        {            if (frame == null)            {                ClassName = string.Empty;                MethodName = string.Empty;                FileName = string.Empty;                NativeOffset = 0;                LineNumber = 0;                ColumnNumber = 0;                return;            }             ClassName = frame.GetMethod().GetFriendlyClassName();            MethodName = frame.GetMethod().GetFriendlyMethodName();            using (Logger.SuppressFirstChanceExceptionLogMessages())            {                try                {                    FileName = frame.GetFileName() ?? string.Empty;                }                catch (SecurityException)                {                    FileName = string.Empty;                }            }            NativeOffset = frame.GetNativeOffset();            LineNumber = frame.GetFileLineNumber();            ColumnNumber = frame.GetFileColumnNumber();        }         /// <summary>        /// Creates a <see cref="LogStackFrame"/> from a <see cref="Stream"/>.        /// </summary>        /// <param name="stream">the stream to load from</param>        public LogStackFrame(Stream stream)        {            byte version = stream.ReadNextByte();            switch (version)            {                case 1:                    ClassName = stream.ReadString();                    MethodName = stream.ReadString();                    FileName = stream.ReadString();                    NativeOffset = stream.ReadInt32();                    LineNumber = stream.ReadInt32();                    ColumnNumber = stream.ReadInt32();                    break;                default:                    throw new VersionNotFoundException("Unknown StackTraceDetails Version");            }        }         /// <summary>        /// Saves this class to a <see cref="Stream"/>        /// </summary>        /// <param name="stream">the stream to write to.</param>        public void Save(Stream stream)        {            stream.Write((byte)1);            stream.Write(ClassName);            stream.Write(MethodName);            stream.Write(FileName);            stream.Write(NativeOffset);            stream.Write(LineNumber);            stream.Write(ColumnNumber);        }         /// <summary>        /// Makes a string        /// </summary>        /// <returns></returns>        public override string ToString()        {            StringBuilder sb = new StringBuilder();            ToString(sb);            return sb.ToString();        }         /// <summary>        /// Appends the details of this stack frame to the provided <see param="stringBuilder"/>.        /// </summary>        /// <param name="stringBuilder">where to append this class information</param>        /// <remarks>        /// Does not append a <see cref="Environment.NewLine"/> to the end of the line.        /// </remarks>        public void ToString(StringBuilder stringBuilder)        {            if (ClassName.Length > 0)            {                stringBuilder.Append(ClassName);                stringBuilder.Append('.');            }            stringBuilder.Append(MethodName);            if (FileName.Length == 0)            {                stringBuilder.Append(" IL offset: ");                stringBuilder.Append(NativeOffset);            }            else            {                stringBuilder.Append(" in ");                stringBuilder.Append(FileName);                stringBuilder.Append(": line ");                stringBuilder.Append(LineNumber);                stringBuilder.Append(':');                stringBuilder.Append(ColumnNumber);            }        }         /// <summary>        /// Gets the hash code data from this frame        /// </summary>        internal int ComputeHashCode()        {            return ClassName.GetHashCode() ^ MethodName.GetHashCode() ^ FileName.GetHashCode() ^ NativeOffset.GetHashCode() ^ LineNumber.GetHashCode() ^ ColumnNumber.GetHashCode();        }         /// <summary>        /// Gets of the two classes are equal        /// </summary>        /// <param name="other">the class to compare.</param>        /// <returns></returns>        public bool Equals(LogStackFrame other)        {            return (object)other != null &&                NativeOffset == other.NativeOffset &&                LineNumber == other.LineNumber &&                ColumnNumber == other.ColumnNumber &&                ClassName == other.ClassName &&                MethodName == other.MethodName &&                FileName == other.FileName;        }     }}