Get an Executable Assembly Name

System.Reflection.Assembly.GetExecutingAssembly().GetName().Name

private static bool Assembly_GetCustomAttributes(
    bool fromRootAssembly, int traceFrame, 
    ref string assemblyPath, bool getPathWithoutFileName,
    ref string assemblyFileName, bool getFileNameWithoutExtension,
    ref string assemblyCompany,
    ref string assemblyDescription,
    ref string assemblyName,
    ref string assemblyProduct,
    ref string assemblyTitle,
    ref string assemblyVersion
)
{
    System.Reflection.Assembly asm;
    if (fromRootAssembly)
    {
        asm = GetRootAssembly();
    }
    else
    {
        asm = GetParentAssembly(traceFrame + 1);
    }
 
    if (asm != null)
    {
        foreach (System.Attribute attr in System.Attribute.GetCustomAttributes(asm))
        {
            if (attr.GetType() == typeof(System.Reflection.AssemblyCompanyAttribute))
            {
                assemblyCompany = ((System.Reflection.AssemblyCompanyAttribute)attr).Company.Trim();
            }
            else
            if (attr.GetType() == typeof(System.Reflection.AssemblyDescriptionAttribute))
            {
                assemblyDescription = ((System.Reflection.AssemblyDescriptionAttribute)attr).Description.Trim();
            }
            else
            if (attr.GetType() == typeof(System.Reflection.AssemblyProductAttribute))
            {
                assemblyProduct = ((System.Reflection.AssemblyProductAttribute)attr).Product.Trim();
            }
            else
            if (attr.GetType() == typeof(System.Reflection.AssemblyTitleAttribute))
            {
                assemblyTitle = ((System.Reflection.AssemblyTitleAttribute)attr).Title.Trim();
            }
            else
            if (attr.GetType() == typeof(System.Reflection.AssemblyVersionAttribute))
            {
                assemblyVersion = ((System.Reflection.AssemblyVersionAttribute)attr).Version.Trim();
            }
        }
 
        if (assemblyVersion.Length <= 0)
        {
            assemblyVersion = asm.GetName().Version.ToString();
        }
        assemblyName = asm.GetName().Name.Trim();

        //string asmLocation = asm.Location.ToString();                // (returns path in lowercase)
        //asmLocation = Pathing.GetProperCase(asmLocation);            // Fix case of returned path
        string asmLocation = Pathing.GetProperCase(asm.Location.ToString());
        if (getPathWithoutFileName)
        {
            assemblyPath = Pathing.GetDirectoryName(asmLocation);
        }
        else
        {
            assemblyPath = asmLocation;
        }
        if (getFileNameWithoutExtension)
        {
            assemblyFileName = Pathing.GetFileNameWithoutExtension(asmLocation);
        }
        else
        {
            assemblyFileName = Pathing.GetFileName(asmLocation);
        }
        return true;
    }
    return false;
}
 
public static System.Reflection.Assembly GetParentAssembly(int traceFrame)
{
    System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace();
    System.Diagnostics.StackFrame parentFrame = trace.GetFrame(traceFrame + 1);
    //System.Reflection.MethodBase parentMethod = parentFrame.GetMethod();
    //System.Type parentType = parentMethod.DeclaringType;
    //return parentType.Assembly;
    return parentFrame.GetMethod().DeclaringType.Assembly;
}
 
public static System.Reflection.Assembly GetRootAssembly()
{
    System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace();
    System.Diagnostics.StackFrame parentFrame = trace.GetFrame(trace.FrameCount - 1);
    //System.Reflection.MethodBase parentMethod = parentFrame.GetMethod();
    //System.Type parentType = parentMethod.DeclaringType;
    //return parentType.Assembly;
    return parentFrame.GetMethod().DeclaringType.Assembly;
}

internal class Pathing
{
    public static string GetProperCase(string parmFullPathFileName)
    {
        // From a presumed full Path+FileName, return the Path in proper case
        // (This method doesn't work for NetWork paths [i.e. "\\Server\RootPath\path"])
        string returnPath = parmFullPathFileName.Trim();
        #region Is there any point in executing this method?
        string driveLetter = " ";
        if (returnPath.Length > 0)
        {
            driveLetter = returnPath.Substring(0, 1).ToUpper();
        }
        if( (returnPath.Length < 4)                            // Minimum size/format: "Z:\x"
        || (driveLetter.CompareTo("A") < 0) || (driveLetter.CompareTo("Z") > 0)
        || (returnPath.Substring(1, 1) != @":")
        || (returnPath.Substring(2, 1) != @"\")
        )
        {
            return returnPath;
        }
        #endregion 
 
        string casedPath = "";
        string[] nodes = StringArrayFrom.NodeElements(@"\", returnPath);
        if (nodes.Length > 0)
        {
            #region Initialize local variables
            string rootNode = "";
            int idxSkip = 0;
            if (nodes[0].Length > 0)
            {
                rootNode = nodes[0].ToUpper() +@"\";
                idxSkip = 1;
            }
            //else
            //{
            //    // NetWork path [i.e. "\\Server\RootPath\path"])
            //    rootNode = @"\\"+ nodes[2] +@"\" + nodes[3];
            //    idxSkip = 4;
            //}
            #endregion 
 
            #region Loop through the nodes [parmFullPathFileName] and build [casedPath]
            System.IO.DirectoryInfo rootDirInfo = new System.IO.DirectoryInfo(rootNode);
            for (int idx = idxSkip; idx < nodes.Length; idx++)
            {
                string node = nodes[idx];
                if (node.Length > 0)
                {
                    System.IO.FileSystemInfo[] fsInfos = rootDirInfo.GetFileSystemInfos(node);
                    if (fsInfos.Length == 1)
                    {
                        casedPath = fsInfos[0].FullName;
 
                        rootDirInfo = new System.IO.DirectoryInfo(casedPath);
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    break;
                }
            }
               #endregion 
        }
 
        if (casedPath.ToLower() == returnPath.ToLower() )
        {
            returnPath = casedPath;
        }
        return returnPath;
    }
 
    public static string GetDirectoryName(string parmFullPathFileName)
    {
        // From a presumed full Path+FileName, return the Path (Directory Name)
        string returnPath = parmFullPathFileName.Trim();
        if (returnPath.Length > 0)
        {
            try
            {
                returnPath = System.IO.Path.GetFullPath(returnPath);    // (just in case) Get absolute path
                returnPath = System.IO.Path.GetDirectoryName(returnPath);
                if (returnPath != null)
                {
                    return returnPath;
                }
            }
            catch
            {}
        }
        return "";                                      // indicate failure
    }
 
    public static string GetFileName(string parmFullPathFileName)
    {
        // From a presumed full Path+FileName (but FileName only should be OK), return the FileName
        return GetFileName_Work(parmFullPathFileName, false, false);
    }
  
    public static string GetFileNameWithoutExtension(string parmFullPathFileName)
    {
        // From a presumed full Path+FileName (but FileName only should be OK), return the FileName without extension
        return GetFileName_Work(parmFullPathFileName, true, false);
    }
}