Configuration data class.

ConfigLoader.cs

internal interface IConfigLoader
{
	IConfigSettings LoadConfig();
}

internal class ConfigLoader : IConfigLoader
{
	public ConfigLoader()
	{
	}
	
	protected String ConfigFilePath()
	{
		return
			Path.Combine(
				Path.GetDirectoryName(
					Assembly.GetExecutingAssembly().Location),
				"settings.xml");
	}
	
	protected FileStream OpenConfigFile()
	{
		return
			new FileStream(
				ConfigFilePath(),
				FileMode.Open,
				FileAccess.Read,
				FileShare.Read);
	}
	
	public IConfigSettings LoadConfig ()
	{
		var settings = null as IConfigSettings;
		
		using (var fs = OpenConfigFile())
		{
			var xml = new XmlSerializer(typeof(ConfigSettings));
			settings = xml.Deserialize(fs) as ConfigSettings;
		}
		
		return settings;
	}
}

ConfigRegistration.cs

protected virtual Config.IConfigSettings ResolveConfigSettings(IComponentContext context)
{
	return
		context.Resolve<Config.IConfigLoader>()
			.LoadConfig();
}

protected virtual void RegisterConfig(ContainerBuilder builder)
{
	builder
		.RegisterType<Config.ConfigLoader>()
		.As<Config.IConfigLoader>()
		.InstancePerLifetimeScope();
	
	builder
		.Register(ResolveConfigSettings)
		.As<Config.IConfigSettings>()
		.InstancePerLifetimeScope();
}

ConfigSettings.cs

internal interface IConfigSettings
{
	String GreetingFileName { get; }
	Int32 WorkIntervalSeconds { get; }
}

[XmlRoot("GreeterSettings")]
public class ConfigSettings : IConfigSettings
{
	public ConfigSettings ()
	{
	}
	
	[XmlAttribute]
	public String GreetingFileName
	{
		get;
		set;
	}
	
	[XmlAttribute]
	public Int32 WorkIntervalSeconds
	{
		get;
		set;
	}
}

GreetService.cs

internal class GreetService : ServiceBase
{
	protected virtual IGreeter Greeter
	{
		get;
		private set;
	}
	
	protected virtual ILogger Logger
	{
		get;
		private set;
	}
	
	protected virtual Func<Owned<IGreetServiceWorker>> WorkerFactory
	{
		get;
		private set;
	}
	
	public GreetService(IServiceNameProvider serviceNameProvider, ILogger logger, Func<Owned<IGreetServiceWorker>> workerFactory)
	{
		serviceNameProvider.ThrowIfNull("serviceNameProvider");
		
		ServiceName =
			serviceNameProvider.ServiceName
				.ThrowIfNullOrEmpty("serviceNameProvider.ServiceName");
		
		Logger = logger.ThrowIfNull("logger");
		WorkerFactory = workerFactory.ThrowIfNull("workerFactory");
		
		CanStop = true;
		AutoLog = true;
	}
	
	protected IGreetServiceWorker CurrentWorker
	{
		get;
		set;
	}

	protected override void OnStart(String[] args)
	{
		Logger.Message("Starting service.");
		
		if (CurrentWorker == null)
		{	
			try
			{
				CurrentWorker = WorkerFactory().Value;
				CurrentWorker.Start();
				
				Logger.Message("Service started.");
			}
			catch (Exception ex)
			{
				Logger.ExceptionAlone(ex);
			}
		}
		else
		{
			Logger.Message("Cannot start service. Service is already running.");
		}
	}

	protected override void OnStop()
	{
		Logger.Message("Stopping service.");
		CurrentWorker.Stop();
		CurrentWorker = null;
		Logger.Message("Service stopped.");
	}
}

settings.xml

<GreeterSettings
	GreetingFileName="hola.txt"
	WorkIntervalSeconds="5" />

WorkInterval.cs

internal interface IWorkInterval
{
	Int32 IntervalSeconds { get; }
}

internal class ConfigWorkIntervalProvider
{
	public Int32 IntervalSeconds
	{
		get;
		private set;
	}
	
	public ConfigWorkIntervalProvider(Config.IConfigSettings settings)
	{
		IntervalSeconds = settings.WorkIntervalSeconds;
	}
}