C＃中的实例类->静态类->实例类

Question

I have done a lot of reading on instance vs. static classes and have not found an answer to my question. Are there any perils to instancing a different class in a static class that was referenced by an instance class?

The current design I am working with is one in which instance classes call a static "Logger" method (passing a series of parameters) to log errors to a text file in the file system. I am refactoring the static "Logger" method to instantiate a parameter class (which is just a series of properties and a few helper methods to return itself as XML or a string) and a DBLogger class to log the error to the database rather than the file system, passing the parameter class as the sole parameter.

This model worked well in my legacy VB6 code, in which the Logger class was instanced, not static.

But now in the .NET code I am not sure if I should make my 2 new classes (parameter and DBLogger) static, or just make the DBLogger static and instance the parameter class. I am concerned about the potential for concurrency/multi-thread data issues with (or without) instances being created from a static class. Am I right to be concerned or am I worrying about nothing?

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

// all code truncated for illustration purposes

namespace ThisIs.A.Test
{
    //INSTANCE
    public class ErrorLogParameters
    {
        private int mThreadId = 0;
        private int mErrorNumber = 0;
        private string mServerDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");

        public int ThreadId
        {
            get { return mThreadId; }
            set { mThreadId = value; }
        }
        public int ErrorNumber
        {
            get { return mErrorNumber; }
            set { mErrorNumber = value; }
        }
        public string ServerDate
        {
            get { return mServerDate; }
        }
    }

    //INSTANCE
    public class ErrorLog
    {
        public void LogErrorToDatabase(ErrorLogParameters criteria)
        {
            //Log error to database here
        }
    }

    //STATIC - Instantiates INSTANCE of ErrorLogParameters and ErrorLog
    public class Logger
    {
        public static void WriteLog(string pstrObjectName, string pstrProcedureName, int plngErrNumber, string pstrErrDescription)
        {
            // create a new parameter object
            ErrorLogParameters objParameters = new ErrorLogParameters();

            // populate object properties
            objParameters.ErrorNumber = mlngErrNumber;
            objParameters.ThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;

            ErrorLog objErrorLog = new ErrorLog();

            objErrorLog.LogErrorToDatabase(objParameters);
        }
    }

    //INSTANCE - Invokes STATIC method
    public class SomeInstance 
    {
        private void ErrorHandler_Log(Exception exception, string procedureName, string additonalDescription, string stackTrace)
        {
            // call from instance class to static class
            Logger.WriteLog(mstrObjectName, procedureName, mlngErrNumber, mstrErrDescription);
        }
    }

}

Answer 1

No, that's absolutely fine - if you're creating an instance of any class within a method, it doesn't matter whether the class declaring that method is a static class or not.

Furthermore, unless you've got something "special" (eg a static variable counting the number of instances created) you're less likely to run into concurrency issues when creating new objects than when using existing objects. Basically, the tricky part of almost all concurrency is working out where mutable data is shared - it doesn't sound like you've got any here (although sample code would help to clarify that).

Answer 2

I would use a combination of the provider and singleton pattern for this.

Create an abstract class called Logger.

1. The Logger class contains abstract methods for writing to log. For example:
   • abstract void LogInfo(LogInfo info);
   • abstract void LogError(Exception exception);
   • etc
2. The Logger class contains a private instance of Logger object.
3. The Logger class contains a static property that returns the private instance.
4. The Logger class contains a static constructor that instantiate the private instance of Logger object. You would probably use Reflection and instantiate the object based on the configuration.
5. Implement a FileLogger that inherits from the Logger object. This logger writes to a file.
6. Implement a SQLLogger that inherits from the Logger object. This logger writes to a database.

Call the logger like so:

• Logger.Instance.WriteInfo(info);
• Logger.Instance.WriteError(exception);

There are a few advantages of using this design:

1. Your logging functionality is fully abstracted. This completely decouple the logging callers from the code that writes the logs. This allows you to write the log to any data stores.
2. You can change which logger to use without compiling the code. Just update the config file.
3. Singleton guarantees thread-safety
4. Testability. You can write Mock tests against abstract classes.

Hope this helps.

Answer 3

There are no concurrency issues with static methods.

Static variables are a different matter.