Codes / EnterpriseLibrary1

Codes

部品

[XmlRoot("sink", Namespace=DistributorSettings.ConfigurationNamespace)]
public class AnotherFlatFileSinkData : SinkData {
	private string fileName = string.Empty;
	private string header = string.Empty;
	private string footer = string.Empty;

	public AnotherFlatFileSinkData() {}

	public AnotherFlatFileSinkData(string name) : this(name, string.Empty) {}

	public AnotherFlatFileSinkData(string name, string fileName) : this(name, string.Empty, string.Empty, string.Empty) {
		this.fileName = fileName;
	}

	public AnotherFlatFileSinkData(string name, string fileName, string header, string footer) : base(name) {
		this.fileName = fileName;
		this.header = header;
		this.footer = footer;
	}

	[XmlAttribute("fileName")]
	public string FileName {
		get { return fileName; }
		set { fileName = value; }
	}

	[XmlAttribute("header")]
	public string Header {
		get { return header; }
		set { header = value; }
	}

	[XmlAttribute("footer")]
	public string Footer {
		get { return footer; }
		set { footer = value; }
	}

	[XmlIgnore]
	public override string TypeName {
		get { return typeof(FlatFileSink).AssemblyQualifiedName; }
		set { }
	}
}

public class AnotherFlatFileSink : LogSink {
	private static object syncObject = new object();
	private LoggingConfigurationView loggingConfigurationView;
	private DefaultLogDestination defaultSink;

	public AnotherFlatFileSink() {
		this.defaultSink = new DefaultLogDestination();
	}

	public override void Initialize(ConfigurationView configurationView) {
		ArgumentValidation.CheckForNullReference(configurationView, "configurationView");
		ArgumentValidation.CheckExpectedType(configurationView, typeof(LoggingConfigurationView));

		this.loggingConfigurationView = (LoggingConfigurationView)configurationView;
	}

	protected override void SendMessageCore(LogEntry logEntry) {
		if (ValidateParameters(logEntry)) {
			try {
				WriteMessageToFile(logEntry);
			} catch (Exception e) {
				logEntry.AddErrorMessage(e.ToString());
				throw;
			} catch {
				logEntry.AddErrorMessage("UnknownError");
			}
		}
	}

	private bool ValidateParameters(LogEntry logEntry) {
		AnotherFlatFileSinkData anotherFlatFileSinkData = GetAnotherFlatFileSinkDataFromCursor();

		bool valid = true;

		if (anotherFlatFileSinkData.FileName == null || anotherFlatFileSinkData.FileName.Length == 0) {
			valid = false;
			logEntry.AddErrorMessage("FileSinkMissingConfiguration");
			this.defaultSink.SendMessage(logEntry);
		}

		return valid;
	}

	private AnotherFlatFileSinkData GetAnotherFlatFileSinkDataFromCursor() {
		SinkData sinkData = loggingConfigurationView.GetSinkData(ConfigurationName);
		ArgumentValidation.CheckExpectedType(sinkData, typeof (AnotherFlatFileSinkData));

		return (AnotherFlatFileSinkData) sinkData;
	}

	private void WriteMessageToFile(LogEntry logEntry) {
		AnotherFlatFileSinkData anotherFlatFileSinkData = GetAnotherFlatFileSinkDataFromCursor();
		string fileName = anotherFlatFileSinkData.FileName;
		string header = anotherFlatFileSinkData.Header;
		string footer = anotherFlatFileSinkData.Footer;

		string directory = Path.GetDirectoryName(fileName);
		if (directory.Length == 0) {
			directory = AppDomain.CurrentDomain.BaseDirectory;
		}
		if (!Directory.Exists(directory)) {
			Directory.CreateDirectory(directory);
		}

		using (FileStream fileStream = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) {
			using (StreamWriter writer = new StreamWriter(fileStream)) {
				lock (syncObject) {
					if (header.Length > 0) { writer.WriteLine(header); }
					writer.WriteLine(FormatEntry(logEntry));
					if (footer.Length > 0) { writer.WriteLine(footer); }

					writer.Flush();
				}
			}
		}
	}
}

設定ツール用

public class DesignManager: IConfigurationDesignManager {
	#region IConfigurationDesignManager メンバ
	public void Register(IServiceProvider serviceProvider) {
		RegisterNodeTypes(serviceProvider);
		RegisterXmlIncludeTypes(serviceProvider);
	}

	public void BuildContext(IServiceProvider serviceProvider, ConfigurationDictionary configurationDictionary) { }

	public void Open(IServiceProvider serviceProvider) { }

	public void Save(IServiceProvider serviceProvider) { }
	#endregion

	private static void RegisterXmlIncludeTypes(IServiceProvider serviceProvider) {
		IXmlIncludeTypeService xmlIncludeTypeService = ServiceHelper.GetXmlIncludeTypeService(serviceProvider);
		xmlIncludeTypeService.AddXmlIncludeType(DistributorSettings.SectionName, typeof(ELTest.Sink.AnotherFlatFileSinkData));
	}
	private static void RegisterNodeTypes(IServiceProvider serviceProvider) {
		INodeCreationService nodeCreationService = ServiceHelper.GetNodeCreationService(serviceProvider);

		Type nodeType = typeof(AnotherFlatFileSinkNode);
		NodeCreationEntry entry =
			NodeCreationEntry.CreateNodeCreationEntryWithMultiples(
			new AddChildNodeCommand(serviceProvider, nodeType),
			nodeType,
			typeof(ELTest.Sink.AnotherFlatFileSinkData),
			"Another Flat File Sink");
		nodeCreationService.AddNodeCreationEntry(entry);
	}
}

[ServiceDependency(typeof(ILinkNodeService))]
public class AnotherFlatFileSinkNode : SinkNode {
	private ELTest.Sink.AnotherFlatFileSinkData _data;

	public AnotherFlatFileSinkNode() : this(new ELTest.Sink.AnotherFlatFileSinkData("Another Flat File Sink")) { }

	public AnotherFlatFileSinkNode(ELTest.Sink.AnotherFlatFileSinkData data) : base(data) {
		this._data = data;
	}

	[Browsable(false)]
	public override string TypeName {
		get { return _data.TypeName; }
	}

	[Category("General")]
	[Description("Optional.")]
	public string Header {
		get { return _data.Header; }
		set { _data.Header = value; }
	}

	[Category("General")]
	[Description("Optional.")]
	public string Footer {
		get { return _data.Footer; }
		set { _data.Footer = value; }
	}

	[Required]
	[Editor(typeof(SaveFileEditor), typeof(UITypeEditor))]
	[FilteredFileNameEditor("All files (*.*)|*.*")]
	[Category("General")]
	[Description("Required.")]
	public string FileName {
		get { return _data.FileName; }
		set { _data.FileName = value; }
	}
}