Question

严格地说，为了保存代码中的输入，我想找到一些方法将文本追加到另一个类返回的成员中。这可能没有意义，所以一个例子。我正在研究的是一个管理测试数据的课程：

public class TestFiles
{
    private const string File1RelativePath = @"TestData\File1.xml";
    private const string File2RelativePath = @"TestData\File2.xml";

    private static string RootPath()
    {
        // don't know the deployment location until runtime 
        return Some_DirectoryName_Determined_At_Run_Time_Returned_BySomeOtherModule();
    }

    public static string File1
    {
        get { return Path.Combine(RootPath() + File1RelativePath); }
    }

    public static string File2
    {
        get { return Path.Combine(RootPath() + File2RelativePath); }
    }
}

这个类完全符合我的要求，我可以简单地通过以下方式调用它：

String FileToUseForTest = TestFiles.File1;

问题是我很懒，当我添加更多文件时，我必须在两个地方执行：常量字符串和get属性。也许我可以在getter中包含字符串文字，但即使这样，我也必须在每个getter中调用Path.Combine（RootPath（）...，这对我来说太过分了。

所以，尝试另一种方法，由于以下原因而无效：

public class TestFiles
{
    public class FileRelativePaths
    {
        private const string File1RelativePath = @"TestData\File1.xml";
        private const string File2RelativePath = @"TestData\File2.xml";
    }

    private static FileRelativePaths relPaths = new RulePackages();

    FileRelativePaths FullPaths
    {
        get { return relPaths; }
    }

    private static string RootPath()
    {
        // No longer called, but somehow need to find a way to append to paths returned in FullPaths
        return Some_DirectoryName_Determined_At_Run_Time_Returned_BySomeOtherModule();
    }
}

这几乎可以工作，我得到了强大的输入，调用者可以通过

获取文件

String FileToUseForTest = TestFiles.FullPaths.File1;

但问题是这只给了我相对路径，我真的想在返回的字符串中附加一些代码（通过使用方法RootPath（））。

那么，有没有什么方法可以让它工作，同时仍然有强大的输入并将代码长度保持在最低限度？我有点不愿意使用上面的第一种方法，但我想我会问是否有创意解决方案。

Answer 1

如何使用运算符重载来执行包含根路径的隐式转换？

class Program
{
    static void Main(string[] args)
    {
        RelativePath relative = @"Relative\Path\One";

        Console.WriteLine(relative.Path);
        string path = relative;
        Console.WriteLine(path);

        Console.ReadLine();
    }
}

public class RelativePath
{

    public static string RootPath()
    {
        return @"C:\MyRootPath\";
    }

    public string Path
    {
        get;
        protected set;
    }

    public RelativePath(string relativePath)
    {
        this.Path = relativePath;
    }

    public static implicit operator RelativePath(string path)
    {
        return new RelativePath(path);
    }

    public static implicit operator string(RelativePath relativePath)
    {
        return System.IO.Path.Combine(RootPath(), relativePath.Path);
    }

}

Answer 2

个人而言，我只是让自己不得不在两个地方改变它。这是一个我不喜欢的替代方案，但在我理解它们时满足您的标准：

public enum XmlFile{
    File1,
    File2
};

public static class TestFiles{
    const string RelativeDirectory = @"TestData";
    const string XmlExtension = @"xml";
    static string RootPath {
        get
        {
            return Some_DirectoryName_Determined_At_Run_Time_Returned_BySomeOtherModule();
        }
    }

    //overload as necessary for other extensions or pass it as an additional parameter
    public static string GetFullPath(XmlFile file){
        return string.Format(@"{0}{1}\{2}.{3}", RootPath, RelativeDirectory, file, XmlExtension);
    }
}

这个片段有一些不幸的副作用：

使用约定将枚举成员与文件名相关联
依赖于枚举的ToString（）
假设RelativeDirectory始终相同（否则，您将需要进一步的约定来容纳）

Answer 3

只需使用小帮手功能......

private static string fixupPath (string dir)
{
    return Path.Combine(RootPath() + dir); 

}

public static string File1
{
    get { return fixupPath(File1RelativePath); }
}

如果您真的想要优化击键而不是可维护性，请使用较短的函数名称。

Answer 4

这样的事情怎么样？注意，未经测试的代码：

public enum TestFileType {
    File1,
    File2,
}

public class TestFiles
{
    private static Dictionary<TestFileType, String> filePaths = new Dictionary<TestFileType, String> 
        { 
            { TestFileType.File1, @"TestData\File1.xml" }, 
            { TestFileType.File2, @"TestData\File2.xml" } 
        };

    public static String GetFile(TestFileType fType) {
        return Path.Combine(RootPath() + filePaths[fType]);
    }
}

// Use thus: 
TestFiles.GetFile(TestFileType.File1);

Answer 5

有几件事情浮现在脑海中。首先，您可以使用枚举，字典和单个“get”函数，而不是具有离散属性：

public enum TestFile { File1, File2 };

public class TestFiles {

  private static Dictionary<TestFile,string> _testFiles = new Dictionary<TestFile,string> {
    { TestFile.File1, @"TestData\File1.xml" },
    { TestFile.File2, @"TestData\File2.xml" },
  };

  public string RootPath() {
    return @"C:\";
  }

  public string Get( TestFile tf ) {
    return Path.Combine( RootPath(), _testFiles[tf] );
  }

  // even better, you can override the array indexing operator
  public string this[TestFile tf] {
    get { 
        return Path.Combine( RootPath(), _testFiles[tf] );
    }
  }
}

如果你想抽象出重复的Path.Combine代码，你总是可以使用一个助手类，虽然我怀疑你在这里获得了很多。不过，它可能会提高可读性：

public static class TestFileHelper {
    public static string RootPath() {
      return @"C:\";
    }

    public static string RootedAtTestDir( this string s ) {
        return Path.Combine( RootPath(), s );
    }
}

然后，您可以写下：

，而不是在任何地方调用Path.Combine

return _testFiles[tf].RootedAtTestDir();

Answer 6

这实际上可能是扩展的一个很好的用例。您可以将它添加到测试程序集/文件中，只需在需要它的地方引用它：

public static class TestExtensions
{
    private static string RootPath = @"C:\Some\Root\Path";
    public static string AddRoot(this string path)
    {
        return Path.Combine(RootPath, path);
    }
}

另一种选择是使用字典，以防你想要定义多个“根”，这样你就可以指定两个东西：路径和根密钥。

public static class TestExtensions
{
    private static Dictionary<string, string> RootPaths = new Dictionary<string, string>();

    public static void RegisterRoot(string rootKey, string rootPath)
    {
        // Omitted null checking, but should do it.
        RootPaths[rootKey] = rootPath;
    }

    public static string AddRoot(this string path, string rootKey)
    {
        return Path.Combine(RootPaths[rootKey], path);
    }
}

用法很简单。只需在任何字符串实例上调用扩展方法。 IE：

// Single root version.
TestFiles.File1.AddRoot(); 
// String literal...
@"Relative\Path\File.xml".AddRoot();
// Dictionary root version.
TestExtensions.RegisterRoot("testRoot", @"C:\Some\Test\Directory");
TestFiles.File1.AddRoot("testRoot");

希望有所帮助。

在访问属性之前执行公共代码的模式

6 个答案: