How should I write my Factory Class - Generates derived objects

Question

To start, I'll lay out my general setup and describe the goal of the classes, as I feel its important for the question:

• This is designed to dynamically cache files and folders as needed by the application.
• If the user needs to copy them somewhere, this allows them to copy the local version instead of downloading off the remote every single time. Instead, it will only download if an update to the file/folder is available. (For folders, this is performed with robocopy mirroring)
• Also, sorry for wall of text here

public enum SyncMode
{
     None = -2, // SyncMode Not Defined by Object (don't actually intend in my use case, added for future compatibility/interfaces)
     AlwaysReturnNetwork = -1, //DynamicPath should prioritize the network string, UNLESS the network is unavailable and the path exists locally.
     Dynamic = 0,   // Another one for potential future objects
     OfflineCache = 1, // Allow file/folder to be downloaded for use in offline mode of the application
     LocalCache = 2,   // Cache the file/folder locally for quicker access
     AlwaysReturnLocal = 3, // Designed to essentially be a file that is required by the application
}

// this class will allow consumers to override some functions, for example the actions to take when downloading the file from remote to local. 
//(base will assume its not web-based, so a web-based consumer will need to implement that functionality by overriding the virtual methods)
// As shown below, the consumer must also specify how to determine if the user is set up to local/offline cache, as well as if the application is running in offline (assume network unavailable) mode
public abstract class FileOperations 
{
   abstract bool IsApplicationOffline {get;}
   abstract bool AllowOfflineCaching {get;}
   abstract bool AllowLocalCaching {get;}
}

public abstract class AbstractNetworkPath
{
    public string LocalPath { get; } // File/Folder might exist at this location on the pc
    public string NetPath { get; } // File/Folder should exist at this location on a remote location
    public SyncMode SyncMode {get;} //Determine how the DynamicPath functions
    public string DynamicPath {get;} //String is returned based on the SyncMode value and if the path exists locally
    protected bool ShouldCache => SyncMode == AlwaysReturnLocal || SyncMode >=OfflineCache && FileOps.AllowOfflineCaching || SyncMode >= LocalCaching && FileOps.AllowLocalCaching;
    internal protected FileOperations FileOps {get;} // Reference to the object passed into the ctor/factory
}

public class SyncedFile : AbstractNetworkPath
{     
     public void CopyTo(string destPath)
     {
          if (ShouldCache) this.FileOps.UpdateFile(this.NetPath, this.LocalPath);
          FileOps.CopyFile(this.DynamicPath, destPath);
     }  
}

public class NetworkFolder: AbstractNetworkPath
{     
     // This class represents a remote folder, and prioritizes the network location
     // This is meant to specify some location, not necessarily one that gets downloaded.
     // For example, a main directory with a bunch of files/folders, most of which the application doesn't need or want.
}  


public class SyncedFolder : NetworkFolder
{
     // This class represents a remote folder, but prioritizes the local location
     // This class also adds the methods to download the folder locally

     public void CopyTo(string destPath)
     {
          if (ShouldCache) this.FileOps.UpdateFolder(this.NetPath, this.LocalPath);
          FileOps.CopyFolder(this.DynamicPath, destPath);
     }  
}  

So here is where it gets fun:

• The factories I want to set up for this will contain the FileOps object so that the consumer doesn't have to constantly specify it in the constructor - the factory will do it for them.
• A SyncedFile exists within a NetworkFolder(but not necessarily in that folder, but maybe in a subfolder path), so the SyncedFileFactory must contain a method to create a object using that parent. This same principle applies to SyncedFolder
• SyncedFile and SyncedFolder both expect to never use the 'AlwaysReturnNetwork' enum value. This is partly why I wanted to use a factory method, to ensure that value is never passed into the CTOR, as it doesn't make sense for those objects to be in that state.
• There also exists an interface I'm allowing creation of the object from. This way, a consumer can read data from a database (or in my case an excel file) into some object that implements the interface, which can then be passed into the factory to construct the object.

Heres are questions:

• My plan is to have a SyncedFileFactory, a NetworkFolderFactory, and a SyncedFolderFactory

  • But, now that I've written that out, I could just evaluate the SyncMode and return either a SyncedFolder OR NetworkFolder from the NetworkFolderFactory. Is this the easy enough to understand, or should I have its own factory for clarity of construction?
  • Note that I didn't think of this originally due to my question below:

• Does it make sense to have a factory that applies its SyncMode to the class being constructed? Or a more generic Factory that simply validates the SyncMode passed into the method?

Here is what I have at the moment:

public class SyncedFileFactory 
{
     Public SyncedFileFactory(SyncMode syncmode, FileOperations fileOps) { /* Ctor*/ }
     public FileOperations FileOperationsObj{get;}
     Public SyncMode SyncMode {get;}
}

public class NSOFactory
{
     Public NSOFactory(FileOperations fileOps)
     {
          FileFactory_Offline  = new(SyncMode.OfflineCache, fileOps);
          FileFactory_LocalCache = new(SyncMode.LocalCache, fileOps);
          FileFactory_Required = new(SyncMode.AlwaysReturnLocal, fileOps);
     }

     public SyncedFileFactory FileFactory_Offline {get;}
     public SyncedFileFactory FileFactory_LocalCache {get;}
     public SyncedFileFactory FileFactory_Required {get;}
}

I like that this enforces the types of SyncModes and only constructs objects with valid sync modes, but when constructing from an object that already has a syncMode specified, we run into a few issues, and I'm unsure the best way to work around this while keeping factory structure clear

• when using the interface (which enforces specifying a SyncMode), it becomes unclear what should happen. (Does it use the SyncMode specified by the interface, or the SyncMode of the factory?)
• Same issue for when generating it using a parent NetworkFolder object.
  • But if the NetworkFolder object is 'AlwaysReturnNetwork', then SyncedFile and SyncedFolder should not inherit it anyway

Edit: Possible Solution - Need Thoughts on this:

So now my line of thinking is essentially:

• OfflineCache should take priority over LocalCache, for construction, but AlwaysReturnLocal is highest priority for construction. So Do I simply evaluate the input parent and the chosen factory and act accordingly? That might be the easiest thing to do. But if someone goes to look at it, you wind up with the output value differing from the input value. That interaction reduces clarity, but keeps in line with intended function of the library.

Answer 1

OK, so as I continued to develop this dll, i ran into some other issues that have since been worked out. I'll detail my resolution to this below for anyone else that may be inspired.

Original Thought Process: Create a factory of each SyncMode type (atleast the primary values). Reason I thought of wanted it:

• Some types don't make sense / cant have certain values. Example: SyncedFile should never be 'AlwaysReturnNetwork'. The whole point of that class is that it gets a file cached locally, so to allow never returning of the local path doesn't make sense.

Problems with this:

• Too many factory objects need to be instantiated
• Some methods inherit the value by default instead of using the factory-specific one. (Creating a SyncedFile that resides within a SyncedFolder inherits the SyncedFolder's enum value)

Original Plans: Have a global settings object the library refers to that takes care of defining the Func<bool> targets that determine if the application is in offline mode, whether to allow local caching, etc. Problems with this:

• A globally defined object like this is fine for a self-contained app. But to be better and more flexible, the func targets should be able to be customized per object if need be.

Solutions:

• Convert the static class used for global settings into an object class. This allows the app to have a single settings object if desired, or have multiple if needed.
• Factory Objects take the new NSOFactorySettings object in their constructor. ( base class now has property of type NSOFactorySettings. All derived classes now point to this property instead of the static class.)
• Factory methods have been rewritten to be more generic, accepting the enum as a parameter instead of relying on the factory's enum value. ( potentially 6 factories reduced to 1. Also, much cleaner and clearer factory code was the result of this change. )
• To enforce the types of enum being passed to a constructor, i created a new Struct type whose underlying value is of the enum type. Then only allow static reference to it.

Struct used for enforcing specific enums:

/// <summary>
    /// Subset of <see cref="SyncMode"/> values that are valid for <see cref="SyncedFile"/> and <see cref="SyncedFolder"/> objects.
    /// </summary>
    [ImmutableObject(true)]
    public readonly struct CacheMode
    {
        private CacheMode(SyncMode mode) { Mode = mode; }

        public static readonly CacheMode Dynamic = new(SyncMode.Dynamic);

        public static readonly CacheMode DynamicOfflineCached = new(SyncMode.DynamicOfflineCached);

        public static readonly CacheMode DynamicCached = new(SyncMode.DynamicCached);

        public static readonly CacheMode AlwaysReturnLocal = new(SyncMode.AlwaysReturnLocal);

        public readonly SyncMode Mode;

        public static implicit operator SyncMode(CacheMode value) => value.Mode;

        public static explicit operator CacheMode(SyncMode value) => FromSyncMode(value);
        
        public static CacheMode FromSyncMode(SyncMode value)
        {
            return value switch
            {
                SyncMode.AlwaysReturnLocal => CacheMode.AlwaysReturnLocal,
                SyncMode.DynamicCached => CacheMode.DynamicCached,
                SyncMode.DynamicOfflineCached => CacheMode.DynamicOfflineCached,
                SyncMode.Dynamic => CacheMode.Dynamic,
                _ => throw new InvalidCastException("SyncMode value must be Dynamic or Greater. Value passed into method: " + Enum.GetName(typeof(SyncMode), value))
            };
        }

        public static CacheMode DefaultOrGreater(SyncMode? syncMode)
        {
            if (syncMode is null || syncMode == SyncMode.Dynamic) return CacheMode.Dynamic;
            return FromSyncMode(Factory.NSOFactoryBase.PrioritizeSyncMode(SyncMode.Dynamic, (SyncMode)syncMode));
        }

        public static CacheMode DefaultOrGreater(SyncMode? syncMode, Interfaces.INetworkSyncObject networkSyncObject)
        {
            if (syncMode is null) return DefaultOrGreater(networkSyncObject?.SyncPriority);
            var mode = NSOFactoryBase.PrioritizeSyncMode((SyncMode)syncMode, networkSyncObject?.SyncPriority ?? SyncMode.Dynamic);
            return DefaultOrGreater(mode);
        }
    }

Factory Class:

namespace NetworkSyncObjects
{
    public partial class SyncedFile
    {

        /// <summary>
        /// Factory to create <see cref="SyncedFile"/> objects. <br/>
        /// This factory does not specify the <see cref="CacheMode"/>.
        /// </summary>
        public class SyncedFileFactory : NSOFactoryBase
        {

            #region < Factory Construction >
            internal protected SyncedFileFactory(NSOFactorySettings factorySettings) : base(factorySettings) { }

            public static SyncedFileFactory CreateFactory(NSOFactorySettings factorySettings)
            {
                //Validate Input
                if (factorySettings is null) throw new ArgumentNullException(nameof(factorySettings));
                return new SyncedFileFactory(factorySettings);
            }

            public static SyncedFileFactory CreateFactory(NSOFactorySettings objectToClone, string rootFolder)
            {
                var fS = new NSOFactorySettings(rootFolder, objectToClone);
                return new SyncedFileFactory(fS);
            }

            #endregion

            static bool PathValidation(string path, string variableName, out Exception e)
            {
                if (String.IsNullOrWhiteSpace(path))
                {
                    e = new ArgumentException($"Invalid Argument: '{variableName}' is null or empty", variableName);
                    return true;
                }
                if (!PathEx.IsPathFullyQualified(path))
                {
                    e = new ArgumentException($"Invalid Argument: '{variableName}' is not fully qualified! \nSupplied path: {path}", variableName);
                    return true;
                }
                if (!Path.HasExtension(path))
                {
                    e = new ArgumentException($"Invalid Argument: '{variableName}' does not have a file extension! \nSupplied path: {path}", variableName);
                    return true;
                }
                if (string.IsNullOrWhiteSpace(Path.GetFileName(path)))
                {
                    e = new ArgumentException($"Unable to retrieve filename from SourceFilePath! \n Supplied path: {path}", variableName);
                    return true;
                }
                e = null;
                return false;
            }

            #region < Factory Methods >

            #region < From Source and Destination FilePath >

            public SyncedFile FromSource(string SourceFilePath, CacheMode syncMode)
            {
                if (PathValidation(SourceFilePath, nameof(SourceFilePath), out var E)) throw E;
                string localPath = ConvertNetworkPathToLocalPath(SourceFilePath, null);
                return FromSourceAndDestination(SourceFilePath, localPath, syncMode);
            }
            public SyncedFile FromSourceAndDestination(string SourceFilePath, string DestinationFilePath, CacheMode syncMode, string ID = null)
            {
                if (PathValidation(SourceFilePath, nameof(SourceFilePath), out var e)) throw e;
                if (PathValidation(DestinationFilePath, nameof(DestinationFilePath), out e)) throw e;
                return new SyncedFile(
                    networkPath: SourceFilePath,
                    localPath: DestinationFilePath,
                    iD: ID ?? "SyncedFile_" + Path.GetFileName(DestinationFilePath),
                    syncMode: syncMode,
                    this.FactorySettings
                    );
            }

            #region < Overloads >

            public SyncedFile FromSourceAndDestination(string SourceFilePath, DirectoryInfo DestinationFolder, CacheMode syncMode) => FromSourceAndDestination(SourceFilePath, Path.Combine(DestinationFolder.FullName, Path.GetFileName(SourceFilePath)), syncMode);

            
            #endregion

            #region < From NetworkFolder >

            /// <inheritdoc cref="SyncedFile.SyncedFile(string, INetworkFolder, CacheMode?)"/>
            public SyncedFile FromNetworkFolder(string filePath, INetworkFolder parent, string iD = null) => new SyncedFile(filePath, parent, CacheMode.DefaultOrGreater(parent.SyncPriority));

            #endregion

            #region < From INetworkSyncDataObject >

      
            public SyncedFile FromIConstructionData(IConstructionData_NetPathOnly dataObject)
            {
                if (dataObject is null) throw new ArgumentNullException(nameof(dataObject));
                if (PathValidation(dataObject.NetworkPath, "dataObject.NetworkPath", out Exception e)) throw e;
                string netPath = FactorySettings.GetUncPath(dataObject.NetworkPath, out MappedDrive drv);
                string localPath = ConvertNetworkPathToLocalPath(dataObject.NetworkPath, drv);

                return new SyncedFile(
                    netPath,
                    localPath,
                    dataObject.ID,
                    CacheMode.DefaultOrGreater(dataObject.SyncMode),
                    this.FactorySettings);
            }

 
            public SyncedFile FromIConstructionData(IConstructionData dataObject)
            {
                if (dataObject is null) throw new ArgumentNullException(nameof(dataObject));
                if (PathValidation(dataObject.NetworkPath, "dataObject.NetworkPath", out Exception e)) throw e;
                if (PathValidation(dataObject.LocalPath, "dataObject.LocalPath", out e)) throw e;

                return new SyncedFile(
                    dataObject.NetworkPath,
                    dataObject.LocalPath,
                    dataObject.ID,
                    CacheMode.DefaultOrGreater(dataObject.SyncMode),
                    this.FactorySettings
                    );
            }

            #endregion

            #endregion
        }
}