Is it right to use delegates as properties in C #?

Question

I need to create a class with two properties:

• Logoutput
• ExceptionOutput

These properties (Actions <>) send a message or an exception depending on the target function. This objective function is set using properties.

I currently have this functional code:

public class Output { private Action<string> logOutput; private Action<Exception, string> exceptionOutput; public Action<string> LogOutput { set { this.logOutput = value; } get { return this.logOutput; } } public Action<Exception, string> ExceptionOutput { set { this.exceptionOutput = value; } get { return this.exceptionOutput; } } public Output() : this(null, null) { } public Output(Action<string> logAction, Action<Exception, string> exceptionAction) { this.logOutput = logAction; this.exceptionOutput = exceptionAction; } public void WriteLogMessage(string format, params object[] args) { if (this.logOutput != null) logOutput(string.Format(format, args)); } public void WriteExceptionMessage(Exception ex, string format, params object[] args) { if (this.exceptionOutput != null) exceptionOutput(ex, string.Format(format, args)); } } 

And this is my form code:

  private void MainForm_Load(object sender, EventArgs e) { // my Output object Output myOutput = new Output(); // set properties myOutput.ExceptionOutput = this.WriteExceptionMessageToTextBox; myOutput.LogOutput = this.WriteLogMessageToTextBox; // test myOutput.WriteLogMessage("this is my log message to text box"); myOutput.WriteExceptionMessage(new Exception("this is my exception"), "this is my exception message to text box"); } private void WriteLogMessageToTextBox(string message) { // nothing to do here if (this.txtBox.IsDisposed) return; if (this.InvokeRequired) { BeginInvoke(new MethodInvoker(delegate() { WriteLogMessageToTextBox(message); })); } else { // write to text box this.txtBox.AppendText(message + Environment.NewLine); } } private void WriteExceptionMessageToTextBox(Exception ex, string message) { // nothing to do here if (this.txtBox.IsDisposed) return; if (this.InvokeRequired) { BeginInvoke(new MethodInvoker(delegate() { WriteExceptionMessageToTextBox(ex, message); })); } else { string msg = ""; msg += string.Format("Program:{0}", message); msg += string.Format("Message{0}", ex.Message); msg += string.Format("StackTrace:{0}", ex.StackTrace); msg += string.Format("Source:{0}", ex.Source); // write to text box this.txtBox.AppendText(msg + Environment.NewLine); } } 

Is this model right? Is there any other way to do this?

Answer 1

Is this model right? Is there any other way to do this?

There is nothing wrong with that, of course. However, events may be a more common approach to handling this, since you are effectively using the delegate as an event in this scenario.

Using events has one significant advantage (potentially), since you can also easily have multiple subscribers, which will make it easier for multiple elements to “listen” for exceptions or log messages. (* Although this works with delegates as well, this would not be the standard for using delegates.)

Answer 2

sorry offtopic but using StringBuilder string not recommended for editing

  string msg = ""; msg += string.Format("Program:{0}", message); msg += string.Format("Message{0}", ex.Message); msg += string.Format("StackTrace:{0}", ex.StackTrace); msg += string.Format("Source:{0}", ex.Source); StringBuilder sb = new StringBuilder(); sb.Append(string.Format("Program:{0}", message)); sb.Append(string.Format("Message{0}", ex.Message)); sb.Append(string.Format("StackTrace:{0}", ex.StackTrace)); sb.Append(string.Format("Source:{0}", ex.Source)); string result = sb.ToString();