public static string AssemblyFileName()

in src/log4net/Util/SystemInfo.cs [427:552]
53 lines of code
10 McCabe index (conditional complexity)

  public static string AssemblyFileName(Assembly myAssembly) 
    => Path.GetFileName(myAssembly.EnsureNotNull().Location);

  /// <summary>
  /// Loads the type specified in the type string.
  /// </summary>
  /// <param name="relativeType">A sibling type to use to load the type.</param>
  /// <param name="typeName">The name of the type to load.</param>
  /// <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
  /// <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
  /// <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
  /// <remarks>
  /// <para>
  /// If the type name is fully qualified, i.e. if contains an assembly name in 
  /// the type name, the type will be loaded from the system using 
  /// <see cref="Type.GetType(string,bool)"/>.
  /// </para>
  /// <para>
  /// If the type name is not fully qualified, it will be loaded from the assembly
  /// containing the specified relative type. If the type is not found in the assembly 
  /// then all the loaded assemblies will be searched for the type.
  /// </para>
  /// </remarks>
  public static Type? GetTypeFromString(Type relativeType, string typeName, bool throwOnError, bool ignoreCase) 
    => GetTypeFromString(relativeType.EnsureNotNull().Assembly, typeName, throwOnError, ignoreCase);

  /// <summary>
  /// Loads the type specified in the type string.
  /// </summary>
  /// <param name="typeName">The name of the type to load.</param>
  /// <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
  /// <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
  /// <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>    
  /// <remarks>
  /// <para>
  /// If the type name is fully qualified, i.e. if contains an assembly name in 
  /// the type name, the type will be loaded from the system using 
  /// <see cref="Type.GetType(string,bool)"/>.
  /// </para>
  /// <para>
  /// If the type name is not fully qualified it will be loaded from the
  /// assembly that is directly calling this method. If the type is not found 
  /// in the assembly then all the loaded assemblies will be searched for the type.
  /// </para>
  /// </remarks>
  public static Type? GetTypeFromString(string typeName, bool throwOnError, bool ignoreCase) 
    => GetTypeFromString(Assembly.GetCallingAssembly(), typeName, throwOnError, ignoreCase);

  /// <summary>
  /// Loads the type specified in the type string.
  /// </summary>
  /// <param name="relativeAssembly">An assembly to load the type from.</param>
  /// <param name="typeName">The name of the type to load.</param>
  /// <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>
  /// <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>
  /// <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>
  /// <remarks>
  /// <para>
  /// If the type name is fully qualified, i.e. if contains an assembly name in 
  /// the type name, the type will be loaded from the system using 
  /// <see cref="Type.GetType(string,bool)"/>.
  /// </para>
  /// <para>
  /// If the type name is not fully qualified it will be loaded from the specified
  /// assembly. If the type is not found in the assembly then all the loaded assemblies 
  /// will be searched for the type.
  /// </para>
  /// </remarks>
  public static Type? GetTypeFromString(Assembly relativeAssembly, string typeName, bool throwOnError, bool ignoreCase)
  {
    // Check if the type name specifies the assembly name
    if (typeName.EnsureNotNull().IndexOf(',') == -1)
    {
      // Attempt to look up the type from the relativeAssembly
      if (relativeAssembly.EnsureNotNull().GetType(typeName, false, ignoreCase) is Type type)
      {
        return type;
      }

      Assembly[]? loadedAssemblies = null;
      try
      {
        loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
      }
      catch (System.Security.SecurityException)
      {
        // Insufficient permissions to get the list of loaded assemblies
      }

      if (loadedAssemblies is not null)
      {
        Type? fallback = null;
        // Search the loaded assemblies for the type
        foreach (Assembly assembly in loadedAssemblies)
        {
          if (assembly.GetType(typeName, false, ignoreCase) is Type t)
          {
            // Found type in loaded assembly
            LogLog.Debug(_declaringType, $"Loaded type [{typeName}] from assembly [{assembly.FullName}] by searching loaded assemblies.");
            if (assembly.GlobalAssemblyCache)
            {
              fallback = t;
            }
            else
            {
              return t;
            }
          }
        }
        if (fallback is not null)
        {
          return fallback;
        }
      }

      // Didn't find the type
      if (throwOnError)
      {
        throw new TypeLoadException($"Could not load type [{typeName}]. Tried assembly [{relativeAssembly.FullName}] and all loaded assemblies");
      }
      return null;
    }

    // Includes explicit assembly name
    return Type.GetType(typeName, throwOnError, ignoreCase);
  }