/// <summary>
/// Creates a new repository for the assembly specified.
/// </summary>
/// <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="ILoggerRepository"/>.</param>
/// <param name="repositoryType">The type of repository to create, must implement <see cref="ILoggerRepository"/>.</param>
/// <param name="repositoryName">The name to assign to the created repository</param>
/// <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
/// <returns>The repository created.</returns>
/// <remarks>
/// <para>
/// The <see cref="ILoggerRepository"/> created will be associated with the repository
/// specified such that a call to <see cref="GetRepository(Assembly)"/> with the
/// same assembly specified will return the same repository instance.
/// </para>
/// <para>
/// The type of the <see cref="ILoggerRepository"/> created and
/// the repository to create can be overridden by specifying the
/// <see cref="log4net.Config.RepositoryAttribute"/> attribute on the
/// <paramref name="repositoryAssembly"/>. The default values are to use the
/// <paramref name="repositoryType"/> implementation of the
/// <see cref="ILoggerRepository"/> interface and to use the
/// <see cref="AssemblyName.Name"/> as the name of the repository.
/// </para>
/// <para>
/// The <see cref="ILoggerRepository"/> created will be automatically
/// configured using any <see cref="log4net.Config.ConfiguratorAttribute"/>
/// attributes defined on the <paramref name="repositoryAssembly"/>.
/// </para>
/// <para>
/// If a repository for the <paramref name="repositoryAssembly"/> already exists
/// that repository will be returned. An error will not be raised and that
/// repository may be of a different type to that specified in <paramref name="repositoryType"/>.
/// Also the <see cref="log4net.Config.RepositoryAttribute"/> attribute on the
/// assembly may be used to override the repository type specified in
/// <paramref name="repositoryType"/>.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null" />.</exception>
public ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type repositoryType, string repositoryName, bool readAssemblyAttributes)
{
if (repositoryAssembly == null)
{
throw new ArgumentNullException("repositoryAssembly");
}
// If the type is not set then use the default type
if (repositoryType == null)
{
repositoryType = m_defaultRepositoryType;
}
lock (this)
{
// Lookup in map
ILoggerRepository rep = m_assembly2repositoryMap[repositoryAssembly] as ILoggerRepository;
if (rep == null)
{
// Not found, therefore create
LogLog.Debug(declaringType, "Creating repository for assembly [" + repositoryAssembly + "]");
// Must specify defaults
string actualRepositoryName = repositoryName;
Type actualRepositoryType = repositoryType;
if (readAssemblyAttributes)
{
// Get the repository and type from the assembly attributes
GetInfoForAssembly(repositoryAssembly, ref actualRepositoryName, ref actualRepositoryType);
}
LogLog.Debug(declaringType, "Assembly [" + repositoryAssembly + "] using repository [" + actualRepositoryName + "] and repository type [" + actualRepositoryType + "]");
// Lookup the repository in the map (as this may already be defined)
rep = m_name2repositoryMap[actualRepositoryName] as ILoggerRepository;
if (rep == null)
{
// Create the repository
rep = CreateRepository(actualRepositoryName, actualRepositoryType);
if (readAssemblyAttributes)
{
try
{
// Look for aliasing attributes
LoadAliases(repositoryAssembly, rep);
// Look for plugins defined on the assembly
LoadPlugins(repositoryAssembly, rep);
// Configure the repository using the assembly attributes
ConfigureRepository(repositoryAssembly, rep);
}
catch (Exception ex)
{
LogLog.Error(declaringType, "Failed to configure repository [" + actualRepositoryName + "] from assembly attributes.", ex);
}
}
}
else
{
LogLog.Debug(declaringType, "repository [" + actualRepositoryName + "] already exists, using repository type [" + rep.GetType().FullName + "]");
if (readAssemblyAttributes)
{
try
{
// Look for plugins defined on the assembly
LoadPlugins(repositoryAssembly, rep);
}
catch (Exception ex)
{
LogLog.Error(declaringType, "Failed to configure repository [" + actualRepositoryName + "] from assembly attributes.", ex);
}
}
}
m_assembly2repositoryMap[repositoryAssembly] = rep;
}
return(rep);
}
}
/// <summary>
/// Creates a new repository for the specified repository.
/// </summary>
/// <param name="repositoryName">The repository to associate with the <see cref="ILoggerRepository"/>.</param>
/// <param name="repositoryType">The type of repository to create, must implement <see cref="ILoggerRepository"/>.
/// If this param is <see langword="null" /> then the default repository type is used.</param>
/// <returns>The new repository.</returns>
/// <remarks>
/// <para>
/// The <see cref="ILoggerRepository"/> created will be associated with the repository
/// specified such that a call to <see cref="M:GetRepository(string)"/> with the
/// same repository specified will return the same repository instance.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null" />.</exception>
/// <exception cref="LogException"><paramref name="repositoryName"/> already exists.</exception>
public ILoggerRepository CreateRepository(string repositoryName, Type repositoryType)
{
if (repositoryName == null)
{
throw new ArgumentNullException("repositoryName");
}
// If the type is not set then use the default type
if (repositoryType == null)
{
repositoryType = m_defaultRepositoryType;
}
lock (this)
{
ILoggerRepository rep = null;
// First check that the repository does not exist
rep = m_name2repositoryMap[repositoryName] as ILoggerRepository;
if (rep != null)
{
throw new LogException("Repository [" + repositoryName + "] is already defined. Repositories cannot be redefined.");
}
else
{
// Lookup an alias before trying to create the new repository
ILoggerRepository aliasedRepository = m_alias2repositoryMap[repositoryName] as ILoggerRepository;
if (aliasedRepository != null)
{
// Found an alias
// Check repository type
if (aliasedRepository.GetType() == repositoryType)
{
// Repository type is compatible
LogLog.Debug(declaringType, "Aliasing repository [" + repositoryName + "] to existing repository [" + aliasedRepository.Name + "]");
rep = aliasedRepository;
// Store in map
m_name2repositoryMap[repositoryName] = rep;
}
else
{
// Invalid repository type for alias
LogLog.Error(declaringType, "Failed to alias repository [" + repositoryName + "] to existing repository [" + aliasedRepository.Name + "]. Requested repository type [" + repositoryType.FullName + "] is not compatible with existing type [" + aliasedRepository.GetType().FullName + "]");
// We now drop through to create the repository without aliasing
}
}
// If we could not find an alias
if (rep == null)
{
LogLog.Debug(declaringType, "Creating repository [" + repositoryName + "] using type [" + repositoryType + "]");
// Call the no arg constructor for the repositoryType
rep = (ILoggerRepository)Activator.CreateInstance(repositoryType);
// Set the name of the repository
rep.Name = repositoryName;
// Store in map
m_name2repositoryMap[repositoryName] = rep;
// Notify listeners that the repository has been created
OnLoggerRepositoryCreatedEvent(rep);
}
}
return(rep);
}
}
/// <summary>
/// Create a new repository for the domain specified
/// </summary>
/// <param name="domain">the domain to associate with the <see cref="ILoggerRepository"/></param>
/// <param name="repositoryType">the type of repository to create, must implement <see cref="ILoggerRepository"/>.
/// If this param is null then the default repository type is used.</param>
/// <returns>the repository created</returns>
/// <remarks>
/// The <see cref="ILoggerRepository"/> created will be associated with the domain
/// specified such that a call to <see cref="GetRepository(string)"/> with the
/// same domain specified will return the same repository instance.
/// </remarks>
/// <exception cref="ArgumentNullException">throw if <paramref name="domain"/> is null</exception>
/// <exception cref="LogException">throw if the <paramref name="domain"/> already exists</exception>
public ILoggerRepository CreateRepository(string domain, Type repositoryType)
{
if (domain == null)
{
throw new ArgumentNullException("domain");
}
// If the type is not set then use the default type
if (repositoryType == null)
{
repositoryType = m_defaultRepositoryType;
}
lock (this)
{
ILoggerRepository rep = null;
// First check that the domain does not exist
rep = m_domain2repositoryMap[domain] as ILoggerRepository;
if (rep != null)
{
throw new LogException("Domain [" + domain + "] is already defined. Domains cannot be redefined.");
}
else
{
// Lookup an alias before trying to create the new domain
ILoggerRepository aliasedRepository = m_alias2repositoryMap[domain] as ILoggerRepository;
if (aliasedRepository != null)
{
// Found an alias
// Check repository type
if (aliasedRepository.GetType() == repositoryType)
{
// Repository type is compatable
LogLog.Debug("DefaultRepositorySelector: Aliasing domain [" + domain + "] to existing repository [" + aliasedRepository.Name + "]");
rep = aliasedRepository;
// Store in map
m_domain2repositoryMap[domain] = rep;
}
else
{
// Invalid repository type for alias
LogLog.Error("DefaultRepositorySelector: Failed to alias domain [" + domain + "] to existing repository [" + aliasedRepository.Name + "]. Requested repository type [" + repositoryType.FullName + "] is not compatable with existing type [" + aliasedRepository.GetType().FullName + "]");
// We now drop through to create the domain without aliasing
}
}
// If we could not find an alias
if (rep == null)
{
LogLog.Debug("DefaultRepositorySelector: Creating repository for domain [" + domain + "] using type [" + repositoryType + "]");
// Call the no arg constructor for the repositoryType
rep = (ILoggerRepository)repositoryType.GetConstructor(SystemInfo.EmptyTypes).Invoke(BindingFlags.Public | BindingFlags.Instance, null, new object[0], CultureInfo.InvariantCulture);
// Set the name of the repository
rep.Name = domain;
// Store in map
m_domain2repositoryMap[domain] = rep;
// Notify listeners that the repository has been created
FireLoggerRepositoryCreatedEvent(rep);
}
}
return(rep);
}
}
/// <summary>
/// Creates a new repository for the assembly specified.
/// </summary>
/// <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository" />.</param>
/// <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository" />.</param>
/// <param name="repositoryName">The name to assign to the created repository</param>
/// <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
/// <returns>The repository created.</returns>
/// <remarks>
/// <para>
/// The <see cref="T:log4net.Repository.ILoggerRepository" /> created will be associated with the repository
/// specified such that a call to <see cref="M:GetRepository(Assembly)" /> with the
/// same assembly specified will return the same repository instance.
/// </para>
/// <para>
/// The type of the <see cref="T:log4net.Repository.ILoggerRepository" /> created and
/// the repository to create can be overridden by specifying the
/// <see cref="T:log4net.Config.RepositoryAttribute" /> attribute on the
/// <paramref name="repositoryAssembly" />. The default values are to use the
/// <paramref name="repositoryType" /> implementation of the
/// <see cref="T:log4net.Repository.ILoggerRepository" /> interface and to use the
/// <see cref="P:System.Reflection.AssemblyName.Name" /> as the name of the repository.
/// </para>
/// <para>
/// The <see cref="T:log4net.Repository.ILoggerRepository" /> created will be automatically
/// configured using any <see cref="T:log4net.Config.ConfiguratorAttribute" />
/// attributes defined on the <paramref name="repositoryAssembly" />.
/// </para>
/// <para>
/// If a repository for the <paramref name="repositoryAssembly" /> already exists
/// that repository will be returned. An error will not be raised and that
/// repository may be of a different type to that specified in <paramref name="repositoryType" />.
/// Also the <see cref="T:log4net.Config.RepositoryAttribute" /> attribute on the
/// assembly may be used to override the repository type specified in
/// <paramref name="repositoryType" />.
/// </para>
/// </remarks>
/// <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly" /> is <see langword="null" />.</exception>
public ILoggerRepository CreateRepository(Assembly repositoryAssembly, Type repositoryType, string repositoryName, bool readAssemblyAttributes)
{
if ((object)repositoryAssembly == null)
{
throw new ArgumentNullException("repositoryAssembly");
}
if ((object)repositoryType == null)
{
repositoryType = m_defaultRepositoryType;
}
lock (this)
{
ILoggerRepository loggerRepository = m_assembly2repositoryMap[repositoryAssembly] as ILoggerRepository;
if (loggerRepository == null)
{
LogLog.Debug(declaringType, "Creating repository for assembly [" + repositoryAssembly + "]");
string repositoryName2 = repositoryName;
Type repositoryType2 = repositoryType;
if (readAssemblyAttributes)
{
GetInfoForAssembly(repositoryAssembly, ref repositoryName2, ref repositoryType2);
}
LogLog.Debug(declaringType, "Assembly [" + repositoryAssembly + "] using repository [" + repositoryName2 + "] and repository type [" + repositoryType2 + "]");
loggerRepository = (m_name2repositoryMap[repositoryName2] as ILoggerRepository);
if (loggerRepository == null)
{
loggerRepository = CreateRepository(repositoryName2, repositoryType2);
if (readAssemblyAttributes)
{
try
{
LoadAliases(repositoryAssembly, loggerRepository);
LoadPlugins(repositoryAssembly, loggerRepository);
ConfigureRepository(repositoryAssembly, loggerRepository);
}
catch (Exception exception)
{
LogLog.Error(declaringType, "Failed to configure repository [" + repositoryName2 + "] from assembly attributes.", exception);
}
}
}
else
{
LogLog.Debug(declaringType, "repository [" + repositoryName2 + "] already exists, using repository type [" + loggerRepository.GetType().FullName + "]");
if (readAssemblyAttributes)
{
try
{
LoadPlugins(repositoryAssembly, loggerRepository);
}
catch (Exception exception2)
{
LogLog.Error(declaringType, "Failed to configure repository [" + repositoryName2 + "] from assembly attributes.", exception2);
}
}
}
m_assembly2repositoryMap[repositoryAssembly] = loggerRepository;
}
return(loggerRepository);
}
}
/// <summary>
/// Create a new repository for the assembly specified
/// </summary>
/// <param name="domainAssembly">the assembly to use to create the domain to associate with the <see cref="ILoggerRepository"/>.</param>
/// <param name="repositoryType">The type of repository to create, must implement <see cref="ILoggerRepository"/>.</param>
/// <param name="domainName">The name to assign to the created repository</param>
/// <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>
/// <returns>The repository created.</returns>
/// <remarks>
/// <para>
/// The <see cref="ILoggerRepository"/> created will be associated with the domain
/// specified such that a call to <see cref="GetRepository(Assembly)"/> with the
/// same assembly specified will return the same repository instance.
/// </para>
/// <para>
/// The type of the <see cref="ILoggerRepository"/> created and
/// the domain to create can be overridden by specifying the
/// <see cref="log4net.Config.DomainAttribute"/> attribute on the
/// <paramref name="assembly"/>. The default values are to use the
/// <paramref name="repositoryType"/> implementation of the
/// <see cref="ILoggerRepository"/> interface and to use the
/// <see cref="AssemblyName.Name"/> as the name of the domain.
/// </para>
/// <para>
/// The <see cref="ILoggerRepository"/> created will be automatically
/// configured using any <see cref="log4net.Config.ConfiguratorAttribute"/>
/// attributes defined on the <paramref name="domainAssembly"/>.
/// </para>
/// <para>
/// If a repository for the <paramref name="domainAssembly"/> already exists
/// that repository will be returned. An error will not be raised and that
/// repository may be of a different type to that specified in <paramref name="repositoryType"/>.
/// Also the <see cref="log4net.Config.DomainAttribute"/> attribute on the
/// assembly may be used to override the repository type specified in
/// <paramref name="repositoryType"/>.
/// </para>
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="domainAssembly"/> is null.</exception>
public ILoggerRepository CreateRepository(Assembly domainAssembly, Type repositoryType, string domainName, bool readAssemblyAttributes)
{
if (domainAssembly == null)
{
throw new ArgumentNullException("domainAssembly");
}
// If the type is not set then use the default type
if (repositoryType == null)
{
repositoryType = m_defaultRepositoryType;
}
lock (this)
{
// Lookup in map
ILoggerRepository rep = m_assembly2repositoryMap[domainAssembly] as ILoggerRepository;
if (rep == null)
{
// Not found, therefore create
LogLog.Debug("DefaultRepositorySelector: Creating repository for assembly [" + domainAssembly + "]");
// Must specify defaults
string domain = domainName;
Type actualRepositoryType = repositoryType;
if (readAssemblyAttributes)
{
// Get the domain and type from the assembly attributes
GetInfoForAssembly(domainAssembly, ref domain, ref actualRepositoryType);
}
LogLog.Debug("DefaultRepositorySelector: Assembly [" + domainAssembly + "] using domain [" + domain + "] and repository type [" + actualRepositoryType + "]");
// Lookup the domain in the map (as this may already be defined)
rep = m_domain2repositoryMap[domain] as ILoggerRepository;
if (rep == null)
{
// Create the repository
rep = CreateRepository(domain, actualRepositoryType);
if (readAssemblyAttributes)
{
// Look for aliasing attributes
LoadAliases(domainAssembly, rep);
// Look for plugins defined on the assembly
LoadPlugins(domainAssembly, rep);
// Configure the repository using the assembly attributes
ConfigureRepository(domainAssembly, rep);
}
}
else
{
LogLog.Debug("DefaultRepositorySelector: domain [" + domain + "] already exisits, using repository type [" + rep.GetType().FullName + "]");
if (readAssemblyAttributes)
{
// Look for plugins defined on the assembly
LoadPlugins(domainAssembly, rep);
}
}
m_assembly2repositoryMap[domainAssembly] = rep;
}
return(rep);
}
}